/* * Copyright © 2009 Red Hat, Inc. * Copyright © 2011 Google, Inc. * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Red Hat Author(s): Behdad Esfahbod * Google Author(s): Behdad Esfahbod, Roozbeh Pournader */ #include "hb.hh" #ifndef HB_NO_OT_TAG /* hb_script_t */ static hb_tag_t hb_ot_old_tag_from_script (hb_script_t script) { /* This seems to be accurate as of end of 2012. */ switch ((hb_tag_t) script) { case HB_SCRIPT_INVALID: return HB_OT_TAG_DEFAULT_SCRIPT; /* KATAKANA and HIRAGANA both map to 'kana' */ case HB_SCRIPT_HIRAGANA: return HB_TAG('k','a','n','a'); /* Spaces at the end are preserved, unlike ISO 15924 */ case HB_SCRIPT_LAO: return HB_TAG('l','a','o',' '); case HB_SCRIPT_YI: return HB_TAG('y','i',' ',' '); /* Unicode-5.0 additions */ case HB_SCRIPT_NKO: return HB_TAG('n','k','o',' '); /* Unicode-5.1 additions */ case HB_SCRIPT_VAI: return HB_TAG('v','a','i',' '); } /* Else, just change first char to lowercase and return */ return ((hb_tag_t) script) | 0x20000000u; } static hb_script_t hb_ot_old_tag_to_script (hb_tag_t tag) { if (unlikely (tag == HB_OT_TAG_DEFAULT_SCRIPT)) return HB_SCRIPT_INVALID; /* This side of the conversion is fully algorithmic. */ /* Any spaces at the end of the tag are replaced by repeating the last * letter. Eg 'nko ' -> 'Nkoo' */ if (unlikely ((tag & 0x0000FF00u) == 0x00002000u)) tag |= (tag >> 8) & 0x0000FF00u; /* Copy second letter to third */ if (unlikely ((tag & 0x000000FFu) == 0x00000020u)) tag |= (tag >> 8) & 0x000000FFu; /* Copy third letter to fourth */ /* Change first char to uppercase and return */ return (hb_script_t) (tag & ~0x20000000u); } static hb_tag_t hb_ot_new_tag_from_script (hb_script_t script) { switch ((hb_tag_t) script) { case HB_SCRIPT_BENGALI: return HB_TAG('b','n','g','2'); case HB_SCRIPT_DEVANAGARI: return HB_TAG('d','e','v','2'); case HB_SCRIPT_GUJARATI: return HB_TAG('g','j','r','2'); case HB_SCRIPT_GURMUKHI: return HB_TAG('g','u','r','2'); case HB_SCRIPT_KANNADA: return HB_TAG('k','n','d','2'); case HB_SCRIPT_MALAYALAM: return HB_TAG('m','l','m','2'); case HB_SCRIPT_ORIYA: return HB_TAG('o','r','y','2'); case HB_SCRIPT_TAMIL: return HB_TAG('t','m','l','2'); case HB_SCRIPT_TELUGU: return HB_TAG('t','e','l','2'); case HB_SCRIPT_MYANMAR: return HB_TAG('m','y','m','2'); } return HB_OT_TAG_DEFAULT_SCRIPT; } static hb_script_t hb_ot_new_tag_to_script (hb_tag_t tag) { switch (tag) { case HB_TAG('b','n','g','2'): return HB_SCRIPT_BENGALI; case HB_TAG('d','e','v','2'): return HB_SCRIPT_DEVANAGARI; case HB_TAG('g','j','r','2'): return HB_SCRIPT_GUJARATI; case HB_TAG('g','u','r','2'): return HB_SCRIPT_GURMUKHI; case HB_TAG('k','n','d','2'): return HB_SCRIPT_KANNADA; case HB_TAG('m','l','m','2'): return HB_SCRIPT_MALAYALAM; case HB_TAG('o','r','y','2'): return HB_SCRIPT_ORIYA; case HB_TAG('t','m','l','2'): return HB_SCRIPT_TAMIL; case HB_TAG('t','e','l','2'): return HB_SCRIPT_TELUGU; case HB_TAG('m','y','m','2'): return HB_SCRIPT_MYANMAR; } return HB_SCRIPT_UNKNOWN; } #ifndef HB_DISABLE_DEPRECATED void hb_ot_tags_from_script (hb_script_t script, hb_tag_t *script_tag_1, hb_tag_t *script_tag_2) { unsigned int count = 2; hb_tag_t tags[2]; hb_ot_tags_from_script_and_language (script, HB_LANGUAGE_INVALID, &count, tags, nullptr, nullptr); *script_tag_1 = count > 0 ? tags[0] : HB_OT_TAG_DEFAULT_SCRIPT; *script_tag_2 = count > 1 ? tags[1] : HB_OT_TAG_DEFAULT_SCRIPT; } #endif /* * Complete list at: * https://docs.microsoft.com/en-us/typography/opentype/spec/scripttags * * Most of the script tags are the same as the ISO 15924 tag but lowercased. * So we just do that, and handle the exceptional cases in a switch. */ static void hb_ot_all_tags_from_script (hb_script_t script, unsigned int *count /* IN/OUT */, hb_tag_t *tags /* OUT */) { unsigned int i = 0; hb_tag_t new_tag = hb_ot_new_tag_from_script (script); if (unlikely (new_tag != HB_OT_TAG_DEFAULT_SCRIPT)) { /* HB_SCRIPT_MYANMAR maps to 'mym2', but there is no 'mym3'. */ if (new_tag != HB_TAG('m','y','m','2')) tags[i++] = new_tag | '3'; if (*count > i) tags[i++] = new_tag; } if (*count > i) { hb_tag_t old_tag = hb_ot_old_tag_from_script (script); if (old_tag != HB_OT_TAG_DEFAULT_SCRIPT) tags[i++] = old_tag; } *count = i; } /** * hb_ot_tag_to_script: * @tag: a script tag * * Converts a script tag to an #hb_script_t. * * Return value: The #hb_script_t corresponding to @tag. * **/ hb_script_t hb_ot_tag_to_script (hb_tag_t tag) { unsigned char digit = tag & 0x000000FFu; if (unlikely (digit == '2' || digit == '3')) return hb_ot_new_tag_to_script (tag & 0xFFFFFF32); return hb_ot_old_tag_to_script (tag); } /* hb_language_t */ static bool subtag_matches (const char *lang_str, const char *limit, const char *subtag) { do { const char *s = strstr (lang_str, subtag); if (!s || s >= limit) return false; if (!ISALNUM (s[strlen (subtag)])) return true; lang_str = s + strlen (subtag); } while (true); } static hb_bool_t lang_matches (const char *lang_str, const char *spec) { unsigned int len = strlen (spec); return strncmp (lang_str, spec, len) == 0 && (lang_str[len] == '\0' || lang_str[len] == '-'); } struct LangTag { char language[4]; hb_tag_t tag; int cmp (const char *a) const { const char *b = this->language; unsigned int da, db; const char *p; p = strchr (a, '-'); da = p ? (unsigned int) (p - a) : strlen (a); p = strchr (b, '-'); db = p ? (unsigned int) (p - b) : strlen (b); return strncmp (a, b, hb_max (da, db)); } int cmp (const LangTag *that) const { return cmp (that->language); } }; #include "hb-ot-tag-table.hh" /* The corresponding languages IDs for the following IDs are unclear, * overlap, or are architecturally weird. Needs more research. */ /*{"??", {HB_TAG('B','C','R',' ')}},*/ /* Bible Cree */ /*{"zh?", {HB_TAG('C','H','N',' ')}},*/ /* Chinese (seen in Microsoft fonts) */ /*{"ar-Syrc?", {HB_TAG('G','A','R',' ')}},*/ /* Garshuni */ /*{"??", {HB_TAG('N','G','R',' ')}},*/ /* Nagari */ /*{"??", {HB_TAG('Y','I','C',' ')}},*/ /* Yi Classic */ /*{"zh?", {HB_TAG('Z','H','P',' ')}},*/ /* Chinese Phonetic */ #ifndef HB_DISABLE_DEPRECATED hb_tag_t hb_ot_tag_from_language (hb_language_t language) { unsigned int count = 1; hb_tag_t tags[1]; hb_ot_tags_from_script_and_language (HB_SCRIPT_UNKNOWN, language, nullptr, nullptr, &count, tags); return count > 0 ? tags[0] : HB_OT_TAG_DEFAULT_LANGUAGE; } #endif static void hb_ot_tags_from_language (const char *lang_str, const char *limit, unsigned int *count, hb_tag_t *tags) { const char *s; unsigned int tag_idx; /* Check for matches of multiple subtags. */ if (hb_ot_tags_from_complex_language (lang_str, limit, count, tags)) return; /* Find a language matching in the first component. */ s = strchr (lang_str, '-'); { if (s && limit - lang_str >= 6) { const char *extlang_end = strchr (s + 1, '-'); /* If there is an extended language tag, use it. */ if (3 == (extlang_end ? extlang_end - s - 1 : strlen (s + 1)) && ISALPHA (s[1])) lang_str = s + 1; } if (hb_sorted_array (ot_languages).bfind (lang_str, &tag_idx)) { unsigned int i; while (tag_idx != 0 && 0 == strcmp (ot_languages[tag_idx].language, ot_languages[tag_idx - 1].language)) tag_idx--; for (i = 0; i < *count && tag_idx + i < ARRAY_LENGTH (ot_languages) && ot_languages[tag_idx + i].tag != HB_TAG_NONE && 0 == strcmp (ot_languages[tag_idx + i].language, ot_languages[tag_idx].language); i++) tags[i] = ot_languages[tag_idx + i].tag; *count = i; return; } } if (!s) s = lang_str + strlen (lang_str); if (s - lang_str == 3) { /* Assume it's ISO-639-3 and upper-case and use it. */ tags[0] = hb_tag_from_string (lang_str, s - lang_str) & ~0x20202000u; *count = 1; return; } *count = 0; } static bool parse_private_use_subtag (const char *private_use_subtag, unsigned int *count, hb_tag_t *tags, const char *prefix, unsigned char (*normalize) (unsigned char)) { #ifdef HB_NO_LANGUAGE_PRIVATE_SUBTAG return false; #endif if (!(private_use_subtag && count && tags && *count)) return false; const char *s = strstr (private_use_subtag, prefix); if (!s) return false; char tag[4]; int i; s += strlen (prefix); if (s[0] == '-') { s += 1; char c; for (i = 0; i < 8 && ISHEX (s[i]); i++) { c = FROMHEX (s[i]); if (i % 2 == 0) tag[i / 2] = c << 4; else tag[i / 2] += c; } if (i != 8) return false; } else { for (i = 0; i < 4 && ISALNUM (s[i]); i++) tag[i] = normalize (s[i]); if (!i) return false; for (; i < 4; i++) tag[i] = ' '; } tags[0] = HB_TAG (tag[0], tag[1], tag[2], tag[3]); if ((tags[0] & 0xDFDFDFDF) == HB_OT_TAG_DEFAULT_SCRIPT) tags[0] ^= ~0xDFDFDFDF; *count = 1; return true; } /** * hb_ot_tags_from_script_and_language: * @script: an #hb_script_t to convert. * @language: an #hb_language_t to convert. * @script_count: (inout) (optional): maximum number of script tags to retrieve (IN) * and actual number of script tags retrieved (OUT) * @script_tags: (out) (optional): array of size at least @script_count to store the * script tag results * @language_count: (inout) (optional): maximum number of language tags to retrieve * (IN) and actual number of language tags retrieved (OUT) * @language_tags: (out) (optional): array of size at least @language_count to store * the language tag results * * Converts an #hb_script_t and an #hb_language_t to script and language tags. * * Since: 2.0.0 **/ void hb_ot_tags_from_script_and_language (hb_script_t script, hb_language_t language, unsigned int *script_count /* IN/OUT */, hb_tag_t *script_tags /* OUT */, unsigned int *language_count /* IN/OUT */, hb_tag_t *language_tags /* OUT */) { bool needs_script = true; if (language == HB_LANGUAGE_INVALID) { if (language_count && language_tags && *language_count) *language_count = 0; } else { const char *lang_str, *s, *limit, *private_use_subtag; bool needs_language; lang_str = hb_language_to_string (language); limit = nullptr; private_use_subtag = nullptr; if (lang_str[0] == 'x' && lang_str[1] == '-') { private_use_subtag = lang_str; } else { for (s = lang_str + 1; *s; s++) { if (s[-1] == '-' && s[1] == '-') { if (s[0] == 'x') { private_use_subtag = s; if (!limit) limit = s - 1; break; } else if (!limit) { limit = s - 1; } } } if (!limit) limit = s; } needs_script = !parse_private_use_subtag (private_use_subtag, script_count, script_tags, "-hbsc", TOLOWER); needs_language = !parse_private_use_subtag (private_use_subtag, language_count, language_tags, "-hbot", TOUPPER); if (needs_language && language_count && language_tags && *language_count) hb_ot_tags_from_language (lang_str, limit, language_count, language_tags); } if (needs_script && script_count && script_tags && *script_count) hb_ot_all_tags_from_script (script, script_count, script_tags); } /** * hb_ot_tag_to_language: * @tag: an language tag * * Converts a language tag to an #hb_language_t. * * Return value: (transfer none) (nullable): * The #hb_language_t corresponding to @tag. * * Since: 0.9.2 **/ hb_language_t hb_ot_tag_to_language (hb_tag_t tag) { unsigned int i; if (tag == HB_OT_TAG_DEFAULT_LANGUAGE) return nullptr; { hb_language_t disambiguated_tag = hb_ot_ambiguous_tag_to_language (tag); if (disambiguated_tag != HB_LANGUAGE_INVALID) return disambiguated_tag; } for (i = 0; i < ARRAY_LENGTH (ot_languages); i++) if (ot_languages[i].tag == tag) return hb_language_from_string (ot_languages[i].language, -1); /* Return a custom language in the form of "x-hbot-AABBCCDD". * If it's three letters long, also guess it's ISO 639-3 and lower-case and * prepend it (if it's not a registered tag, the private use subtags will * ensure that calling hb_ot_tag_from_language on the result will still return * the same tag as the original tag). */ { char buf[20]; char *str = buf; if (ISALPHA (tag >> 24) && ISALPHA ((tag >> 16) & 0xFF) && ISALPHA ((tag >> 8) & 0xFF) && (tag & 0xFF) == ' ') { buf[0] = TOLOWER (tag >> 24); buf[1] = TOLOWER ((tag >> 16) & 0xFF); buf[2] = TOLOWER ((tag >> 8) & 0xFF); buf[3] = '-'; str += 4; } snprintf (str, 16, "x-hbot-%08x", tag); return hb_language_from_string (&*buf, -1); } } /** * hb_ot_tags_to_script_and_language: * @script_tag: a script tag * @language_tag: a language tag * @script: (out) (optional): the #hb_script_t corresponding to @script_tag. * @language: (out) (optional): the #hb_language_t corresponding to @script_tag and * @language_tag. * * Converts a script tag and a language tag to an #hb_script_t and an * #hb_language_t. * * Since: 2.0.0 **/ void hb_ot_tags_to_script_and_language (hb_tag_t script_tag, hb_tag_t language_tag, hb_script_t *script /* OUT */, hb_language_t *language /* OUT */) { hb_script_t script_out = hb_ot_tag_to_script (script_tag); if (script) *script = script_out; if (language) { unsigned int script_count = 1; hb_tag_t primary_script_tag[1]; hb_ot_tags_from_script_and_language (script_out, HB_LANGUAGE_INVALID, &script_count, primary_script_tag, nullptr, nullptr); *language = hb_ot_tag_to_language (language_tag); if (script_count == 0 || primary_script_tag[0] != script_tag) { unsigned char *buf; const char *lang_str = hb_language_to_string (*language); size_t len = strlen (lang_str); buf = (unsigned char *) hb_malloc (len + 16); if (unlikely (!buf)) { *language = nullptr; } else { int shift; memcpy (buf, lang_str, len); if (lang_str[0] != 'x' || lang_str[1] != '-') { buf[len++] = '-'; buf[len++] = 'x'; } buf[len++] = '-'; buf[len++] = 'h'; buf[len++] = 'b'; buf[len++] = 's'; buf[len++] = 'c'; buf[len++] = '-'; for (shift = 28; shift >= 0; shift -= 4) buf[len++] = TOHEX (script_tag >> shift); *language = hb_language_from_string ((char *) buf, len); hb_free (buf); } } } } #ifdef MAIN static inline void test_langs_sorted () { for (unsigned int i = 1; i < ARRAY_LENGTH (ot_languages); i++) { int c = ot_languages[i].cmp (&ot_languages[i - 1]); if (c > 0) { fprintf (stderr, "ot_languages not sorted at index %d: %s %d %s\n", i, ot_languages[i-1].language, c, ot_languages[i].language); abort(); } } } int main () { test_langs_sorted (); return 0; } #endif #endif