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