Make more CPDF_Parser method const.

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 <memory>
 #include <set>
@@ skipping 43 matching lines @@
     ++offset;
   }
   return -1;
 }
 
 int32_t GetDirectInteger(CPDF_Dictionary* pDict, const CFX_ByteStringC& key) {
   CPDF_Number* pObj = ToNumber(pDict->GetElement(key));
   return pObj ? pObj->GetInteger() : 0;
 }
 
-bool CheckDirectType(CPDF_Dictionary* pDict,
-                     const CFX_ByteStringC& key,
-                     int32_t iType) {
-  CPDF_Object* pObj = pDict->GetElement(key);
-  return !pObj || pObj->GetType() == iType;
-}
-
 FX_DWORD GetVarInt(const uint8_t* p, int32_t n) {
   FX_DWORD result = 0;
   for (int32_t i = 0; i < n; ++i)
     result = result * 256 + p[i];
   return result;
 }
 
 int32_t GetStreamNCount(CPDF_StreamAcc* pObjStream) {
   return pObjStream->GetDict()->GetInteger("N");
 }
@@ skipping 48 matching lines @@
   return m_ObjectInfo.empty() ? 0 : m_ObjectInfo.rbegin()->first;
 }
 
 bool CPDF_Parser::IsValidObjectNumber(FX_DWORD objnum) const {
   return !m_ObjectInfo.empty() && objnum <= m_ObjectInfo.rbegin()->first;
 }
 
 void CPDF_Parser::SetEncryptDictionary(CPDF_Dictionary* pDict) {
   m_pEncryptDict = pDict;
 }
+
+FX_FILESIZE CPDF_Parser::GetObjectPositionOrZero(FX_DWORD objnum) const {
+  auto it = m_ObjectInfo.find(objnum);
+  return it != m_ObjectInfo.end() ? it->second.pos : 0;
+}
+
 void CPDF_Parser::CloseParser(FX_BOOL bReParse) {
   m_bVersionUpdated = FALSE;
   if (!bReParse) {
     delete m_pDocument;
     m_pDocument = NULL;
   }
   if (m_pTrailer) {
     m_pTrailer->Release();
     m_pTrailer = NULL;
   }
@@ skipping 187 matching lines @@
     m_Syntax.SetEncrypt(pCryptoHandler.release());
   }
   return PDFPARSE_ERROR_SUCCESS;
 }
 void CPDF_Parser::ReleaseEncryptHandler() {
   m_Syntax.m_pCryptoHandler.reset();
   if (!m_bForceUseSecurityHandler) {
     m_pSecurityHandler.reset();
   }
 }
-FX_FILESIZE CPDF_Parser::GetObjectOffset(FX_DWORD objnum) {
+
+FX_FILESIZE CPDF_Parser::GetObjectOffset(FX_DWORD objnum) const {
   if (!IsValidObjectNumber(objnum))
     return 0;
 
   if (m_V5Type[objnum] == 1)
-    return m_ObjectInfo[objnum].pos;
+    return GetObjectPositionOrZero(objnum);
 
   if (m_V5Type[objnum] == 2) {
-    FX_FILESIZE pos = m_ObjectInfo[objnum].pos;
-    return m_ObjectInfo[pos].pos;
+    FX_FILESIZE pos = GetObjectPositionOrZero(objnum);
+    return GetObjectPositionOrZero(pos);
   }
   return 0;
 }
 
 FX_BOOL CPDF_Parser::LoadAllCrossRefV4(FX_FILESIZE xrefpos) {
   if (!LoadCrossRefV4(xrefpos, 0, TRUE)) {
     return FALSE;
   }
   m_pTrailer = LoadTrailerV4();
   if (!m_pTrailer) {
@@ skipping 865 matching lines @@
   const CPDF_Stream* pStream =
       ToStream(m_pDocument ? m_pDocument->GetIndirectObject(objnum) : nullptr);
   if (!pStream)
     return nullptr;
 
   pStreamAcc = new CPDF_StreamAcc;
   pStreamAcc->LoadAllData(pStream);
   m_ObjectStreamMap.SetAt((void*)(uintptr_t)objnum, pStreamAcc);
   return pStreamAcc;
 }
-FX_FILESIZE CPDF_Parser::GetObjectSize(FX_DWORD objnum) {
+
+FX_FILESIZE CPDF_Parser::GetObjectSize(FX_DWORD objnum) const {
   if (!IsValidObjectNumber(objnum))
     return 0;
 
-  if (m_V5Type[objnum] == 2) {
-    objnum = m_ObjectInfo[objnum].pos;
-  }
+  if (m_V5Type[objnum] == 2)
+    objnum = GetObjectPositionOrZero(objnum);
+
   if (m_V5Type[objnum] == 1 || m_V5Type[objnum] == 255) {
-    FX_FILESIZE offset = m_ObjectInfo[objnum].pos;
-    if (offset == 0) {
+    FX_FILESIZE offset = GetObjectPositionOrZero(objnum);
+    if (offset == 0)
       return 0;
-    }
-    void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(),
-                                  m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
-                                  CompareFileSize);
-    if (!pResult) {
+
+    FX_FILESIZE* pResult = static_cast<FX_FILESIZE*>(FXSYS_bsearch(
+        &offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
+        sizeof(FX_FILESIZE), CompareFileSize));
+    if (!pResult)
       return 0;
-    }
-    if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)m_SortedOffset.GetData() ==
-        m_SortedOffset.GetSize() - 1) {
+
+    if (pResult - m_SortedOffset.GetData() == m_SortedOffset.GetSize() - 1)
       return 0;
-    }
-    return ((FX_FILESIZE*)pResult)[1] - offset;
+
+    return pResult[1] - offset;
   }
   return 0;
 }
+
 void CPDF_Parser::GetIndirectBinary(FX_DWORD objnum,
                                     uint8_t*& pBuffer,
                                     FX_DWORD& size) {
   pBuffer = NULL;
   size = 0;
   if (!IsValidObjectNumber(objnum))
     return;
 
   if (m_V5Type[objnum] == 2) {
     CPDF_StreamAcc* pObjStream = GetObjectStream(m_ObjectInfo[objnum].pos);
@@ skipping 415 matching lines @@
 
 CPDF_SyntaxParser::CPDF_SyntaxParser() {
   m_pFileAccess = NULL;
   m_pFileBuf = NULL;
   m_BufSize = CPDF_ModuleMgr::kFileBufSize;
   m_pFileBuf = NULL;
   m_MetadataObjnum = 0;
   m_dwWordPos = 0;
   m_bFileStream = FALSE;
 }
+
 CPDF_SyntaxParser::~CPDF_SyntaxParser() {
   FX_Free(m_pFileBuf);
 }
 
 FX_BOOL CPDF_SyntaxParser::GetCharAt(FX_FILESIZE pos, uint8_t& ch) {
   CFX_AutoRestorer<FX_FILESIZE> save_pos(&m_Pos);
   m_Pos = pos;
   return GetNextChar(ch);
 }
 
@@ skipping 54 matching lines @@
   ch = m_pFileBuf[pos - m_BufOffset];
   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;
 }
-#define MAX_WORD_BUFFER 256
+
 void CPDF_SyntaxParser::GetNextWord() {
   m_WordSize = 0;
   m_bIsNumber = TRUE;
   uint8_t ch;
   if (!GetNextChar(ch)) {
     return;
   }
   while (1) {
     while (PDFCharIsWhitespace(ch)) {
       if (!GetNextChar(ch))
@@ skipping 16 matching lines @@
     if (ch == '/') {
       while (1) {
         if (!GetNextChar(ch))
           return;
 
         if (!PDFCharIsOther(ch) && !PDFCharIsNumeric(ch)) {
           m_Pos--;
           return;
         }
 
-        if (m_WordSize < MAX_WORD_BUFFER)
+        if (m_WordSize < sizeof(m_WordBuffer) - 1)
           m_WordBuffer[m_WordSize++] = ch;
       }
     } else if (ch == '<') {
       if (!GetNextChar(ch))
         return;
       if (ch == '<')
         m_WordBuffer[m_WordSize++] = ch;
       else
         m_Pos--;
     } else if (ch == '>') {
       if (!GetNextChar(ch))
         return;
       if (ch == '>')
         m_WordBuffer[m_WordSize++] = ch;
       else
         m_Pos--;
     }
     return;
   }
 
   while (1) {
-    if (m_WordSize < MAX_WORD_BUFFER)
+    if (m_WordSize < sizeof(m_WordBuffer) - 1)
       m_WordBuffer[m_WordSize++] = ch;
 
     if (!PDFCharIsNumeric(ch))
       m_bIsNumber = FALSE;
     if (!GetNextChar(ch))
       return;
 
     if (PDFCharIsDelimiter(ch) || PDFCharIsWhitespace(ch)) {
       m_Pos--;
       break;
@@ skipping 153 matching lines @@
       if (PDFCharIsLineEnding(ch))
         break;
     }
   }
   m_Pos--;
 }
 
 CFX_ByteString CPDF_SyntaxParser::GetNextWord(FX_BOOL& bIsNumber) {
   GetNextWord();
   bIsNumber = m_bIsNumber;
-  return CFX_ByteString((const FX_CHAR*)m_WordBuffer, m_WordSize);
+  return CFX_ByteString(m_WordBuffer, m_WordSize);
 }
 CFX_ByteString CPDF_SyntaxParser::GetKeyword() {
-  GetNextWord();
-  return CFX_ByteString((const FX_CHAR*)m_WordBuffer, m_WordSize);
+  FX_BOOL dummy;
+  return GetNextWord(dummy);
 }
 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;
   }
@@ skipping 457 matching lines @@
   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) {
     return 0;
   }
   m_WordBuffer[m_WordSize] = 0;
-  return FXSYS_atoi((const FX_CHAR*)m_WordBuffer);
+  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]);
   bool bCheckRight = !PDFCharIsDelimiter(tag[taglen - 1]) &&
                      !PDFCharIsWhitespace(tag[taglen - 1]);
@@ skipping 310 matching lines @@
   CFX_ArrayTemplate<CPDF_Object*> m_objs_array;
 
   FX_FILESIZE m_Pos;
 
   FX_FILESIZE m_bufferOffset;
 
   FX_DWORD m_bufferSize;
 
   CFX_ByteString m_WordBuf;
 
-  uint8_t m_WordBuffer[257];
-
-  FX_DWORD m_WordSize;
-
   uint8_t m_bufferData[512];
 
   CFX_FileSizeArray m_CrossOffset;
 
   CFX_DWordArray m_XRefStreamList;
 
   CFX_DWordArray m_PageObjList;
 
   FX_DWORD m_PagesObjNum;
 
@@ skipping 72 matching lines @@
 CPDF_DataAvail::CPDF_DataAvail(IFX_FileAvail* pFileAvail,
                                IFX_FileRead* pFileRead,
                                FX_BOOL bSupportHintTable)
     : IPDF_DataAvail(pFileAvail, pFileRead) {
   m_Pos = 0;
   m_dwFileLen = 0;
   if (m_pFileRead) {
     m_dwFileLen = (FX_DWORD)m_pFileRead->GetSize();
   }
   m_dwCurrentOffset = 0;
-  m_WordSize = 0;
   m_dwXRefOffset = 0;
   m_bufferOffset = 0;
   m_dwFirstPageNo = 0;
   m_bufferSize = 0;
   m_PagesObjNum = 0;
   m_dwCurrentXRefSteam = 0;
   m_dwAcroFormObjNum = 0;
   m_dwInfoObjNum = 0;
   m_pDocument = 0;
   m_dwEncryptObjNum = 0;
@@ skipping 845 matching lines @@
     }
     pObj->Release();
     return -1;
   }
   pHints->AddSegment(m_Pos, req_size);
   return 0;
 }
 inline void CPDF_DataAvail::SetStartOffset(FX_FILESIZE dwOffset) {
   m_Pos = dwOffset;
 }
-#define MAX_WORD_BUFFER 256
+
 FX_BOOL CPDF_DataAvail::GetNextToken(CFX_ByteString& token) {
-  m_WordSize = 0;
   uint8_t ch;
   if (!GetNextChar(ch))
     return FALSE;
 
   while (1) {
     while (PDFCharIsWhitespace(ch)) {
       if (!GetNextChar(ch))
         return FALSE;
     }
 
     if (ch != '%')
       break;
 
     while (1) {
       if (!GetNextChar(ch))
         return FALSE;
       if (PDFCharIsLineEnding(ch))
         break;
     }
   }
 
+  uint8_t buffer[256];
+  FX_DWORD index = 0;
   if (PDFCharIsDelimiter(ch)) {
-    m_WordBuffer[m_WordSize++] = ch;
+    buffer[index++] = ch;
     if (ch == '/') {
       while (1) {
         if (!GetNextChar(ch))
           return FALSE;
 
         if (!PDFCharIsOther(ch) && !PDFCharIsNumeric(ch)) {
           m_Pos--;
-          CFX_ByteString ret(m_WordBuffer, m_WordSize);
+          CFX_ByteString ret(buffer, index);
           token = ret;
           return TRUE;
         }
 
-        if (m_WordSize < MAX_WORD_BUFFER)
-          m_WordBuffer[m_WordSize++] = ch;
+        if (index < sizeof(buffer))
+          buffer[index++] = ch;
       }
     } else if (ch == '<') {
       if (!GetNextChar(ch))
         return FALSE;
 
       if (ch == '<')
-        m_WordBuffer[m_WordSize++] = ch;
+        buffer[index++] = ch;
       else
         m_Pos--;
     } else if (ch == '>') {
       if (!GetNextChar(ch))
         return FALSE;
 
       if (ch == '>')
-        m_WordBuffer[m_WordSize++] = ch;
+        buffer[index++] = ch;
       else
         m_Pos--;
     }
 
-    CFX_ByteString ret(m_WordBuffer, m_WordSize);
+    CFX_ByteString ret(buffer, index);
     token = ret;
     return TRUE;
   }
 
   while (1) {
-    if (m_WordSize < MAX_WORD_BUFFER)
-      m_WordBuffer[m_WordSize++] = ch;
+    if (index < sizeof(buffer))
+      buffer[index++] = ch;
 
     if (!GetNextChar(ch))
       return FALSE;
 
     if (PDFCharIsDelimiter(ch) || PDFCharIsWhitespace(ch)) {
       m_Pos--;
       break;
     }
   }
 
-  CFX_ByteString ret(m_WordBuffer, m_WordSize);
-  token = ret;
+  token = CFX_ByteString(buffer, index);
   return TRUE;
 }
+
 FX_BOOL CPDF_DataAvail::GetNextChar(uint8_t& ch) {
   FX_FILESIZE pos = m_Pos;
   if (pos >= m_dwFileLen) {
     return FALSE;
   }
   if (m_bufferOffset >= pos ||
       (FX_FILESIZE)(m_bufferOffset + m_bufferSize) <= pos) {
     FX_FILESIZE read_pos = pos;
     FX_DWORD read_size = 512;
     if ((FX_FILESIZE)read_size > m_dwFileLen) {
@@ skipping 1116 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();
 }