Remove FX_BOOL from core

core/fxcrt/fx_xml_parser.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 "core/fxcrt/xml_int.h"
 
 #include <vector>
 
@@ skipping 152 matching lines @@
 size_t CXML_DataStmAcc::GetBlockSize() {
   return m_dwSize;
 }
 
 FX_FILESIZE CXML_DataStmAcc::GetBlockOffset() {
   return m_nStart;
 }
 
 CXML_Parser::CXML_Parser()
     : m_pDataAcc(nullptr),
-      m_bOwnedStream(FALSE),
+      m_bOwnedStream(false),
       m_nOffset(0),
-      m_bSaveSpaceChars(FALSE),
+      m_bSaveSpaceChars(false),
       m_pBuffer(nullptr),
       m_dwBufferSize(0),
       m_nBufferOffset(0),
       m_dwIndex(0) {}
 
 CXML_Parser::~CXML_Parser() {
   if (m_bOwnedStream) {
     m_pDataAcc->Release();
   }
 }
@@ skipping 233 matching lines @@
     }
     m_nOffset = m_nBufferOffset + (FX_FILESIZE)m_dwIndex;
     if (ch == mark || m_dwIndex < m_dwBufferSize || IsEOF()) {
       break;
     }
   } while (ReadNextBlock());
   value = decoder.GetResult();
 }
 void CXML_Parser::GetTagName(CFX_ByteString& space,
                              CFX_ByteString& name,
-                             FX_BOOL& bEndTag,
-                             FX_BOOL bStartTag) {
+                             bool& bEndTag,
+                             bool bStartTag) {
   m_nOffset = m_nBufferOffset + (FX_FILESIZE)m_dwIndex;
   if (IsEOF()) {
     return;
   }
-  bEndTag = FALSE;
+  bEndTag = false;
   uint8_t ch;
   int32_t iState = bStartTag ? 1 : 0;
   do {
     while (m_dwIndex < m_dwBufferSize) {
       ch = m_pBuffer[m_dwIndex];
       switch (iState) {
         case 0:
           m_dwIndex++;
           if (ch != '<') {
             break;
           }
           iState = 1;
           break;
         case 1:
           if (ch == '?') {
             m_dwIndex++;
             SkipLiterals("?>");
             iState = 0;
             break;
           } else if (ch == '!') {
             m_dwIndex++;
             SkipLiterals("-->");
             iState = 0;
             break;
           }
           if (ch == '/') {
             m_dwIndex++;
             GetName(space, name);
-            bEndTag = TRUE;
+            bEndTag = true;
           } else {
             GetName(space, name);
-            bEndTag = FALSE;
+            bEndTag = false;
           }
           return;
       }
     }
     m_nOffset = m_nBufferOffset + (FX_FILESIZE)m_dwIndex;
     if (m_dwIndex < m_dwBufferSize || IsEOF()) {
       break;
     }
   } while (ReadNextBlock());
 }
-CXML_Element* CXML_Parser::ParseElement(CXML_Element* pParent,
-                                        FX_BOOL bStartTag) {
+CXML_Element* CXML_Parser::ParseElement(CXML_Element* pParent, bool bStartTag) {
   m_nOffset = m_nBufferOffset + (FX_FILESIZE)m_dwIndex;
   if (IsEOF()) {
     return nullptr;
   }
   CFX_ByteString tag_name, tag_space;
-  FX_BOOL bEndTag;
+  bool bEndTag;
   GetTagName(tag_space, tag_name, bEndTag, bStartTag);
   if (tag_name.IsEmpty() || bEndTag) {
     return nullptr;
   }
   CXML_Element* pElement = new CXML_Element;
   pElement->m_pParent = pParent;
   pElement->SetTag(tag_space.AsStringC(), tag_name.AsStringC());
   do {
     CFX_ByteString attr_space, attr_name;
     while (m_dwIndex < m_dwBufferSize) {
@@ skipping 40 matching lines @@
     m_nOffset = m_nBufferOffset + (FX_FILESIZE)m_dwIndex;
     delete pElement;
     return nullptr;
   }
   SkipWhiteSpaces();
   if (IsEOF()) {
     return pElement;
   }
   CFX_UTF8Decoder decoder;
   CFX_WideTextBuf content;
-  FX_BOOL bCDATA = FALSE;
+  bool bCDATA = false;
   int32_t iState = 0;
   do {
     while (m_dwIndex < m_dwBufferSize) {
       ch = m_pBuffer[m_dwIndex++];
       switch (iState) {
         case 0:
           if (ch == '<') {
             iState = 1;
           } else if (ch == '&') {
             decoder.ClearStatus();
@@ skipping 17 matching lines @@
             iState = 10;
           } else {
             content << decoder.GetResult();
             CFX_WideString dataStr = content.MakeString();
             if (!bCDATA && !m_bSaveSpaceChars) {
               dataStr.TrimRight(L" \t\r\n");
             }
             InsertContentSegment(bCDATA, dataStr.AsStringC(), pElement);
             content.Clear();
             decoder.Clear();
-            bCDATA = FALSE;
+            bCDATA = false;
             iState = 0;
             m_dwIndex--;
-            CXML_Element* pSubElement = ParseElement(pElement, TRUE);
+            CXML_Element* pSubElement = ParseElement(pElement, true);
             if (!pSubElement) {
               break;
             }
             pSubElement->m_pParent = pElement;
             pElement->m_Children.push_back(
                 {CXML_Element::Element, pSubElement});
             SkipWhiteSpaces();
           }
           break;
         case 2:
@@ skipping 20 matching lines @@
     }
   } while (ReadNextBlock());
   content << decoder.GetResult();
   CFX_WideString dataStr = content.MakeString();
   if (!m_bSaveSpaceChars) {
     dataStr.TrimRight(L" \t\r\n");
   }
   InsertContentSegment(bCDATA, dataStr.AsStringC(), pElement);
   content.Clear();
   decoder.Clear();
-  bCDATA = FALSE;
+  bCDATA = false;
   return pElement;
 }
-void CXML_Parser::InsertContentSegment(FX_BOOL bCDATA,
+void CXML_Parser::InsertContentSegment(bool bCDATA,
                                        const CFX_WideStringC& content,
                                        CXML_Element* pElement) {
   if (content.IsEmpty()) {
     return;
   }
   CXML_Content* pContent = new CXML_Content;
   pContent->Set(bCDATA, content);
   pElement->m_Children.push_back({CXML_Element::Content, pContent});
 }
 static CXML_Element* XML_ContinueParse(CXML_Parser& parser,
-                                       FX_BOOL bSaveSpaceChars,
+                                       bool bSaveSpaceChars,
                                        FX_FILESIZE* pParsedSize) {
   parser.m_bSaveSpaceChars = bSaveSpaceChars;
-  CXML_Element* pElement = parser.ParseElement(nullptr, FALSE);
+  CXML_Element* pElement = parser.ParseElement(nullptr, false);
   if (pParsedSize) {
     *pParsedSize = parser.m_nOffset;
   }
   return pElement;
 }
 CXML_Element* CXML_Element::Parse(const void* pBuffer,
                                   size_t size,
-                                  FX_BOOL bSaveSpaceChars,
+                                  bool bSaveSpaceChars,
                                   FX_FILESIZE* pParsedSize) {
   CXML_Parser parser;
   if (!parser.Init((uint8_t*)pBuffer, size)) {
     return nullptr;
   }
   return XML_ContinueParse(parser, bSaveSpaceChars, pParsedSize);
 }
 CXML_Element* CXML_Element::Parse(IFX_SeekableReadStream* pFile,
-                                  FX_BOOL bSaveSpaceChars,
+                                  bool bSaveSpaceChars,
                                   FX_FILESIZE* pParsedSize) {
   CXML_Parser parser;
   if (!parser.Init(pFile)) {
     return nullptr;
   }
   return XML_ContinueParse(parser, bSaveSpaceChars, pParsedSize);
 }
 CXML_Element* CXML_Element::Parse(IFX_BufferRead* pBuffer,
-                                  FX_BOOL bSaveSpaceChars,
+                                  bool bSaveSpaceChars,
                                   FX_FILESIZE* pParsedSize) {
   CXML_Parser parser;
   if (!parser.Init(pBuffer)) {
     return nullptr;
   }
   return XML_ContinueParse(parser, bSaveSpaceChars, pParsedSize);
 }
 CXML_Element::CXML_Element() : m_QSpaceName(), m_TagName(), m_AttrMap() {}
 CXML_Element::CXML_Element(const CFX_ByteStringC& qSpace,
                            const CFX_ByteStringC& tagName)
@@ skipping 16 matching lines @@
     if (record.type == Content) {
       delete static_cast<CXML_Content*>(record.child);
     } else if (record.type == Element) {
       CXML_Element* child = static_cast<CXML_Element*>(record.child);
       child->RemoveChildren();
       delete child;
     }
   }
   m_Children.clear();
 }
-CFX_ByteString CXML_Element::GetTagName(FX_BOOL bQualified) const {
+CFX_ByteString CXML_Element::GetTagName(bool bQualified) const {
   if (!bQualified || m_QSpaceName.IsEmpty()) {
     return m_TagName;
   }
   CFX_ByteString bsTag = m_QSpaceName;
   bsTag += ":";
   bsTag += m_TagName;
   return bsTag;
 }
 
-CFX_ByteString CXML_Element::GetNamespace(FX_BOOL bQualified) const {
+CFX_ByteString CXML_Element::GetNamespace(bool bQualified) const {
   return bQualified ? m_QSpaceName : GetNamespaceURI(m_QSpaceName);
 }
 
 CFX_ByteString CXML_Element::GetNamespaceURI(
     const CFX_ByteString& qName) const {
   const CFX_WideString* pwsSpace;
   const CXML_Element* pElement = this;
   do {
     if (qName.IsEmpty()) {
       pwsSpace = pElement->m_AttrMap.Lookup("", "xmlns");
@@ skipping 12 matching lines @@
                                   CFX_ByteString& name,
                                   CFX_WideString& value) const {
   if (index < 0 || index >= m_AttrMap.GetSize()) {
     return;
   }
   CXML_AttrItem& item = m_AttrMap.GetAt(index);
   space = item.m_QSpaceName;
   name = item.m_AttrName;
   value = item.m_Value;
 }
-FX_BOOL CXML_Element::HasAttr(const CFX_ByteStringC& name) const {
+bool CXML_Element::HasAttr(const CFX_ByteStringC& name) const {
   CFX_ByteStringC bsSpace;
   CFX_ByteStringC bsName;
   FX_XML_SplitQualifiedName(name, bsSpace, bsName);
   return !!m_AttrMap.Lookup(CFX_ByteString(bsSpace), CFX_ByteString(bsName));
 }
-FX_BOOL CXML_Element::GetAttrValue(const CFX_ByteStringC& name,
-                                   CFX_WideString& attribute) const {
+bool CXML_Element::GetAttrValue(const CFX_ByteStringC& name,
+                                CFX_WideString& attribute) const {
   CFX_ByteStringC bsSpace;
   CFX_ByteStringC bsName;
   FX_XML_SplitQualifiedName(name, bsSpace, bsName);
   return GetAttrValue(bsSpace, bsName, attribute);
 }
-FX_BOOL CXML_Element::GetAttrValue(const CFX_ByteStringC& space,
-                                   const CFX_ByteStringC& name,
-                                   CFX_WideString& attribute) const {
+bool CXML_Element::GetAttrValue(const CFX_ByteStringC& space,
+                                const CFX_ByteStringC& name,
+                                CFX_WideString& attribute) const {
   const CFX_WideString* pValue =
       m_AttrMap.Lookup(CFX_ByteString(space), CFX_ByteString(name));
   if (pValue) {
     attribute = *pValue;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CXML_Element::GetAttrInteger(const CFX_ByteStringC& name,
-                                     int& attribute) const {
+bool CXML_Element::GetAttrInteger(const CFX_ByteStringC& name,
+                                  int& attribute) const {
   CFX_ByteStringC bsSpace;
   CFX_ByteStringC bsName;
   FX_XML_SplitQualifiedName(name, bsSpace, bsName);
   const CFX_WideString* pwsValue =
       m_AttrMap.Lookup(CFX_ByteString(bsSpace), CFX_ByteString(bsName));
   if (pwsValue) {
     attribute = pwsValue->GetInteger();
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CXML_Element::GetAttrInteger(const CFX_ByteStringC& space,
-                                     const CFX_ByteStringC& name,
-                                     int& attribute) const {
+bool CXML_Element::GetAttrInteger(const CFX_ByteStringC& space,
+                                  const CFX_ByteStringC& name,
+                                  int& attribute) const {
   const CFX_WideString* pwsValue =
       m_AttrMap.Lookup(CFX_ByteString(space), CFX_ByteString(name));
   if (pwsValue) {
     attribute = pwsValue->GetInteger();
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
-FX_BOOL CXML_Element::GetAttrFloat(const CFX_ByteStringC& name,
-                                   FX_FLOAT& attribute) const {
+bool CXML_Element::GetAttrFloat(const CFX_ByteStringC& name,
+                                FX_FLOAT& attribute) const {
   CFX_ByteStringC bsSpace, bsName;
   FX_XML_SplitQualifiedName(name, bsSpace, bsName);
   return GetAttrFloat(bsSpace, bsName, attribute);
 }
-FX_BOOL CXML_Element::GetAttrFloat(const CFX_ByteStringC& space,
-                                   const CFX_ByteStringC& name,
-                                   FX_FLOAT& attribute) const {
+bool CXML_Element::GetAttrFloat(const CFX_ByteStringC& space,
+                                const CFX_ByteStringC& name,
+                                FX_FLOAT& attribute) const {
   const CFX_WideString* pValue =
       m_AttrMap.Lookup(CFX_ByteString(space), CFX_ByteString(name));
   if (pValue) {
     attribute = pValue->GetFloat();
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 CXML_Element::ChildType CXML_Element::GetChildType(uint32_t index) const {
   return index < m_Children.size() ? m_Children[index].type : Invalid;
 }
 CFX_WideString CXML_Element::GetContent(uint32_t index) const {
   if (index < m_Children.size() && m_Children[index].type == Content) {
     CXML_Content* pContent =
         static_cast<CXML_Content*>(m_Children[index].child);
     if (pContent)
       return pContent->m_Content;
@@ skipping 89 matching lines @@
   m_pMap->push_back({space, name, CFX_WideString(value)});
 }
 
 int CXML_AttrMap::GetSize() const {
   return m_pMap ? pdfium::CollectionSize<int>(*m_pMap) : 0;
 }
 
 CXML_AttrItem& CXML_AttrMap::GetAt(int index) const {
   return (*m_pMap)[index];
 }