third_party/txt/src/minikin/FontLanguage.cpp - mirrors/engine - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "Minikin"

 #include "FontLanguage.h"

 #include <hb.h>
 #include <string.h>
 #include <unicode/uloc.h>
 #include <algorithm>

 namespace minikin {

 #define SCRIPT_TAG(c1, c2, c3, c4)                                           \
   (((uint32_t)(c1)) << 24 | ((uint32_t)(c2)) << 16 | ((uint32_t)(c3)) << 8 | \
    ((uint32_t)(c4)))

 // Check if a language code supports emoji according to its subtag
 static bool isEmojiSubtag(const char* buf,
                           size_t bufLen,
                           const char* subtag,
                           size_t subtagLen) {
   if (bufLen < subtagLen) {
     return false;
   }
   if (strncmp(buf, subtag, subtagLen) != 0) {
     return false;  // no match between two strings
   }
   return (bufLen == subtagLen || buf[subtagLen] == '\0' ||
           buf[subtagLen] == '-' || buf[subtagLen] == '_');
 }

 // Pack the three letter code into 15 bits and stored to 16 bit integer. The
 // highest bit is 0. For the region code, the letters must be all digits in
 // three letter case, so the number of possible values are 10. For the language
 // code, the letters must be all small alphabets, so the number of possible
 // values are 26. Thus, 5 bits are sufficient for each case and we can pack the
 // three letter language code or region code to 15 bits.
 //
 // In case of two letter code, use fullbit(0x1f) for the first letter instead.
 static uint16_t packLanguageOrRegion(const char* c,
                                      size_t length,
                                      uint8_t twoLetterBase,
                                      uint8_t threeLetterBase) {
   if (length == 2) {
     return 0x7c00u |  // 0x1fu << 10
            (uint16_t)(c[0] - twoLetterBase) << 5 |
            (uint16_t)(c[1] - twoLetterBase);
   } else {
     return ((uint16_t)(c[0] - threeLetterBase) << 10) |
            (uint16_t)(c[1] - threeLetterBase) << 5 |
            (uint16_t)(c[2] - threeLetterBase);
   }
 }

 static size_t unpackLanguageOrRegion(uint16_t in,
                                      char* out,
                                      uint8_t twoLetterBase,
                                      uint8_t threeLetterBase) {
   uint8_t first = (in >> 10) & 0x1f;
   uint8_t second = (in >> 5) & 0x1f;
   uint8_t third = in & 0x1f;

   if (first == 0x1f) {
     out[0] = second + twoLetterBase;
     out[1] = third + twoLetterBase;
     return 2;
   } else {
     out[0] = first + threeLetterBase;
     out[1] = second + threeLetterBase;
     out[2] = third + threeLetterBase;
     return 3;
   }
 }

 // Find the next '-' or '_' index from startOffset position. If not found,
 // returns bufferLength.
 static size_t nextDelimiterIndex(const char* buffer,
                                  size_t bufferLength,
                                  size_t startOffset) {
   for (size_t i = startOffset; i < bufferLength; ++i) {
     if (buffer[i] == '-' || buffer[i] == '_') {
       return i;
     }
   }
   return bufferLength;
 }

 static inline bool isLowercase(char c) {
   return 'a' <= c && c <= 'z';
 }

 static inline bool isUppercase(char c) {
   return 'A' <= c && c <= 'Z';
 }

 static inline bool isDigit(char c) {
   return '0' <= c && c <= '9';
 }

 // Returns true if the buffer is valid for language code.
 static inline bool isValidLanguageCode(const char* buffer, size_t length) {
   if (length != 2 && length != 3)
     return false;
   if (!isLowercase(buffer[0]))
     return false;
   if (!isLowercase(buffer[1]))
     return false;
   if (length == 3 && !isLowercase(buffer[2]))
     return false;
   return true;
 }

 // Returns true if buffer is valid for script code. The length of buffer must
 // be 4.
 static inline bool isValidScriptCode(const char* buffer) {
   return isUppercase(buffer[0]) && isLowercase(buffer[1]) &&
          isLowercase(buffer[2]) && isLowercase(buffer[3]);
 }

 // Returns true if the buffer is valid for region code.
 static inline bool isValidRegionCode(const char* buffer, size_t length) {
   return (length == 2 && isUppercase(buffer[0]) && isUppercase(buffer[1])) ||
          (length == 3 && isDigit(buffer[0]) && isDigit(buffer[1]) &&
           isDigit(buffer[2]));
 }

 // Parse BCP 47 language identifier into internal structure
 FontLanguage::FontLanguage(const char* buf, size_t length) : FontLanguage() {
   size_t firstDelimiterPos = nextDelimiterIndex(buf, length, 0);
   if (isValidLanguageCode(buf, firstDelimiterPos)) {
     mLanguage = packLanguageOrRegion(buf, firstDelimiterPos, 'a', 'a');
   } else {
     // We don't understand anything other than two-letter or three-letter
     // language codes, so we skip parsing the rest of the string.
     return;
   }

   if (firstDelimiterPos == length) {
     mHbLanguage = hb_language_from_string(getString().c_str(), -1);
     return;  // Language code only.
   }

   size_t nextComponentStartPos = firstDelimiterPos + 1;
   size_t nextDelimiterPos =
       nextDelimiterIndex(buf, length, nextComponentStartPos);
   size_t componentLength = nextDelimiterPos - nextComponentStartPos;

   if (componentLength == 4) {
     // Possibly script code.
     const char* p = buf + nextComponentStartPos;
     if (isValidScriptCode(p)) {
       mScript = SCRIPT_TAG(p[0], p[1], p[2], p[3]);
       mSubScriptBits = scriptToSubScriptBits(mScript);
     }

     if (nextDelimiterPos == length) {
       mHbLanguage = hb_language_from_string(getString().c_str(), -1);
       mEmojiStyle = resolveEmojiStyle(buf, length, mScript);
       return;  // No region code.
     }

     nextComponentStartPos = nextDelimiterPos + 1;
     nextDelimiterPos = nextDelimiterIndex(buf, length, nextComponentStartPos);
     componentLength = nextDelimiterPos - nextComponentStartPos;
   }

   if (componentLength == 2 || componentLength == 3) {
     // Possibly region code.
     const char* p = buf + nextComponentStartPos;
     if (isValidRegionCode(p, componentLength)) {
       mRegion = packLanguageOrRegion(p, componentLength, 'A', '0');
     }
   }

   mHbLanguage = hb_language_from_string(getString().c_str(), -1);
   mEmojiStyle = resolveEmojiStyle(buf, length, mScript);
 }

 // static
 FontLanguage::EmojiStyle FontLanguage::resolveEmojiStyle(const char* buf,
                                                          size_t length,
                                                          uint32_t script) {
   // First, lookup emoji subtag.
   // 10 is the length of "-u-em-text", which is the shortest emoji subtag,
   // unnecessary comparison can be avoided if total length is smaller than 10.
   const size_t kMinSubtagLength = 10;
   if (length >= kMinSubtagLength) {
     static const char kPrefix[] = "-u-em-";
     const char* pos =
         std::search(buf, buf + length, kPrefix, kPrefix + strlen(kPrefix));
     if (pos != buf + length) {  // found
       pos += strlen(kPrefix);
       const size_t remainingLength = length - (pos - buf);
       if (isEmojiSubtag(pos, remainingLength, "emoji", 5)) {
         return EMSTYLE_EMOJI;
       } else if (isEmojiSubtag(pos, remainingLength, "text", 4)) {
         return EMSTYLE_TEXT;
       } else if (isEmojiSubtag(pos, remainingLength, "default", 7)) {
         return EMSTYLE_DEFAULT;
       }
     }
   }

   // If no emoji subtag was provided, resolve the emoji style from script code.
   if (script == SCRIPT_TAG('Z', 's', 'y', 'e')) {
     return EMSTYLE_EMOJI;
   } else if (script == SCRIPT_TAG('Z', 's', 'y', 'm')) {
     return EMSTYLE_TEXT;
   }

   return EMSTYLE_EMPTY;
 }

 // static
 uint8_t FontLanguage::scriptToSubScriptBits(uint32_t script) {
   uint8_t subScriptBits = 0u;
   switch (script) {
     case SCRIPT_TAG('B', 'o', 'p', 'o'):
       subScriptBits = kBopomofoFlag;
       break;
     case SCRIPT_TAG('H', 'a', 'n', 'g'):
       subScriptBits = kHangulFlag;
       break;
     case SCRIPT_TAG('H', 'a', 'n', 'b'):
       // Bopomofo is almost exclusively used in Taiwan.
       subScriptBits = kHanFlag | kBopomofoFlag;
       break;
     case SCRIPT_TAG('H', 'a', 'n', 'i'):
       subScriptBits = kHanFlag;
       break;
     case SCRIPT_TAG('H', 'a', 'n', 's'):
       subScriptBits = kHanFlag | kSimplifiedChineseFlag;
       break;
     case SCRIPT_TAG('H', 'a', 'n', 't'):
       subScriptBits = kHanFlag | kTraditionalChineseFlag;
       break;
     case SCRIPT_TAG('H', 'i', 'r', 'a'):
       subScriptBits = kHiraganaFlag;
       break;
     case SCRIPT_TAG('H', 'r', 'k', 't'):
       subScriptBits = kKatakanaFlag | kHiraganaFlag;
       break;
     case SCRIPT_TAG('J', 'p', 'a', 'n'):
       subScriptBits = kHanFlag | kKatakanaFlag | kHiraganaFlag;
       break;
     case SCRIPT_TAG('K', 'a', 'n', 'a'):
       subScriptBits = kKatakanaFlag;
       break;
     case SCRIPT_TAG('K', 'o', 'r', 'e'):
       subScriptBits = kHanFlag | kHangulFlag;
       break;
   }
   return subScriptBits;
 }

 std::string FontLanguage::getString() const {
   if (isUnsupported()) {
     return "und";
   }
   char buf[16];
   size_t i = unpackLanguageOrRegion(mLanguage, buf, 'a', 'a');
   if (mScript != 0) {
     buf[i++] = '-';
     buf[i++] = (mScript >> 24) & 0xFFu;
     buf[i++] = (mScript >> 16) & 0xFFu;
     buf[i++] = (mScript >> 8) & 0xFFu;
     buf[i++] = mScript & 0xFFu;
   }
   if (mRegion != INVALID_CODE) {
     buf[i++] = '-';
     i += unpackLanguageOrRegion(mRegion, buf + i, 'A', '0');
   }
   return std::string(buf, i);
 }

 bool FontLanguage::isEqualScript(const FontLanguage& other) const {
   return other.mScript == mScript;
 }

 // static
 bool FontLanguage::supportsScript(uint8_t providedBits, uint8_t requestedBits) {
   return requestedBits != 0 && (providedBits & requestedBits) == requestedBits;
 }

 bool FontLanguage::supportsHbScript(hb_script_t script) const {
   static_assert(
       SCRIPT_TAG('J', 'p', 'a', 'n') == HB_TAG('J', 'p', 'a', 'n'),
       "The Minikin script and HarfBuzz hb_script_t have different encodings.");
   if (script == mScript)
     return true;
   return supportsScript(mSubScriptBits, scriptToSubScriptBits(script));
 }

 int FontLanguage::calcScoreFor(const FontLanguages& supported) const {
   bool languageScriptMatch = false;
   bool subtagMatch = false;
   bool scriptMatch = false;

   for (size_t i = 0; i < supported.size(); ++i) {
     if (mEmojiStyle != EMSTYLE_EMPTY &&
         mEmojiStyle == supported[i].mEmojiStyle) {
       subtagMatch = true;
       if (mLanguage == supported[i].mLanguage) {
         return 4;
       }
     }
     if (isEqualScript(supported[i]) ||
         supportsScript(supported[i].mSubScriptBits, mSubScriptBits)) {
       scriptMatch = true;
       if (mLanguage == supported[i].mLanguage) {
         languageScriptMatch = true;
       }
     }
   }

   if (supportsScript(supported.getUnionOfSubScriptBits(), mSubScriptBits)) {
     scriptMatch = true;
     if (mLanguage == supported[0].mLanguage &&
         supported.isAllTheSameLanguage()) {
       return 3;
     }
   }

   if (languageScriptMatch) {
     return 3;
   } else if (subtagMatch) {
     return 2;
   } else if (scriptMatch) {
     return 1;
   }
   return 0;
 }

 FontLanguages::FontLanguages(std::vector<FontLanguage>&& languages)
     : mLanguages(std::move(languages)) {
   if (mLanguages.empty()) {
     return;
   }

   const FontLanguage& lang = mLanguages[0];

   mIsAllTheSameLanguage = true;
   mUnionOfSubScriptBits = lang.mSubScriptBits;
   for (size_t i = 1; i < mLanguages.size(); ++i) {
     mUnionOfSubScriptBits |= mLanguages[i].mSubScriptBits;
     if (mIsAllTheSameLanguage && lang.mLanguage != mLanguages[i].mLanguage) {
       mIsAllTheSameLanguage = false;
     }
   }
 }

 #undef SCRIPT_TAG
 }  // namespace minikin
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "Minikin"

	#include "FontLanguage.h"

	#include <hb.h>
	#include <string.h>
	#include <unicode/uloc.h>
	#include <algorithm>

	namespace minikin {

	#define SCRIPT_TAG(c1, c2, c3, c4) \
	(((uint32_t)(c1)) << 24 \| ((uint32_t)(c2)) << 16 \| ((uint32_t)(c3)) << 8 \| \
	((uint32_t)(c4)))

	// Check if a language code supports emoji according to its subtag
	static bool isEmojiSubtag(const char* buf,
	size_t bufLen,
	const char* subtag,
	size_t subtagLen) {
	if (bufLen < subtagLen) {
	return false;
	}
	if (strncmp(buf, subtag, subtagLen) != 0) {
	return false; // no match between two strings
	}
	return (bufLen == subtagLen \|\| buf[subtagLen] == '\0' \|\|
	buf[subtagLen] == '-' \|\| buf[subtagLen] == '_');
	}

	// Pack the three letter code into 15 bits and stored to 16 bit integer. The
	// highest bit is 0. For the region code, the letters must be all digits in
	// three letter case, so the number of possible values are 10. For the language
	// code, the letters must be all small alphabets, so the number of possible
	// values are 26. Thus, 5 bits are sufficient for each case and we can pack the
	// three letter language code or region code to 15 bits.
	//
	// In case of two letter code, use fullbit(0x1f) for the first letter instead.
	static uint16_t packLanguageOrRegion(const char* c,
	size_t length,
	uint8_t twoLetterBase,
	uint8_t threeLetterBase) {
	if (length == 2) {
	return 0x7c00u \| // 0x1fu << 10
	(uint16_t)(c[0] - twoLetterBase) << 5 \|
	(uint16_t)(c[1] - twoLetterBase);
	} else {
	return ((uint16_t)(c[0] - threeLetterBase) << 10) \|
	(uint16_t)(c[1] - threeLetterBase) << 5 \|
	(uint16_t)(c[2] - threeLetterBase);
	}
	}

	static size_t unpackLanguageOrRegion(uint16_t in,
	char* out,
	uint8_t twoLetterBase,
	uint8_t threeLetterBase) {
	uint8_t first = (in >> 10) & 0x1f;
	uint8_t second = (in >> 5) & 0x1f;
	uint8_t third = in & 0x1f;

	if (first == 0x1f) {
	out[0] = second + twoLetterBase;
	out[1] = third + twoLetterBase;
	return 2;
	} else {
	out[0] = first + threeLetterBase;
	out[1] = second + threeLetterBase;
	out[2] = third + threeLetterBase;
	return 3;
	}
	}

	// Find the next '-' or '_' index from startOffset position. If not found,
	// returns bufferLength.
	static size_t nextDelimiterIndex(const char* buffer,
	size_t bufferLength,
	size_t startOffset) {
	for (size_t i = startOffset; i < bufferLength; ++i) {
	if (buffer[i] == '-' \|\| buffer[i] == '_') {
	return i;
	}
	}
	return bufferLength;
	}

	static inline bool isLowercase(char c) {
	return 'a' <= c && c <= 'z';
	}

	static inline bool isUppercase(char c) {
	return 'A' <= c && c <= 'Z';
	}

	static inline bool isDigit(char c) {
	return '0' <= c && c <= '9';
	}

	// Returns true if the buffer is valid for language code.
	static inline bool isValidLanguageCode(const char* buffer, size_t length) {
	if (length != 2 && length != 3)
	return false;
	if (!isLowercase(buffer[0]))
	return false;
	if (!isLowercase(buffer[1]))
	return false;
	if (length == 3 && !isLowercase(buffer[2]))
	return false;
	return true;
	}

	// Returns true if buffer is valid for script code. The length of buffer must
	// be 4.
	static inline bool isValidScriptCode(const char* buffer) {
	return isUppercase(buffer[0]) && isLowercase(buffer[1]) &&
	isLowercase(buffer[2]) && isLowercase(buffer[3]);
	}

	// Returns true if the buffer is valid for region code.
	static inline bool isValidRegionCode(const char* buffer, size_t length) {
	return (length == 2 && isUppercase(buffer[0]) && isUppercase(buffer[1])) \|\|
	(length == 3 && isDigit(buffer[0]) && isDigit(buffer[1]) &&
	isDigit(buffer[2]));
	}

	// Parse BCP 47 language identifier into internal structure
	FontLanguage::FontLanguage(const char* buf, size_t length) : FontLanguage() {
	size_t firstDelimiterPos = nextDelimiterIndex(buf, length, 0);
	if (isValidLanguageCode(buf, firstDelimiterPos)) {
	mLanguage = packLanguageOrRegion(buf, firstDelimiterPos, 'a', 'a');
	} else {
	// We don't understand anything other than two-letter or three-letter
	// language codes, so we skip parsing the rest of the string.
	return;
	}

	if (firstDelimiterPos == length) {
	mHbLanguage = hb_language_from_string(getString().c_str(), -1);
	return; // Language code only.
	}

	size_t nextComponentStartPos = firstDelimiterPos + 1;
	size_t nextDelimiterPos =
	nextDelimiterIndex(buf, length, nextComponentStartPos);
	size_t componentLength = nextDelimiterPos - nextComponentStartPos;

	if (componentLength == 4) {
	// Possibly script code.
	const char* p = buf + nextComponentStartPos;
	if (isValidScriptCode(p)) {
	mScript = SCRIPT_TAG(p[0], p[1], p[2], p[3]);
	mSubScriptBits = scriptToSubScriptBits(mScript);
	}

	if (nextDelimiterPos == length) {
	mHbLanguage = hb_language_from_string(getString().c_str(), -1);
	mEmojiStyle = resolveEmojiStyle(buf, length, mScript);
	return; // No region code.
	}

	nextComponentStartPos = nextDelimiterPos + 1;
	nextDelimiterPos = nextDelimiterIndex(buf, length, nextComponentStartPos);
	componentLength = nextDelimiterPos - nextComponentStartPos;
	}

	if (componentLength == 2 \|\| componentLength == 3) {
	// Possibly region code.
	const char* p = buf + nextComponentStartPos;
	if (isValidRegionCode(p, componentLength)) {
	mRegion = packLanguageOrRegion(p, componentLength, 'A', '0');
	}
	}

	mHbLanguage = hb_language_from_string(getString().c_str(), -1);
	mEmojiStyle = resolveEmojiStyle(buf, length, mScript);
	}

	// static
	FontLanguage::EmojiStyle FontLanguage::resolveEmojiStyle(const char* buf,
	size_t length,
	uint32_t script) {
	// First, lookup emoji subtag.
	// 10 is the length of "-u-em-text", which is the shortest emoji subtag,
	// unnecessary comparison can be avoided if total length is smaller than 10.
	const size_t kMinSubtagLength = 10;
	if (length >= kMinSubtagLength) {
	static const char kPrefix[] = "-u-em-";
	const char* pos =
	std::search(buf, buf + length, kPrefix, kPrefix + strlen(kPrefix));
	if (pos != buf + length) { // found
	pos += strlen(kPrefix);
	const size_t remainingLength = length - (pos - buf);
	if (isEmojiSubtag(pos, remainingLength, "emoji", 5)) {
	return EMSTYLE_EMOJI;
	} else if (isEmojiSubtag(pos, remainingLength, "text", 4)) {
	return EMSTYLE_TEXT;
	} else if (isEmojiSubtag(pos, remainingLength, "default", 7)) {
	return EMSTYLE_DEFAULT;
	}
	}
	}

	// If no emoji subtag was provided, resolve the emoji style from script code.
	if (script == SCRIPT_TAG('Z', 's', 'y', 'e')) {
	return EMSTYLE_EMOJI;
	} else if (script == SCRIPT_TAG('Z', 's', 'y', 'm')) {
	return EMSTYLE_TEXT;
	}

	return EMSTYLE_EMPTY;
	}

	// static
	uint8_t FontLanguage::scriptToSubScriptBits(uint32_t script) {
	uint8_t subScriptBits = 0u;
	switch (script) {
	case SCRIPT_TAG('B', 'o', 'p', 'o'):
	subScriptBits = kBopomofoFlag;
	break;
	case SCRIPT_TAG('H', 'a', 'n', 'g'):
	subScriptBits = kHangulFlag;
	break;
	case SCRIPT_TAG('H', 'a', 'n', 'b'):
	// Bopomofo is almost exclusively used in Taiwan.
	subScriptBits = kHanFlag \| kBopomofoFlag;
	break;
	case SCRIPT_TAG('H', 'a', 'n', 'i'):
	subScriptBits = kHanFlag;
	break;
	case SCRIPT_TAG('H', 'a', 'n', 's'):
	subScriptBits = kHanFlag \| kSimplifiedChineseFlag;
	break;
	case SCRIPT_TAG('H', 'a', 'n', 't'):
	subScriptBits = kHanFlag \| kTraditionalChineseFlag;
	break;
	case SCRIPT_TAG('H', 'i', 'r', 'a'):
	subScriptBits = kHiraganaFlag;
	break;
	case SCRIPT_TAG('H', 'r', 'k', 't'):
	subScriptBits = kKatakanaFlag \| kHiraganaFlag;
	break;
	case SCRIPT_TAG('J', 'p', 'a', 'n'):
	subScriptBits = kHanFlag \| kKatakanaFlag \| kHiraganaFlag;
	break;
	case SCRIPT_TAG('K', 'a', 'n', 'a'):
	subScriptBits = kKatakanaFlag;
	break;
	case SCRIPT_TAG('K', 'o', 'r', 'e'):
	subScriptBits = kHanFlag \| kHangulFlag;
	break;
	}
	return subScriptBits;
	}

	std::string FontLanguage::getString() const {
	if (isUnsupported()) {
	return "und";
	}
	char buf[16];
	size_t i = unpackLanguageOrRegion(mLanguage, buf, 'a', 'a');
	if (mScript != 0) {
	buf[i++] = '-';
	buf[i++] = (mScript >> 24) & 0xFFu;
	buf[i++] = (mScript >> 16) & 0xFFu;
	buf[i++] = (mScript >> 8) & 0xFFu;
	buf[i++] = mScript & 0xFFu;
	}
	if (mRegion != INVALID_CODE) {
	buf[i++] = '-';
	i += unpackLanguageOrRegion(mRegion, buf + i, 'A', '0');
	}
	return std::string(buf, i);
	}

	bool FontLanguage::isEqualScript(const FontLanguage& other) const {
	return other.mScript == mScript;
	}

	// static
	bool FontLanguage::supportsScript(uint8_t providedBits, uint8_t requestedBits) {
	return requestedBits != 0 && (providedBits & requestedBits) == requestedBits;
	}

	bool FontLanguage::supportsHbScript(hb_script_t script) const {
	static_assert(
	SCRIPT_TAG('J', 'p', 'a', 'n') == HB_TAG('J', 'p', 'a', 'n'),
	"The Minikin script and HarfBuzz hb_script_t have different encodings.");
	if (script == mScript)
	return true;
	return supportsScript(mSubScriptBits, scriptToSubScriptBits(script));
	}

	int FontLanguage::calcScoreFor(const FontLanguages& supported) const {
	bool languageScriptMatch = false;
	bool subtagMatch = false;
	bool scriptMatch = false;

	for (size_t i = 0; i < supported.size(); ++i) {
	if (mEmojiStyle != EMSTYLE_EMPTY &&
	mEmojiStyle == supported[i].mEmojiStyle) {
	subtagMatch = true;
	if (mLanguage == supported[i].mLanguage) {
	return 4;
	}
	}
	if (isEqualScript(supported[i]) \|\|
	supportsScript(supported[i].mSubScriptBits, mSubScriptBits)) {
	scriptMatch = true;
	if (mLanguage == supported[i].mLanguage) {
	languageScriptMatch = true;
	}
	}
	}

	if (supportsScript(supported.getUnionOfSubScriptBits(), mSubScriptBits)) {
	scriptMatch = true;
	if (mLanguage == supported[0].mLanguage &&
	supported.isAllTheSameLanguage()) {
	return 3;
	}
	}

	if (languageScriptMatch) {
	return 3;
	} else if (subtagMatch) {
	return 2;
	} else if (scriptMatch) {
	return 1;
	}
	return 0;
	}

	FontLanguages::FontLanguages(std::vector<FontLanguage>&& languages)
	: mLanguages(std::move(languages)) {
	if (mLanguages.empty()) {
	return;
	}

	const FontLanguage& lang = mLanguages[0];

	mIsAllTheSameLanguage = true;
	mUnionOfSubScriptBits = lang.mSubScriptBits;
	for (size_t i = 1; i < mLanguages.size(); ++i) {
	mUnionOfSubScriptBits \|= mLanguages[i].mSubScriptBits;
	if (mIsAllTheSameLanguage && lang.mLanguage != mLanguages[i].mLanguage) {
	mIsAllTheSameLanguage = false;
	}
	}
	}

	#undef SCRIPT_TAG
	} // namespace minikin