Change CPDF_SyntaxParser::GetNextWord() to not pass by non-const ref.

core/src/fpdfapi/fpdf_parser/fpdf_parser_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 "parser_int.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 198 matching lines @@
   FX_BOOL bXRefRebuilt = FALSE;
   if (m_Syntax.SearchWord("startxref", TRUE, FALSE, 4096)) {
     FX_FILESIZE startxref_offset = m_Syntax.SavePos();
     void* pResult = FXSYS_bsearch(&startxref_offset, m_SortedOffset.GetData(),
                                   m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
                                   CompareFileSize);
     if (!pResult)
       m_SortedOffset.Add(startxref_offset);
 
     m_Syntax.GetKeyword();
-    FX_BOOL bNumber;
-    CFX_ByteString xrefpos_str = m_Syntax.GetNextWord(bNumber);
+    bool bNumber;
+    CFX_ByteString xrefpos_str = m_Syntax.GetNextWord(&bNumber);
     if (!bNumber)
       return PDFPARSE_ERROR_FORMAT;
 
     m_LastXRefOffset = (FX_FILESIZE)FXSYS_atoi64(xrefpos_str);
     if (!LoadAllCrossRefV4(m_LastXRefOffset) &&
         !LoadAllCrossRefV5(m_LastXRefOffset)) {
       if (!RebuildCrossRef())
         return PDFPARSE_ERROR_FORMAT;
 
       bXRefRebuilt = TRUE;
@@ skipping 285 matching lines @@
     return false;
 
   if (!FindPosInOffsets(pos))
     m_SortedOffset.Add(pos);
 
   if (streampos && !FindPosInOffsets(streampos))
       m_SortedOffset.Add(streampos);
 
   while (1) {
     FX_FILESIZE SavedPos = m_Syntax.SavePos();
-    FX_BOOL bIsNumber;
-    CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
+    bool bIsNumber;
+    CFX_ByteString word = m_Syntax.GetNextWord(&bIsNumber);
     if (word.IsEmpty())
       return false;
 
     if (!bIsNumber) {
       m_Syntax.RestorePos(SavedPos);
       break;
     }
     FX_DWORD start_objnum = FXSYS_atoi(word);
     if (start_objnum >= kMaxObjectNumber)
       return false;
@@ skipping 336 matching lines @@
                     } else {
                       if (pObj->IsStream()) {
                         m_pTrailer = ToDictionary(pTrailer->Clone());
                         pObj->Release();
                       } else {
                         m_pTrailer = pTrailer;
                       }
                       FX_FILESIZE dwSavePos = m_Syntax.SavePos();
                       CFX_ByteString strWord = m_Syntax.GetKeyword();
                       if (!strWord.Compare("startxref")) {
-                        FX_BOOL bNumber = FALSE;
-                        CFX_ByteString bsOffset = m_Syntax.GetNextWord(bNumber);
+                        bool bNumber;
+                        CFX_ByteString bsOffset =
+                            m_Syntax.GetNextWord(&bNumber);
                         if (bNumber) {
                           m_LastXRefOffset = FXSYS_atoi(bsOffset);
                         }
                       }
                       m_Syntax.RestorePos(dwSavePos);
                     }
                   } else {
                     pObj->Release();
                   }
                 }
@@ skipping 414 matching lines @@
 
   if (m_V5Type[objnum] != 1)
     return;
 
   FX_FILESIZE pos = m_ObjectInfo[objnum].pos;
   if (pos == 0) {
     return;
   }
   FX_FILESIZE SavedPos = m_Syntax.SavePos();
   m_Syntax.RestorePos(pos);
-  FX_BOOL bIsNumber;
-  CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
+  bool bIsNumber;
+  CFX_ByteString word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_Syntax.RestorePos(SavedPos);
     return;
   }
   FX_DWORD parser_objnum = FXSYS_atoi(word);
   if (parser_objnum && parser_objnum != objnum) {
     m_Syntax.RestorePos(SavedPos);
     return;
   }
-  word = m_Syntax.GetNextWord(bIsNumber);
+  word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_Syntax.RestorePos(SavedPos);
     return;
   }
   if (m_Syntax.GetKeyword() != "obj") {
     m_Syntax.RestorePos(SavedPos);
     return;
   }
   void* pResult =
       FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
                     sizeof(FX_FILESIZE), CompareFileSize);
   if (!pResult) {
     m_Syntax.RestorePos(SavedPos);
     return;
   }
   FX_FILESIZE nextoff = ((FX_FILESIZE*)pResult)[1];
   FX_BOOL bNextOffValid = FALSE;
   if (nextoff != pos) {
     m_Syntax.RestorePos(nextoff);
-    word = m_Syntax.GetNextWord(bIsNumber);
+    word = m_Syntax.GetNextWord(&bIsNumber);
     if (word == "xref") {
       bNextOffValid = TRUE;
     } else if (bIsNumber) {
-      word = m_Syntax.GetNextWord(bIsNumber);
+      word = m_Syntax.GetNextWord(&bIsNumber);
       if (bIsNumber && m_Syntax.GetKeyword() == "obj") {
         bNextOffValid = TRUE;
       }
     }
   }
   if (!bNextOffValid) {
     m_Syntax.RestorePos(pos);
     while (1) {
       if (m_Syntax.GetKeyword() == "endobj") {
         break;
@@ skipping 10 matching lines @@
   m_Syntax.ReadBlock(pBuffer, size);
   m_Syntax.RestorePos(SavedPos);
 }
 
 CPDF_Object* CPDF_Parser::ParseIndirectObjectAt(CPDF_IndirectObjects* pObjList,
                                                 FX_FILESIZE pos,
                                                 FX_DWORD objnum,
                                                 PARSE_CONTEXT* pContext) {
   FX_FILESIZE SavedPos = m_Syntax.SavePos();
   m_Syntax.RestorePos(pos);
-  FX_BOOL bIsNumber;
-  CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
+  bool bIsNumber;
+  CFX_ByteString word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   FX_FILESIZE objOffset = m_Syntax.SavePos();
   objOffset -= word.GetLength();
   FX_DWORD parser_objnum = FXSYS_atoi(word);
   if (objnum && parser_objnum != objnum) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
-  word = m_Syntax.GetNextWord(bIsNumber);
+  word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   FX_DWORD parser_gennum = FXSYS_atoi(word);
   if (m_Syntax.GetKeyword() != "obj") {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   CPDF_Object* pObj =
@@ skipping 13 matching lines @@
   return pObj;
 }
 CPDF_Object* CPDF_Parser::ParseIndirectObjectAtByStrict(
     CPDF_IndirectObjects* pObjList,
     FX_FILESIZE pos,
     FX_DWORD objnum,
     PARSE_CONTEXT* pContext,
     FX_FILESIZE* pResultPos) {
   FX_FILESIZE SavedPos = m_Syntax.SavePos();
   m_Syntax.RestorePos(pos);
-  FX_BOOL bIsNumber;
-  CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
+  bool bIsNumber;
+  CFX_ByteString word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   FX_DWORD parser_objnum = FXSYS_atoi(word);
   if (objnum && parser_objnum != objnum) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
-  word = m_Syntax.GetNextWord(bIsNumber);
+  word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   FX_DWORD gennum = FXSYS_atoi(word);
   if (m_Syntax.GetKeyword() != "obj") {
     m_Syntax.RestorePos(SavedPos);
     return NULL;
   }
   CPDF_Object* pObj =
@@ skipping 41 matching lines @@
     return;
   }
   m_Syntax.m_pCryptoHandler.reset(pSecurityHandler->CreateCryptoHandler());
   m_Syntax.m_pCryptoHandler->Init(NULL, pSecurityHandler);
 }
 FX_BOOL CPDF_Parser::IsLinearizedFile(IFX_FileRead* pFileAccess,
                                       FX_DWORD offset) {
   m_Syntax.InitParser(pFileAccess, offset);
   m_Syntax.RestorePos(m_Syntax.m_HeaderOffset + 9);
   FX_FILESIZE SavedPos = m_Syntax.SavePos();
-  FX_BOOL bIsNumber;
-  CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
+  bool bIsNumber;
+  CFX_ByteString word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     return FALSE;
   }
   FX_DWORD objnum = FXSYS_atoi(word);
-  word = m_Syntax.GetNextWord(bIsNumber);
+  word = m_Syntax.GetNextWord(&bIsNumber);
   if (!bIsNumber) {
     return FALSE;
   }
   FX_DWORD gennum = FXSYS_atoi(word);
   if (m_Syntax.GetKeyword() != "obj") {
     m_Syntax.RestorePos(SavedPos);
     return FALSE;
   }
   m_pLinearized = m_Syntax.GetObject(nullptr, objnum, gennum, nullptr, true);
   if (!m_pLinearized) {
     return FALSE;
   }
 
   CPDF_Dictionary* pDict = m_pLinearized->GetDict();
   if (pDict && pDict->GetElement("Linearized")) {
-    m_Syntax.GetNextWord(bIsNumber);
+    m_Syntax.GetNextWord(nullptr);
 
     CPDF_Object* pLen = pDict->GetElement("L");
     if (!pLen) {
       m_pLinearized->Release();
       m_pLinearized = NULL;
       return FALSE;
     }
     if (pLen->GetInteger() != (int)pFileAccess->GetSize()) {
       return FALSE;
     }
@@ skipping 233 matching lines @@
   return TRUE;
 }
 FX_BOOL CPDF_SyntaxParser::ReadBlock(uint8_t* pBuf, FX_DWORD size) {
   if (!m_pFileAccess->ReadBlock(pBuf, m_Pos + m_HeaderOffset, size)) {
     return FALSE;
   }
   m_Pos += size;
   return TRUE;
 }
 
-void CPDF_SyntaxParser::GetNextWord() {
+void CPDF_SyntaxParser::GetNextWordInternal(bool* bIsNumber) {
   m_WordSize = 0;
-  m_bIsNumber = TRUE;
+  if (bIsNumber)
+    *bIsNumber = true;
   uint8_t ch;
   if (!GetNextChar(ch)) {
     return;
   }
   while (1) {
     while (PDFCharIsWhitespace(ch)) {
       if (!GetNextChar(ch))
         return;
     }
     if (ch != '%')
       break;
 
     while (1) {
       if (!GetNextChar(ch))
         return;
       if (PDFCharIsLineEnding(ch))
         break;
     }
   }
 
   if (PDFCharIsDelimiter(ch)) {
-    m_bIsNumber = FALSE;
+    if (bIsNumber)
+      *bIsNumber = false;
     m_WordBuffer[m_WordSize++] = ch;
     if (ch == '/') {
       while (1) {
         if (!GetNextChar(ch))
           return;
 
         if (!PDFCharIsOther(ch) && !PDFCharIsNumeric(ch)) {
           m_Pos--;
           return;
         }
@@ skipping 17 matching lines @@
         m_Pos--;
     }
     return;
   }
 
   while (1) {
     if (m_WordSize < sizeof(m_WordBuffer) - 1)
       m_WordBuffer[m_WordSize++] = ch;
 
     if (!PDFCharIsNumeric(ch))
-      m_bIsNumber = FALSE;
+      if (bIsNumber)
+        *bIsNumber = false;
     if (!GetNextChar(ch))
       return;
 
     if (PDFCharIsDelimiter(ch) || PDFCharIsWhitespace(ch)) {
       m_Pos--;
       break;
     }
   }
 }
+
 CFX_ByteString CPDF_SyntaxParser::ReadString() {
   uint8_t ch;
   if (!GetNextChar(ch)) {
     return CFX_ByteString();
   }
   CFX_ByteTextBuf buf;
   int32_t parlevel = 0;
   int32_t status = 0, iEscCode = 0;
   while (1) {
     switch (status) {
@@ skipping 137 matching lines @@
     while (1) {
       if (!GetNextChar(ch))
         return;
       if (PDFCharIsLineEnding(ch))
         break;
     }
   }
   m_Pos--;
 }
 
-CFX_ByteString CPDF_SyntaxParser::GetNextWord(FX_BOOL& bIsNumber) {
-  GetNextWord();
-  bIsNumber = m_bIsNumber;
-  return CFX_ByteString(m_WordBuffer, m_WordSize);
+CFX_ByteString CPDF_SyntaxParser::GetNextWord(bool* bIsNumber) {
+  GetNextWordInternal(bIsNumber);
+  return CFX_ByteString((const FX_CHAR*)m_WordBuffer, m_WordSize);
 }
+
 CFX_ByteString CPDF_SyntaxParser::GetKeyword() {
-  FX_BOOL dummy;
-  return GetNextWord(dummy);
+  return GetNextWord(nullptr);
 }
+
 CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjects* pObjList,
                                           FX_DWORD objnum,
                                           FX_DWORD gennum,
                                           PARSE_CONTEXT* pContext,
                                           FX_BOOL bDecrypt) {
   CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
   if (++s_CurrentRecursionDepth > kParserMaxRecursionDepth) {
     return NULL;
   }
   FX_FILESIZE SavedPos = m_Pos;
   FX_BOOL bTypeOnly = pContext && (pContext->m_Flags & PDFPARSE_TYPEONLY);
-  FX_BOOL bIsNumber;
-  CFX_ByteString word = GetNextWord(bIsNumber);
+  bool bIsNumber;
+  CFX_ByteString word = GetNextWord(&bIsNumber);
   if (word.GetLength() == 0) {
     if (bTypeOnly)
       return (CPDF_Object*)PDFOBJ_INVALID;
     return NULL;
   }
   if (bIsNumber) {
     FX_FILESIZE SavedPos = m_Pos;
-    CFX_ByteString nextword = GetNextWord(bIsNumber);
+    CFX_ByteString nextword = GetNextWord(&bIsNumber);
     if (bIsNumber) {
-      CFX_ByteString nextword2 = GetNextWord(bIsNumber);
+      CFX_ByteString nextword2 = GetNextWord(nullptr);
       if (nextword2 == "R") {
         FX_DWORD objnum = FXSYS_atoi(word);
         if (bTypeOnly)
           return (CPDF_Object*)PDFOBJ_REFERENCE;
         return new CPDF_Reference(pObjList, objnum);
       }
     }
     m_Pos = SavedPos;
     if (bTypeOnly)
       return (CPDF_Object*)PDFOBJ_NUMBER;
@@ skipping 48 matching lines @@
       return (CPDF_Object*)PDFOBJ_DICTIONARY;
 
     if (pContext)
       pContext->m_DictStart = SavedPos;
 
     int32_t nKeys = 0;
     FX_FILESIZE dwSignValuePos = 0;
     std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         new CPDF_Dictionary);
     while (1) {
-      FX_BOOL bIsNumber;
-      CFX_ByteString key = GetNextWord(bIsNumber);
+      CFX_ByteString key = GetNextWord(nullptr);
       if (key.IsEmpty())
         return nullptr;
 
       FX_FILESIZE SavedPos = m_Pos - key.GetLength();
       if (key == ">>")
         break;
 
       if (key == "endobj") {
         m_Pos = SavedPos;
         break;
@@ skipping 30 matching lines @@
       pDict->SetAt("Contents", pObj);
       m_Pos = dwSavePos;
     }
     if (pContext) {
       pContext->m_DictEnd = m_Pos;
       if (pContext->m_Flags & PDFPARSE_NOSTREAM) {
         return pDict.release();
       }
     }
     FX_FILESIZE SavedPos = m_Pos;
-    FX_BOOL bIsNumber;
-    CFX_ByteString nextword = GetNextWord(bIsNumber);
+    CFX_ByteString nextword = GetNextWord(nullptr);
     if (nextword != "stream") {
       m_Pos = SavedPos;
       return pDict.release();
     }
 
     return ReadStream(pDict.release(), pContext, objnum, gennum);
   }
   if (word == ">>") {
     m_Pos = SavedPos;
     return nullptr;
   }
   if (bTypeOnly)
     return (CPDF_Object*)PDFOBJ_INVALID;
 
   return nullptr;
 }
 
 CPDF_Object* CPDF_SyntaxParser::GetObjectByStrict(
     CPDF_IndirectObjects* pObjList,
     FX_DWORD objnum,
     FX_DWORD gennum,
     PARSE_CONTEXT* pContext) {
   CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
   if (++s_CurrentRecursionDepth > kParserMaxRecursionDepth) {
     return NULL;
   }
   FX_FILESIZE SavedPos = m_Pos;
   FX_BOOL bTypeOnly = pContext && (pContext->m_Flags & PDFPARSE_TYPEONLY);
-  FX_BOOL bIsNumber;
-  CFX_ByteString word = GetNextWord(bIsNumber);
+  bool bIsNumber;
+  CFX_ByteString word = GetNextWord(&bIsNumber);
   if (word.GetLength() == 0) {
     if (bTypeOnly)
       return (CPDF_Object*)PDFOBJ_INVALID;
     return nullptr;
   }
   if (bIsNumber) {
     FX_FILESIZE SavedPos = m_Pos;
-    CFX_ByteString nextword = GetNextWord(bIsNumber);
+    CFX_ByteString nextword = GetNextWord(&bIsNumber);
     if (bIsNumber) {
-      CFX_ByteString nextword2 = GetNextWord(bIsNumber);
+      CFX_ByteString nextword2 = GetNextWord(nullptr);
       if (nextword2 == "R") {
         if (bTypeOnly)
           return (CPDF_Object*)PDFOBJ_REFERENCE;
         FX_DWORD objnum = FXSYS_atoi(word);
         return new CPDF_Reference(pObjList, objnum);
       }
     }
     m_Pos = SavedPos;
     if (bTypeOnly)
       return (CPDF_Object*)PDFOBJ_NUMBER;
@@ skipping 44 matching lines @@
   }
   if (word == "<<") {
     if (bTypeOnly)
       return (CPDF_Object*)PDFOBJ_DICTIONARY;
     if (pContext)
       pContext->m_DictStart = SavedPos;
 
     std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         new CPDF_Dictionary);
     while (1) {
-      FX_BOOL bIsNumber;
       FX_FILESIZE SavedPos = m_Pos;
-      CFX_ByteString key = GetNextWord(bIsNumber);
+      CFX_ByteString key = GetNextWord(nullptr);
       if (key.IsEmpty())
         return nullptr;
 
       if (key == ">>")
         break;
 
       if (key == "endobj") {
         m_Pos = SavedPos;
         break;
       }
@@ skipping 14 matching lines @@
                         obj.release());
       }
     }
     if (pContext) {
       pContext->m_DictEnd = m_Pos;
       if (pContext->m_Flags & PDFPARSE_NOSTREAM) {
         return pDict.release();
       }
     }
     FX_FILESIZE SavedPos = m_Pos;
-    FX_BOOL bIsNumber;
-    CFX_ByteString nextword = GetNextWord(bIsNumber);
+    CFX_ByteString nextword = GetNextWord(nullptr);
     if (nextword != "stream") {
       m_Pos = SavedPos;
       return pDict.release();
     }
 
     return ReadStream(pDict.release(), pContext, objnum, gennum);
   }
   if (word == ">>") {
     m_Pos = SavedPos;
     return nullptr;
@@ skipping 43 matching lines @@
   if (!pCryptoHandler) {
     FX_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);
-      GetNextWord();
+      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.GetPtr(),
                        kEndStreamStr.GetLength()) == 0) {
         bSearchForKeyword = FALSE;
       }
     }
     if (bSearchForKeyword) {
       // If len is not available, len needs to be calculated
@@ skipping 79 matching lines @@
       len = dest_buf.GetSize();
       dest_buf.DetachBuffer();
     }
   }
   CPDF_Stream* pStream = new CPDF_Stream(pData, len, pDict);
   if (pContext) {
     pContext->m_DataEnd = pContext->m_DataStart + len;
   }
   streamStartPos = m_Pos;
   FXSYS_memset(m_WordBuffer, 0, kEndObjStr.GetLength() + 1);
-  GetNextWord();
+  GetNextWordInternal(nullptr);
   int numMarkers = ReadEOLMarkers(m_Pos);
   if (m_WordSize == kEndObjStr.GetLength() && numMarkers != 0 &&
       FXSYS_memcmp(m_WordBuffer, kEndObjStr.GetPtr(), kEndObjStr.GetLength()) ==
           0) {
     m_Pos = streamStartPos;
   }
   return pStream;
 }
 void CPDF_SyntaxParser::InitParser(IFX_FileRead* pFileAccess,
                                    FX_DWORD HeaderOffset) {
   FX_Free(m_pFileBuf);
   m_pFileBuf = FX_Alloc(uint8_t, m_BufSize);
   m_HeaderOffset = HeaderOffset;
   m_FileLen = pFileAccess->GetSize();
   m_Pos = 0;
   m_pFileAccess = pFileAccess;
   m_BufOffset = 0;
   pFileAccess->ReadBlock(
       m_pFileBuf, 0,
       (size_t)((FX_FILESIZE)m_BufSize > m_FileLen ? m_FileLen : m_BufSize));
 }
 int32_t CPDF_SyntaxParser::GetDirectNum() {
-  GetNextWord();
-  if (!m_bIsNumber) {
+  bool bIsNumber;
+  GetNextWordInternal(&bIsNumber);
+  if (!bIsNumber)
     return 0;
-  }
+
   m_WordBuffer[m_WordSize] = 0;
   return FXSYS_atoi(reinterpret_cast<const FX_CHAR*>(m_WordBuffer));
 }
 
 bool CPDF_SyntaxParser::IsWholeWord(FX_FILESIZE startpos,
                                     FX_FILESIZE limit,
                                     const CFX_ByteStringC& tag,
                                     FX_BOOL checkKeyword) {
   const FX_DWORD taglen = tag.GetLength();
   bool bCheckLeft = !PDFCharIsDelimiter(tag[0]) && !PDFCharIsWhitespace(tag[0]);
@@ skipping 1108 matching lines @@
 
   m_docStatus = PDF_DATAAVAIL_DONE;
   return TRUE;
 }
 CPDF_Object* CPDF_DataAvail::ParseIndirectObjectAt(
     FX_FILESIZE pos,
     FX_DWORD objnum,
     CPDF_IndirectObjects* pObjList) {
   FX_FILESIZE SavedPos = m_syntaxParser.SavePos();
   m_syntaxParser.RestorePos(pos);
-  FX_BOOL bIsNumber;
-  CFX_ByteString word = m_syntaxParser.GetNextWord(bIsNumber);
-  if (!bIsNumber) {
-    return NULL;
-  }
+  bool bIsNumber;
+  CFX_ByteString word = m_syntaxParser.GetNextWord(&bIsNumber);
+  if (!bIsNumber)
+    return nullptr;
+
   FX_DWORD parser_objnum = FXSYS_atoi(word);
-  if (objnum && parser_objnum != objnum) {
-    return NULL;
-  }
-  word = m_syntaxParser.GetNextWord(bIsNumber);
-  if (!bIsNumber) {
-    return NULL;
-  }
+  if (objnum && parser_objnum != objnum)
+    return nullptr;
+
+  word = m_syntaxParser.GetNextWord(&bIsNumber);
+  if (!bIsNumber)
+    return nullptr;
+
   FX_DWORD gennum = FXSYS_atoi(word);
   if (m_syntaxParser.GetKeyword() != "obj") {
     m_syntaxParser.RestorePos(SavedPos);
-    return NULL;
+    return nullptr;
   }
   CPDF_Object* pObj =
       m_syntaxParser.GetObject(pObjList, parser_objnum, gennum, nullptr, true);
   m_syntaxParser.RestorePos(SavedPos);
   return pObj;
 }
 IPDF_DataAvail::DocLinearizationStatus CPDF_DataAvail::IsLinearizedPDF() {
   FX_DWORD req_size = 1024;
   if (!m_pFileAvail->IsDataAvail(0, req_size)) {
     return LinearizationUnknown;
@@ skipping 15 matching lines @@
 FX_BOOL CPDF_DataAvail::IsLinearizedFile(uint8_t* pData, FX_DWORD dwLen) {
   ScopedFileStream file(FX_CreateMemoryStream(pData, (size_t)dwLen, FALSE));
   int32_t offset = GetHeaderOffset(file.get());
   if (offset == -1) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
   m_dwHeaderOffset = offset;
   m_syntaxParser.InitParser(file.get(), offset);
   m_syntaxParser.RestorePos(m_syntaxParser.m_HeaderOffset + 9);
-  FX_BOOL bNumber = FALSE;
-  CFX_ByteString wordObjNum = m_syntaxParser.GetNextWord(bNumber);
-  if (!bNumber) {
+  bool bNumber;
+  CFX_ByteString wordObjNum = m_syntaxParser.GetNextWord(&bNumber);
+  if (!bNumber)
     return FALSE;
-  }
+
   FX_DWORD objnum = FXSYS_atoi(wordObjNum);
   if (m_pLinearized) {
     m_pLinearized->Release();
     m_pLinearized = NULL;
   }
   m_pLinearized =
       ParseIndirectObjectAt(m_syntaxParser.m_HeaderOffset + 9, objnum);
   if (!m_pLinearized) {
     return FALSE;
   }
@@ skipping 19 matching lines @@
 FX_BOOL CPDF_DataAvail::CheckEnd(IFX_DownloadHints* pHints) {
   FX_DWORD req_pos = (FX_DWORD)(m_dwFileLen > 1024 ? m_dwFileLen - 1024 : 0);
   FX_DWORD dwSize = (FX_DWORD)(m_dwFileLen - req_pos);
   if (m_pFileAvail->IsDataAvail(req_pos, dwSize)) {
     uint8_t buffer[1024];
     m_pFileRead->ReadBlock(buffer, req_pos, dwSize);
     ScopedFileStream file(FX_CreateMemoryStream(buffer, (size_t)dwSize, FALSE));
     m_syntaxParser.InitParser(file.get(), 0);
     m_syntaxParser.RestorePos(dwSize - 1);
     if (m_syntaxParser.SearchWord("startxref", TRUE, FALSE, dwSize)) {
-      FX_BOOL bNumber;
-      m_syntaxParser.GetNextWord(bNumber);
-      CFX_ByteString xrefpos_str = m_syntaxParser.GetNextWord(bNumber);
+      m_syntaxParser.GetNextWord(nullptr);
+      bool bNumber;
+      CFX_ByteString xrefpos_str = m_syntaxParser.GetNextWord(&bNumber);
       if (!bNumber) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
         return FALSE;
       }
       m_dwXRefOffset = (FX_FILESIZE)FXSYS_atoi64(xrefpos_str);
       if (!m_dwXRefOffset || m_dwXRefOffset > m_dwFileLen) {
         m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
         return TRUE;
       }
       m_dwLastXRefOffset = m_dwXRefOffset;
@@ skipping 12 matching lines @@
   xref_offset = 0;
   FX_DWORD req_size =
       (FX_DWORD)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512);
   if (m_pFileAvail->IsDataAvail(m_Pos, req_size)) {
     int32_t iSize = (int32_t)(m_Pos + req_size - m_dwCurrentXRefSteam);
     CFX_BinaryBuf buf(iSize);
     uint8_t* pBuf = buf.GetBuffer();
     m_pFileRead->ReadBlock(pBuf, m_dwCurrentXRefSteam, iSize);
     ScopedFileStream file(FX_CreateMemoryStream(pBuf, (size_t)iSize, FALSE));
     m_parser.m_Syntax.InitParser(file.get(), 0);
-    FX_BOOL bNumber = FALSE;
-    CFX_ByteString objnum = m_parser.m_Syntax.GetNextWord(bNumber);
-    if (!bNumber) {
+    bool bNumber;
+    CFX_ByteString objnum = m_parser.m_Syntax.GetNextWord(&bNumber);
+    if (!bNumber)
       return -1;
-    }
+
     FX_DWORD objNum = FXSYS_atoi(objnum);
     CPDF_Object* pObj = m_parser.ParseIndirectObjectAt(NULL, 0, objNum, NULL);
     if (!pObj) {
       m_Pos += m_parser.m_Syntax.SavePos();
       return 0;
     }
     CPDF_Dictionary* pDict = pObj->GetDict();
     CPDF_Name* pName = ToName(pDict ? pDict->GetElement("Type") : nullptr);
     if (pName) {
       if (pName->GetString() == "XRef") {
@@ skipping 1195 matching lines @@
   if (!m_pLinearizedDict)
     return -1;
   CPDF_Array* pRange = m_pLinearizedDict->GetArray("H");
   if (!pRange)
     return -1;
   CPDF_Object* pStreamLen = pRange->GetElementValue(1);
   if (!pStreamLen)
     return -1;
   return pStreamLen->GetInteger();
 }