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.hh"
  30
  31 #include "hb-machinery.hh"
  32
  33 #include <locale.h>
  34 #ifdef HAVE_XLOCALE_H
  35 #include <xlocale.h>
  36 #endif
  37
  38
  39 /**
  40  * SECTION:hb-common
  41  * @title: hb-common
  42  * @short_description: Common data types
  43  * @include: hb.h
  44  *
  45  * Common data types used across HarfBuzz are defined here.
  46  **/
  47
  48
  49 /* hb_options_t */
  50
  51 hb_atomic_int_t _hb_options;
  52
  53 void
  54 _hb_options_init ()
  55 {
  56   hb_options_union_t u;
  57   u.i = 0;
  58   u.opts.initialized = true;
  59
  60   const char *c = getenv ("HB_OPTIONS");
  61   if (c)
  62   {
  63     while (*c)
  64     {
  65       const char *p = strchr (c, ':');
  66       if (!p)
  67         p = c + strlen (c);
  68
  69 #define OPTION(name, symbol) \
  70         if (0 == strncmp (c, name, p - c) && strlen (name) == p - c) u.opts.symbol = true;
  71
  72       OPTION ("uniscribe-bug-compatible", uniscribe_bug_compatible);
  73       OPTION ("aat", aat);
  74
  75 #undef OPTION
  76
  77       c = *p ? p + 1 : p;
  78     }
  79
  80   }
  81
  82   /* This is idempotent and threadsafe. */
  83   _hb_options.set_relaxed (u.i);
  84 }
  85
  86
  87 /* hb_tag_t */
  88
  89 /**
  90  * hb_tag_from_string:
  91  * @str: (array length=len) (element-type uint8_t):
  92  * @len:
  93  *
  94  *
  95  *
  96  * Return value:
  97  *
  98  * Since: 0.9.2
  99  **/
 100 hb_tag_t
 101 hb_tag_from_string (const char *str, int len)
 102 {
 103   char tag[4];
 104   unsigned int i;
 105
 106   if (!str || !len || !*str)
 107     return HB_TAG_NONE;
 108
 109   if (len < 0 || len > 4)
 110     len = 4;
 111   for (i = 0; i < (unsigned) len && str[i]; i++)
 112     tag[i] = str[i];
 113   for (; i < 4; i++)
 114     tag[i] = ' ';
 115
 116   return HB_TAG (tag[0], tag[1], tag[2], tag[3]);
 117 }
 118
 119 /**
 120  * hb_tag_to_string:
 121  * @tag:
 122  * @buf: (out caller-allocates) (array fixed-size=4) (element-type uint8_t):
 123  *
 124  *
 125  *
 126  * Since: 0.9.5
 127  **/
 128 void
 129 hb_tag_to_string (hb_tag_t tag, char *buf)
 130 {
 131   buf[0] = (char) (uint8_t) (tag >> 24);
 132   buf[1] = (char) (uint8_t) (tag >> 16);
 133   buf[2] = (char) (uint8_t) (tag >>  8);
 134   buf[3] = (char) (uint8_t) (tag >>  0);
 135 }
 136
 137
 138 /* hb_direction_t */
 139
 140 const char direction_strings[][4] = {
 141   "ltr",
 142   "rtl",
 143   "ttb",
 144   "btt"
 145 };
 146
 147 /**
 148  * hb_direction_from_string:
 149  * @str: (array length=len) (element-type uint8_t):
 150  * @len:
 151  *
 152  *
 153  *
 154  * Return value:
 155  *
 156  * Since: 0.9.2
 157  **/
 158 hb_direction_t
 159 hb_direction_from_string (const char *str, int len)
 160 {
 161   if (unlikely (!str || !len || !*str))
 162     return HB_DIRECTION_INVALID;
 163
 164   /* Lets match loosely: just match the first letter, such that
 165    * all of "ltr", "left-to-right", etc work!
 166    */
 167   char c = TOLOWER (str[0]);
 168   for (unsigned int i = 0; i < ARRAY_LENGTH (direction_strings); i++)
 169     if (c == direction_strings[i][0])
 170       return (hb_direction_t) (HB_DIRECTION_LTR + i);
 171
 172   return HB_DIRECTION_INVALID;
 173 }
 174
 175 /**
 176  * hb_direction_to_string:
 177  * @direction:
 178  *
 179  *
 180  *
 181  * Return value: (transfer none):
 182  *
 183  * Since: 0.9.2
 184  **/
 185 const char *
 186 hb_direction_to_string (hb_direction_t direction)
 187 {
 188   if (likely ((unsigned int) (direction - HB_DIRECTION_LTR)
 189               < ARRAY_LENGTH (direction_strings)))
 190     return direction_strings[direction - HB_DIRECTION_LTR];
 191
 192   return "invalid";
 193 }
 194
 195
 196 /* hb_language_t */
 197
 198 struct hb_language_impl_t {
 199   const char s[1];
 200 };
 201
 202 static const char canon_map[256] = {
 203    0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,
 204    0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,   0,   0,   0,
 205    0,   0,   0,   0,   0,   0,   0,   0,    0,   0,   0,   0,   0,  '-',  0,   0,
 206   '0', '1', '2', '3', '4', '5', '6', '7',  '8', '9',  0,   0,   0,   0,   0,   0,
 207    0,  'a', 'b', 'c', 'd', 'e', 'f', 'g',  'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
 208   'p', 'q', 'r', 's', 't', 'u', 'v', 'w',  'x', 'y', 'z',  0,   0,   0,   0,  '-',
 209    0,  'a', 'b', 'c', 'd', 'e', 'f', 'g',  'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
 210   'p', 'q', 'r', 's', 't', 'u', 'v', 'w',  'x', 'y', 'z',  0,   0,   0,   0,   0
 211 };
 212
 213 static bool
 214 lang_equal (hb_language_t  v1,
 215             const void    *v2)
 216 {
 217   const unsigned char *p1 = (const unsigned char *) v1;
 218   const unsigned char *p2 = (const unsigned char *) v2;
 219
 220   while (*p1 && *p1 == canon_map[*p2]) {
 221     p1++;
 222     p2++;
 223   }
 224
 225   return *p1 == canon_map[*p2];
 226 }
 227
 228 #if 0
 229 static unsigned int
 230 lang_hash (const void *key)
 231 {
 232   const unsigned char *p = key;
 233   unsigned int h = 0;
 234   while (canon_map[*p])
 235     {
 236       h = (h << 5) - h + canon_map[*p];
 237       p++;
 238     }
 239
 240   return h;
 241 }
 242 #endif
 243
 244
 245 struct hb_language_item_t {
 246
 247   struct hb_language_item_t *next;
 248   hb_language_t lang;
 249
 250   bool operator == (const char *s) const
 251   { return lang_equal (lang, s); }
 252
 253   hb_language_item_t & operator = (const char *s) {
 254     /* If a custom allocated is used calling strdup() pairs
 255     badly with a call to the custom free() in fini() below.
 256     Therefore don't call strdup(), implement its behavior.
 257     */
 258     size_t len = strlen(s) + 1;
 259     lang = (hb_language_t) malloc(len);
 260     if (likely (lang))
 261     {
 262       memcpy((unsigned char *) lang, s, len);
 263       for (unsigned char *p = (unsigned char *) lang; *p; p++)
 264         *p = canon_map[*p];
 265     }
 266
 267     return *this;
 268   }
 269
 270   void fini () { free ((void *) lang); }
 271 };
 272
 273
 274 /* Thread-safe lock-free language list */
 275
 276 static hb_atomic_ptr_t <hb_language_item_t> langs;
 277
 278 #if HB_USE_ATEXIT
 279 static void
 280 free_langs ()
 281 {
 282 retry:
 283   hb_language_item_t *first_lang = langs;
 284   if (unlikely (!langs.cmpexch (first_lang, nullptr)))
 285     goto retry;
 286
 287   while (first_lang) {
 288     hb_language_item_t *next = first_lang->next;
 289     first_lang->fini ();
 290     free (first_lang);
 291     first_lang = next;
 292   }
 293 }
 294 #endif
 295
 296 static hb_language_item_t *
 297 lang_find_or_insert (const char *key)
 298 {
 299 retry:
 300   hb_language_item_t *first_lang = langs;
 301
 302   for (hb_language_item_t *lang = first_lang; lang; lang = lang->next)
 303     if (*lang == key)
 304       return lang;
 305
 306   /* Not found; allocate one. */
 307   hb_language_item_t *lang = (hb_language_item_t *) calloc (1, sizeof (hb_language_item_t));
 308   if (unlikely (!lang))
 309     return nullptr;
 310   lang->next = first_lang;
 311   *lang = key;
 312   if (unlikely (!lang->lang))
 313   {
 314     free (lang);
 315     return nullptr;
 316   }
 317
 318   if (unlikely (!langs.cmpexch (first_lang, lang)))
 319   {
 320     lang->fini ();
 321     free (lang);
 322     goto retry;
 323   }
 324
 325 #if HB_USE_ATEXIT
 326   if (!first_lang)
 327     atexit (free_langs); /* First person registers atexit() callback. */
 328 #endif
 329
 330   return lang;
 331 }
 332
 333
 334 /**
 335  * hb_language_from_string:
 336  * @str: (array length=len) (element-type uint8_t): a string representing
 337  *       a BCP 47 language tag
 338  * @len: length of the @str, or -1 if it is %NULL-terminated.
 339  *
 340  * Converts @str representing a BCP 47 language tag to the corresponding
 341  * #hb_language_t.
 342  *
 343  * Return value: (transfer none):
 344  * The #hb_language_t corresponding to the BCP 47 language tag.
 345  *
 346  * Since: 0.9.2
 347  **/
 348 hb_language_t
 349 hb_language_from_string (const char *str, int len)
 350 {
 351   if (!str || !len || !*str)
 352     return HB_LANGUAGE_INVALID;
 353
 354   hb_language_item_t *item = nullptr;
 355   if (len >= 0)
 356   {
 357     /* NUL-terminate it. */
 358     char strbuf[64];
 359     len = MIN (len, (int) sizeof (strbuf) - 1);
 360     memcpy (strbuf, str, len);
 361     strbuf[len] = '\0';
 362     item = lang_find_or_insert (strbuf);
 363   }
 364   else
 365     item = lang_find_or_insert (str);
 366
 367   return likely (item) ? item->lang : HB_LANGUAGE_INVALID;
 368 }
 369
 370 /**
 371  * hb_language_to_string:
 372  * @language: an #hb_language_t to convert.
 373  *
 374  * See hb_language_from_string().
 375  *
 376  * Return value: (transfer none):
 377  * A %NULL-terminated string representing the @language. Must not be freed by
 378  * the caller.
 379  *
 380  * Since: 0.9.2
 381  **/
 382 const char *
 383 hb_language_to_string (hb_language_t language)
 384 {
 385   /* This is actually nullptr-safe! */
 386   return language->s;
 387 }
 388
 389 /**
 390  * hb_language_get_default:
 391  *
 392  * Get default language from current locale.
 393  *
 394  * Note that the first time this function is called, it calls
 395  * "setlocale (LC_CTYPE, nullptr)" to fetch current locale.  The underlying
 396  * setlocale function is, in many implementations, NOT threadsafe.  To avoid
 397  * problems, call this function once before multiple threads can call it.
 398  * This function is only used from hb_buffer_guess_segment_properties() by
 399  * HarfBuzz itself.
 400  *
 401  * Return value: (transfer none):
 402  *
 403  * Since: 0.9.2
 404  **/
 405 hb_language_t
 406 hb_language_get_default ()
 407 {
 408   static hb_atomic_ptr_t <hb_language_t> default_language;
 409
 410   hb_language_t language = default_language;
 411   if (unlikely (language == HB_LANGUAGE_INVALID))
 412   {
 413     language = hb_language_from_string (setlocale (LC_CTYPE, nullptr), -1);
 414     (void) default_language.cmpexch (HB_LANGUAGE_INVALID, language);
 415   }
 416
 417   return language;
 418 }
 419
 420
 421 /* hb_script_t */
 422
 423 /**
 424  * hb_script_from_iso15924_tag:
 425  * @tag: an #hb_tag_t representing an ISO 15924 tag.
 426  *
 427  * Converts an ISO 15924 script tag to a corresponding #hb_script_t.
 428  *
 429  * Return value:
 430  * An #hb_script_t corresponding to the ISO 15924 tag.
 431  *
 432  * Since: 0.9.2
 433  **/
 434 hb_script_t
 435 hb_script_from_iso15924_tag (hb_tag_t tag)
 436 {
 437   if (unlikely (tag == HB_TAG_NONE))
 438     return HB_SCRIPT_INVALID;
 439
 440   /* Be lenient, adjust case (one capital letter followed by three small letters) */
 441   tag = (tag & 0xDFDFDFDFu) | 0x00202020u;
 442
 443   switch (tag) {
 444
 445     /* These graduated from the 'Q' private-area codes, but
 446      * the old code is still aliased by Unicode, and the Qaai
 447      * one in use by ICU. */
 448     case HB_TAG('Q','a','a','i'): return HB_SCRIPT_INHERITED;
 449     case HB_TAG('Q','a','a','c'): return HB_SCRIPT_COPTIC;
 450
 451     /* Script variants from https://unicode.org/iso15924/ */
 452     case HB_TAG('C','y','r','s'): return HB_SCRIPT_CYRILLIC;
 453     case HB_TAG('L','a','t','f'): return HB_SCRIPT_LATIN;
 454     case HB_TAG('L','a','t','g'): return HB_SCRIPT_LATIN;
 455     case HB_TAG('S','y','r','e'): return HB_SCRIPT_SYRIAC;
 456     case HB_TAG('S','y','r','j'): return HB_SCRIPT_SYRIAC;
 457     case HB_TAG('S','y','r','n'): return HB_SCRIPT_SYRIAC;
 458   }
 459
 460   /* If it looks right, just use the tag as a script */
 461   if (((uint32_t) tag & 0xE0E0E0E0u) == 0x40606060u)
 462     return (hb_script_t) tag;
 463
 464   /* Otherwise, return unknown */
 465   return HB_SCRIPT_UNKNOWN;
 466 }
 467
 468 /**
 469  * hb_script_from_string:
 470  * @str: (array length=len) (element-type uint8_t): a string representing an
 471  *       ISO 15924 tag.
 472  * @len: length of the @str, or -1 if it is %NULL-terminated.
 473  *
 474  * Converts a string @str representing an ISO 15924 script tag to a
 475  * corresponding #hb_script_t. Shorthand for hb_tag_from_string() then
 476  * hb_script_from_iso15924_tag().
 477  *
 478  * Return value:
 479  * An #hb_script_t corresponding to the ISO 15924 tag.
 480  *
 481  * Since: 0.9.2
 482  **/
 483 hb_script_t
 484 hb_script_from_string (const char *str, int len)
 485 {
 486   return hb_script_from_iso15924_tag (hb_tag_from_string (str, len));
 487 }
 488
 489 /**
 490  * hb_script_to_iso15924_tag:
 491  * @script: an #hb_script_ to convert.
 492  *
 493  * See hb_script_from_iso15924_tag().
 494  *
 495  * Return value:
 496  * An #hb_tag_t representing an ISO 15924 script tag.
 497  *
 498  * Since: 0.9.2
 499  **/
 500 hb_tag_t
 501 hb_script_to_iso15924_tag (hb_script_t script)
 502 {
 503   return (hb_tag_t) script;
 504 }
 505
 506 /**
 507  * hb_script_get_horizontal_direction:
 508  * @script:
 509  *
 510  *
 511  *
 512  * Return value:
 513  *
 514  * Since: 0.9.2
 515  **/
 516 hb_direction_t
 517 hb_script_get_horizontal_direction (hb_script_t script)
 518 {
 519   /* https://docs.google.com/spreadsheets/d/1Y90M0Ie3MUJ6UVCRDOypOtijlMDLNNyyLk36T6iMu0o */
 520   switch ((hb_tag_t) script)
 521   {
 522     /* Unicode-1.1 additions */
 523     case HB_SCRIPT_ARABIC:
 524     case HB_SCRIPT_HEBREW:
 525
 526     /* Unicode-3.0 additions */
 527     case HB_SCRIPT_SYRIAC:
 528     case HB_SCRIPT_THAANA:
 529
 530     /* Unicode-4.0 additions */
 531     case HB_SCRIPT_CYPRIOT:
 532
 533     /* Unicode-4.1 additions */
 534     case HB_SCRIPT_KHAROSHTHI:
 535
 536     /* Unicode-5.0 additions */
 537     case HB_SCRIPT_PHOENICIAN:
 538     case HB_SCRIPT_NKO:
 539
 540     /* Unicode-5.1 additions */
 541     case HB_SCRIPT_LYDIAN:
 542
 543     /* Unicode-5.2 additions */
 544     case HB_SCRIPT_AVESTAN:
 545     case HB_SCRIPT_IMPERIAL_ARAMAIC:
 546     case HB_SCRIPT_INSCRIPTIONAL_PAHLAVI:
 547     case HB_SCRIPT_INSCRIPTIONAL_PARTHIAN:
 548     case HB_SCRIPT_OLD_SOUTH_ARABIAN:
 549     case HB_SCRIPT_OLD_TURKIC:
 550     case HB_SCRIPT_SAMARITAN:
 551
 552     /* Unicode-6.0 additions */
 553     case HB_SCRIPT_MANDAIC:
 554
 555     /* Unicode-6.1 additions */
 556     case HB_SCRIPT_MEROITIC_CURSIVE:
 557     case HB_SCRIPT_MEROITIC_HIEROGLYPHS:
 558
 559     /* Unicode-7.0 additions */
 560     case HB_SCRIPT_MANICHAEAN:
 561     case HB_SCRIPT_MENDE_KIKAKUI:
 562     case HB_SCRIPT_NABATAEAN:
 563     case HB_SCRIPT_OLD_NORTH_ARABIAN:
 564     case HB_SCRIPT_PALMYRENE:
 565     case HB_SCRIPT_PSALTER_PAHLAVI:
 566
 567     /* Unicode-8.0 additions */
 568     case HB_SCRIPT_HATRAN:
 569
 570     /* Unicode-9.0 additions */
 571     case HB_SCRIPT_ADLAM:
 572
 573     /* Unicode-11.0 additions */
 574     case HB_SCRIPT_HANIFI_ROHINGYA:
 575     case HB_SCRIPT_OLD_SOGDIAN:
 576     case HB_SCRIPT_SOGDIAN:
 577
 578       return HB_DIRECTION_RTL;
 579
 580
 581     /* https://github.com/harfbuzz/harfbuzz/issues/1000 */
 582     case HB_SCRIPT_OLD_HUNGARIAN:
 583     case HB_SCRIPT_OLD_ITALIC:
 584     case HB_SCRIPT_RUNIC:
 585
 586       return HB_DIRECTION_INVALID;
 587   }
 588
 589   return HB_DIRECTION_LTR;
 590 }
 591
 592
 593 /* hb_user_data_array_t */
 594
 595 bool
 596 hb_user_data_array_t::set (hb_user_data_key_t *key,
 597                            void *              data,
 598                            hb_destroy_func_t   destroy,
 599                            hb_bool_t           replace)
 600 {
 601   if (!key)
 602     return false;
 603
 604   if (replace) {
 605     if (!data && !destroy) {
 606       items.remove (key, lock);
 607       return true;
 608     }
 609   }
 610   hb_user_data_item_t item = {key, data, destroy};
 611   bool ret = !!items.replace_or_insert (item, lock, (bool) replace);
 612
 613   return ret;
 614 }
 615
 616 void *
 617 hb_user_data_array_t::get (hb_user_data_key_t *key)
 618 {
 619   hb_user_data_item_t item = {nullptr, nullptr, nullptr};
 620
 621   return items.find (key, &item, lock) ? item.data : nullptr;
 622 }
 623
 624
 625 /* hb_version */
 626
 627
 628 /**
 629  * SECTION:hb-version
 630  * @title: hb-version
 631  * @short_description: Information about the version of HarfBuzz in use
 632  * @include: hb.h
 633  *
 634  * These functions and macros allow accessing version of the HarfBuzz
 635  * library used at compile- as well as run-time, and to direct code
 636  * conditionally based on those versions, again, at compile- or run-time.
 637  **/
 638
 639
 640 /**
 641  * hb_version:
 642  * @major: (out): Library major version component.
 643  * @minor: (out): Library minor version component.
 644  * @micro: (out): Library micro version component.
 645  *
 646  * Returns library version as three integer components.
 647  *
 648  * Since: 0.9.2
 649  **/
 650 void
 651 hb_version (unsigned int *major,
 652             unsigned int *minor,
 653             unsigned int *micro)
 654 {
 655   *major = HB_VERSION_MAJOR;
 656   *minor = HB_VERSION_MINOR;
 657   *micro = HB_VERSION_MICRO;
 658 }
 659
 660 /**
 661  * hb_version_string:
 662  *
 663  * Returns library version as a string with three components.
 664  *
 665  * Return value: library version string.
 666  *
 667  * Since: 0.9.2
 668  **/
 669 const char *
 670 hb_version_string ()
 671 {
 672   return HB_VERSION_STRING;
 673 }
 674
 675 /**
 676  * hb_version_atleast:
 677  * @major:
 678  * @minor:
 679  * @micro:
 680  *
 681  *
 682  *
 683  * Return value:
 684  *
 685  * Since: 0.9.30
 686  **/
 687 hb_bool_t
 688 hb_version_atleast (unsigned int major,
 689                     unsigned int minor,
 690                     unsigned int micro)
 691 {
 692   return HB_VERSION_ATLEAST (major, minor, micro);
 693 }
 694
 695
 696
 697 /* hb_feature_t and hb_variation_t */
 698
 699 static bool
 700 parse_space (const char **pp, const char *end)
 701 {
 702   while (*pp < end && ISSPACE (**pp))
 703     (*pp)++;
 704   return true;
 705 }
 706
 707 static bool
 708 parse_char (const char **pp, const char *end, char c)
 709 {
 710   parse_space (pp, end);
 711
 712   if (*pp == end || **pp != c)
 713     return false;
 714
 715   (*pp)++;
 716   return true;
 717 }
 718
 719 static bool
 720 parse_uint (const char **pp, const char *end, unsigned int *pv)
 721 {
 722   char buf[32];
 723   unsigned int len = MIN (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - *pp));
 724   strncpy (buf, *pp, len);
 725   buf[len] = '\0';
 726
 727   char *p = buf;
 728   char *pend = p;
 729   unsigned int v;
 730
 731   /* Intentionally use strtol instead of strtoul, such that
 732    * -1 turns into "big number"... */
 733   errno = 0;
 734   v = strtol (p, &pend, 0);
 735   if (errno || p == pend)
 736     return false;
 737
 738   *pv = v;
 739   *pp += pend - p;
 740   return true;
 741 }
 742
 743 static bool
 744 parse_uint32 (const char **pp, const char *end, uint32_t *pv)
 745 {
 746   char buf[32];
 747   unsigned int len = MIN (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - *pp));
 748   strncpy (buf, *pp, len);
 749   buf[len] = '\0';
 750
 751   char *p = buf;
 752   char *pend = p;
 753   unsigned int v;
 754
 755   /* Intentionally use strtol instead of strtoul, such that
 756    * -1 turns into "big number"... */
 757   errno = 0;
 758   v = strtol (p, &pend, 0);
 759   if (errno || p == pend)
 760     return false;
 761
 762   *pv = v;
 763   *pp += pend - p;
 764   return true;
 765 }
 766
 767 #if defined (HAVE_NEWLOCALE) && defined (HAVE_STRTOD_L)
 768 #define USE_XLOCALE 1
 769 #define HB_LOCALE_T locale_t
 770 #define HB_CREATE_LOCALE(locName) newlocale (LC_ALL_MASK, locName, nullptr)
 771 #define HB_FREE_LOCALE(loc) freelocale (loc)
 772 #elif defined(_MSC_VER)
 773 #define USE_XLOCALE 1
 774 #define HB_LOCALE_T _locale_t
 775 #define HB_CREATE_LOCALE(locName) _create_locale (LC_ALL, locName)
 776 #define HB_FREE_LOCALE(loc) _free_locale (loc)
 777 #define strtod_l(a, b, c) _strtod_l ((a), (b), (c))
 778 #endif
 779
 780 #ifdef USE_XLOCALE
 781
 782 #if HB_USE_ATEXIT
 783 static void free_static_C_locale ();
 784 #endif
 785
 786 static struct hb_C_locale_lazy_loader_t : hb_lazy_loader_t<hb_remove_pointer (HB_LOCALE_T),
 787                                                           hb_C_locale_lazy_loader_t>
 788 {
 789   static HB_LOCALE_T create ()
 790   {
 791     HB_LOCALE_T C_locale = HB_CREATE_LOCALE ("C");
 792
 793 #if HB_USE_ATEXIT
 794     atexit (free_static_C_locale);
 795 #endif
 796
 797     return C_locale;
 798   }
 799   static void destroy (HB_LOCALE_T p)
 800   {
 801     HB_FREE_LOCALE (p);
 802   }
 803   static HB_LOCALE_T get_null ()
 804   {
 805     return nullptr;
 806   }
 807 } static_C_locale;
 808
 809 #if HB_USE_ATEXIT
 810 static
 811 void free_static_C_locale ()
 812 {
 813   static_C_locale.free_instance ();
 814 }
 815 #endif
 816
 817 static HB_LOCALE_T
 818 get_C_locale ()
 819 {
 820   return static_C_locale.get_unconst ();
 821 }
 822 #endif /* USE_XLOCALE */
 823
 824 static bool
 825 parse_float (const char **pp, const char *end, float *pv)
 826 {
 827   char buf[32];
 828   unsigned int len = MIN (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - *pp));
 829   strncpy (buf, *pp, len);
 830   buf[len] = '\0';
 831
 832   char *p = buf;
 833   char *pend = p;
 834   float v;
 835
 836   errno = 0;
 837 #ifdef USE_XLOCALE
 838   v = strtod_l (p, &pend, get_C_locale ());
 839 #else
 840   v = strtod (p, &pend);
 841 #endif
 842   if (errno || p == pend)
 843     return false;
 844
 845   *pv = v;
 846   *pp += pend - p;
 847   return true;
 848 }
 849
 850 static bool
 851 parse_bool (const char **pp, const char *end, uint32_t *pv)
 852 {
 853   parse_space (pp, end);
 854
 855   const char *p = *pp;
 856   while (*pp < end && ISALPHA(**pp))
 857     (*pp)++;
 858
 859   /* CSS allows on/off as aliases 1/0. */
 860   if (*pp - p == 2 && 0 == strncmp (p, "on", 2))
 861     *pv = 1;
 862   else if (*pp - p == 3 && 0 == strncmp (p, "off", 3))
 863     *pv = 0;
 864   else
 865     return false;
 866
 867   return true;
 868 }
 869
 870 /* hb_feature_t */
 871
 872 static bool
 873 parse_feature_value_prefix (const char **pp, const char *end, hb_feature_t *feature)
 874 {
 875   if (parse_char (pp, end, '-'))
 876     feature->value = 0;
 877   else {
 878     parse_char (pp, end, '+');
 879     feature->value = 1;
 880   }
 881
 882   return true;
 883 }
 884
 885 static bool
 886 parse_tag (const char **pp, const char *end, hb_tag_t *tag)
 887 {
 888   parse_space (pp, end);
 889
 890   char quote = 0;
 891
 892   if (*pp < end && (**pp == '\'' || **pp == '"'))
 893   {
 894     quote = **pp;
 895     (*pp)++;
 896   }
 897
 898   const char *p = *pp;
 899   while (*pp < end && (ISALNUM(**pp) || **pp == '_'))
 900     (*pp)++;
 901
 902   if (p == *pp || *pp - p > 4)
 903     return false;
 904
 905   *tag = hb_tag_from_string (p, *pp - p);
 906
 907   if (quote)
 908   {
 909     /* CSS expects exactly four bytes.  And we only allow quotations for
 910      * CSS compatibility.  So, enforce the length. */
 911      if (*pp - p != 4)
 912        return false;
 913     if (*pp == end || **pp != quote)
 914       return false;
 915     (*pp)++;
 916   }
 917
 918   return true;
 919 }
 920
 921 static bool
 922 parse_feature_indices (const char **pp, const char *end, hb_feature_t *feature)
 923 {
 924   parse_space (pp, end);
 925
 926   bool has_start;
 927
 928   feature->start = HB_FEATURE_GLOBAL_START;
 929   feature->end = HB_FEATURE_GLOBAL_END;
 930
 931   if (!parse_char (pp, end, '['))
 932     return true;
 933
 934   has_start = parse_uint (pp, end, &feature->start);
 935
 936   if (parse_char (pp, end, ':') || parse_char (pp, end, ';')) {
 937     parse_uint (pp, end, &feature->end);
 938   } else {
 939     if (has_start)
 940       feature->end = feature->start + 1;
 941   }
 942
 943   return parse_char (pp, end, ']');
 944 }
 945
 946 static bool
 947 parse_feature_value_postfix (const char **pp, const char *end, hb_feature_t *feature)
 948 {
 949   bool had_equal = parse_char (pp, end, '=');
 950   bool had_value = parse_uint32 (pp, end, &feature->value) ||
 951                    parse_bool (pp, end, &feature->value);
 952   /* CSS doesn't use equal-sign between tag and value.
 953    * If there was an equal-sign, then there *must* be a value.
 954    * A value without an equal-sign is ok, but not required. */
 955   return !had_equal || had_value;
 956 }
 957
 958 static bool
 959 parse_one_feature (const char **pp, const char *end, hb_feature_t *feature)
 960 {
 961   return parse_feature_value_prefix (pp, end, feature) &&
 962          parse_tag (pp, end, &feature->tag) &&
 963          parse_feature_indices (pp, end, feature) &&
 964          parse_feature_value_postfix (pp, end, feature) &&
 965          parse_space (pp, end) &&
 966          *pp == end;
 967 }
 968
 969 /**
 970  * hb_feature_from_string:
 971  * @str: (array length=len) (element-type uint8_t): a string to parse
 972  * @len: length of @str, or -1 if string is %NULL terminated
 973  * @feature: (out): the #hb_feature_t to initialize with the parsed values
 974  *
 975  * Parses a string into a #hb_feature_t.
 976  *
 977  * TODO: document the syntax here.
 978  *
 979  * Return value:
 980  * %true if @str is successfully parsed, %false otherwise.
 981  *
 982  * Since: 0.9.5
 983  **/
 984 hb_bool_t
 985 hb_feature_from_string (const char *str, int len,
 986                         hb_feature_t *feature)
 987 {
 988   hb_feature_t feat;
 989
 990   if (len < 0)
 991     len = strlen (str);
 992
 993   if (likely (parse_one_feature (&str, str + len, &feat)))
 994   {
 995     if (feature)
 996       *feature = feat;
 997     return true;
 998   }
 999
1000   if (feature)
1001     memset (feature, 0, sizeof (*feature));
1002   return false;
1003 }
1004
1005 /**
1006  * hb_feature_to_string:
1007  * @feature: an #hb_feature_t to convert
1008  * @buf: (array length=size) (out): output string
1009  * @size: the allocated size of @buf
1010  *
1011  * Converts a #hb_feature_t into a %NULL-terminated string in the format
1012  * understood by hb_feature_from_string(). The client in responsible for
1013  * allocating big enough size for @buf, 128 bytes is more than enough.
1014  *
1015  * Since: 0.9.5
1016  **/
1017 void
1018 hb_feature_to_string (hb_feature_t *feature,
1019                       char *buf, unsigned int size)
1020 {
1021   if (unlikely (!size)) return;
1022
1023   char s[128];
1024   unsigned int len = 0;
1025   if (feature->value == 0)
1026     s[len++] = '-';
1027   hb_tag_to_string (feature->tag, s + len);
1028   len += 4;
1029   while (len && s[len - 1] == ' ')
1030     len--;
1031   if (feature->start != 0 || feature->end != (unsigned int) -1)
1032   {
1033     s[len++] = '[';
1034     if (feature->start)
1035       len += MAX (0, snprintf (s + len, ARRAY_LENGTH (s) - len, "%u", feature->start));
1036     if (feature->end != feature->start + 1) {
1037       s[len++] = ':';
1038       if (feature->end != (unsigned int) -1)
1039         len += MAX (0, snprintf (s + len, ARRAY_LENGTH (s) - len, "%u", feature->end));
1040     }
1041     s[len++] = ']';
1042   }
1043   if (feature->value > 1)
1044   {
1045     s[len++] = '=';
1046     len += MAX (0, snprintf (s + len, ARRAY_LENGTH (s) - len, "%u", feature->value));
1047   }
1048   assert (len < ARRAY_LENGTH (s));
1049   len = MIN (len, size - 1);
1050   memcpy (buf, s, len);
1051   buf[len] = '\0';
1052 }
1053
1054 /* hb_variation_t */
1055
1056 static bool
1057 parse_variation_value (const char **pp, const char *end, hb_variation_t *variation)
1058 {
1059   parse_char (pp, end, '='); /* Optional. */
1060   return parse_float (pp, end, &variation->value);
1061 }
1062
1063 static bool
1064 parse_one_variation (const char **pp, const char *end, hb_variation_t *variation)
1065 {
1066   return parse_tag (pp, end, &variation->tag) &&
1067          parse_variation_value (pp, end, variation) &&
1068          parse_space (pp, end) &&
1069          *pp == end;
1070 }
1071
1072 /**
1073  * hb_variation_from_string:
1074  *
1075  * Since: 1.4.2
1076  */
1077 hb_bool_t
1078 hb_variation_from_string (const char *str, int len,
1079                           hb_variation_t *variation)
1080 {
1081   hb_variation_t var;
1082
1083   if (len < 0)
1084     len = strlen (str);
1085
1086   if (likely (parse_one_variation (&str, str + len, &var)))
1087   {
1088     if (variation)
1089       *variation = var;
1090     return true;
1091   }
1092
1093   if (variation)
1094     memset (variation, 0, sizeof (*variation));
1095   return false;
1096 }
1097
1098 /**
1099  * hb_variation_to_string:
1100  *
1101  * Since: 1.4.2
1102  */
1103 void
1104 hb_variation_to_string (hb_variation_t *variation,
1105                         char *buf, unsigned int size)
1106 {
1107   if (unlikely (!size)) return;
1108
1109   char s[128];
1110   unsigned int len = 0;
1111   hb_tag_to_string (variation->tag, s + len);
1112   len += 4;
1113   while (len && s[len - 1] == ' ')
1114     len--;
1115   s[len++] = '=';
1116   len += MAX (0, snprintf (s + len, ARRAY_LENGTH (s) - len, "%g", (double) variation->value));
1117
1118   assert (len < ARRAY_LENGTH (s));
1119   len = MIN (len, size - 1);
1120   memcpy (buf, s, len);
1121   buf[len] = '\0';
1122 }
1123
1124 /* If there is no visibility control, then hb-static.cc will NOT
1125  * define anything.  Instead, we get it to define one set in here
1126  * only, so only libharfbuzz.so defines them, not other libs. */
1127 #ifdef HB_NO_VISIBILITY
1128 #undef HB_NO_VISIBILITY
1129 #include "hb-static.cc"
1130 #define HB_NO_VISIBILITY 1
1131 #endif