Remove FX_BOOL from core

core/fpdfapi/parser/cpdf_syntax_parser.cpp

 // Copyright 2016 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/fpdfapi/parser/cpdf_syntax_parser.h"
 
 #include <vector>
 
@@ skipping 33 matching lines @@
     : m_MetadataObjnum(0),
       m_pFileAccess(nullptr),
       m_pFileBuf(nullptr),
       m_BufSize(CPDF_ModuleMgr::kFileBufSize),
       m_pPool(pPool) {}
 
 CPDF_SyntaxParser::~CPDF_SyntaxParser() {
   FX_Free(m_pFileBuf);
 }
 
-FX_BOOL CPDF_SyntaxParser::GetCharAt(FX_FILESIZE pos, uint8_t& ch) {
+bool CPDF_SyntaxParser::GetCharAt(FX_FILESIZE pos, uint8_t& ch) {
   CFX_AutoRestorer<FX_FILESIZE> save_pos(&m_Pos);
   m_Pos = pos;
   return GetNextChar(ch);
 }
 
-FX_BOOL CPDF_SyntaxParser::GetNextChar(uint8_t& ch) {
+bool CPDF_SyntaxParser::GetNextChar(uint8_t& ch) {
   FX_FILESIZE pos = m_Pos + m_HeaderOffset;
   if (pos >= m_FileLen)
-    return FALSE;
+    return false;
 
   if (m_BufOffset >= pos || (FX_FILESIZE)(m_BufOffset + m_BufSize) <= pos) {
     FX_FILESIZE read_pos = pos;
     uint32_t read_size = m_BufSize;
     if ((FX_FILESIZE)read_size > m_FileLen)
       read_size = (uint32_t)m_FileLen;
 
     if ((FX_FILESIZE)(read_pos + read_size) > m_FileLen) {
       if (m_FileLen < (FX_FILESIZE)read_size) {
         read_pos = 0;
         read_size = (uint32_t)m_FileLen;
       } else {
         read_pos = m_FileLen - read_size;
       }
     }
 
     if (!m_pFileAccess->ReadBlock(m_pFileBuf, read_pos, read_size))
-      return FALSE;
+      return false;
 
     m_BufOffset = read_pos;
   }
   ch = m_pFileBuf[pos - m_BufOffset];
   m_Pos++;
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_SyntaxParser::GetCharAtBackward(FX_FILESIZE pos, uint8_t& ch) {
+bool CPDF_SyntaxParser::GetCharAtBackward(FX_FILESIZE pos, uint8_t& ch) {
   pos += m_HeaderOffset;
   if (pos >= m_FileLen)
-    return FALSE;
+    return false;
 
   if (m_BufOffset >= pos || (FX_FILESIZE)(m_BufOffset + m_BufSize) <= pos) {
     FX_FILESIZE read_pos;
     if (pos < (FX_FILESIZE)m_BufSize)
       read_pos = 0;
     else
       read_pos = pos - m_BufSize + 1;
 
     uint32_t read_size = m_BufSize;
     if ((FX_FILESIZE)(read_pos + read_size) > m_FileLen) {
       if (m_FileLen < (FX_FILESIZE)read_size) {
         read_pos = 0;
         read_size = (uint32_t)m_FileLen;
       } else {
         read_pos = m_FileLen - read_size;
       }
     }
 
     if (!m_pFileAccess->ReadBlock(m_pFileBuf, read_pos, read_size))
-      return FALSE;
+      return false;
 
     m_BufOffset = read_pos;
   }
   ch = m_pFileBuf[pos - m_BufOffset];
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_SyntaxParser::ReadBlock(uint8_t* pBuf, uint32_t size) {
+bool CPDF_SyntaxParser::ReadBlock(uint8_t* pBuf, uint32_t size) {
   if (!m_pFileAccess->ReadBlock(pBuf, m_Pos + m_HeaderOffset, size))
-    return FALSE;
+    return false;
   m_Pos += size;
-  return TRUE;
+  return true;
 }
 
 void CPDF_SyntaxParser::GetNextWordInternal(bool* bIsNumber) {
   m_WordSize = 0;
   if (bIsNumber)
     *bIsNumber = true;
 
   uint8_t ch;
   if (!GetNextChar(ch))
     return;
@@ skipping 238 matching lines @@
   return CFX_ByteString((const FX_CHAR*)m_WordBuffer, m_WordSize);
 }
 
 CFX_ByteString CPDF_SyntaxParser::GetKeyword() {
   return GetNextWord(nullptr);
 }
 
 CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjectHolder* pObjList,
                                           uint32_t objnum,
                                           uint32_t gennum,
-                                          FX_BOOL bDecrypt) {
+                                          bool bDecrypt) {
   CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
   if (++s_CurrentRecursionDepth > kParserMaxRecursionDepth)
     return nullptr;
 
   FX_FILESIZE SavedObjPos = m_Pos;
   bool bIsNumber;
   CFX_ByteString word = GetNextWord(&bIsNumber);
   if (word.GetLength() == 0)
     return nullptr;
 
@@ skipping 12 matching lines @@
   if (word == "true" || word == "false")
     return new CPDF_Boolean(word == "true");
 
   if (word == "null")
     return new CPDF_Null;
 
   if (word == "(") {
     CFX_ByteString str = ReadString();
     if (m_pCryptoHandler && bDecrypt)
       m_pCryptoHandler->Decrypt(objnum, gennum, str);
-    return new CPDF_String(MaybeIntern(str), FALSE);
+    return new CPDF_String(MaybeIntern(str), false);
   }
 
   if (word == "<") {
     CFX_ByteString str = ReadHexString();
     if (m_pCryptoHandler && bDecrypt)
       m_pCryptoHandler->Decrypt(objnum, gennum, str);
-    return new CPDF_String(MaybeIntern(str), TRUE);
+    return new CPDF_String(MaybeIntern(str), true);
   }
 
   if (word == "[") {
     CPDF_Array* pArray = new CPDF_Array;
     while (CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, true))
       pArray->Add(pObj);
 
     return pArray;
   }
 
@@ skipping 93 matching lines @@
   if (word == "true" || word == "false")
     return new CPDF_Boolean(word == "true");
 
   if (word == "null")
     return new CPDF_Null;
 
   if (word == "(") {
     CFX_ByteString str = ReadString();
     if (m_pCryptoHandler)
       m_pCryptoHandler->Decrypt(objnum, gennum, str);
-    return new CPDF_String(MaybeIntern(str), FALSE);
+    return new CPDF_String(MaybeIntern(str), false);
   }
 
   if (word == "<") {
     CFX_ByteString str = ReadHexString();
     if (m_pCryptoHandler)
       m_pCryptoHandler->Decrypt(objnum, gennum, str);
-    return new CPDF_String(MaybeIntern(str), TRUE);
+    return new CPDF_String(MaybeIntern(str), true);
   }
 
   if (word == "[") {
     std::unique_ptr<CPDF_Array, ReleaseDeleter<CPDF_Array>> pArray(
         new CPDF_Array);
     while (CPDF_Object* pObj = GetObject(pObjList, objnum, gennum, true))
       pArray->Add(pObj);
 
     return m_WordBuffer[0] == ']' ? pArray.release() : nullptr;
   }
@@ skipping 87 matching lines @@
   // Locate the start of stream.
   ToNextLine();
   FX_FILESIZE streamStartPos = m_Pos;
 
   const CFX_ByteStringC kEndStreamStr("endstream");
   const CFX_ByteStringC kEndObjStr("endobj");
 
   CPDF_CryptoHandler* pCryptoHandler =
       objnum == (uint32_t)m_MetadataObjnum ? nullptr : m_pCryptoHandler.get();
   if (!pCryptoHandler) {
-    FX_BOOL bSearchForKeyword = TRUE;
+    bool bSearchForKeyword = true;
     if (len >= 0) {
       pdfium::base::CheckedNumeric<FX_FILESIZE> pos = m_Pos;
       pos += len;
       if (pos.IsValid() && pos.ValueOrDie() < m_FileLen)
         m_Pos = pos.ValueOrDie();
 
       m_Pos += ReadEOLMarkers(m_Pos);
       FXSYS_memset(m_WordBuffer, 0, kEndStreamStr.GetLength() + 1);
       GetNextWordInternal(nullptr);
       // Earlier version of PDF specification doesn't require EOL marker before
       // 'endstream' keyword. If keyword 'endstream' follows the bytes in
       // specified length, it signals the end of stream.
       if (FXSYS_memcmp(m_WordBuffer, kEndStreamStr.raw_str(),
                        kEndStreamStr.GetLength()) == 0) {
-        bSearchForKeyword = FALSE;
+        bSearchForKeyword = false;
       }
     }
 
     if (bSearchForKeyword) {
       // If len is not available, len needs to be calculated
       // by searching the keywords "endstream" or "endobj".
       m_Pos = streamStartPos;
       FX_FILESIZE endStreamOffset = 0;
       while (endStreamOffset >= 0) {
         endStreamOffset = FindTag(kEndStreamStr, 0);
 
         // Can't find "endstream".
         if (endStreamOffset < 0)
           break;
 
         // Stop searching when "endstream" is found.
         if (IsWholeWord(m_Pos - kEndStreamStr.GetLength(), m_FileLen,
-                        kEndStreamStr, TRUE)) {
+                        kEndStreamStr, true)) {
           endStreamOffset = m_Pos - streamStartPos - kEndStreamStr.GetLength();
           break;
         }
       }
 
       m_Pos = streamStartPos;
       FX_FILESIZE endObjOffset = 0;
       while (endObjOffset >= 0) {
         endObjOffset = FindTag(kEndObjStr, 0);
 
         // Can't find "endobj".
         if (endObjOffset < 0)
           break;
 
         // Stop searching when "endobj" is found.
         if (IsWholeWord(m_Pos - kEndObjStr.GetLength(), m_FileLen, kEndObjStr,
-                        TRUE)) {
+                        true)) {
           endObjOffset = m_Pos - streamStartPos - kEndObjStr.GetLength();
           break;
         }
       }
 
       // Can't find "endstream" or "endobj".
       if (endStreamOffset < 0 && endObjOffset < 0) {
         pDict->Release();
         return nullptr;
       }
@@ skipping 89 matching lines @@
   if (!bIsNumber)
     return 0;
 
   m_WordBuffer[m_WordSize] = 0;
   return FXSYS_atoui(reinterpret_cast<const FX_CHAR*>(m_WordBuffer));
 }
 
 bool CPDF_SyntaxParser::IsWholeWord(FX_FILESIZE startpos,
                                     FX_FILESIZE limit,
                                     const CFX_ByteStringC& tag,
-                                    FX_BOOL checkKeyword) {
+                                    bool checkKeyword) {
   const uint32_t taglen = tag.GetLength();
 
   bool bCheckLeft = !PDFCharIsDelimiter(tag[0]) && !PDFCharIsWhitespace(tag[0]);
   bool bCheckRight = !PDFCharIsDelimiter(tag[taglen - 1]) &&
                      !PDFCharIsWhitespace(tag[taglen - 1]);
 
   uint8_t ch;
   if (bCheckRight && startpos + (int32_t)taglen <= limit &&
       GetCharAt(startpos + (int32_t)taglen, ch)) {
     if (PDFCharIsNumeric(ch) || PDFCharIsOther(ch) ||
         (checkKeyword && PDFCharIsDelimiter(ch))) {
       return false;
     }
   }
 
   if (bCheckLeft && startpos > 0 && GetCharAt(startpos - 1, ch)) {
     if (PDFCharIsNumeric(ch) || PDFCharIsOther(ch) ||
         (checkKeyword && PDFCharIsDelimiter(ch))) {
       return false;
     }
   }
   return true;
 }
 
 // TODO(dsinclair): Split into a SearchWordForward and SearchWordBackwards
 // and drop the bool.
-FX_BOOL CPDF_SyntaxParser::SearchWord(const CFX_ByteStringC& tag,
-                                      FX_BOOL bWholeWord,
-                                      FX_BOOL bForward,
-                                      FX_FILESIZE limit) {
+bool CPDF_SyntaxParser::SearchWord(const CFX_ByteStringC& tag,
+                                   bool bWholeWord,
+                                   bool bForward,
+                                   FX_FILESIZE limit) {
   int32_t taglen = tag.GetLength();
   if (taglen == 0)
-    return FALSE;
+    return false;
 
   FX_FILESIZE pos = m_Pos;
   int32_t offset = 0;
   if (!bForward)
     offset = taglen - 1;
 
   const uint8_t* tag_data = tag.raw_str();
   uint8_t byte;
   while (1) {
     if (bForward) {
       if (limit && pos >= m_Pos + limit)
-        return FALSE;
+        return false;
 
       if (!GetCharAt(pos, byte))
-        return FALSE;
+        return false;
 
     } else {
       if (limit && pos <= m_Pos - limit)
-        return FALSE;
+        return false;
 
       if (!GetCharAtBackward(pos, byte))
-        return FALSE;
+        return false;
     }
 
     if (byte == tag_data[offset]) {
       if (bForward) {
         offset++;
         if (offset < taglen) {
           pos++;
           continue;
         }
       } else {
         offset--;
         if (offset >= 0) {
           pos--;
           continue;
         }
       }
 
       FX_FILESIZE startpos = bForward ? pos - taglen + 1 : pos;
-      if (!bWholeWord || IsWholeWord(startpos, limit, tag, FALSE)) {
+      if (!bWholeWord || IsWholeWord(startpos, limit, tag, false)) {
         m_Pos = startpos;
-        return TRUE;
+        return true;
       }
     }
 
     if (bForward) {
       offset = byte == tag_data[0] ? 1 : 0;
       pos++;
     } else {
       offset = byte == tag_data[taglen - 1] ? taglen - 2 : taglen - 1;
       pos--;
     }
 
     if (pos < 0)
-      return FALSE;
+      return false;
   }
 
-  return FALSE;
+  return false;
 }
 
 int32_t CPDF_SyntaxParser::SearchMultiWord(const CFX_ByteStringC& tags,
-                                           FX_BOOL bWholeWord,
+                                           bool bWholeWord,
                                            FX_FILESIZE limit) {
   int32_t ntags = 1;
   for (int i = 0; i < tags.GetLength(); ++i) {
     if (tags[i] == 0)
       ++ntags;
   }
 
   // Ensure that the input byte string happens to be nul-terminated. This
   // need not be the case, but the loop below uses this guarantee to put
   // the last pattern into the vector.
@@ skipping 24 matching lines @@
       if (pat.m_bsTag[pat.m_Offset] != byte) {
         pat.m_Offset = (pat.m_bsTag[0] == byte) ? 1 : 0;
         continue;
       }
 
       ++pat.m_Offset;
       if (pat.m_Offset != pat.m_bsTag.GetLength())
         continue;
 
       if (!bWholeWord || IsWholeWord(pos - pat.m_bsTag.GetLength(), limit,
-                                     pat.m_bsTag, FALSE)) {
+                                     pat.m_bsTag, false)) {
         return i;
       }
 
       pat.m_Offset = (pat.m_bsTag[0] == byte) ? 1 : 0;
     }
   }
   return -1;
 }
 
 FX_FILESIZE CPDF_SyntaxParser::FindTag(const CFX_ByteStringC& tag,
@@ skipping 23 matching lines @@
 }
 
 void CPDF_SyntaxParser::SetEncrypt(
     std::unique_ptr<CPDF_CryptoHandler> pCryptoHandler) {
   m_pCryptoHandler = std::move(pCryptoHandler);
 }
 
 CFX_ByteString CPDF_SyntaxParser::MaybeIntern(const CFX_ByteString& str) {
   return m_pPool ? m_pPool->Intern(str) : str;
 }