Get rid of NULLs in xfa/

xfa/fxfa/parser/xfa_basic_imp.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 "xfa/fxfa/parser/xfa_basic_imp.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fgas/crt/fgas_codepage.h"
@@ skipping 18 matching lines @@
     int32_t iMid = (iStart + iEnd) / 2;
     const XFA_PACKETINFO* pInfo = g_XFAPacketData + iMid;
     if (uHash == pInfo->uHash) {
       return pInfo;
     } else if (uHash < pInfo->uHash) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
-  return NULL;
+  return nullptr;
 }
 
 const XFA_PACKETINFO* XFA_GetPacketByID(uint32_t dwPacket) {
   int32_t iStart = 0, iEnd = g_iXFAPacketCount - 1;
   do {
     int32_t iMid = (iStart + iEnd) / 2;
     uint32_t dwFind = (g_XFAPacketData + iMid)->eName;
     if (dwPacket == dwFind) {
       return g_XFAPacketData + iMid;
     } else if (dwPacket < dwFind) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
-  return NULL;
+  return nullptr;
 }
 
 const XFA_PACKETINFO* XFA_GetPacketByIndex(XFA_PACKET ePacket) {
   return g_XFAPacketData + ePacket;
 }
 
 const XFA_ATTRIBUTEENUMINFO* XFA_GetAttributeEnumByName(
     const CFX_WideStringC& wsName) {
   if (wsName.IsEmpty())
     return nullptr;
 
   uint32_t uHash = FX_HashCode_GetW(wsName, false);
   int32_t iStart = 0;
   int32_t iEnd = g_iXFAEnumCount - 1;
   do {
     int32_t iMid = (iStart + iEnd) / 2;
     const XFA_ATTRIBUTEENUMINFO* pInfo = g_XFAEnumData + iMid;
     if (uHash == pInfo->uHash) {
       return pInfo;
     } else if (uHash < pInfo->uHash) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
-  return NULL;
+  return nullptr;
 }
 const XFA_ATTRIBUTEENUMINFO* XFA_GetAttributeEnumByID(XFA_ATTRIBUTEENUM eName) {
   return g_XFAEnumData + eName;
 }
 
 const XFA_ATTRIBUTEINFO* XFA_GetAttributeByName(const CFX_WideStringC& wsName) {
   if (wsName.IsEmpty())
     return nullptr;
 
   uint32_t uHash = FX_HashCode_GetW(wsName, false);
   int32_t iStart = 0;
   int32_t iEnd = g_iXFAAttributeCount - 1;
   do {
     int32_t iMid = (iStart + iEnd) / 2;
     const XFA_ATTRIBUTEINFO* pInfo = g_XFAAttributeData + iMid;
     if (uHash == pInfo->uHash) {
       return pInfo;
     } else if (uHash < pInfo->uHash) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
   return nullptr;
 }
 const XFA_ATTRIBUTEINFO* XFA_GetAttributeByID(XFA_ATTRIBUTE eName) {
-  return (eName < g_iXFAAttributeCount) ? (g_XFAAttributeData + eName) : NULL;
+  return (eName < g_iXFAAttributeCount) ? (g_XFAAttributeData + eName)
+                                        : nullptr;
 }
 FX_BOOL XFA_GetAttributeDefaultValue(void*& pValue,
                                      XFA_ELEMENT eElement,
                                      XFA_ATTRIBUTE eAttribute,
                                      XFA_ATTRIBUTETYPE eType,
                                      uint32_t dwPacket) {
   const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttribute);
-  if (pInfo == NULL) {
+  if (!pInfo)
     return FALSE;
-  }
+
   if (dwPacket && (dwPacket & pInfo->dwPackets) == 0) {
     return FALSE;
   }
   if (pInfo->eType == eType) {
     pValue = pInfo->pDefValue;
     return TRUE;
   } else if (pInfo->eType == XFA_ATTRIBUTETYPE_NOTSURE) {
     const XFA_NOTSUREATTRIBUTE* pAttr =
         XFA_GetNotsureAttribute(eElement, eAttribute, eType);
     if (pAttr) {
@@ skipping 14 matching lines @@
   return XFA_ATTRIBUTEENUM_Unknown;
 }
 CFX_WideStringC XFA_GetAttributeDefaultValue_Cdata(XFA_ELEMENT eElement,
                                                    XFA_ATTRIBUTE eAttribute,
                                                    uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Cdata, dwPacket)) {
     return (const FX_WCHAR*)pValue;
   }
-  return NULL;
+  return nullptr;
 }
 FX_BOOL XFA_GetAttributeDefaultValue_Boolean(XFA_ELEMENT eElement,
                                              XFA_ATTRIBUTE eAttribute,
                                              uint32_t dwPacket) {
   void* pValue;
   if (XFA_GetAttributeDefaultValue(pValue, eElement, eAttribute,
                                    XFA_ATTRIBUTETYPE_Boolean, dwPacket)) {
     return (FX_BOOL)(uintptr_t)pValue;
   }
   return FALSE;
@@ skipping 21 matching lines @@
     int32_t iMid = (iStart + iEnd) / 2;
     const XFA_ELEMENTINFO* pInfo = g_XFAElementData + iMid;
     if (uHash == pInfo->uHash) {
       return pInfo;
     } else if (uHash < pInfo->uHash) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
-  return NULL;
+  return nullptr;
 }
 const XFA_ELEMENTINFO* XFA_GetElementByID(XFA_ELEMENT eName) {
-  return (eName < g_iXFAElementCount) ? (g_XFAElementData + eName) : NULL;
+  return (eName < g_iXFAElementCount) ? (g_XFAElementData + eName) : nullptr;
 }
 const uint16_t* XFA_GetElementChildren(XFA_ELEMENT eElement, int32_t& iCount) {
   if (eElement >= g_iXFAElementCount) {
-    return NULL;
+    return nullptr;
   }
   const XFA_ELEMENTHIERARCHY* pElement = g_XFAElementChildrenIndex + eElement;
   iCount = pElement->wCount;
   return g_XFAElementChildrenData + pElement->wStart;
 }
 const uint8_t* XFA_GetElementAttributes(XFA_ELEMENT eElement, int32_t& iCount) {
   if (eElement >= g_iXFAElementCount) {
-    return NULL;
+    return nullptr;
   }
   const XFA_ELEMENTHIERARCHY* pElement = g_XFAElementAttributeIndex + eElement;
   iCount = pElement->wCount;
   return g_XFAElementAttributeData + pElement->wStart;
 }
 
 const XFA_ATTRIBUTEINFO* XFA_GetAttributeOfElement(XFA_ELEMENT eElement,
                                                    XFA_ATTRIBUTE eAttribute,
                                                    uint32_t dwPacket) {
   int32_t iCount = 0;
   const uint8_t* pAttr = XFA_GetElementAttributes(eElement, iCount);
   if (!pAttr || iCount < 1)
     return nullptr;
 
   if (!std::binary_search(pAttr, pAttr + iCount, eAttribute))
     return nullptr;
 
   const XFA_ATTRIBUTEINFO* pInfo = XFA_GetAttributeByID(eAttribute);
   ASSERT(pInfo);
   if (dwPacket == XFA_XDPPACKET_UNKNOWN)
     return pInfo;
   return (dwPacket & pInfo->dwPackets) ? pInfo : nullptr;
 }
 
 const XFA_PROPERTY* XFA_GetElementProperties(XFA_ELEMENT eElement,
                                              int32_t& iCount) {
   if (eElement >= g_iXFAElementCount) {
-    return NULL;
+    return nullptr;
   }
   const XFA_ELEMENTHIERARCHY* pElement = g_XFAElementPropertyIndex + eElement;
   iCount = pElement->wCount;
   return g_XFAElementPropertyData + pElement->wStart;
 }
 const XFA_PROPERTY* XFA_GetPropertyOfElement(XFA_ELEMENT eElement,
                                              XFA_ELEMENT eProperty,
                                              uint32_t dwPacket) {
   int32_t iCount = 0;
   const XFA_PROPERTY* pProperty = XFA_GetElementProperties(eElement, iCount);
-  if (pProperty == NULL || iCount < 1) {
-    return NULL;
-  }
+  if (!pProperty || iCount < 1)
+    return nullptr;
+
   int32_t iStart = 0, iEnd = iCount - 1, iMid;
   do {
     iMid = (iStart + iEnd) / 2;
     XFA_ELEMENT eName = (XFA_ELEMENT)pProperty[iMid].eName;
     if (eProperty == eName) {
       break;
     } else if (eProperty < eName) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
   if (iStart > iEnd) {
-    return NULL;
+    return nullptr;
   }
   const XFA_ELEMENTINFO* pInfo = XFA_GetElementByID(eProperty);
   ASSERT(pInfo);
   if (dwPacket == XFA_XDPPACKET_UNKNOWN)
     return pProperty + iMid;
-  return (dwPacket & pInfo->dwPackets) ? (pProperty + iMid) : NULL;
+  return (dwPacket & pInfo->dwPackets) ? (pProperty + iMid) : nullptr;
 }
 const XFA_NOTSUREATTRIBUTE* XFA_GetNotsureAttribute(XFA_ELEMENT eElement,
                                                     XFA_ATTRIBUTE eAttribute,
                                                     XFA_ATTRIBUTETYPE eType) {
   int32_t iStart = 0, iEnd = g_iXFANotsureCount - 1;
   do {
     int32_t iMid = (iStart + iEnd) / 2;
     const XFA_NOTSUREATTRIBUTE* pAttr = g_XFANotsureAttributes + iMid;
     if (eElement == pAttr->eElement) {
       if (pAttr->eAttribute == eAttribute) {
         if (eType == XFA_ATTRIBUTETYPE_NOTSURE || eType == pAttr->eType) {
           return pAttr;
         }
-        return NULL;
+        return nullptr;
       } else {
         int32_t iBefore = iMid - 1;
         if (iBefore >= 0) {
           pAttr = g_XFANotsureAttributes + iBefore;
           while (eElement == pAttr->eElement) {
             if (pAttr->eAttribute == eAttribute) {
               if (eType == XFA_ATTRIBUTETYPE_NOTSURE || eType == pAttr->eType) {
                 return pAttr;
               }
-              return NULL;
+              return nullptr;
             }
             iBefore--;
             if (iBefore < 0) {
               break;
             }
             pAttr = g_XFANotsureAttributes + iBefore;
           }
         }
         int32_t iAfter = iMid + 1;
         if (iAfter <= g_iXFANotsureCount - 1) {
           pAttr = g_XFANotsureAttributes + iAfter;
           while (eElement == pAttr->eElement) {
             if (pAttr->eAttribute == eAttribute) {
               if (eType == XFA_ATTRIBUTETYPE_NOTSURE || eType == pAttr->eType) {
                 return pAttr;
               }
-              return NULL;
+              return nullptr;
             }
             iAfter++;
             if (iAfter > g_iXFANotsureCount - 1) {
               break;
             }
             pAttr = g_XFANotsureAttributes + iAfter;
           }
         }
-        return NULL;
+        return nullptr;
       }
     } else if (eElement < pAttr->eElement) {
       iEnd = iMid - 1;
     } else {
       iStart = iMid + 1;
     }
   } while (iStart <= iEnd);
-  return NULL;
+  return nullptr;
 }
 
 const XFA_METHODINFO* XFA_GetMethodByName(XFA_ELEMENT eElement,
                                           const CFX_WideStringC& wsMethodName) {
   if (wsMethodName.IsEmpty())
     return nullptr;
 
   int32_t iElementIndex = eElement;
   while (iElementIndex != -1) {
     const XFA_SCRIPTHIERARCHY* scriptIndex = g_XFAScriptIndex + iElementIndex;
@@ skipping 11 matching lines @@
       if (uHash == pInfo->uHash) {
         return pInfo;
       } else if (uHash < pInfo->uHash) {
         iEnd = iMid - 1;
       } else {
         iStart = iMid + 1;
       }
     } while (iStart <= iEnd);
     iElementIndex = scriptIndex->wParentIndex;
   }
-  return NULL;
+  return nullptr;
 }
 const XFA_SCRIPTATTRIBUTEINFO* XFA_GetScriptAttributeByName(
     XFA_ELEMENT eElement,
     const CFX_WideStringC& wsAttributeName) {
   if (wsAttributeName.IsEmpty())
     return nullptr;
 
   int32_t iElementIndex = eElement;
   while (iElementIndex != -1) {
     const XFA_SCRIPTHIERARCHY* scriptIndex = g_XFAScriptIndex + iElementIndex;
@@ skipping 10 matching lines @@
       if (uHash == pInfo->uHash) {
         return pInfo;
       } else if (uHash < pInfo->uHash) {
         iEnd = iMid - 1;
       } else {
         iStart = iMid + 1;
       }
     } while (iStart <= iEnd);
     iElementIndex = scriptIndex->wParentIndex;
   }
-  return NULL;
+  return nullptr;
 }
 void CXFA_Measurement::Set(const CFX_WideStringC& wsMeasure) {
   if (wsMeasure.IsEmpty()) {
     m_fValue = 0;
     m_eUnit = XFA_UNIT_Unknown;
     return;
   }
   int32_t iUsedLen = 0;
   int32_t iOffset = (wsMeasure.GetAt(0) == L'=') ? 1 : 0;
   FX_FLOAT fValue = FX_wcstof(wsMeasure.c_str() + iOffset,
@@ skipping 161 matching lines @@
   m_iPosition += iMaxLength;
   bEOS = IsEOF();
   return iMaxLength;
 }
 uint16_t CXFA_WideTextRead::GetCodePage() const {
   return (sizeof(FX_WCHAR) == 2) ? FX_CODEPAGE_UTF16LE : FX_CODEPAGE_UTF32LE;
 }
 uint16_t CXFA_WideTextRead::SetCodePage(uint16_t wCodePage) {
   return GetCodePage();
 }