Get rid of most instance of 'foo == NULL'

core/src/fpdfapi/fpdf_font/fpdf_font_cid.cpp

 // Copyright 2014 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 "font_int.h"
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_page.h"
@@ skipping 830 matching lines @@
   return TRUE;
 }
 
 FX_WORD CPDF_CMap::CIDFromCharCode(FX_DWORD charcode) const {
   if (m_Coding == CIDCODING_CID) {
     return (FX_WORD)charcode;
   }
   if (m_pEmbedMap) {
     return FPDFAPI_CIDFromCharCode(m_pEmbedMap, charcode);
   }
-  if (m_pMapping == NULL) {
+  if (!m_pMapping) {
     return (FX_WORD)charcode;
   }
   if (charcode >> 16) {
     if (m_pAddMapping) {
       void* found = FXSYS_bsearch(&charcode, m_pAddMapping + 4,
                                   *(FX_DWORD*)m_pAddMapping, 8, CompareCID);
-      if (found == NULL) {
+      if (!found) {
         if (m_pUseMap) {
           return m_pUseMap->CIDFromCharCode(charcode);
         }
         return 0;
       }
       return (FX_WORD)(((FX_DWORD*)found)[1] % 65536 + charcode -
                        *(FX_DWORD*)found);
     }
     if (m_pUseMap)
       return m_pUseMap->CIDFromCharCode(charcode);
@@ skipping 182 matching lines @@
 }
 CPDF_CIDFont::~CPDF_CIDFont() {
   if (m_pAnsiWidths) {
     FX_Free(m_pAnsiWidths);
   }
   delete m_pAllocatedCMap;
   delete m_pCIDToGIDMap;
   delete m_pTTGSUBTable;
 }
 FX_WORD CPDF_CIDFont::CIDFromCharCode(FX_DWORD charcode) const {
-  if (m_pCMap == NULL) {
+  if (!m_pCMap) {
     return (FX_WORD)charcode;
   }
   return m_pCMap->CIDFromCharCode(charcode);
 }
 FX_BOOL CPDF_CIDFont::IsVertWriting() const {
   return m_pCMap ? m_pCMap->IsVertWriting() : FALSE;
 }
 
 FX_WCHAR CPDF_CIDFont::_UnicodeFromCharCode(FX_DWORD charcode) const {
   switch (m_pCMap->m_Coding) {
     case CIDCODING_UCS2:
     case CIDCODING_UTF16:
       return (FX_WCHAR)charcode;
     case CIDCODING_CID:
-      if (m_pCID2UnicodeMap == NULL || !m_pCID2UnicodeMap->IsLoaded()) {
+      if (!m_pCID2UnicodeMap || !m_pCID2UnicodeMap->IsLoaded()) {
         return 0;
       }
       return m_pCID2UnicodeMap->UnicodeFromCID((FX_WORD)charcode);
   }
-  if (!m_pCMap->IsLoaded() || m_pCID2UnicodeMap == NULL ||
+  if (!m_pCMap->IsLoaded() || !m_pCID2UnicodeMap ||
       !m_pCID2UnicodeMap->IsLoaded()) {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
     FX_WCHAR unicode;
     int charsize = 1;
     if (charcode > 255) {
       charcode = (charcode % 256) * 256 + (charcode / 256);
       charsize = 2;
     }
     int ret = FXSYS_MultiByteToWideChar(g_CharsetCPs[m_pCMap->m_Coding], 0,
                                         (const FX_CHAR*)&charcode, charsize,
@@ skipping 12 matching lines @@
   return m_pCID2UnicodeMap->UnicodeFromCID(CIDFromCharCode(charcode));
 }
 FX_DWORD CPDF_CIDFont::_CharCodeFromUnicode(FX_WCHAR unicode) const {
   switch (m_pCMap->m_Coding) {
     case CIDCODING_UNKNOWN:
       return 0;
     case CIDCODING_UCS2:
     case CIDCODING_UTF16:
       return unicode;
     case CIDCODING_CID: {
-      if (m_pCID2UnicodeMap == NULL || !m_pCID2UnicodeMap->IsLoaded()) {
+      if (!m_pCID2UnicodeMap || !m_pCID2UnicodeMap->IsLoaded()) {
         return 0;
       }
       FX_DWORD CID = 0;
       while (CID < 65536) {
         FX_WCHAR this_unicode = m_pCID2UnicodeMap->UnicodeFromCID((FX_WORD)CID);
         if (this_unicode == unicode) {
           return CID;
         }
         CID++;
       }
@@ skipping 25 matching lines @@
   }
 #endif
   return 0;
 }
 
 FX_BOOL CPDF_CIDFont::_Load() {
   if (m_pFontDict->GetString("Subtype") == "TrueType") {
     return LoadGB2312();
   }
   CPDF_Array* pFonts = m_pFontDict->GetArray("DescendantFonts");
-  if (pFonts == NULL) {
+  if (!pFonts) {
     return FALSE;
   }
   if (pFonts->GetCount() != 1) {
     return FALSE;
   }
   CPDF_Dictionary* pCIDFontDict = pFonts->GetDict(0);
-  if (pCIDFontDict == NULL) {
+  if (!pCIDFontDict) {
     return FALSE;
   }
   m_BaseFont = pCIDFontDict->GetString("BaseFont");
   if ((m_BaseFont.Compare("CourierStd") == 0 ||
        m_BaseFont.Compare("CourierStd-Bold") == 0 ||
        m_BaseFont.Compare("CourierStd-BoldOblique") == 0 ||
        m_BaseFont.Compare("CourierStd-Oblique") == 0) &&
       !IsEmbedded()) {
     m_bAdobeCourierStd = TRUE;
   }
   CPDF_Dictionary* pFontDesc = pCIDFontDict->GetDict("FontDescriptor");
   if (pFontDesc) {
     LoadFontDescriptor(pFontDesc);
   }
   CPDF_Object* pEncoding = m_pFontDict->GetElementValue("Encoding");
-  if (pEncoding == NULL) {
+  if (!pEncoding) {
     return FALSE;
   }
   CFX_ByteString subtype = pCIDFontDict->GetString("Subtype");
   m_bType1 = (subtype == "CIDFontType0");
 
   if (pEncoding->IsName()) {
     CFX_ByteString cmap = pEncoding->GetString();
     m_pCMap =
         CPDF_ModuleMgr::Get()
             ->GetPageModule()
             ->GetFontGlobals()
             ->m_CMapManager.GetPredefinedCMap(cmap, m_pFontFile && m_bType1);
   } else if (CPDF_Stream* pStream = pEncoding->AsStream()) {
     m_pAllocatedCMap = m_pCMap = new CPDF_CMap;
     CPDF_StreamAcc acc;
     acc.LoadAllData(pStream, FALSE);
     m_pCMap->LoadEmbedded(acc.GetData(), acc.GetSize());
   } else {
     return FALSE;
   }
-  if (m_pCMap == NULL) {
+  if (!m_pCMap) {
     return FALSE;
   }
   m_Charset = m_pCMap->m_Charset;
   if (m_Charset == CIDSET_UNKNOWN) {
     CPDF_Dictionary* pCIDInfo = pCIDFontDict->GetDict("CIDSystemInfo");
     if (pCIDInfo) {
       m_Charset = CharsetFromOrdering(pCIDInfo->GetString("Ordering"));
     }
   }
   if (m_Charset != CIDSET_UNKNOWN)
     m_pCID2UnicodeMap =
         CPDF_ModuleMgr::Get()
             ->GetPageModule()
             ->GetFontGlobals()
             ->m_CMapManager.GetCID2UnicodeMap(
                 m_Charset,
-                m_pFontFile == NULL && (m_pCMap->m_Coding == CIDCODING_CID ||
-                                        pCIDFontDict->KeyExist("W")));
+                !m_pFontFile && (m_pCMap->m_Coding == CIDCODING_CID ||
+                                 pCIDFontDict->KeyExist("W")));
   if (m_Font.GetFace()) {
     if (m_bType1) {
       FXFT_Select_Charmap(m_Font.GetFace(), FXFT_ENCODING_UNICODE);
     } else {
       FT_UseCIDCharmap(m_Font.GetFace(), m_pCMap->m_Coding);
     }
   }
   m_DefaultWidth = pCIDFontDict->GetInteger("DW", 1000);
   CPDF_Array* pWidthArray = pCIDFontDict->GetArray("W");
   if (pWidthArray) {
@@ skipping 93 matching lines @@
         rect.top = TT2PDF(FXFT_Get_Glyph_HoriBearingY(face), face);
         rect.top += rect.top / 64;
         rect.bottom = TT2PDF(
             FXFT_Get_Glyph_HoriBearingY(face) - FXFT_Get_Glyph_Height(face),
             face);
       }
     }
   } else {
     rect = FX_RECT(0, 0, 0, 0);
   }
-  if (m_pFontFile == NULL && m_Charset == CIDSET_JAPAN1) {
+  if (!m_pFontFile && m_Charset == CIDSET_JAPAN1) {
     FX_WORD CID = CIDFromCharCode(charcode);
     const uint8_t* pTransform = GetCIDTransform(CID);
     if (pTransform && !bVert) {
       CFX_Matrix matrix(CIDTransformToFloat(pTransform[0]),
                         CIDTransformToFloat(pTransform[1]),
                         CIDTransformToFloat(pTransform[2]),
                         CIDTransformToFloat(pTransform[3]),
                         CIDTransformToFloat(pTransform[4]) * 1000,
                         CIDTransformToFloat(pTransform[5]) * 1000);
       CFX_FloatRect rect_f(rect);
@@ skipping 104 matching lines @@
   }
   if (pVertGlyph) {
     *pVertGlyph = FALSE;
   }
   return index;
 }
 int CPDF_CIDFont::GlyphFromCharCode(FX_DWORD charcode, FX_BOOL* pVertGlyph) {
   if (pVertGlyph) {
     *pVertGlyph = FALSE;
   }
-  if (m_pFontFile == NULL && m_pCIDToGIDMap == NULL) {
+  if (!m_pFontFile && !m_pCIDToGIDMap) {
     FX_WORD cid = CIDFromCharCode(charcode);
     FX_WCHAR unicode = 0;
     if (m_bCIDIsGID) {
 #if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
       return cid;
 #else
       if (m_Flags & PDFFONT_SYMBOLIC) {
         return cid;
       }
       CFX_WideString uni_str = UnicodeFromCharCode(charcode);
@@ skipping 25 matching lines @@
       if (!bMSUnicode) {
         bMacRoman = FT_UseTTCharmap(face, 1, 0);
       }
       iBaseEncoding = PDFFONT_ENCODING_STANDARD;
       if (bMSUnicode) {
         iBaseEncoding = PDFFONT_ENCODING_WINANSI;
       } else if (bMacRoman) {
         iBaseEncoding = PDFFONT_ENCODING_MACROMAN;
       }
       const FX_CHAR* name = GetAdobeCharName(iBaseEncoding, NULL, charcode);
-      if (name == NULL) {
+      if (!name) {
         return charcode == 0 ? -1 : (int)charcode;
       }
       FX_WORD unicode = PDF_UnicodeFromAdobeName(name);
       if (unicode) {
         if (bMSUnicode) {
           index = FXFT_Get_Char_Index(face, unicode);
         } else if (bMacRoman) {
           FX_DWORD maccode =
               FT_CharCodeFromUnicode(FXFT_ENCODING_APPLE_ROMAN, unicode);
           index = !maccode ? FXFT_Get_Name_Index(face, (char*)name)
@@ skipping 91 matching lines @@
 int CPDF_CIDFont::GetCharSize(FX_DWORD charcode) const {
   return m_pCMap->GetCharSize(charcode);
 }
 int CPDF_CIDFont::CountChar(const FX_CHAR* pString, int size) const {
   return m_pCMap->CountChar(pString, size);
 }
 int CPDF_CIDFont::AppendChar(FX_CHAR* str, FX_DWORD charcode) const {
   return m_pCMap->AppendChar(str, charcode);
 }
 FX_BOOL CPDF_CIDFont::IsUnicodeCompatible() const {
-  if (!m_pCMap->IsLoaded() || m_pCID2UnicodeMap == NULL ||
+  if (!m_pCMap->IsLoaded() || !m_pCID2UnicodeMap ||
       !m_pCID2UnicodeMap->IsLoaded()) {
     return m_pCMap->m_Coding != CIDCODING_UNKNOWN;
   }
   return TRUE;
 }
 FX_BOOL CPDF_CIDFont::IsFontStyleFromCharCode(FX_DWORD charcode) const {
   return TRUE;
 }
 void CPDF_CIDFont::LoadSubstFont() {
   m_Font.LoadSubst(m_BaseFont, !m_bType1, m_Flags, m_StemV * 5, m_ItalicAngle,
@@ skipping 86 matching lines @@
 
 const uint8_t* CPDF_CIDFont::GetCIDTransform(FX_WORD CID) const {
   if (m_Charset != CIDSET_JAPAN1 || m_pFontFile)
     return nullptr;
 
   const struct CIDTransform* found = (const struct CIDTransform*)FXSYS_bsearch(
       &CID, g_Japan1_VertCIDs, FX_ArraySize(g_Japan1_VertCIDs),
       sizeof(g_Japan1_VertCIDs[0]), CompareCIDTransform);
   return found ? &found->a : nullptr;
 }