• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
_hb_options_init()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
hb_tag_from_string(const char * str,int len)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
hb_tag_to_string(hb_tag_t tag,char * buf)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
hb_direction_from_string(const char * str,int len)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 *
hb_direction_to_string(hb_direction_t direction)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
lang_equal(hb_language_t v1,const void * v2)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 
operator ==hb_language_item_t250   bool operator == (const char *s) const
251   { return lang_equal (lang, s); }
252 
operator =hb_language_item_t253   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 
finihb_language_item_t270   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
free_langs()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 *
lang_find_or_insert(const char * key)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
hb_language_from_string(const char * str,int len)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 *
hb_language_to_string(hb_language_t language)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
hb_language_get_default()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
hb_script_from_iso15924_tag(hb_tag_t tag)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
hb_script_from_string(const char * str,int len)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
hb_script_to_iso15924_tag(hb_script_t script)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
hb_script_get_horizontal_direction(hb_script_t script)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
set(hb_user_data_key_t * key,void * data,hb_destroy_func_t destroy,hb_bool_t replace)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 *
get(hb_user_data_key_t * key)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
hb_version(unsigned int * major,unsigned int * minor,unsigned int * micro)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 *
hb_version_string()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
hb_version_atleast(unsigned int major,unsigned int minor,unsigned int micro)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
parse_space(const char ** pp,const char * end)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
parse_char(const char ** pp,const char * end,char c)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
parse_uint(const char ** pp,const char * end,unsigned int * pv)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
parse_uint32(const char ** pp,const char * end,uint32_t * pv)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 {
createhb_C_locale_lazy_loader_t789   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   }
destroyhb_C_locale_lazy_loader_t799   static void destroy (HB_LOCALE_T p)
800   {
801     HB_FREE_LOCALE (p);
802   }
get_nullhb_C_locale_lazy_loader_t803   static HB_LOCALE_T get_null ()
804   {
805     return nullptr;
806   }
807 } static_C_locale;
808 
809 #if HB_USE_ATEXIT
810 static
free_static_C_locale()811 void free_static_C_locale ()
812 {
813   static_C_locale.free_instance ();
814 }
815 #endif
816 
817 static HB_LOCALE_T
get_C_locale()818 get_C_locale ()
819 {
820   return static_C_locale.get_unconst ();
821 }
822 #endif /* USE_XLOCALE */
823 
824 static bool
parse_float(const char ** pp,const char * end,float * pv)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
parse_bool(const char ** pp,const char * end,uint32_t * pv)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
parse_feature_value_prefix(const char ** pp,const char * end,hb_feature_t * feature)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
parse_tag(const char ** pp,const char * end,hb_tag_t * tag)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
parse_feature_indices(const char ** pp,const char * end,hb_feature_t * feature)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
parse_feature_value_postfix(const char ** pp,const char * end,hb_feature_t * feature)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
parse_one_feature(const char ** pp,const char * end,hb_feature_t * feature)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
hb_feature_from_string(const char * str,int len,hb_feature_t * feature)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
hb_feature_to_string(hb_feature_t * feature,char * buf,unsigned int size)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
parse_variation_value(const char ** pp,const char * end,hb_variation_t * variation)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
parse_one_variation(const char ** pp,const char * end,hb_variation_t * variation)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
hb_variation_from_string(const char * str,int len,hb_variation_t * variation)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
hb_variation_to_string(hb_variation_t * variation,char * buf,unsigned int size)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
1132