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

core/src/fpdfapi/fpdf_font/fpdf_font.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/src/fpdfapi/fpdf_page/pageint.h"
 #include "core/include/fpdfapi/fpdf_module.h"
@@ skipping 333 matching lines @@
     if (rect.bottom == rect.top) {
       m_Descent = m_FontBBox.bottom;
     } else {
       m_Descent = rect.bottom;
     }
   }
 }
 void CPDF_Font::LoadUnicodeMap() {
   m_bToUnicodeLoaded = TRUE;
   CPDF_Stream* pStream = m_pFontDict->GetStream("ToUnicode");
-  if (pStream == NULL) {
+  if (!pStream) {
     return;
   }
   m_pToUnicodeMap = new CPDF_ToUnicodeMap;
   m_pToUnicodeMap->Load(pStream);
 }
 int CPDF_Font::GetStringWidth(const FX_CHAR* pString, int size) {
   int offset = 0;
   int width = 0;
   while (offset < size) {
     FX_DWORD charcode = GetNextChar(pString, size, offset);
@@ skipping 53 matching lines @@
       CFX_ByteString tag = basefont.Left(4);
       int i;
       int count = sizeof(ChineseFontNames) / sizeof(ChineseFontNames[0]);
       for (i = 0; i < count; ++i) {
         if (tag == CFX_ByteString((const FX_CHAR*)ChineseFontNames[i])) {
           break;
         }
       }
       if (i < count) {
         CPDF_Dictionary* pFontDesc = pFontDict->GetDict("FontDescriptor");
-        if (pFontDesc == NULL || !pFontDesc->KeyExist("FontFile2")) {
+        if (!pFontDesc || !pFontDesc->KeyExist("FontFile2")) {
           pFont = new CPDF_CIDFont;
           pFont->m_pFontDict = pFontDict;
           pFont->m_pDocument = pDoc;
           if (!pFont->Load()) {
             delete pFont;
             return NULL;
           }
           return pFont;
         }
       }
 #endif
     }
     pFont = new CPDF_TrueTypeFont;
   } else if (type == "Type3") {
     pFont = new CPDF_Type3Font;
   } else if (type == "Type0") {
     pFont = new CPDF_CIDFont;
   } else {
     pFont = new CPDF_Type1Font;
   }
   pFont->m_pFontDict = pFontDict;
   pFont->m_pDocument = pDoc;
   if (!pFont->Load()) {
     delete pFont;
     return NULL;
   }
   return pFont;
 }
 FX_BOOL CPDF_Font::Load() {
-  if (m_pFontDict == NULL) {
+  if (!m_pFontDict) {
     return FALSE;
   }
   CFX_ByteString type = m_pFontDict->GetString("Subtype");
   m_BaseFont = m_pFontDict->GetString("BaseFont");
   if (type == "MMType1") {
     type = "Type1";
   }
   return _Load();
 }
 static CFX_WideString _FontMap_GetWideString(CFX_CharMap* pMap,
@@ skipping 12 matching lines @@
 CFX_WideString CPDF_ToUnicodeMap::Lookup(FX_DWORD charcode) {
   auto it = m_Map.find(charcode);
   if (it != m_Map.end()) {
     FX_DWORD value = it->second;
     FX_WCHAR unicode = (FX_WCHAR)(value & 0xffff);
     if (unicode != 0xffff) {
       return unicode;
     }
     const FX_WCHAR* buf = m_MultiCharBuf.GetBuffer();
     FX_DWORD buf_len = m_MultiCharBuf.GetLength();
-    if (buf == NULL || buf_len == 0) {
+    if (!buf || buf_len == 0) {
       return CFX_WideString();
     }
     FX_DWORD index = value >> 16;
     if (index >= buf_len) {
       return CFX_WideString();
     }
     FX_DWORD len = buf[index];
     if (index + len < index || index + len >= buf_len) {
       return CFX_WideString();
     }
@@ skipping 195 matching lines @@
   } else {
     return FALSE;
   }
   return TRUE;
 }
 void CPDF_Font::LoadPDFEncoding(CPDF_Object* pEncoding,
                                 int& iBaseEncoding,
                                 CFX_ByteString*& pCharNames,
                                 FX_BOOL bEmbedded,
                                 FX_BOOL bTrueType) {
-  if (pEncoding == NULL) {
+  if (!pEncoding) {
     if (m_BaseFont == "Symbol") {
       iBaseEncoding = bTrueType ? PDFFONT_ENCODING_MS_SYMBOL
                                 : PDFFONT_ENCODING_ADOBE_SYMBOL;
     } else if (!bEmbedded && iBaseEncoding == PDFFONT_ENCODING_BUILTIN) {
       iBaseEncoding = PDFFONT_ENCODING_WINANSI;
     }
     return;
   }
   if (pEncoding->IsName()) {
     if (iBaseEncoding == PDFFONT_ENCODING_ADOBE_SYMBOL ||
@@ skipping 23 matching lines @@
     CFX_ByteString bsEncoding = pDict->GetString("BaseEncoding");
     if (bsEncoding.Compare("MacExpertEncoding") == 0 && bTrueType) {
       bsEncoding = "WinAnsiEncoding";
     }
     GetPredefinedEncoding(iBaseEncoding, bsEncoding);
   }
   if ((!bEmbedded || bTrueType) && iBaseEncoding == PDFFONT_ENCODING_BUILTIN) {
     iBaseEncoding = PDFFONT_ENCODING_STANDARD;
   }
   CPDF_Array* pDiffs = pDict->GetArray("Differences");
-  if (pDiffs == NULL) {
+  if (!pDiffs) {
     return;
   }
   pCharNames = new CFX_ByteString[256];
   FX_DWORD cur_code = 0;
   for (FX_DWORD i = 0; i < pDiffs->GetCount(); i++) {
     CPDF_Object* pElement = pDiffs->GetElementValue(i);
     if (!pElement)
       continue;
 
     if (CPDF_Name* pName = pElement->AsName()) {
@@ skipping 110 matching lines @@
                                 const CFX_ByteString* pCharNames,
                                 int charcode) {
   ASSERT(charcode >= 0 && charcode < 256);
   if (charcode < 0 || charcode >= 256) {
     return NULL;
   }
   const FX_CHAR* name = NULL;
   if (pCharNames) {
     name = pCharNames[charcode];
   }
-  if ((name == NULL || name[0] == 0) && iBaseEncoding) {
+  if ((!name || name[0] == 0) && iBaseEncoding) {
     name = PDF_CharNameFromPredefinedCharSet(iBaseEncoding, charcode);
   }
-  if (name == NULL || name[0] == 0) {
-    return NULL;
-  }
-  return name;
+  return name && name[0] ? name : nullptr;
 }
 FX_BOOL CPDF_SimpleFont::LoadCommon() {
   CPDF_Dictionary* pFontDesc = m_pFontDict->GetDict("FontDescriptor");
   if (pFontDesc) {
     LoadFontDescriptor(pFontDesc);
   }
   CPDF_Array* pWidthArray = m_pFontDict->GetArray("Widths");
   int width_start = 0, width_end = -1;
   m_bUseFontWidth = TRUE;
   if (pWidthArray) {
@@ skipping 221 matching lines @@
         return;
       }
     }
     FXFT_Select_Charmap(m_Font.GetFace(), FXFT_ENCODING_UNICODE);
     if (m_BaseEncoding == 0) {
       m_BaseEncoding = PDFFONT_ENCODING_STANDARD;
     }
     for (int charcode = 0; charcode < 256; charcode++) {
       const FX_CHAR* name =
           GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
-      if (name == NULL) {
+      if (!name) {
         continue;
       }
       m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
       m_GlyphIndex[charcode] = FXFT_Get_Char_Index(
           m_Font.GetFace(), m_Encoding.m_Unicodes[charcode]);
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
       FX_CHAR name_glyph[256];
       FXFT_Get_Glyph_Name(m_Font.GetFace(), m_GlyphIndex[charcode], name_glyph,
                           256);
       name_glyph[255] = 0;
@@ skipping 80 matching lines @@
       }
       return;
     }
     FX_BOOL bUnicode = FALSE;
     if (0 == FXFT_Select_Charmap(m_Font.GetFace(), FXFT_ENCODING_UNICODE)) {
       bUnicode = TRUE;
     }
     for (int charcode = 0; charcode < 256; charcode++) {
       const FX_CHAR* name =
           GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
-      if (name == NULL) {
+      if (!name) {
         continue;
       }
       m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
       const FX_CHAR* pStrUnicode = _GlyphNameRemap(name);
       if (pStrUnicode &&
           0 == FXFT_Get_Name_Index(m_Font.GetFace(), (char*)name)) {
         name = pStrUnicode;
       }
       m_GlyphIndex[charcode] =
           FXFT_Get_Name_Index(m_Font.GetFace(), (char*)name);
@@ skipping 79 matching lines @@
 #endif
     return;
   }
   FX_BOOL bUnicode = FALSE;
   if (0 == FXFT_Select_Charmap(m_Font.GetFace(), FXFT_ENCODING_UNICODE)) {
     bUnicode = TRUE;
   }
   for (int charcode = 0; charcode < 256; charcode++) {
     const FX_CHAR* name =
         GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
-    if (name == NULL) {
+    if (!name) {
       continue;
     }
     m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
     m_GlyphIndex[charcode] = FXFT_Get_Name_Index(m_Font.GetFace(), (char*)name);
     if (m_GlyphIndex[charcode] == 0) {
       if (FXSYS_strcmp(name, ".notdef") != 0 &&
           FXSYS_strcmp(name, "space") != 0) {
         m_GlyphIndex[charcode] = FXFT_Get_Char_Index(
             m_Font.GetFace(),
             bUnicode ? m_Encoding.m_Unicodes[charcode] : charcode);
@@ skipping 104 matching lines @@
     if (baseEncoding == PDFFONT_ENCODING_WINANSI && !bSupportWin) {
       baseEncoding =
           bSupportMac ? PDFFONT_ENCODING_MACROMAN : PDFFONT_ENCODING_BUILTIN;
     } else if (baseEncoding == PDFFONT_ENCODING_MACROMAN && !bSupportMac) {
       baseEncoding =
           bSupportWin ? PDFFONT_ENCODING_WINANSI : PDFFONT_ENCODING_BUILTIN;
     }
   }
   if (((baseEncoding == PDFFONT_ENCODING_MACROMAN ||
         baseEncoding == PDFFONT_ENCODING_WINANSI) &&
-       m_pCharNames == NULL) ||
+       !m_pCharNames) ||
       (m_Flags & PDFFONT_NONSYMBOLIC)) {
     if (!FXFT_Has_Glyph_Names(m_Font.GetFace()) &&
         (!m_Font.GetFace()->num_charmaps || !m_Font.GetFace()->charmaps)) {
       int nStartChar = m_pFontDict->GetInteger("FirstChar");
       if (nStartChar < 0 || nStartChar > 255)
         return;
 
       int charcode = 0;
       for (; charcode < nStartChar; charcode++) {
         m_GlyphIndex[charcode] = 0;
@@ skipping 12 matching lines @@
         bMSSymbol = !bMacRoman && FT_UseTTCharmap(m_Font.GetFace(), 3, 0);
       } else {
         bMSSymbol = FT_UseTTCharmap(m_Font.GetFace(), 3, 0);
         bMacRoman = !bMSSymbol && FT_UseTTCharmap(m_Font.GetFace(), 1, 0);
       }
     }
     FX_BOOL bToUnicode = m_pFontDict->KeyExist("ToUnicode");
     for (int charcode = 0; charcode < 256; charcode++) {
       const FX_CHAR* name =
           GetAdobeCharName(baseEncoding, m_pCharNames, charcode);
-      if (name == NULL) {
+      if (!name) {
         m_GlyphIndex[charcode] =
             m_pFontFile ? FXFT_Get_Char_Index(m_Font.GetFace(), charcode) : -1;
         continue;
       }
       m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
       if (bMSSymbol) {
         const uint8_t prefix[4] = {0x00, 0xf0, 0xf1, 0xf2};
         for (int j = 0; j < 4; j++) {
           FX_WORD unicode = prefix[j] * 256 + charcode;
           m_GlyphIndex[charcode] =
@@ skipping 55 matching lines @@
           bGotOne = TRUE;
           break;
         }
       }
     }
     if (bGotOne) {
       if (baseEncoding != PDFFONT_ENCODING_BUILTIN) {
         for (int charcode = 0; charcode < 256; charcode++) {
           const FX_CHAR* name =
               GetAdobeCharName(baseEncoding, m_pCharNames, charcode);
-          if (name == NULL) {
+          if (!name) {
             continue;
           }
           m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
         }
       } else if (FT_UseTTCharmap(m_Font.GetFace(), 1, 0)) {
         for (int charcode = 0; charcode < 256; charcode++) {
           m_Encoding.m_Unicodes[charcode] =
               FT_UnicodeFromCharCode(FXFT_ENCODING_APPLE_ROMAN, charcode);
         }
       }
@@ skipping 186 matching lines @@
   rect = pChar->m_BBox;
 }
 
 CPDF_Type3Char::CPDF_Type3Char(CPDF_Form* pForm)
     : m_pForm(pForm), m_pBitmap(nullptr), m_bColored(FALSE) {}
 
 CPDF_Type3Char::~CPDF_Type3Char() {
   delete m_pForm;
   delete m_pBitmap;
 }