Fix clang_use_chrome_plugin for Mac and Skia builds

xfa/fgas/font/fgas_stdfontmgr.cpp

 // Copyright 2015 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fgas/font/fgas_stdfontmgr.h"
 
 #include "core/fxcrt/include/fx_stream.h"
 #include "core/fxge/include/fx_ge.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
 #include "xfa/fgas/font/fgas_fontutils.h"
 #include "xfa/fgas/font/fgas_gefont.h"
 
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
+
 IFGAS_FontMgr* IFGAS_FontMgr::Create(FX_LPEnumAllFonts pEnumerator) {
   return new CFGAS_StdFontMgrImp(pEnumerator);
 }
+
 CFGAS_StdFontMgrImp::CFGAS_StdFontMgrImp(FX_LPEnumAllFonts pEnumerator)
     : m_pEnumerator(pEnumerator),
       m_FontFaces(),
       m_CPFonts(8),
       m_FamilyFonts(16),
       m_UnicodeFonts(16),
       m_BufferFonts(4),
       m_StreamFonts(4),
       m_DeriveFonts(4) {
   if (m_pEnumerator) {
@@ skipping 38 matching lines @@
       CFGAS_GEFont::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     dwHash = FGAS_GetFontFamilyHash(pFD->wsFontFace, dwFontStyles, wCodePage);
     m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     return LoadFont(pFont, dwFontStyles, wCodePage);
   }
   return NULL;
 }
+
 CFGAS_GEFont* CFGAS_StdFontMgrImp::GetDefFontByCharset(
     uint8_t nCharset,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetDefFontByCodePage(FX_GetCodePageFromCharset(nCharset), dwFontStyles,
                               pszFontFamily);
 }
 
 CFGAS_GEFont* CFGAS_StdFontMgrImp::GetDefFontByUnicode(
     FX_WCHAR wUnicode,
@@ skipping 34 matching lines @@
   return nullptr;
 }
 
 CFGAS_GEFont* CFGAS_StdFontMgrImp::GetDefFontByLanguage(
     uint16_t wLanguage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetDefFontByCodePage(FX_GetDefCodePageByLanguage(wLanguage),
                               dwFontStyles, pszFontFamily);
 }
+
 CFGAS_GEFont* CFGAS_StdFontMgrImp::LoadFont(const FX_WCHAR* pszFontFamily,
                                             uint32_t dwFontStyles,
                                             uint16_t wCodePage) {
   uint32_t dwHash =
       FGAS_GetFontFamilyHash(pszFontFamily, dwFontStyles, wCodePage);
   CFGAS_GEFont* pFont = NULL;
   if (m_FamilyFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
     return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : NULL;
   }
   FX_FONTDESCRIPTOR const* pFD = NULL;
@@ skipping 11 matching lines @@
       CFGAS_GEFont::LoadFont(pFD->wsFontFace, dwFontStyles, wCodePage, this);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
     m_CPFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     return LoadFont(pFont, dwFontStyles, wCodePage);
   }
   return NULL;
 }
+
 CFGAS_GEFont* CFGAS_StdFontMgrImp::LoadFont(const uint8_t* pBuffer,
                                             int32_t iLength) {
   ASSERT(pBuffer && iLength > 0);
   CFGAS_GEFont* pFont = NULL;
   if (m_BufferFonts.Lookup((void*)pBuffer, (void*&)pFont)) {
     if (pFont) {
       return pFont->Retain();
     }
   }
   pFont = CFGAS_GEFont::LoadFont(pBuffer, iLength, this);
@@ skipping 28 matching lines @@
     m_StreamFonts.SetAt((void*)pFontStream, (void*)pFont);
     if (pszFontAlias) {
       uint32_t dwHash =
           FGAS_GetFontFamilyHash(pszFontAlias, dwFontStyles, wCodePage);
       m_FamilyFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     }
     return LoadFont(pFont, dwFontStyles, wCodePage);
   }
   return NULL;
 }
+
 CFGAS_GEFont* CFGAS_StdFontMgrImp::LoadFont(CFGAS_GEFont* pSrcFont,
                                             uint32_t dwFontStyles,
                                             uint16_t wCodePage) {
   ASSERT(pSrcFont);
   if (pSrcFont->GetFontStyles() == dwFontStyles) {
     return pSrcFont->Retain();
   }
   void* buffer[3] = {pSrcFont, (void*)(uintptr_t)dwFontStyles,
                      (void*)(uintptr_t)wCodePage};
   uint32_t dwHash = FX_HashCode_GetA(
@@ skipping 31 matching lines @@
   while (pos) {
     pFind = NULL;
     fontMap.GetNextAssoc(pos, pKey, pFind);
     if (pFind != (void*)pFont) {
       continue;
     }
     fontMap.RemoveKey(pKey);
     break;
   }
 }
+
 void CFGAS_StdFontMgrImp::RemoveFont(CFGAS_GEFont* pFont) {
   RemoveFont(m_CPFonts, pFont);
   RemoveFont(m_FamilyFonts, pFont);
   RemoveFont(m_UnicodeFonts, pFont);
   RemoveFont(m_BufferFonts, pFont);
   RemoveFont(m_StreamFonts, pFont);
   RemoveFont(m_DeriveFonts, pFont);
   int32_t iFind = m_Fonts.Find(pFont);
   if (iFind > -1) {
     m_Fonts.RemoveAt(iFind, 1);
   }
 }
+
 FX_FONTDESCRIPTOR const* CFGAS_StdFontMgrImp::FindFont(
     const FX_WCHAR* pszFontFamily,
     uint32_t dwFontStyles,
     uint32_t dwMatchFlags,
     uint16_t wCodePage,
     uint32_t dwUSB,
     FX_WCHAR wUnicode) {
   FX_FONTMATCHPARAMS params;
   FXSYS_memset(&params, 0, sizeof(params));
   params.dwUSB = dwUSB;
@@ skipping 18 matching lines @@
       FX_FONTDESCRIPTOR const* pMatch = m_FontFaces.GetPtrAt(i);
       if (*pMatch == *pDesc) {
         return pMatch;
       }
     }
     int index = m_FontFaces.Add(*pDesc);
     return m_FontFaces.GetPtrAt(index);
   }
   return NULL;
 }
+
 FX_FONTDESCRIPTOR const* FX_DefFontMatcher(FX_LPFONTMATCHPARAMS pParams,
                                            const CFX_FontDescriptors& fonts) {
   FX_FONTDESCRIPTOR const* pBestFont = NULL;
   int32_t iBestSimilar = 0;
   FX_BOOL bMatchStyle =
       (pParams->dwMatchFlags & FX_FONTMATCHPARA_MacthStyle) > 0;
   int32_t iCount = fonts.GetSize();
   for (int32_t i = 0; i < iCount; ++i) {
     FX_FONTDESCRIPTOR const* pFont = fonts.GetPtrAt(i);
     if ((pFont->dwFontStyles & FX_FONTSTYLE_BoldItalic) ==
@@ skipping 35 matching lines @@
       }
     }
     int32_t iSimilarValue = FX_GetSimilarValue(pFont, pParams->dwFontStyles);
     if (iBestSimilar < iSimilarValue) {
       iBestSimilar = iSimilarValue;
       pBestFont = pFont;
     }
   }
   return iBestSimilar < 1 ? NULL : pBestFont;
 }
+
 int32_t FX_GetSimilarValue(FX_FONTDESCRIPTOR const* pFont,
                            uint32_t dwFontStyles) {
   int32_t iValue = 0;
   if ((dwFontStyles & FX_FONTSTYLE_Symbolic) ==
       (pFont->dwFontStyles & FX_FONTSTYLE_Symbolic)) {
     iValue += 64;
   }
   if ((dwFontStyles & FX_FONTSTYLE_FixedPitch) ==
       (pFont->dwFontStyles & FX_FONTSTYLE_FixedPitch)) {
     iValue += 32;
   }
   if ((dwFontStyles & FX_FONTSTYLE_Serif) ==
       (pFont->dwFontStyles & FX_FONTSTYLE_Serif)) {
     iValue += 16;
   }
   if ((dwFontStyles & FX_FONTSTYLE_Script) ==
       (pFont->dwFontStyles & FX_FONTSTYLE_Script)) {
     iValue += 8;
   }
   return iValue;
 }
+
 FX_LPMatchFont FX_GetDefFontMatchor() {
   return FX_DefFontMatcher;
 }
+
 uint32_t FX_GetGdiFontStyles(const LOGFONTW& lf) {
   uint32_t dwStyles = 0;
   if ((lf.lfPitchAndFamily & 0x03) == FIXED_PITCH) {
     dwStyles |= FX_FONTSTYLE_FixedPitch;
   }
   uint8_t nFamilies = lf.lfPitchAndFamily & 0xF0;
   if (nFamilies == FF_ROMAN) {
     dwStyles |= FX_FONTSTYLE_Serif;
   }
   if (nFamilies == FF_SCRIPT) {
     dwStyles |= FX_FONTSTYLE_Script;
   }
   if (lf.lfCharSet == SYMBOL_CHARSET) {
     dwStyles |= FX_FONTSTYLE_Symbolic;
   }
   return dwStyles;
 }
+
 static int32_t CALLBACK FX_GdiFontEnumProc(ENUMLOGFONTEX* lpelfe,
                                            NEWTEXTMETRICEX* lpntme,
                                            DWORD dwFontType,
                                            LPARAM lParam) {
   if (dwFontType != TRUETYPE_FONTTYPE) {
     return 1;
   }
   const LOGFONTW& lf = ((LPENUMLOGFONTEXW)lpelfe)->elfLogFont;
   if (lf.lfFaceName[0] == L'@') {
     return 1;
   }
   FX_FONTDESCRIPTOR* pFont = FX_Alloc(FX_FONTDESCRIPTOR, 1);
   FXSYS_memset(pFont, 0, sizeof(FX_FONTDESCRIPTOR));
   pFont->uCharSet = lf.lfCharSet;
   pFont->dwFontStyles = FX_GetGdiFontStyles(lf);
   FXSYS_wcsncpy(pFont->wsFontFace, (const FX_WCHAR*)lf.lfFaceName, 31);
   pFont->wsFontFace[31] = 0;
   FXSYS_memcpy(&pFont->FontSignature, &lpntme->ntmFontSig,
                sizeof(lpntme->ntmFontSig));
   ((CFX_FontDescriptors*)lParam)->Add(*pFont);
   FX_Free(pFont);
   return 1;
 }
+
 static void FX_EnumGdiFonts(CFX_FontDescriptors& fonts,
                             const FX_WCHAR* pwsFaceName,
                             FX_WCHAR wUnicode) {
   HDC hDC = ::GetDC(NULL);
   LOGFONTW lfFind;
   FXSYS_memset(&lfFind, 0, sizeof(lfFind));
   lfFind.lfCharSet = DEFAULT_CHARSET;
   if (pwsFaceName) {
     FXSYS_wcsncpy(lfFind.lfFaceName, pwsFaceName, 31);
     lfFind.lfFaceName[31] = 0;
   }
   EnumFontFamiliesExW(hDC, (LPLOGFONTW)&lfFind,
                       (FONTENUMPROCW)FX_GdiFontEnumProc, (LPARAM)&fonts, 0);
   ::ReleaseDC(NULL, hDC);
 }
+
 FX_LPEnumAllFonts FX_GetDefFontEnumerator() {
   return FX_EnumGdiFonts;
 }
+
 #else
 const FX_CHAR* g_FontFolders[] = {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_LINUX_
     "/usr/share/fonts", "/usr/share/X11/fonts/Type1",
     "/usr/share/X11/fonts/TTF", "/usr/local/share/fonts",
 #elif _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
     "~/Library/Fonts", "/Library/Fonts", "/System/Library/Fonts",
 #elif _FXM_PLATFORM_ == _FXM_PLATFORM_ANDROID_
     "/system/fonts",
 #endif
 };
 
+CFX_FontDescriptor::CFX_FontDescriptor()
+    : m_nFaceIndex(0), m_dwFontStyles(0), m_dwUsb(), m_dwCsb() {}

[Lei Zhang, 2016/06/20 17:45:02]

Does this actually initialize |m_dwUsb| and |m_dwCsb| ?

[Wei Li, 2016/06/20 18:04:10]

Yes, this will zero initialize the vars, same as ={}

+
+CFX_FontDescriptor::~CFX_FontDescriptor() {}
+
 CFX_FontSourceEnum_File::CFX_FontSourceEnum_File() {
   for (size_t i = 0; i < FX_ArraySize(g_FontFolders); ++i)
     m_FolderPaths.Add(g_FontFolders[i]);
 }
 
+CFX_FontSourceEnum_File::~CFX_FontSourceEnum_File() {}
+
 CFX_ByteString CFX_FontSourceEnum_File::GetNextFile() {
 Restart:
   void* pCurHandle =
       m_FolderQueue.GetSize() == 0
           ? NULL
           : m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->pFileHandle;
   if (NULL == pCurHandle) {
     if (m_FolderPaths.GetSize() < 1) {
       return "";
     }
@@ skipping 40 matching lines @@
       pCurHandle = hpp.pFileHandle;
       continue;
     }
     bsName =
         m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->bsParentPath +
         bsFolderSpearator + bsName;
     break;
   }
   return bsName;
 }
+
 FX_POSITION CFX_FontSourceEnum_File::GetStartPosition() {
   m_wsNext = GetNextFile().UTF8Decode();
   if (0 == m_wsNext.GetLength()) {
     return (FX_POSITION)0;
   }
   return (FX_POSITION)-1;
 }
 
 IFX_FileAccess* CFX_FontSourceEnum_File::GetNext(FX_POSITION& pos) {
   IFX_FileAccess* pAccess = FX_CreateDefaultFileAccess(m_wsNext.AsStringC());
@@ skipping 58 matching lines @@
       continue;
     }
     RegisterFaces(pFontStream, nullptr);
     pFontStream->Release();
     pFontSource->Release();
   }
   if (m_InstalledFonts.GetSize() == 0)
     return FALSE;
   return TRUE;
 }
+
 FX_BOOL CFGAS_FontMgrImp::EnumFonts() {
   if (EnumFontsFromFontMapper())
     return TRUE;
   return EnumFontsFromFiles();
 }
+
 void CFGAS_FontMgrImp::Release() {
   for (int32_t i = 0; i < m_InstalledFonts.GetSize(); i++) {
     delete m_InstalledFonts[i];
   }
   FX_POSITION pos = m_Hash2CandidateList.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     CFX_FontDescriptorInfos* pDescs;
     m_Hash2CandidateList.GetNextAssoc(pos, dwHash, pDescs);
     delete pDescs;
   }
   pos = m_Hash2Fonts.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     CFX_ArrayTemplate<CFGAS_GEFont*>* pFonts;
     m_Hash2Fonts.GetNextAssoc(pos, dwHash, pFonts);
     delete pFonts;
   }
   m_Hash2Fonts.RemoveAll();
   pos = m_IFXFont2FileRead.GetStartPosition();
   while (pos) {
     CFGAS_GEFont* pFont;
     IFX_FileRead* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
   delete this;
 }
+
 CFGAS_GEFont* CFGAS_FontMgrImp::GetDefFontByCodePage(
     uint16_t wCodePage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return nullptr;
 }
+
 CFGAS_GEFont* CFGAS_FontMgrImp::GetDefFontByCharset(
     uint8_t nCharset,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return nullptr;
 }
+
 CFGAS_GEFont* CFGAS_FontMgrImp::GetDefFontByUnicode(
     FX_WCHAR wUnicode,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return nullptr;
 }
+
 CFGAS_GEFont* CFGAS_FontMgrImp::GetDefFontByLanguage(
     uint16_t wLanguage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return nullptr;
 }
 
 CFGAS_GEFont* CFGAS_FontMgrImp::GetFontByCodePage(
     uint16_t wCodePage,
     uint32_t dwFontStyles,
@@ skipping 27 matching lines @@
 
   CFX_FontDescriptor* pDesc = sortedFonts->GetAt(0).pFont;
   CFGAS_GEFont* pFont =
       LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr);
   if (pFont)
     pFont->SetLogicalFontStyle(dwFontStyles);
 
   pFonts->Add(pFont);
   return pFont;
 }
+
 CFGAS_GEFont* CFGAS_FontMgrImp::GetFontByCharset(
     uint8_t nCharset,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetFontByCodePage(FX_GetCodePageFromCharset(nCharset), dwFontStyles,
                            pszFontFamily);
 }
+
 CFGAS_GEFont* CFGAS_FontMgrImp::GetFontByUnicode(
     FX_WCHAR wUnicode,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   CFGAS_GEFont* pFont = nullptr;
   if (m_FailedUnicodes2NULL.Lookup(wUnicode, pFont))
     return nullptr;
   const FGAS_FONTUSB* x = FGAS_GetUnicodeBitField(wUnicode);
   uint16_t wCodePage = x ? x->wCodePage : 0xFFFF;
   uint16_t wBitField = x ? x->wBitField : 0x03E7;
@@ skipping 31 matching lines @@
     if (!pFont)
       continue;
     pFont->SetLogicalFontStyle(dwFontStyles);
     pFonts->Add(pFont);
     return pFont;
   }
   if (!pszFontFamily)
     m_FailedUnicodes2NULL.SetAt(wUnicode, nullptr);
   return nullptr;
 }
+
 FX_BOOL CFGAS_FontMgrImp::VerifyUnicode(CFX_FontDescriptor* pDesc,
                                         FX_WCHAR wcUnicode) {
   IFX_FileRead* pFileRead = CreateFontStream(pDesc->m_wsFaceName.UTF8Encode());
   if (!pFileRead)
     return FALSE;
   FXFT_Face pFace = LoadFace(pFileRead, pDesc->m_nFaceIndex);
   FT_Error retCharmap = FXFT_Select_Charmap(pFace, FXFT_ENCODING_UNICODE);
   FT_Error retIndex = FXFT_Get_Char_Index(pFace, wcUnicode);
   pFileRead->Release();
   if (!pFace)
@@ skipping 157 matching lines @@
   if (!pSystemFontInfo)
     return nullptr;
 
   pSystemFontInfo->EnumFontList(pFontMapper);
   for (int32_t i = 0; i < pFontMapper->GetFaceSize(); ++i) {
     if (pFontMapper->GetFaceName(i) == bsFaceName)
       return CreateFontStream(pFontMapper, pSystemFontInfo, i);
   }
   return nullptr;
 }
+
 int32_t CFGAS_FontMgrImp::MatchFonts(CFX_FontDescriptorInfos& MatchedFonts,
                                      uint16_t wCodePage,
                                      uint32_t dwFontStyles,
                                      const CFX_WideString& FontName,
                                      FX_WCHAR wcUnicode) {
   MatchedFonts.RemoveAll();
   CFX_WideString wsNormalizedFontName = FontName;
 
   CFX_FontDescriptor* pFont = nullptr;
   int32_t nCount = m_InstalledFonts.GetSize();
@@ skipping 125 matching lines @@
   if (wBit != (uint16_t)999) {
     ASSERT(wBit < 128);
     if (0 == (pInstalled->m_dwUsb[wBit / 32] & (1 << (wBit % 32)))) {
       nPenalty += 0xFFFF;
     } else {
       nPenalty -= 60000;
     }
   }
   return nPenalty;
 }
+
 void CFGAS_FontMgrImp::ClearFontCache() {
   FX_POSITION pos = m_Hash2CandidateList.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     CFX_FontDescriptorInfos* pDescs;
     m_Hash2CandidateList.GetNextAssoc(pos, dwHash, pDescs);
     delete pDescs;
   }
   pos = m_IFXFont2FileRead.GetStartPosition();
   while (pos) {
     CFGAS_GEFont* pFont;
     IFX_FileRead* pFileRead;
     m_IFXFont2FileRead.GetNextAssoc(pos, pFont, pFileRead);
     pFileRead->Release();
   }
 }
+
 void CFGAS_FontMgrImp::RemoveFont(CFGAS_GEFont* pEFont) {
   if (NULL == pEFont) {
     return;
   }
   IFX_FileRead* pFileRead;
   if (m_IFXFont2FileRead.Lookup(pEFont, pFileRead)) {
     pFileRead->Release();
     m_IFXFont2FileRead.RemoveKey(pEFont);
   }
   FX_POSITION pos;
@@ skipping 66 matching lines @@
       continue;
     // All faces keep number of faces. It can be retrieved from any one face.
     if (num_faces == 0)
       num_faces = pFace->num_faces;
     RegisterFace(pFace, m_InstalledFonts, pFaceName);
     if (FXFT_Get_Face_External_Stream(pFace))
       FXFT_Clear_Face_External_Stream(pFace);
     FXFT_Done_Face(pFace);
   } while (index < num_faces);
 }
+
 uint32_t CFGAS_FontMgrImp::GetFlags(FXFT_Face pFace) {
   uint32_t flag = 0;
   if (FT_IS_FIXED_WIDTH(pFace)) {
     flag |= FX_FONTSTYLE_FixedPitch;
   }
   TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2);
   if (!pOS2) {
     return flag;
   }
   if (pOS2->ulCodePageRange1 & (1 << 31)) {
     flag |= FX_FONTSTYLE_Symbolic;
   }
   if (pOS2->panose[0] == 2) {
     uint8_t uSerif = pOS2->panose[1];
     if ((uSerif > 1 && uSerif < 10) || uSerif > 13) {
       flag |= FX_FONTSTYLE_Serif;
     }
   }
   return flag;
 }
+
 #define GetUInt8(p) ((uint8_t)((p)[0]))
 #define GetUInt16(p) ((uint16_t)((p)[0] << 8 | (p)[1]))
 #define GetUInt32(p) \
   ((uint32_t)((p)[0] << 24 | (p)[1] << 16 | (p)[2] << 8 | (p)[3]))
+
 void CFGAS_FontMgrImp::GetNames(const uint8_t* name_table,
                                 CFX_WideStringArray& Names) {
   if (NULL == name_table) {
     return;
   }
   uint8_t* lpTable = (uint8_t*)name_table;
   CFX_WideString wsFamily;
   uint8_t* sp = lpTable + 2;
   uint8_t* lpNameRecord = lpTable + 6;
   uint16_t nNameCount = GetUInt16(sp);
@@ skipping 22 matching lines @@
     }
   }
 }
 #undef GetUInt8
 #undef GetUInt16
 #undef GetUInt32
 struct FX_BIT2CHARSET {
   uint16_t wBit;
   uint16_t wCharset;
 };
+
 FX_BIT2CHARSET g_FX_Bit2Charset1[16] = {
     {1 << 0, FX_CHARSET_ANSI},
     {1 << 1, FX_CHARSET_MSWin_EasterEuropean},
     {1 << 2, FX_CHARSET_MSWin_Cyrillic},
     {1 << 3, FX_CHARSET_MSWin_Greek},
     {1 << 4, FX_CHARSET_MSWin_Turkish},
     {1 << 5, FX_CHARSET_MSWin_Hebrew},
     {1 << 6, FX_CHARSET_MSWin_Arabic},
     {1 << 7, FX_CHARSET_MSWin_Baltic},
     {1 << 8, FX_CHARSET_MSWin_Vietnamese},
     {1 << 9, FX_CHARSET_Default},
     {1 << 10, FX_CHARSET_Default},
     {1 << 11, FX_CHARSET_Default},
     {1 << 12, FX_CHARSET_Default},
     {1 << 13, FX_CHARSET_Default},
     {1 << 14, FX_CHARSET_Default},
     {1 << 15, FX_CHARSET_Default},
 };
+
 FX_BIT2CHARSET g_FX_Bit2Charset2[16] = {
     {1 << 0, FX_CHARSET_Thai},
     {1 << 1, FX_CHARSET_ShiftJIS},
     {1 << 2, FX_CHARSET_ChineseSimplified},
     {1 << 3, FX_CHARSET_Korean},
     {1 << 4, FX_CHARSET_ChineseTriditional},
     {1 << 5, FX_CHARSET_Johab},
     {1 << 6, FX_CHARSET_Default},
     {1 << 7, FX_CHARSET_Default},
     {1 << 8, FX_CHARSET_Default},
     {1 << 9, FX_CHARSET_Default},
     {1 << 10, FX_CHARSET_Default},
     {1 << 11, FX_CHARSET_Default},
     {1 << 12, FX_CHARSET_Default},
     {1 << 13, FX_CHARSET_Default},
     {1 << 14, FX_CHARSET_OEM},
     {1 << 15, FX_CHARSET_Symbol},
 };
+
 FX_BIT2CHARSET g_FX_Bit2Charset3[16] = {
     {1 << 0, FX_CHARSET_Default},  {1 << 1, FX_CHARSET_Default},
     {1 << 2, FX_CHARSET_Default},  {1 << 3, FX_CHARSET_Default},
     {1 << 4, FX_CHARSET_Default},  {1 << 5, FX_CHARSET_Default},
     {1 << 6, FX_CHARSET_Default},  {1 << 7, FX_CHARSET_Default},
     {1 << 8, FX_CHARSET_Default},  {1 << 9, FX_CHARSET_Default},
     {1 << 10, FX_CHARSET_Default}, {1 << 11, FX_CHARSET_Default},
     {1 << 12, FX_CHARSET_Default}, {1 << 13, FX_CHARSET_Default},
     {1 << 14, FX_CHARSET_Default}, {1 << 15, FX_CHARSET_Default},
 };
+
 FX_BIT2CHARSET g_FX_Bit2Charset4[16] = {
     {1 << 0, FX_CHARSET_Default},  {1 << 1, FX_CHARSET_Default},
     {1 << 2, FX_CHARSET_Default},  {1 << 3, FX_CHARSET_Default},
     {1 << 4, FX_CHARSET_Default},  {1 << 5, FX_CHARSET_Default},
     {1 << 6, FX_CHARSET_Default},  {1 << 7, FX_CHARSET_Default},
     {1 << 8, FX_CHARSET_Default},  {1 << 9, FX_CHARSET_Default},
     {1 << 10, FX_CHARSET_Default}, {1 << 11, FX_CHARSET_Default},
     {1 << 12, FX_CHARSET_Default}, {1 << 13, FX_CHARSET_Default},
     {1 << 14, FX_CHARSET_Default}, {1 << 15, FX_CHARSET_US},
 };
+
 #define CODEPAGERANGE_IMPLEMENT(n)                   \
   for (int32_t i = 0; i < 16; i++) {                 \
     if ((a##n & g_FX_Bit2Charset##n[i].wBit) != 0) { \
       Charsets.Add(g_FX_Bit2Charset##n[i].wCharset); \
     }                                                \
   }
+
 void CFGAS_FontMgrImp::GetCharsets(FXFT_Face pFace,
                                    CFX_ArrayTemplate<uint16_t>& Charsets) {
   Charsets.RemoveAll();
   TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2);
   if (NULL != pOS2) {
     uint16_t a1, a2, a3, a4;
     a1 = pOS2->ulCodePageRange1 & 0x0000ffff;
     CODEPAGERANGE_IMPLEMENT(1);
     a2 = (pOS2->ulCodePageRange1 >> 16) & 0x0000ffff;
     CODEPAGERANGE_IMPLEMENT(2);
     a3 = pOS2->ulCodePageRange2 & 0x0000ffff;
     CODEPAGERANGE_IMPLEMENT(3);
     a4 = (pOS2->ulCodePageRange2 >> 16) & 0x0000ffff;
     CODEPAGERANGE_IMPLEMENT(4);
   } else {
     Charsets.Add(FX_CHARSET_Default);
   }
 }
+
 #undef CODEPAGERANGE_IMPLEMENT
 void CFGAS_FontMgrImp::GetUSBCSB(FXFT_Face pFace,
                                  uint32_t* USB,
                                  uint32_t* CSB) {
   TT_OS2* pOS2 = (TT_OS2*)FT_Get_Sfnt_Table(pFace, ft_sfnt_os2);
   if (NULL != pOS2) {
     USB[0] = pOS2->ulUnicodeRange1;
     USB[1] = pOS2->ulUnicodeRange2;
     USB[2] = pOS2->ulUnicodeRange3;
     USB[3] = pOS2->ulUnicodeRange4;
     CSB[0] = pOS2->ulCodePageRange1;
     CSB[1] = pOS2->ulCodePageRange2;
   } else {
     USB[0] = 0;
     USB[1] = 0;
     USB[2] = 0;
     USB[3] = 0;
     CSB[0] = 0;
     CSB[1] = 0;
   }
 }
+
 int32_t CFGAS_FontMgrImp::IsPartName(const CFX_WideString& Name1,
                                      const CFX_WideString& Name2) {
   if (Name1.Find(Name2.c_str()) != -1) {
     return 1;
   }
   return 0;
 }
+
 #endif