Remove NULL in xfa/

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"
@@ skipping 10 matching lines @@
 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) {
-    m_pEnumerator(m_FontFaces, NULL, 0xFEFF);
+    m_pEnumerator(m_FontFaces, nullptr, 0xFEFF);
   }
 }
 
 CFGAS_StdFontMgrImp::~CFGAS_StdFontMgrImp() {
   m_FontFaces.RemoveAll();
   m_CPFonts.RemoveAll();
   m_FamilyFonts.RemoveAll();
   m_UnicodeFonts.RemoveAll();
   m_BufferFonts.RemoveAll();
   m_StreamFonts.RemoveAll();
   m_DeriveFonts.RemoveAll();
   for (int32_t i = m_Fonts.GetUpperBound(); i >= 0; i--)
     m_Fonts[i]->Release();
 }
 
 void CFGAS_StdFontMgrImp::Release() {
   delete this;
 }
 
 CFGAS_GEFont* CFGAS_StdFontMgrImp::GetDefFontByCodePage(
     uint16_t wCodePage,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   uint32_t dwHash = FGAS_GetFontHashCode(wCodePage, dwFontStyles);
-  CFGAS_GEFont* pFont = NULL;
+  CFGAS_GEFont* pFont = nullptr;
   if (m_CPFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
-    return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : NULL;
+    return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : nullptr;
   }
-  FX_FONTDESCRIPTOR const* pFD;
-  if ((pFD = FindFont(pszFontFamily, dwFontStyles, TRUE, wCodePage)) == NULL) {
-    if ((pFD = FindFont(NULL, dwFontStyles, TRUE, wCodePage)) == NULL) {
-      if ((pFD = FindFont(NULL, dwFontStyles, FALSE, wCodePage)) == NULL)
-        return NULL;
-    }
-  }
-  ASSERT(pFD);
+  FX_FONTDESCRIPTOR const* pFD =
+      FindFont(pszFontFamily, dwFontStyles, TRUE, wCodePage);
+  if (!pFD)
+    pFD = FindFont(nullptr, dwFontStyles, TRUE, wCodePage);
+  if (!pFD)
+    pFD = FindFont(nullptr, dwFontStyles, FALSE, wCodePage);
+  if (!pFD)
+    return nullptr;
+
   pFont =
       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;
+  return nullptr;
 }
 
 CFGAS_GEFont* CFGAS_StdFontMgrImp::GetDefFontByCharset(
     uint8_t nCharset,
     uint32_t dwFontStyles,
     const FX_WCHAR* pszFontFamily) {
   return GetDefFontByCodePage(FX_GetCodePageFromCharset(nCharset), dwFontStyles,
                               pszFontFamily);
 }
 
@@ skipping 42 matching lines @@
     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;
+  CFGAS_GEFont* pFont = nullptr;
   if (m_FamilyFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont)) {
-    return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : NULL;
+    return pFont ? LoadFont(pFont, dwFontStyles, wCodePage) : nullptr;
   }
-  FX_FONTDESCRIPTOR const* pFD = NULL;
-  if ((pFD = FindFont(pszFontFamily, dwFontStyles, TRUE, wCodePage)) == NULL) {
-    if ((pFD = FindFont(pszFontFamily, dwFontStyles, FALSE, wCodePage)) ==
-        NULL) {
-      return NULL;
-    }
-  }
-  ASSERT(pFD);
+  FX_FONTDESCRIPTOR const* pFD =
+      FindFont(pszFontFamily, dwFontStyles, TRUE, wCodePage);
+  if (!pFD)
+    pFD = FindFont(pszFontFamily, dwFontStyles, FALSE, wCodePage);
+  if (!pFD)
+    return nullptr;
+
   if (wCodePage == 0xFFFF) {
     wCodePage = FX_GetCodePageFromCharset(pFD->uCharSet);
   }
   pFont =
       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;
+  return nullptr;
 }
 
 CFGAS_GEFont* CFGAS_StdFontMgrImp::LoadFont(const uint8_t* pBuffer,
                                             int32_t iLength) {
   ASSERT(pBuffer && iLength > 0);
-  CFGAS_GEFont* pFont = NULL;
+  CFGAS_GEFont* pFont = nullptr;
   if (m_BufferFonts.Lookup((void*)pBuffer, (void*&)pFont)) {
     if (pFont) {
       return pFont->Retain();
     }
   }
   pFont = CFGAS_GEFont::LoadFont(pBuffer, iLength, this);
   if (pFont) {
     m_Fonts.Add(pFont);
     m_BufferFonts.SetAt((void*)pBuffer, pFont);
     return pFont->Retain();
   }
-  return NULL;
+  return nullptr;
 }
 
 CFGAS_GEFont* CFGAS_StdFontMgrImp::LoadFont(IFX_Stream* pFontStream,
                                             const FX_WCHAR* pszFontAlias,
                                             uint32_t dwFontStyles,
                                             uint16_t wCodePage,
                                             FX_BOOL bSaveStream) {
   ASSERT(pFontStream && pFontStream->GetLength() > 0);
-  CFGAS_GEFont* pFont = NULL;
+  CFGAS_GEFont* pFont = nullptr;
   if (m_StreamFonts.Lookup((void*)pFontStream, (void*&)pFont)) {
     if (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);
     }
   }
   pFont = CFGAS_GEFont::LoadFont(pFontStream, this, bSaveStream);
   if (pFont) {
     m_Fonts.Add(pFont);
     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;
+  return nullptr;
 }
 
 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(
       CFX_ByteStringC((uint8_t*)buffer, sizeof(buffer)), false);
-  CFGAS_GEFont* pFont = NULL;
+  CFGAS_GEFont* pFont = nullptr;
   if (m_DeriveFonts.GetCount() > 0) {
     m_DeriveFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont);
     if (pFont) {
       return pFont->Retain();
     }
   }
   pFont = pSrcFont->Derive(dwFontStyles, wCodePage);
   if (pFont) {
     m_DeriveFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
     int32_t index = m_Fonts.Find(pFont);
     if (index < 0) {
       m_Fonts.Add(pFont);
       pFont->Retain();
     }
     return pFont;
   }
-  return NULL;
+  return nullptr;
 }
 
 void CFGAS_StdFontMgrImp::ClearFontCache() {
   for (int32_t i = 0; i < m_Fonts.GetSize(); i++)
     m_Fonts[i]->Reset();
 }
 
 void CFGAS_StdFontMgrImp::RemoveFont(CFX_MapPtrToPtr& fontMap,
                                      CFGAS_GEFont* pFont) {
   FX_POSITION pos = fontMap.GetStartPosition();
   void* pKey;
   void* pFind;
   while (pos) {
-    pFind = NULL;
+    pFind = nullptr;
     fontMap.GetNextAssoc(pos, pKey, pFind);
     if (pFind != (void*)pFont) {
       continue;
     }
     fontMap.RemoveKey(pKey);
     break;
   }
 }
 
 void CFGAS_StdFontMgrImp::RemoveFont(CFGAS_GEFont* pFont) {
@@ skipping 24 matching lines @@
   params.pwsFamily = pszFontFamily;
   params.dwFontStyles = dwFontStyles;
   params.dwMatchFlags = dwMatchFlags;
   FX_FONTDESCRIPTOR const* pDesc = FX_DefFontMatcher(&params, m_FontFaces);
   if (pDesc) {
     return pDesc;
   }
   if (pszFontFamily && m_pEnumerator) {
     CFX_FontDescriptors namedFonts;
     m_pEnumerator(namedFonts, pszFontFamily, wUnicode);
-    params.pwsFamily = NULL;
+    params.pwsFamily = nullptr;
     pDesc = FX_DefFontMatcher(&params, namedFonts);
-    if (pDesc == NULL) {
-      return NULL;
+    if (!pDesc) {
+      return nullptr;
     }
     for (int32_t i = m_FontFaces.GetSize() - 1; i >= 0; i--) {
       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;
+  return nullptr;
 }
 
 FX_FONTDESCRIPTOR const* FX_DefFontMatcher(FX_LPFONTMATCHPARAMS pParams,
                                            const CFX_FontDescriptors& fonts) {
-  FX_FONTDESCRIPTOR const* pBestFont = NULL;
+  FX_FONTDESCRIPTOR const* pBestFont = nullptr;
   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) ==
         FX_FONTSTYLE_BoldItalic) {
       continue;
     }
@@ skipping 30 matching lines @@
       if (FXSYS_wcsicmp(pParams->pwsFamily, pFont->wsFontFace) == 0) {
         return pFont;
       }
     }
     int32_t iSimilarValue = FX_GetSimilarValue(pFont, pParams->dwFontStyles);
     if (iBestSimilar < iSimilarValue) {
       iBestSimilar = iSimilarValue;
       pBestFont = pFont;
     }
   }
-  return iBestSimilar < 1 ? NULL : pBestFont;
+  return iBestSimilar < 1 ? nullptr : 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) ==
@@ skipping 53 matching lines @@
   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);
+  HDC hDC = ::GetDC(nullptr);
   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);
+  ::ReleaseDC(nullptr, 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",
@@ skipping 13 matching lines @@
 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) {
+      m_FolderQueue.GetSize() != 0
+          ? m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->pFileHandle
+          : nullptr;
+  if (!pCurHandle) {
     if (m_FolderPaths.GetSize() < 1) {
       return "";
     }
     pCurHandle =
         FX_OpenFolder(m_FolderPaths[m_FolderPaths.GetSize() - 1].c_str());
     FX_HandleParentPath hpp;
     hpp.pFileHandle = pCurHandle;
     hpp.bsParentPath = m_FolderPaths[m_FolderPaths.GetSize() - 1];
     m_FolderQueue.Add(hpp);
   }
@@ skipping 19 matching lines @@
     }
     if (bsName == "." || bsName == "..") {
       continue;
     }
     if (bFolder) {
       FX_HandleParentPath hpp;
       hpp.bsParentPath =
           m_FolderQueue.GetDataPtr(m_FolderQueue.GetSize() - 1)->bsParentPath +
           bsFolderSpearator + bsName;
       hpp.pFileHandle = FX_OpenFolder(hpp.bsParentPath.c_str());
-      if (hpp.pFileHandle == NULL) {
+      if (!hpp.pFileHandle) {
         continue;
       }
       m_FolderQueue.Add(hpp);
       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()) {
+  if (m_wsNext.GetLength() == 0) {
     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());
   m_wsNext = GetNextFile().UTF8Decode();
-  pos = 0 != m_wsNext.GetLength() ? pAccess : NULL;
+  pos = m_wsNext.GetLength() != 0 ? pAccess : nullptr;
   return pAccess;
 }
 
 IFGAS_FontMgr* IFGAS_FontMgr::Create(CFX_FontSourceEnum_File* pFontEnum) {
   if (!pFontEnum)
     return nullptr;
 
   std::unique_ptr<CFGAS_FontMgrImp> pFontMgr(new CFGAS_FontMgrImp(pFontEnum));
   if (!pFontMgr->EnumFonts())
     return nullptr;
@@ skipping 164 matching lines @@
     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))
+  if (m_FailedUnicodes2Nullptr.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;
   CFX_ByteString bsHash;
   if (wCodePage == 0xFFFF)
     bsHash.Format("%d, %d, %d", wCodePage, wBitField, dwFontStyles);
   else
     bsHash.Format("%d, %d", wCodePage, dwFontStyles);
   bsHash += CFX_WideString(pszFontFamily).UTF8Encode();
@@ skipping 22 matching lines @@
     if (!VerifyUnicode(pDesc, wUnicode))
       continue;
     pFont = LoadFont(pDesc->m_wsFaceName, pDesc->m_nFaceIndex, nullptr);
     if (!pFont)
       continue;
     pFont->SetLogicalFontStyle(dwFontStyles);
     pFonts->Add(pFont);
     return pFont;
   }
   if (!pszFontFamily)
-    m_FailedUnicodes2NULL.SetAt(wUnicode, nullptr);
+    m_FailedUnicodes2Nullptr.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);
@@ skipping 325 matching lines @@
   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) {
+  if (!pEFont) {
     return;
   }
   IFX_FileRead* pFileRead;
   if (m_IFXFont2FileRead.Lookup(pEFont, pFileRead)) {
     pFileRead->Release();
     m_IFXFont2FileRead.RemoveKey(pEFont);
   }
   FX_POSITION pos;
   pos = m_Hash2Fonts.GetStartPosition();
   while (pos) {
     uint32_t dwHash;
     CFX_ArrayTemplate<CFGAS_GEFont*>* pFonts;
     m_Hash2Fonts.GetNextAssoc(pos, dwHash, pFonts);
-    if (NULL != pFonts) {
+    if (pFonts) {
       for (int32_t i = 0; i < pFonts->GetSize(); i++) {
         if (pFonts->GetAt(i) == pEFont) {
-          pFonts->SetAt(i, NULL);
+          pFonts->SetAt(i, nullptr);
         }
       }
     } else {
       m_Hash2Fonts.RemoveKey(dwHash);
     }
   }
 }
 
 void CFGAS_FontMgrImp::RegisterFace(FXFT_Face pFace,
                                     CFX_FontDescriptors& Fonts,
@@ skipping 70 matching lines @@
   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) {
+  if (!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);
   uint8_t* lpStr = lpTable + GetUInt16(sp + 2);
   for (uint16_t j = 0; j < nNameCount; j++) {
     uint16_t nNameID = GetUInt16(lpNameRecord + j * 12 + 6);
@@ skipping 109 matching lines @@
     charsets.push_back(FX_CHARSET_Default);
   }
   return charsets;
 }
 
 #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) {
+  if (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