Roll HarfBuzz to 0.9.32

third_party/harfbuzz-ng/src/hb-ot-tag.cc

 /*
  * 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
@@ skipping 39 matching lines @@
     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',' ');
     /* Unicode-5.2 additions */
     /* Unicode-6.0 additions */
   }
 
   /* Else, just change first char to lowercase and return */
-  return ((hb_tag_t) script) | 0x20000000;
+  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 & 0x0000FF00) == 0x00002000))
-    tag |= (tag >> 8) & 0x0000FF00; /* Copy second letter to third */
-  if (unlikely ((tag & 0x000000FF) == 0x00000020))
-    tag |= (tag >> 8) & 0x000000FF; /* Copy third letter to fourth */
+  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 & ~0x20000000);
+  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');
@@ skipping 49 matching lines @@
   new_tag = hb_ot_new_tag_from_script (script);
   if (unlikely (new_tag != HB_OT_TAG_DEFAULT_SCRIPT)) {
     *script_tag_2 = *script_tag_1;
     *script_tag_1 = new_tag;
   }
 }
 
 hb_script_t
 hb_ot_tag_to_script (hb_tag_t tag)
 {
-  if (unlikely ((tag & 0x000000FF) == '2'))
+  if (unlikely ((tag & 0x000000FFu) == '2'))
     return hb_ot_new_tag_to_script (tag);
 
   return hb_ot_old_tag_to_script (tag);
 }
 
 
 /* hb_language_t */
 
 typedef struct {
-  char language[6];
+  char language[4];
   hb_tag_t tag;
 } LangTag;
 
 /*
  * Complete list at:
  * http://www.microsoft.com/typography/otspec/languagetags.htm
  *
  * Generated by intersecting the OpenType language tag list from
  * Draft OpenType 1.5 spec, with with the ISO 639-3 codes from
  * 2008-08-04, matching on name, and finally adjusted manually.
@@ skipping 586 matching lines @@
 /*{"??",        HB_TAG('T','C','R',' ')},*/     /* TH-Cree */
 /*{"tnz?/tog?/toi?",    HB_TAG('T','N','G',' ')},*/     /* Tonga */
 /*{"enh?/yrk?", HB_TAG('T','N','E',' ')},*/     /* Tundra Nenets */
 /*{"??",        HB_TAG('W','C','R',' ')},*/     /* West-Cree */
 /*{"cre?",      HB_TAG('Y','C','R',' ')},*/     /* Y-Cree */
 /*{"??",        HB_TAG('Y','I','C',' ')},*/     /* Yi Classic */
 /*{"ii?/Yiii?", HB_TAG('Y','I','M',' ')},*/     /* Yi Modern */
 /*{"??",        HB_TAG('Z','H','P',' ')},*/     /* Chinese Phonetic */
 };
 
-static const LangTag ot_languages_zh[] = {
+typedef struct {
+  char language[8];
+  hb_tag_t tag;
+} LangTagLong;
+static const LangTagLong ot_languages_zh[] = {
   {"zh-cn",     HB_TAG('Z','H','S',' ')},       /* Chinese (China) */
   {"zh-hk",     HB_TAG('Z','H','H',' ')},       /* Chinese (Hong Kong) */
   {"zh-mo",     HB_TAG('Z','H','T',' ')},       /* Chinese (Macao) */
   {"zh-sg",     HB_TAG('Z','H','S',' ')},       /* Chinese (Singapore) */
-  {"zh-tw",     HB_TAG('Z','H','T',' ')}        /* Chinese (Taiwan) */
+  {"zh-tw",     HB_TAG('Z','H','T',' ')},       /* Chinese (Taiwan) */
+  {"zh-hans",   HB_TAG('Z','H','S',' ')},       /* Chinese (Simplified) */
+  {"zh-hant",   HB_TAG('Z','H','T',' ')},       /* Chinese (Traditional) */
 };
 
 static int
 lang_compare_first_component (const char *a,
                               const char *b)
 {
   unsigned int da, db;
   const char *p;
 
   p = strchr (a, '-');
@@ skipping 11 matching lines @@
   unsigned int len = strlen (spec);
 
   return strncmp (lang_str, spec, len) == 0 &&
          (lang_str[len] == '\0' || lang_str[len] == '-');
 }
 
 hb_tag_t
 hb_ot_tag_from_language (hb_language_t language)
 {
   const char *lang_str, *s;
-  const LangTag *lang_tag;
 
   if (language == HB_LANGUAGE_INVALID)
     return HB_OT_TAG_DEFAULT_LANGUAGE;
 
   lang_str = hb_language_to_string (language);
 
   s = strstr (lang_str, "x-hbot");
   if (s) {
     char tag[4];
     int i;
     s += 6;
     for (i = 0; i < 4 && ISALPHA (s[i]); i++)
       tag[i] = TOUPPER (s[i]);
     if (i) {
       for (; i < 4; i++)
         tag[i] = ' ';
       return HB_TAG_CHAR4 (tag);
     }
   }
 
   /* Find a language matching in the first component */
-  lang_tag = (LangTag *) bsearch (lang_str, ot_languages,
-                                  ARRAY_LENGTH (ot_languages), sizeof (LangTag),
-                                  (hb_compare_func_t) lang_compare_first_component);
-  if (lang_tag)
-    return lang_tag->tag;
+  {
+    const LangTag *lang_tag;
+    lang_tag = (LangTag *) bsearch (lang_str, ot_languages,
+                                    ARRAY_LENGTH (ot_languages), sizeof (LangTag),
+                                    (hb_compare_func_t) lang_compare_first_component);
+    if (lang_tag)
+      return lang_tag->tag;
+  }
 
   /* Otherwise, check the Chinese ones */
   if (0 == lang_compare_first_component (lang_str, "zh"))
   {
     unsigned int i;
 
     for (i = 0; i < ARRAY_LENGTH (ot_languages_zh); i++)
     {
+      const LangTagLong *lang_tag;
       lang_tag = &ot_languages_zh[i];
-      if (lang_matches (lang_tag->language, lang_str))
+      if (lang_matches (lang_str, lang_tag->language))
         return lang_tag->tag;
     }
 
     /* Otherwise just return 'ZHS ' */
     return HB_TAG('Z','H','S',' ');
   }
 
   s = strchr (lang_str, '-');
   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. */
-    return hb_tag_from_string (lang_str, s - lang_str) & ~0x20202000;
+    return hb_tag_from_string (lang_str, s - lang_str) & ~0x20202000u;
   }
 
   return HB_OT_TAG_DEFAULT_LANGUAGE;
 }
 
 hb_language_t
 hb_ot_tag_to_language (hb_tag_t tag)
 {
   unsigned int i;
 
   if (tag == HB_OT_TAG_DEFAULT_LANGUAGE)
     return NULL;
 
   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);
 
   /* If tag starts with ZH, it's Chinese */
-  if ((tag & 0xFFFF0000)  == 0x5A480000) {
+  if ((tag & 0xFFFF0000u)  == 0x5A480000u) {
     switch (tag) {
       case HB_TAG('Z','H','H',' '): return hb_language_from_string ("zh-hk", -1); /* Hong Kong */
-      default: {
-        /* Encode the tag... */
-        unsigned char buf[14] = "zh-x-hbot";
-        buf[9] = tag >> 24;
-        buf[10] = (tag >> 16) & 0xFF;
-        buf[11] = (tag >> 8) & 0xFF;
-        buf[12] = tag & 0xFF;
-        if (buf[12] == 0x20)
-          buf[12] = '\0';
-        buf[13] = '\0';
-        return hb_language_from_string ((char *) buf, -1);
-      }
+      case HB_TAG('Z','H','S',' '): return hb_language_from_string ("zh-Hans", -1); /* Simplified */
+      case HB_TAG('Z','H','T',' '): return hb_language_from_string ("zh-Hant", -1); /* Traditional */
+      default: break; /* Fall through */
     }
   }
 
   /* Else return a custom language in the form of "x-hbotABCD" */
   {
     unsigned char buf[11] = "x-hbot";
     buf[6] = tag >> 24;
     buf[7] = (tag >> 16) & 0xFF;
     buf[8] = (tag >> 8) & 0xFF;
     buf[9] = tag & 0xFF;
     if (buf[9] == 0x20)
       buf[9] = '\0';
     buf[10] = '\0';
     return hb_language_from_string ((char *) buf, -1);
   }
 }