Get rid of NULLs in xfa/

xfa/fde/xml/fde_xml_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/fde/xml/fde_xml_imp.h"
 
 #include <algorithm>
 
@@ skipping 56 matching lines @@
       if (bFirstChar) {
         return g_XMLNameChars[iMid].bStartChar;
       }
       return TRUE;
     }
   }
   return FALSE;
 }
 
 CFDE_XMLNode::CFDE_XMLNode()
-    : m_pParent(NULL), m_pChild(NULL), m_pPrior(NULL), m_pNext(NULL) {}
+    : m_pParent(nullptr),
+      m_pChild(nullptr),
+      m_pPrior(nullptr),
+      m_pNext(nullptr) {}
 CFDE_XMLNode::~CFDE_XMLNode() {
   DeleteChildren();
 }
 void CFDE_XMLNode::DeleteChildren() {
   CFDE_XMLNode *pChild = m_pChild, *pTemp;
-  while (pChild != NULL) {
+  while (pChild) {
     pTemp = pChild->m_pNext;
     pChild->Release();
     pChild = pTemp;
   }
-  m_pChild = NULL;
+  m_pChild = nullptr;
 }
 int32_t CFDE_XMLNode::CountChildNodes() const {
   int32_t iCount = 0;
   CFDE_XMLNode* pChild = m_pChild;
-  while (pChild != NULL) {
+  while (pChild) {
     iCount++;
     pChild = pChild->m_pNext;
   }
   return iCount;
 }
 CFDE_XMLNode* CFDE_XMLNode::GetChildNode(int32_t index) const {
   CFDE_XMLNode* pChild = m_pChild;
-  while (pChild != NULL) {
+  while (pChild) {
     if (index == 0) {
       return pChild;
     }
     index--;
     pChild = pChild->m_pNext;
   }
-  return NULL;
+  return nullptr;
 }
 int32_t CFDE_XMLNode::GetChildNodeIndex(CFDE_XMLNode* pNode) const {
   int32_t index = 0;
   CFDE_XMLNode* pChild = m_pChild;
-  while (pChild != NULL) {
+  while (pChild) {
     if (pChild == pNode) {
       return index;
     }
     index++;
     pChild = pChild->m_pNext;
   }
   return -1;
 }
 CFDE_XMLNode* CFDE_XMLNode::GetPath(const FX_WCHAR* pPath,
                                     int32_t iLength,
                                     FX_BOOL bQualifiedName) const {
-  ASSERT(pPath != NULL);
+  ASSERT(pPath);
   if (iLength < 0) {
     iLength = FXSYS_wcslen(pPath);
   }
   if (iLength == 0) {
-    return NULL;
+    return nullptr;
   }
   CFX_WideString csPath;
   const FX_WCHAR* pStart = pPath;
   const FX_WCHAR* pEnd = pPath + iLength;
   FX_WCHAR ch;
   while (pStart < pEnd) {
     ch = *pStart++;
     if (ch == L'/') {
       break;
     } else {
       csPath += ch;
     }
   }
   iLength -= pStart - pPath;
-  CFDE_XMLNode* pFind = NULL;
+  CFDE_XMLNode* pFind = nullptr;
   if (csPath.GetLength() < 1) {
     pFind = GetNodeItem(CFDE_XMLNode::Root);
   } else if (csPath.Compare(L"..") == 0) {
     pFind = m_pParent;
   } else if (csPath.Compare(L".") == 0) {
     pFind = (CFDE_XMLNode*)this;
   } else {
     CFX_WideString wsTag;
     CFDE_XMLNode* pNode = m_pChild;
-    while (pNode != NULL) {
+    while (pNode) {
       if (pNode->GetType() == FDE_XMLNODE_Element) {
         if (bQualifiedName) {
           ((CFDE_XMLElement*)pNode)->GetTagName(wsTag);
         } else {
           ((CFDE_XMLElement*)pNode)->GetLocalTagName(wsTag);
         }
         if (wsTag.Compare(csPath) == 0) {
           if (iLength < 1) {
             pFind = pNode;
           } else {
             pFind = pNode->GetPath(pStart, iLength, bQualifiedName);
           }
-          if (pFind != NULL) {
+          if (pFind)
             return pFind;
-          }
         }
       }
       pNode = pNode->m_pNext;
     }
   }
-  if (pFind == NULL || iLength < 1) {
+  if (!pFind || iLength < 1)
     return pFind;
-  }
   return pFind->GetPath(pStart, iLength, bQualifiedName);
 }
 int32_t CFDE_XMLNode::InsertChildNode(CFDE_XMLNode* pNode, int32_t index) {
-  ASSERT(pNode != NULL);
   pNode->m_pParent = this;
-  if (m_pChild == NULL) {
+  if (!m_pChild) {
     m_pChild = pNode;
-    pNode->m_pPrior = NULL;
-    pNode->m_pNext = NULL;
+    pNode->m_pPrior = nullptr;
+    pNode->m_pNext = nullptr;
     return 0;
-  } else if (index == 0) {
+  }
+  if (index == 0) {
     pNode->m_pNext = m_pChild;
-    pNode->m_pPrior = NULL;
+    pNode->m_pPrior = nullptr;
     m_pChild->m_pPrior = pNode;
     m_pChild = pNode;
     return 0;
   }
   int32_t iCount = 0;
   CFDE_XMLNode* pFind = m_pChild;
-  while (++iCount != index && pFind->m_pNext != NULL) {
+  while (++iCount != index && pFind->m_pNext) {
     pFind = pFind->m_pNext;
   }
   pNode->m_pPrior = pFind;
   pNode->m_pNext = pFind->m_pNext;
-  if (pFind->m_pNext != NULL) {
+  if (pFind->m_pNext)
     pFind->m_pNext->m_pPrior = pNode;
-  }
   pFind->m_pNext = pNode;
   return iCount;
 }
 void CFDE_XMLNode::RemoveChildNode(CFDE_XMLNode* pNode) {
-  ASSERT(m_pChild != NULL && pNode != NULL);
+  ASSERT(m_pChild && pNode);
   if (m_pChild == pNode) {
     m_pChild = pNode->m_pNext;
   } else {
     pNode->m_pPrior->m_pNext = pNode->m_pNext;
   }
-  if (pNode->m_pNext != NULL) {
+  if (pNode->m_pNext)
     pNode->m_pNext->m_pPrior = pNode->m_pPrior;
-  }
-  pNode->m_pParent = NULL;
-  pNode->m_pNext = NULL;
-  pNode->m_pPrior = NULL;
+  pNode->m_pParent = nullptr;
+  pNode->m_pNext = nullptr;
+  pNode->m_pPrior = nullptr;
 }
 CFDE_XMLNode* CFDE_XMLNode::GetNodeItem(CFDE_XMLNode::NodeItem eItem) const {
   switch (eItem) {
     case CFDE_XMLNode::Root: {
       CFDE_XMLNode* pParent = (CFDE_XMLNode*)this;
-      while (pParent->m_pParent != NULL) {
+      while (pParent->m_pParent) {
         pParent = pParent->m_pParent;
       }
       return pParent;
     }
     case CFDE_XMLNode::Parent:
       return m_pParent;
     case CFDE_XMLNode::FirstSibling: {
       CFDE_XMLNode* pItem = (CFDE_XMLNode*)this;
-      while (pItem->m_pPrior != NULL) {
+      while (pItem->m_pPrior) {
         pItem = pItem->m_pPrior;
       }
-      return pItem == (CFDE_XMLNode*)this ? NULL : pItem;
+      return pItem == (CFDE_XMLNode*)this ? nullptr : pItem;
     }
     case CFDE_XMLNode::PriorSibling:
       return m_pPrior;
     case CFDE_XMLNode::NextSibling:
       return m_pNext;
     case CFDE_XMLNode::LastSibling: {
       CFDE_XMLNode* pItem = (CFDE_XMLNode*)this;
-      while (pItem->m_pNext != NULL) {
+      while (pItem->m_pNext)
         pItem = pItem->m_pNext;
-      }
-      return pItem == (CFDE_XMLNode*)this ? NULL : pItem;
+      return pItem == (CFDE_XMLNode*)this ? nullptr : pItem;
     }
     case CFDE_XMLNode::FirstNeighbor: {
       CFDE_XMLNode* pParent = (CFDE_XMLNode*)this;
-      while (pParent->m_pParent != NULL) {
+      while (pParent->m_pParent)
         pParent = pParent->m_pParent;
-      }
-      return pParent == (CFDE_XMLNode*)this ? NULL : pParent;
+      return pParent == (CFDE_XMLNode*)this ? nullptr : pParent;
     }
     case CFDE_XMLNode::PriorNeighbor: {
-      if (m_pPrior == NULL) {
+      if (!m_pPrior)
         return m_pParent;
-      }
+
       CFDE_XMLNode* pItem = m_pPrior;
-      while (CFDE_XMLNode* pTemp = pItem->m_pChild) {
-        pItem = pTemp;
-        while ((pTemp = pItem->m_pNext) != NULL) {
-          pItem = pTemp;
-        }
+      while (pItem->m_pChild) {
+        pItem = pItem->m_pChild;
+        while (pItem->m_pNext)
+          pItem = pItem->m_pNext;
       }
       return pItem;
     }
     case CFDE_XMLNode::NextNeighbor: {
-      if (m_pChild != NULL) {
+      if (m_pChild)
         return m_pChild;
-      }
-      if (m_pNext != NULL) {
+      if (m_pNext)
         return m_pNext;
-      }
       CFDE_XMLNode* pItem = m_pParent;
-      while (pItem != NULL) {
-        if (pItem->m_pNext != NULL) {
+      while (pItem) {
+        if (pItem->m_pNext)
           return pItem->m_pNext;
-        }
         pItem = pItem->m_pParent;
       }
-      return NULL;
+      return nullptr;
     }
     case CFDE_XMLNode::LastNeighbor: {
       CFDE_XMLNode* pItem = (CFDE_XMLNode*)this;
-      while (pItem->m_pParent != NULL) {
+      while (pItem->m_pParent) {
         pItem = pItem->m_pParent;
       }
       while (TRUE) {
-        while (pItem->m_pNext != NULL) {
+        while (pItem->m_pNext)
           pItem = pItem->m_pNext;
-        }
-        if (pItem->m_pChild == NULL) {
+        if (!pItem->m_pChild)
           break;
-        }
         pItem = pItem->m_pChild;
       }
-      return pItem == (CFDE_XMLNode*)this ? NULL : pItem;
+      return pItem == (CFDE_XMLNode*)this ? nullptr : pItem;
     }
     case CFDE_XMLNode::FirstChild:
       return m_pChild;
     case CFDE_XMLNode::LastChild: {
-      if (m_pChild == NULL) {
-        return NULL;
-      }
+      if (!m_pChild)
+        return nullptr;
+
       CFDE_XMLNode* pChild = m_pChild;
-      while (pChild->m_pNext != NULL) {
+      while (pChild->m_pNext)
         pChild = pChild->m_pNext;
-      }
       return pChild;
     }
     default:
       break;
   }
-  return NULL;
+  return nullptr;
 }
 int32_t CFDE_XMLNode::GetNodeLevel() const {
   int32_t iLevel = 0;
   CFDE_XMLNode* pItem = (CFDE_XMLNode*)this;
-  while ((pItem = pItem->m_pParent) != NULL) {
+  while ((pItem = pItem->m_pParent) != nullptr) {
     iLevel++;
   }
   return iLevel;
 }
 FX_BOOL CFDE_XMLNode::InsertNodeItem(CFDE_XMLNode::NodeItem eItem,
                                      CFDE_XMLNode* pNode) {
-  ASSERT(pNode != NULL);
   switch (eItem) {
     case CFDE_XMLNode::NextSibling: {
       pNode->m_pParent = m_pParent;
       pNode->m_pNext = m_pNext;
       pNode->m_pPrior = this;
       if (m_pNext) {
         m_pNext->m_pPrior = pNode;
       }
       m_pNext = pNode;
       return TRUE;
     }
     case CFDE_XMLNode::PriorSibling: {
       pNode->m_pParent = m_pParent;
       pNode->m_pNext = this;
       pNode->m_pPrior = m_pPrior;
       if (m_pPrior) {
         m_pPrior->m_pNext = pNode;
       } else if (m_pParent) {
         m_pParent->m_pChild = pNode;
       }
       m_pPrior = pNode;
       return TRUE;
     }
     default:
       return FALSE;
   }
 }
 CFDE_XMLNode* CFDE_XMLNode::RemoveNodeItem(CFDE_XMLNode::NodeItem eItem) {
-  CFDE_XMLNode* pNode = NULL;
+  CFDE_XMLNode* pNode = nullptr;
   switch (eItem) {
     case CFDE_XMLNode::NextSibling:
       if (m_pNext) {
         pNode = m_pNext;
         m_pNext = pNode->m_pNext;
         if (m_pNext) {
           m_pNext->m_pPrior = this;
         }
-        pNode->m_pParent = NULL;
-        pNode->m_pNext = NULL;
-        pNode->m_pPrior = NULL;
+        pNode->m_pParent = nullptr;
+        pNode->m_pNext = nullptr;
+        pNode->m_pPrior = nullptr;
       }
       break;
     default:
       break;
   }
   return pNode;
 }
 CFDE_XMLNode* CFDE_XMLNode::Clone(FX_BOOL bRecursive) {
-  return NULL;
+  return nullptr;
 }
 void CFDE_XMLNode::SaveXMLNode(IFX_Stream* pXMLStream) {
   CFDE_XMLNode* pNode = (CFDE_XMLNode*)this;
-  ASSERT(pXMLStream != NULL && pNode != NULL);
   switch (pNode->GetType()) {
     case FDE_XMLNODE_Instruction: {
       CFX_WideString ws;
       CFDE_XMLInstruction* pInstruction = (CFDE_XMLInstruction*)pNode;
       if (pInstruction->m_wsTarget.CompareNoCase(L"xml") == 0) {
         ws = L"<?xml version=\"1.0\" encoding=\"";
         uint16_t wCodePage = pXMLStream->GetCodePage();
         if (wCodePage == FX_CODEPAGE_UTF16LE) {
           ws += L"UTF-16";
         } else if (wCodePage == FX_CODEPAGE_UTF16BE) {
@@ skipping 50 matching lines @@
         wsValue = attributes[i + 1];
         wsValue.Replace(L"&", L"&amp;");
         wsValue.Replace(L"<", L"&lt;");
         wsValue.Replace(L">", L"&gt;");
         wsValue.Replace(L"\'", L"&apos;");
         wsValue.Replace(L"\"", L"&quot;");
         ws += wsValue;
         ws += L"\"";
         pXMLStream->WriteString(ws.c_str(), ws.GetLength());
       }
-      if (pNode->m_pChild == NULL) {
-        ws = L"\n/>";
-        pXMLStream->WriteString(ws.c_str(), ws.GetLength());
-      } else {
+      if (pNode->m_pChild) {
         ws = L"\n>";
         pXMLStream->WriteString(ws.c_str(), ws.GetLength());
         CFDE_XMLNode* pChild = pNode->m_pChild;
-        while (pChild != NULL) {
+        while (pChild) {
           pChild->SaveXMLNode(pXMLStream);
           pChild = pChild->m_pNext;
         }
         ws = L"</";
         ws += ((CFDE_XMLElement*)pNode)->m_wsTag;
         ws += L"\n>";
-        pXMLStream->WriteString(ws.c_str(), ws.GetLength());
+      } else {
+        ws = L"\n/>";
       }
+      pXMLStream->WriteString(ws.c_str(), ws.GetLength());
     } break;
     case FDE_XMLNODE_Text: {
       CFX_WideString ws = ((CFDE_XMLText*)pNode)->m_wsText;
       ws.Replace(L"&", L"&amp;");
       ws.Replace(L"<", L"&lt;");
       ws.Replace(L">", L"&gt;");
       ws.Replace(L"\'", L"&apos;");
       ws.Replace(L"\"", L"&quot;");
       pXMLStream->WriteString(ws.c_str(), ws.GetLength());
     } break;
@@ skipping 157 matching lines @@
 CFDE_XMLElement::CFDE_XMLElement(const CFX_WideString& wsTag)
     : CFDE_XMLNode(), m_wsTag(wsTag), m_Attributes() {
   ASSERT(m_wsTag.GetLength() > 0);
 }
 CFDE_XMLElement::~CFDE_XMLElement() {
   m_Attributes.RemoveAll();
 }
 CFDE_XMLNode* CFDE_XMLElement::Clone(FX_BOOL bRecursive) {
   CFDE_XMLElement* pClone = new CFDE_XMLElement(m_wsTag);
   if (!pClone) {
-    return NULL;
+    return nullptr;
   }
   pClone->m_Attributes.Copy(m_Attributes);
   if (bRecursive) {
     CloneChildren(pClone);
   } else {
     CFX_WideString wsText;
     CFDE_XMLNode* pChild = m_pChild;
-    while (pChild != NULL) {
+    while (pChild) {
       switch (pChild->GetType()) {
         case FDE_XMLNODE_Text:
           wsText += ((CFDE_XMLText*)pChild)->m_wsText;
           break;
         default:
           break;
       }
       pChild = pChild->m_pNext;
     }
     pClone->SetTextData(wsText);
@@ skipping 21 matching lines @@
 }
 void CFDE_XMLElement::GetNamespaceURI(CFX_WideString& wsNamespace) const {
   CFX_WideString wsAttri(L"xmlns"), wsPrefix;
   GetNamespacePrefix(wsPrefix);
   if (wsPrefix.GetLength() > 0) {
     wsAttri += L":";
     wsAttri += wsPrefix;
   }
   wsNamespace.clear();
   CFDE_XMLNode* pNode = (CFDE_XMLNode*)this;
-  while (pNode != NULL) {
+  while (pNode) {
     if (pNode->GetType() != FDE_XMLNODE_Element) {
       break;
     }
     CFDE_XMLElement* pElement = (CFDE_XMLElement*)pNode;
     if (!pElement->HasAttribute(wsAttri.c_str())) {
       pNode = pNode->GetNodeItem(CFDE_XMLNode::Parent);
       continue;
     }
     pElement->GetString(wsAttri.c_str(), wsNamespace);
     break;
@@ skipping 90 matching lines @@
     if (m_Attributes[i].Compare(pwsAttriName) == 0) {
       m_Attributes.RemoveAt(i + 1);
       m_Attributes.RemoveAt(i);
       return;
     }
   }
 }
 void CFDE_XMLElement::GetTextData(CFX_WideString& wsText) const {
   CFX_WideTextBuf buffer;
   CFDE_XMLNode* pChild = m_pChild;
-  while (pChild != NULL) {
+  while (pChild) {
     switch (pChild->GetType()) {
       case FDE_XMLNODE_Text:
         buffer << ((CFDE_XMLText*)pChild)->m_wsText;
         break;
       case FDE_XMLNODE_CharData:
         buffer << ((CFDE_XMLCharData*)pChild)->m_wsCharData;
         break;
       default:
         break;
     }
@@ skipping 15 matching lines @@
 }
 
 CFDE_XMLCharData::CFDE_XMLCharData(const CFX_WideString& wsCData)
     : CFDE_XMLDeclaration(), m_wsCharData(wsCData) {}
 CFDE_XMLNode* CFDE_XMLCharData::Clone(FX_BOOL bRecursive) {
   CFDE_XMLCharData* pClone = new CFDE_XMLCharData(m_wsCharData);
   return pClone;
 }
 
 CFDE_XMLDoc::CFDE_XMLDoc()
-    : m_pRoot(NULL), m_pSyntaxParser(NULL), m_pXMLParser(NULL) {
+    : m_pRoot(nullptr), m_pSyntaxParser(nullptr), m_pXMLParser(nullptr) {
   Reset(TRUE);
   CFDE_XMLInstruction* pXML = new CFDE_XMLInstruction(L"xml");
   m_pRoot->InsertChildNode(pXML);
 }
 CFDE_XMLDoc::~CFDE_XMLDoc() {
   Reset(FALSE);
 }
 void CFDE_XMLDoc::Reset(FX_BOOL bInitRoot) {
   m_iStatus = 0;
-  m_pStream = NULL;
+  m_pStream = nullptr;
   if (bInitRoot) {
-    if (m_pRoot == NULL) {
+    if (m_pRoot)
+      m_pRoot->DeleteChildren();
+    else
       m_pRoot = new CFDE_XMLNode;
-    } else {
-      m_pRoot->DeleteChildren();
-    }
   } else {
-    if (m_pRoot != NULL) {
+    if (m_pRoot) {
       m_pRoot->Release();
-      m_pRoot = NULL;
+      m_pRoot = nullptr;
     }
   }
   ReleaseParser();
 }
 void CFDE_XMLDoc::ReleaseParser() {
-  if (m_pXMLParser != NULL) {
+  if (m_pXMLParser) {
     m_pXMLParser->Release();
-    m_pXMLParser = NULL;
+    m_pXMLParser = nullptr;
   }
-  if (m_pSyntaxParser != NULL) {
+  if (m_pSyntaxParser) {
     m_pSyntaxParser->Release();
-    m_pSyntaxParser = NULL;
+    m_pSyntaxParser = nullptr;
   }
 }
 FX_BOOL CFDE_XMLDoc::LoadXML(IFX_Stream* pXMLStream,
                              int32_t iXMLPlaneSize,
                              int32_t iTextDataSize,
                              FDE_XMLREADERHANDLER* pHandler) {
-  if (pXMLStream == NULL) {
+  if (!pXMLStream)
     return FALSE;
-  }
+
   Reset(TRUE);
   iXMLPlaneSize = iXMLPlaneSize / 1024;
   if (iXMLPlaneSize < 1) {
     iXMLPlaneSize = 1;
   }
   iXMLPlaneSize *= 1024;
   if (iXMLPlaneSize < 4096) {
     iXMLPlaneSize = 4096;
   }
   iTextDataSize = iTextDataSize / 128;
   if (iTextDataSize < 1) {
     iTextDataSize = 1;
   }
   iTextDataSize *= 128;
   if (iTextDataSize < 128) {
     iTextDataSize = 128;
   }
   m_pStream = pXMLStream;
   uint16_t wCodePage = m_pStream->GetCodePage();
   if (wCodePage != FX_CODEPAGE_UTF16LE && wCodePage != FX_CODEPAGE_UTF16BE &&
       wCodePage != FX_CODEPAGE_UTF8) {
     m_pStream->SetCodePage(FX_CODEPAGE_UTF8);
   }
   m_pSyntaxParser = new CFDE_XMLSyntaxParser;
-  if (m_pSyntaxParser == NULL) {
-    return FALSE;
-  }
+
   m_pSyntaxParser->Init(m_pStream, iXMLPlaneSize, iTextDataSize);
-  if (pHandler == NULL) {
+  if (pHandler)
+    m_pXMLParser = new CFDE_XMLSAXParser(pHandler, m_pSyntaxParser);
+  else
     m_pXMLParser = new CFDE_XMLDOMParser(m_pRoot, m_pSyntaxParser);
-  } else {
-    m_pXMLParser = new CFDE_XMLSAXParser(pHandler, m_pSyntaxParser);
-  }
   return TRUE;
 }
 FX_BOOL CFDE_XMLDoc::LoadXML(CFDE_XMLParser* pXMLParser) {
-  if (pXMLParser == NULL) {
+  if (!pXMLParser)
     return FALSE;
-  }
+
   Reset(TRUE);
   m_pXMLParser = pXMLParser;
-  return m_pXMLParser != NULL;
+  return !!m_pXMLParser;
 }
 int32_t CFDE_XMLDoc::DoLoad(IFX_Pause* pPause) {
-  if (m_iStatus >= 100) {
+  if (m_iStatus >= 100)
     return m_iStatus;
-  }
-  ASSERT(m_pXMLParser != NULL);
   return m_iStatus = m_pXMLParser->DoParser(pPause);
 }
 void CFDE_XMLDoc::CloseXML() {
   ReleaseParser();
 }
 void CFDE_XMLDoc::SaveXMLNode(IFX_Stream* pXMLStream, CFDE_XMLNode* pINode) {
   CFDE_XMLNode* pNode = (CFDE_XMLNode*)pINode;
-  ASSERT(pXMLStream != NULL && pNode != NULL);
   switch (pNode->GetType()) {
     case FDE_XMLNODE_Instruction: {
       CFX_WideString ws;
       CFDE_XMLInstruction* pInstruction = (CFDE_XMLInstruction*)pNode;
       if (pInstruction->m_wsTarget.CompareNoCase(L"xml") == 0) {
         ws = L"<?xml version=\"1.0\" encoding=\"";
         uint16_t wCodePage = pXMLStream->GetCodePage();
         if (wCodePage == FX_CODEPAGE_UTF16LE) {
           ws += L"UTF-16";
         } else if (wCodePage == FX_CODEPAGE_UTF16BE) {
@@ skipping 50 matching lines @@
         wsValue = attributes[i + 1];
         wsValue.Replace(L"&", L"&amp;");
         wsValue.Replace(L"<", L"&lt;");
         wsValue.Replace(L">", L"&gt;");
         wsValue.Replace(L"\'", L"&apos;");
         wsValue.Replace(L"\"", L"&quot;");
         ws += wsValue;
         ws += L"\"";
         pXMLStream->WriteString(ws.c_str(), ws.GetLength());
       }
-      if (pNode->m_pChild == NULL) {
-        ws = L"\n/>";
-        pXMLStream->WriteString(ws.c_str(), ws.GetLength());
-      } else {
+      if (pNode->m_pChild) {
         ws = L"\n>";
         pXMLStream->WriteString(ws.c_str(), ws.GetLength());
         CFDE_XMLNode* pChild = pNode->m_pChild;
-        while (pChild != NULL) {
+        while (pChild) {
           SaveXMLNode(pXMLStream, static_cast<CFDE_XMLNode*>(pChild));
           pChild = pChild->m_pNext;
         }
         ws = L"</";
         ws += ((CFDE_XMLElement*)pNode)->m_wsTag;
         ws += L"\n>";
-        pXMLStream->WriteString(ws.c_str(), ws.GetLength());
+      } else {
+        ws = L"\n/>";
       }
+      pXMLStream->WriteString(ws.c_str(), ws.GetLength());
     } break;
     case FDE_XMLNODE_Text: {
       CFX_WideString ws = ((CFDE_XMLText*)pNode)->m_wsText;
       ws.Replace(L"&", L"&amp;");
       ws.Replace(L"<", L"&lt;");
       ws.Replace(L">", L"&gt;");
       ws.Replace(L"\'", L"&apos;");
       ws.Replace(L"\"", L"&quot;");
       pXMLStream->WriteString(ws.c_str(), ws.GetLength());
     } break;
     case FDE_XMLNODE_CharData: {
       CFX_WideString ws = L"<![CDATA[";
       ws += ((CFDE_XMLCharData*)pNode)->m_wsCharData;
       ws += L"]]>";
       pXMLStream->WriteString(ws.c_str(), ws.GetLength());
     } break;
     case FDE_XMLNODE_Unknown:
       break;
     default:
       break;
   }
 }
 void CFDE_XMLDoc::SaveXML(IFX_Stream* pXMLStream, FX_BOOL bSaveBOM) {
-  if (pXMLStream == NULL || pXMLStream == m_pStream) {
+  if (!pXMLStream || pXMLStream == m_pStream) {
     m_pStream->Seek(FX_STREAMSEEK_Begin, 0);
     pXMLStream = m_pStream;
   }
   ASSERT((pXMLStream->GetAccessModes() & FX_STREAMACCESS_Text) != 0);
   ASSERT((pXMLStream->GetAccessModes() & FX_STREAMACCESS_Write) != 0);
   uint16_t wCodePage = pXMLStream->GetCodePage();
   if (wCodePage != FX_CODEPAGE_UTF16LE && wCodePage != FX_CODEPAGE_UTF16BE &&
       wCodePage != FX_CODEPAGE_UTF8) {
     wCodePage = FX_CODEPAGE_UTF8;
     pXMLStream->SetCodePage(wCodePage);
   }
   if (bSaveBOM) {
     pXMLStream->WriteString(L"\xFEFF", 1);
   }
   CFDE_XMLNode* pNode = m_pRoot->m_pChild;
-  while (pNode != NULL) {
+  while (pNode) {
     SaveXMLNode(pXMLStream, static_cast<CFDE_XMLNode*>(pNode));
     pNode = pNode->m_pNext;
   }
   if (pXMLStream == m_pStream) {
     int32_t iPos = pXMLStream->GetPosition();
     pXMLStream->SetLength(iPos);
   }
 }
 CFDE_XMLDOMParser::CFDE_XMLDOMParser(CFDE_XMLNode* pRoot,
                                      CFDE_XMLSyntaxParser* pParser)
     : m_pParser(pParser),
       m_pParent(pRoot),
-      m_pChild(NULL),
+      m_pChild(nullptr),
       m_NodeStack(16),
       m_ws1(),
       m_ws2() {
   m_NodeStack.Push(m_pParent);
 }
 CFDE_XMLDOMParser::~CFDE_XMLDOMParser() {
   m_NodeStack.RemoveAll();
   m_ws1.clear();
   m_ws2.clear();
 }
@@ skipping 46 matching lines @@
         m_pParser->GetTagName(m_ws1);
         m_pChild = new CFDE_XMLElement(m_ws1);
         m_pParent->InsertChildNode(m_pChild);
         m_NodeStack.Push(m_pChild);
         m_pParent = m_pChild;
         break;
       case FDE_XmlSyntaxResult::AttriName:
         m_pParser->GetAttributeName(m_ws1);
         break;
       case FDE_XmlSyntaxResult::AttriValue:
-        if (m_pChild == NULL) {
+        if (!m_pChild) {
           syntaxParserResult = FDE_XmlSyntaxResult::Error;
           break;
         }
         m_pParser->GetAttributeName(m_ws2);
         if (m_pChild->GetType() == FDE_XMLNODE_Element) {
           ((CFDE_XMLElement*)m_pChild)->SetString(m_ws1, m_ws2);
         } else if (m_pChild->GetType() == FDE_XMLNODE_Instruction) {
           ((CFDE_XMLInstruction*)m_pChild)->SetString(m_ws1, m_ws2);
         }
         m_ws1.clear();
         break;
       case FDE_XmlSyntaxResult::Text:
         m_pParser->GetTextData(m_ws1);
         m_pChild = new CFDE_XMLText(m_ws1);
         m_pParent->InsertChildNode(m_pChild);
         m_pChild = m_pParent;
         break;
       case FDE_XmlSyntaxResult::CData:
         m_pParser->GetTextData(m_ws1);
         m_pChild = new CFDE_XMLCharData(m_ws1);
         m_pParent->InsertChildNode(m_pChild);
         m_pChild = m_pParent;
         break;
       case FDE_XmlSyntaxResult::TargetData:
-        if (m_pChild == NULL ||
-            m_pChild->GetType() != FDE_XMLNODE_Instruction) {
+        if (!m_pChild || m_pChild->GetType() != FDE_XMLNODE_Instruction) {
           syntaxParserResult = FDE_XmlSyntaxResult::Error;
           break;
         }
         if (!m_ws1.IsEmpty()) {
           ((CFDE_XMLInstruction*)m_pChild)->AppendData(m_ws1);
         }
         m_pParser->GetTargetData(m_ws1);
         ((CFDE_XMLInstruction*)m_pChild)->AppendData(m_ws1);
         m_ws1.clear();
         break;
       default:
         break;
     }
     if (syntaxParserResult == FDE_XmlSyntaxResult::Error ||
         syntaxParserResult == FDE_XmlSyntaxResult::EndOfString) {
       break;
     }
-    if (pPause != NULL && iCount > 500 && pPause->NeedToPauseNow()) {
+    if (pPause && iCount > 500 && pPause->NeedToPauseNow()) {
       break;
     }
   }
   return m_pParser->GetStatus();
 }
 CFDE_XMLSAXParser::CFDE_XMLSAXParser(FDE_XMLREADERHANDLER* pHandler,
                                      CFDE_XMLSyntaxParser* pParser)
     : m_pHandler(pHandler),
       m_pParser(pParser),
       m_TagStack(16),
-      m_pTagTop(NULL),
+      m_pTagTop(nullptr),
       m_ws1(),
       m_ws2() {}
 CFDE_XMLSAXParser::~CFDE_XMLSAXParser() {
   m_TagStack.RemoveAll();
   m_ws1.clear();
   m_ws2.clear();
 }
 int32_t CFDE_XMLSAXParser::DoParser(IFX_Pause* pPause) {
   FDE_XmlSyntaxResult syntaxParserResult;
   int32_t iCount = 0;
   while (TRUE) {
     syntaxParserResult = m_pParser->DoSyntaxParse();
     switch (syntaxParserResult) {
       case FDE_XmlSyntaxResult::ElementBreak:
-        if (m_pTagTop == NULL) {
+        if (!m_pTagTop) {
           syntaxParserResult = FDE_XmlSyntaxResult::Error;
           break;
         }
         if (m_pTagTop->eType == FDE_XMLNODE_Element) {
           m_pHandler->OnTagBreak(m_pHandler, m_pTagTop->wsTagName);
         }
         break;
       case FDE_XmlSyntaxResult::ElementClose:
-        if (m_pTagTop == NULL || m_pTagTop->eType != FDE_XMLNODE_Element) {
+        if (!m_pTagTop || m_pTagTop->eType != FDE_XMLNODE_Element) {
           syntaxParserResult = FDE_XmlSyntaxResult::Error;
           break;
         }
         m_pParser->GetTagName(m_ws1);
         if (m_ws1.GetLength() > 0 && m_ws1.Compare(m_pTagTop->wsTagName) != 0) {
           syntaxParserResult = FDE_XmlSyntaxResult::Error;
           break;
         } else if (m_ws1.GetLength() == 0) {
           m_pHandler->OnTagBreak(m_pHandler, m_pTagTop->wsTagName);
         }
@@ skipping 18 matching lines @@
         xmlTag.eType = FDE_XMLNODE_Element;
         Push(xmlTag);
         m_pHandler->OnTagEnter(m_pHandler, FDE_XMLNODE_Element,
                                m_pTagTop->wsTagName);
       } break;
       case FDE_XmlSyntaxResult::AttriName:
         m_pParser->GetTargetName(m_ws1);
         break;
       case FDE_XmlSyntaxResult::AttriValue:
         m_pParser->GetAttributeName(m_ws2);
-        if (m_pTagTop == NULL) {
+        if (!m_pTagTop) {
           syntaxParserResult = FDE_XmlSyntaxResult::Error;
           break;
         }
         if (m_pTagTop->eType == FDE_XMLNODE_Element) {
           m_pHandler->OnAttribute(m_pHandler, m_ws1, m_ws2);
         }
         m_ws1.clear();
         break;
       case FDE_XmlSyntaxResult::CData:
         m_pParser->GetTextData(m_ws1);
         m_pHandler->OnData(m_pHandler, FDE_XMLNODE_CharData, m_ws1);
         break;
       case FDE_XmlSyntaxResult::Text:
         m_pParser->GetTextData(m_ws1);
         m_pHandler->OnData(m_pHandler, FDE_XMLNODE_Text, m_ws1);
         break;
       case FDE_XmlSyntaxResult::TargetData:
         m_pParser->GetTargetData(m_ws1);
         m_pHandler->OnData(m_pHandler, FDE_XMLNODE_Instruction, m_ws1);
         m_ws1.clear();
         break;
       default:
         break;
     }
     if (syntaxParserResult == FDE_XmlSyntaxResult::Error ||
         syntaxParserResult == FDE_XmlSyntaxResult::EndOfString) {
       break;
     }
-    if (pPause != NULL && iCount > 500 && pPause->NeedToPauseNow()) {
+    if (pPause && iCount > 500 && pPause->NeedToPauseNow()) {
       break;
     }
   }
   return m_pParser->GetStatus();
 }
 inline void CFDE_XMLSAXParser::Push(const CFDE_XMLTAG& xmlTag) {
   m_TagStack.Push(xmlTag);
   m_pTagTop = m_TagStack.GetTopElement();
 }
 inline void CFDE_XMLSAXParser::Pop() {
@@ skipping 153 matching lines @@
       m_syntaxParserState(FDE_XmlSyntaxState::Text),
       m_wQuotationMark(0),
       m_iEntityStart(-1),
       m_SkipStack(16) {
   m_CurNode.iNodeNum = -1;
   m_CurNode.eNodeType = FDE_XMLNODE_Unknown;
 }
 void CFDE_XMLSyntaxParser::Init(IFX_Stream* pStream,
                                 int32_t iXMLPlaneSize,
                                 int32_t iTextDataSize) {
-  ASSERT(m_pStream == NULL && m_pBuffer == NULL);
-  ASSERT(pStream != NULL && iXMLPlaneSize > 0);
+  ASSERT(!m_pStream && !m_pBuffer);
+  ASSERT(pStream && iXMLPlaneSize > 0);
   int32_t iStreamLength = pStream->GetLength();
   ASSERT(iStreamLength > 0);
   m_pStream = pStream;
   m_iXMLPlaneSize = std::min(iXMLPlaneSize, iStreamLength);
   uint8_t bom[4];
   m_iCurrentPos = m_pStream->GetBOM(bom);
-  ASSERT(m_pBuffer == NULL);
+  ASSERT(!m_pBuffer);
 
   FX_SAFE_INT32 alloc_size_safe = m_iXMLPlaneSize;
   alloc_size_safe += 1;  // For NUL.
   if (!alloc_size_safe.IsValid() || alloc_size_safe.ValueOrDie() <= 0) {
     m_syntaxParserResult = FDE_XmlSyntaxResult::Error;
     return;
   }
 
   m_pBuffer = FX_Alloc(FX_WCHAR, alloc_size_safe.ValueOrDie());
   m_pStart = m_pEnd = m_pBuffer;
@@ skipping 226 matching lines @@
             m_iDataLength++;
             m_syntaxParserState = FDE_XmlSyntaxState::TargetData;
           } else if (m_iDataLength > 0) {
             m_iTextDataLength = m_iDataLength;
             m_BlockBuffer.Reset();
             m_pCurrentBlock = m_BlockBuffer.GetAvailableBlock(m_iIndexInBlock);
             syntaxParserResult = FDE_XmlSyntaxResult::TargetData;
           } else {
             m_pStart++;
             FDE_XMLNODE* pXMLNode = m_XMLNodeStack.GetTopElement();
-            if (pXMLNode == NULL) {
+            if (!pXMLNode) {
               m_syntaxParserResult = FDE_XmlSyntaxResult::Error;
               return m_syntaxParserResult;
             }
             m_XMLNodeStack.Pop();
             pXMLNode = m_XMLNodeStack.GetTopElement();
-            if (pXMLNode == NULL) {
+            if (pXMLNode) {
+              m_CurNode = *pXMLNode;
+            } else {
               m_CurNode.iNodeNum = -1;
               m_CurNode.eNodeType = FDE_XMLNODE_Unknown;
-            } else {
-              m_CurNode = *pXMLNode;
             }
             m_iCurrentNodeNum = m_CurNode.iNodeNum;
             m_BlockBuffer.Reset();
             m_pCurrentBlock = m_BlockBuffer.GetAvailableBlock(m_iIndexInBlock);
             m_syntaxParserState = FDE_XmlSyntaxState::Text;
             syntaxParserResult = FDE_XmlSyntaxResult::InstructionClose;
           }
           break;
         case FDE_XmlSyntaxState::BreakElement:
           if (ch == L'>') {
             m_syntaxParserState = FDE_XmlSyntaxState::Text;
             syntaxParserResult = FDE_XmlSyntaxResult::ElementBreak;
           } else if (ch == L'/') {
             m_syntaxParserState = FDE_XmlSyntaxState::CloseElement;
           } else {
             m_syntaxParserResult = FDE_XmlSyntaxResult::Error;
             return m_syntaxParserResult;
           }
           m_pStart++;
           break;
         case FDE_XmlSyntaxState::CloseElement:
           if (!FDE_IsXMLNameChar(ch, m_iDataLength < 1)) {
             if (ch == L'>') {
               FDE_XMLNODE* pXMLNode = m_XMLNodeStack.GetTopElement();
-              if (pXMLNode == NULL) {
+              if (!pXMLNode) {
                 m_syntaxParserResult = FDE_XmlSyntaxResult::Error;
                 return m_syntaxParserResult;
               }
               m_XMLNodeStack.Pop();
               pXMLNode = m_XMLNodeStack.GetTopElement();
-              if (pXMLNode == NULL) {
+              if (pXMLNode) {
+                m_CurNode = *pXMLNode;
+              } else {
                 m_CurNode.iNodeNum = -1;
                 m_CurNode.eNodeType = FDE_XMLNODE_Unknown;
-              } else {
-                m_CurNode = *pXMLNode;
               }
               m_iCurrentNodeNum = m_CurNode.iNodeNum;
               m_iTextDataLength = m_iDataLength;
               m_BlockBuffer.Reset();
               m_pCurrentBlock =
                   m_BlockBuffer.GetAvailableBlock(m_iIndexInBlock);
               m_syntaxParserState = FDE_XmlSyntaxState::Text;
               syntaxParserResult = FDE_XmlSyntaxResult::ElementClose;
             } else if (!FDE_IsXMLWhiteSpace(ch)) {
               m_syntaxParserResult = FDE_XmlSyntaxResult::Error;
@@ skipping 175 matching lines @@
       }
       if (syntaxParserResult != FDE_XmlSyntaxResult::None)
         return syntaxParserResult;
     }
   }
   return FDE_XmlSyntaxResult::Text;
 }
 
 CFDE_XMLSyntaxParser::~CFDE_XMLSyntaxParser() {
   if (m_pCurrentBlock) {
-    m_pCurrentBlock = NULL;
+    m_pCurrentBlock = nullptr;
   }
   FX_Free(m_pBuffer);
 }
 
 int32_t CFDE_XMLSyntaxParser::GetStatus() const {
-  if (m_pStream == NULL) {
+  if (!m_pStream)
     return -1;
-  }
+
   int32_t iStreamLength = m_pStream->GetLength();
   if (iStreamLength < 1) {
     return 100;
   }
   if (m_syntaxParserResult == FDE_XmlSyntaxResult::Error) {
     return -1;
   }
   if (m_syntaxParserResult == FDE_XmlSyntaxResult::EndOfString) {
     return 100;
   }
@@ skipping 16 matching lines @@
     } else if ((uint32_t)unicode < 0x4000000) {
       nbytes = 5;
     } else {
       nbytes = 6;
     }
     iDstNum += nbytes;
   }
   return iDstNum;
 }
 FX_FILESIZE CFDE_XMLSyntaxParser::GetCurrentBinaryPos() const {
-  if (m_pStream == NULL) {
+  if (!m_pStream)
     return 0;
-  }
+
   int32_t nSrcLen = m_pStart - m_pBuffer;
   int32_t nDstLen = FX_GetUTF8EncodeLength(m_pBuffer, nSrcLen);
   return m_iParsedBytes + nDstLen;
 }
 
 void CFDE_XMLSyntaxParser::ParseTextChar(FX_WCHAR ch) {
   if (m_iIndexInBlock == m_iAllocStep) {
     m_pCurrentBlock = m_BlockBuffer.GetAvailableBlock(m_iIndexInBlock);
     if (!m_pCurrentBlock) {
       return;
@@ skipping 58 matching lines @@
     m_BlockBuffer.DeleteTextChars(m_iDataLength - m_iEntityStart, FALSE);
     m_pCurrentBlock = m_BlockBuffer.GetAvailableBlock(m_iIndexInBlock);
     m_iEntityStart = -1;
   } else {
     if (m_iEntityStart < 0 && ch == L'&') {
       m_iEntityStart = m_iDataLength - 1;
     }
   }
   m_pStart++;
 }