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
51hb_atomic_int_t _hb_options;
52
53void
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 **/
100hb_tag_t
101hb_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 **/
128void
129hb_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
140const 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 **/
158hb_direction_t
159hb_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 **/
185const char *
186hb_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
198struct hb_language_impl_t {
199 const char s[1];
200};
201
202static 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
213static bool
214lang_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
229static unsigned int
230lang_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
245struct 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
276static hb_atomic_ptr_t <hb_language_item_t> langs;
277
278#if HB_USE_ATEXIT
279static void
280free_langs ()
281{
282retry:
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
296static hb_language_item_t *
297lang_find_or_insert (const char *key)
298{
299retry:
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 **/
348hb_language_t
349hb_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 **/
382const char *
383hb_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 **/
405hb_language_t
406hb_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 **/
434hb_script_t
435hb_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 **/
483hb_script_t
484hb_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 **/
500hb_tag_t
501hb_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 **/
516hb_direction_t
517hb_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
595bool
596hb_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
616void *
617hb_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 **/
650void
651hb_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 **/
669const char *
670hb_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 **/
687hb_bool_t
688hb_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
699static bool
700parse_space (const char **pp, const char *end)
701{
702 while (*pp < end && ISSPACE (**pp))
703 (*pp)++;
704 return true;
705}
706
707static bool
708parse_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
719static bool
720parse_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
743static bool
744parse_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
783static void free_static_C_locale ();
784#endif
785
786static 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
810static
811void free_static_C_locale ()
812{
813 static_C_locale.free_instance ();
814}
815#endif
816
817static HB_LOCALE_T
818get_C_locale ()
819{
820 return static_C_locale.get_unconst ();
821}
822#endif /* USE_XLOCALE */
823
824static bool
825parse_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
850static bool
851parse_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
872static bool
873parse_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
885static bool
886parse_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
921static bool
922parse_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
946static bool
947parse_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
958static bool
959parse_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 **/
984hb_bool_t
985hb_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 **/
1017void
1018hb_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
1056static bool
1057parse_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
1063static bool
1064parse_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 */
1077hb_bool_t
1078hb_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 */
1103void
1104hb_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