Reland "Cleanup some numeric code.""

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 <set>
 #include <utility>
 #include <vector>
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_page.h"
 #include "core/include/fpdfapi/fpdf_parser.h"
+#include "core/include/fxcrt/fx_ext.h"
 #include "core/include/fxcrt/fx_safe_types.h"
 #include "core/src/fpdfapi/fpdf_page/pageint.h"
 #include "third_party/base/nonstd_unique_ptr.h"
 #include "third_party/base/stl_util.h"
 
 namespace {
 
 struct SearchTagRecord {
   const uint8_t* m_pTag;
   FX_DWORD m_Len;
@@ skipping 131 matching lines @@
 }
 CPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler();
 CPDF_SecurityHandler* FPDF_CreatePubKeyHandler(void*);
 FX_DWORD CPDF_Parser::StartParse(IFX_FileRead* pFileAccess,
                                  FX_BOOL bReParse,
                                  FX_BOOL bOwnFileRead) {
   CloseParser(bReParse);
   m_bXRefStream = FALSE;
   m_LastXRefOffset = 0;
   m_bOwnFileRead = bOwnFileRead;
+
   int32_t offset = GetHeaderOffset(pFileAccess);
   if (offset == -1) {
-    if (bOwnFileRead && pFileAccess) {
+    if (bOwnFileRead && pFileAccess)
       pFileAccess->Release();
-    }
     return PDFPARSE_ERROR_FORMAT;
   }
   m_Syntax.InitParser(pFileAccess, offset);
+
   uint8_t ch;
-  if (!m_Syntax.GetCharAt(5, ch)) {
+  if (!m_Syntax.GetCharAt(5, ch))
     return PDFPARSE_ERROR_FORMAT;
-  }
-  if (ch >= '0' && ch <= '9') {
-    m_FileVersion = (ch - '0') * 10;
-  }
-  if (!m_Syntax.GetCharAt(7, ch)) {
+  if (std::isdigit(ch))
+    m_FileVersion = FXSYS_toDecimalDigit(ch) * 10;
+
+  if (!m_Syntax.GetCharAt(7, ch))
     return PDFPARSE_ERROR_FORMAT;
-  }
-  if (ch >= '0' && ch <= '9') {
-    m_FileVersion += ch - '0';
-  }
-  if (m_Syntax.m_FileLen < m_Syntax.m_HeaderOffset + 9) {
+  if (std::isdigit(ch))
+    m_FileVersion += FXSYS_toDecimalDigit(ch);
+
+  if (m_Syntax.m_FileLen < m_Syntax.m_HeaderOffset + 9)
     return PDFPARSE_ERROR_FORMAT;
-  }
+
   m_Syntax.RestorePos(m_Syntax.m_FileLen - m_Syntax.m_HeaderOffset - 9);
-  if (!bReParse) {
+  if (!bReParse)
     m_pDocument = new CPDF_Document(this);
-  }
+
   FX_BOOL bXRefRebuilt = FALSE;
   if (m_Syntax.SearchWord(FX_BSTRC("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 == NULL) {
+    if (!pResult)
       m_SortedOffset.Add(startxref_offset);
-    }
+
     m_Syntax.GetKeyword();
     FX_BOOL bNumber;
     CFX_ByteString xrefpos_str = m_Syntax.GetNextWord(bNumber);
-    if (!bNumber) {
+    if (!bNumber)
       return PDFPARSE_ERROR_FORMAT;
-    }
+
     m_LastXRefOffset = (FX_FILESIZE)FXSYS_atoi64(xrefpos_str);
     if (!LoadAllCrossRefV4(m_LastXRefOffset) &&
         !LoadAllCrossRefV5(m_LastXRefOffset)) {
-      if (!RebuildCrossRef()) {
+      if (!RebuildCrossRef())
         return PDFPARSE_ERROR_FORMAT;
-      }
+
       bXRefRebuilt = TRUE;
       m_LastXRefOffset = 0;
     }
   } else {
-    if (!RebuildCrossRef()) {
+    if (!RebuildCrossRef())
       return PDFPARSE_ERROR_FORMAT;
-    }
+
     bXRefRebuilt = TRUE;
   }
   FX_DWORD dwRet = SetEncryptHandler();
-  if (dwRet != PDFPARSE_ERROR_SUCCESS) {
+  if (dwRet != PDFPARSE_ERROR_SUCCESS)
     return dwRet;
-  }
+
   m_pDocument->LoadDoc();
-  if (m_pDocument->GetRoot() == NULL || m_pDocument->GetPageCount() == 0) {
-    if (bXRefRebuilt) {
+  if (!m_pDocument->GetRoot() || m_pDocument->GetPageCount() == 0) {
+    if (bXRefRebuilt)
       return PDFPARSE_ERROR_FORMAT;
-    }
+
     ReleaseEncryptHandler();
-    if (!RebuildCrossRef()) {
+    if (!RebuildCrossRef())
       return PDFPARSE_ERROR_FORMAT;
-    }
+
     dwRet = SetEncryptHandler();
-    if (dwRet != PDFPARSE_ERROR_SUCCESS) {
+    if (dwRet != PDFPARSE_ERROR_SUCCESS)
       return dwRet;
-    }
+
     m_pDocument->LoadDoc();
-    if (m_pDocument->GetRoot() == NULL) {
+    if (!m_pDocument->GetRoot())
       return PDFPARSE_ERROR_FORMAT;
-    }
   }
   FXSYS_qsort(m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
               sizeof(FX_FILESIZE), CompareFileSize);
   FX_DWORD RootObjNum = GetRootObjNum();
   if (RootObjNum == 0) {
     ReleaseEncryptHandler();
     RebuildCrossRef();
     RootObjNum = GetRootObjNum();
-    if (RootObjNum == 0) {
+    if (RootObjNum == 0)
       return PDFPARSE_ERROR_FORMAT;
-    }
+
     dwRet = SetEncryptHandler();
-    if (dwRet != PDFPARSE_ERROR_SUCCESS) {
+    if (dwRet != PDFPARSE_ERROR_SUCCESS)
       return dwRet;
-    }
   }
   if (m_pSecurityHandler && !m_pSecurityHandler->IsMetadataEncrypted()) {
     CPDF_Reference* pMetadata =
         ToReference(m_pDocument->GetRoot()->GetElement(FX_BSTRC("Metadata")));
     if (pMetadata)
       m_Syntax.m_MetadataObjnum = pMetadata->GetRefObjNum();
   }
   return PDFPARSE_ERROR_SUCCESS;
 }
 FX_DWORD CPDF_Parser::SetEncryptHandler() {
@@ skipping 183 matching lines @@
     for (int32_t i = 0; i < block_size; i++) {
       FX_DWORD objnum = start_objnum + block * 1024 + i;
       char* pEntry = pBuf + i * recordsize;
       if (pEntry[17] == 'f') {
         m_CrossRef.SetAtGrow(objnum, 0);
         m_V5Type.SetAtGrow(objnum, 0);
       } else {
         int32_t offset = FXSYS_atoi(pEntry);
         if (offset == 0) {
           for (int32_t c = 0; c < 10; c++) {
-            if (pEntry[c] < '0' || pEntry[c] > '9') {
+            if (!std::isdigit(pEntry[c]))
               return FALSE;
-            }
           }
         }
         m_CrossRef.SetAtGrow(objnum, offset);
         int32_t version = FXSYS_atoi(pEntry + 11);
         if (version >= 1) {
           m_bVersionUpdated = TRUE;
         }
         m_ObjVersion.SetAtGrow(objnum, version);
         if (m_CrossRef[objnum] < m_Syntax.m_FileLen) {
           void* pResult = FXSYS_bsearch(
@@ skipping 78 matching lines @@
                 start_objnum--;
                 objnum = 0;
               }
             }
             m_CrossRef.SetAtGrow(objnum, 0);
             m_V5Type.SetAtGrow(objnum, 0);
           } else {
             FX_FILESIZE offset = (FX_FILESIZE)FXSYS_atoi64(pEntry);
             if (offset == 0) {
               for (int32_t c = 0; c < 10; c++) {
-                if (pEntry[c] < '0' || pEntry[c] > '9') {
+                if (!std::isdigit(pEntry[c]))
                   return false;
-                }
               }
             }
             m_CrossRef.SetAtGrow(objnum, offset);
             int32_t version = FXSYS_atoi(pEntry + 11);
             if (version >= 1) {
               m_bVersionUpdated = TRUE;
             }
             m_ObjVersion.SetAtGrow(objnum, version);
             if (m_CrossRef[objnum] < m_Syntax.m_FileLen &&
                 !FindPosInOffsets(m_CrossRef[objnum])) {
@@ skipping 47 matching lines @@
     if (size > 4096) {
       size = 4096;
     }
     if (!m_Syntax.m_pFileAccess->ReadBlock(buffer, pos, size)) {
       break;
     }
     for (FX_DWORD i = 0; i < size; i++) {
       uint8_t byte = buffer[i];
       switch (status) {
         case 0:
-          if (PDFCharIsWhitespace(byte)) {
+          if (PDFCharIsWhitespace(byte))
             status = 1;
-          }
-          if (byte <= '9' && byte >= '0') {
+
+          if (std::isdigit(byte)) {
             --i;
             status = 1;
           }
+
           if (byte == '%') {
             inside_index = 0;
             status = 9;
           }
+
           if (byte == '(') {
             status = 10;
             depth = 1;
           }
+
           if (byte == '<') {
             inside_index = 1;
             status = 11;
           }
-          if (byte == '\\') {
+
+          if (byte == '\\')
             status = 13;
-          }
+
           if (byte == 't') {
             status = 7;
             inside_index = 1;
           }
           break;
         case 1:
           if (PDFCharIsWhitespace(byte)) {
             break;
-          } else if (byte <= '9' && byte >= '0') {
+          } else if (std::isdigit(byte)) {
             start_pos = pos + i;
             status = 2;
-            objnum = byte - '0';
+            objnum = FXSYS_toDecimalDigit(byte);
           } else if (byte == 't') {
             status = 7;
             inside_index = 1;
           } else if (byte == 'x') {
             status = 8;
             inside_index = 1;
           } else {
             --i;
             status = 0;
           }
           break;
         case 2:
-          if (byte <= '9' && byte >= '0') {
-            objnum = objnum * 10 + byte - '0';
+          if (std::isdigit(byte)) {
+            objnum = objnum * 10 + FXSYS_toDecimalDigit(byte);
             break;
           } else if (PDFCharIsWhitespace(byte)) {
             status = 3;
           } else {
             --i;
             status = 14;
             inside_index = 0;
           }
           break;
         case 3:
-          if (byte <= '9' && byte >= '0') {
+          if (std::isdigit(byte)) {
             start_pos1 = pos + i;
             status = 4;
-            gennum = byte - '0';
+            gennum = FXSYS_toDecimalDigit(byte);
           } else if (PDFCharIsWhitespace(byte)) {
             break;
           } else if (byte == 't') {
             status = 7;
             inside_index = 1;
           } else {
             --i;
             status = 0;
           }
           break;
         case 4:
-          if (byte <= '9' && byte >= '0') {
-            gennum = gennum * 10 + byte - '0';
+          if (std::isdigit(byte)) {
+            gennum = gennum * 10 + FXSYS_toDecimalDigit(byte);
             break;
           } else if (PDFCharIsWhitespace(byte)) {
             status = 5;
           } else {
             --i;
             status = 0;
           }
           break;
         case 5:
           if (byte == 'o') {
             status = 6;
             inside_index = 1;
           } else if (PDFCharIsWhitespace(byte)) {
             break;
-          } else if (byte <= '9' && byte >= '0') {
+          } else if (std::isdigit(byte)) {
             objnum = gennum;
-            gennum = byte - '0';
+            gennum = FXSYS_toDecimalDigit(byte);
             start_pos = start_pos1;
             start_pos1 = pos + i;
             status = 4;
           } else if (byte == 't') {
             status = 7;
             inside_index = 1;
           } else {
             --i;
             status = 0;
           }
@@ skipping 1114 matching lines @@
           parlevel++;
           buf.AppendChar('(');
         } else if (ch == '\\') {
           status = 1;
         } else {
           buf.AppendChar(ch);
         }
         break;
       case 1:
         if (ch >= '0' && ch <= '7') {
-          iEscCode = ch - '0';
+          iEscCode = FXSYS_toDecimalDigit(ch);
           status = 2;
           break;
         }
         if (ch == 'n') {
           buf.AppendChar('\n');
         } else if (ch == 'r') {
           buf.AppendChar('\r');
         } else if (ch == 't') {
           buf.AppendChar('\t');
         } else if (ch == 'b') {
           buf.AppendChar('\b');
         } else if (ch == 'f') {
           buf.AppendChar('\f');
         } else if (ch == '\r') {
           status = 4;
           break;
         } else if (ch == '\n') {
         } else {
           buf.AppendChar(ch);
         }
         status = 0;
         break;
       case 2:
         if (ch >= '0' && ch <= '7') {
-          iEscCode = iEscCode * 8 + ch - '0';
+          iEscCode = iEscCode * 8 + FXSYS_toDecimalDigit(ch);
           status = 3;
         } else {
           buf.AppendChar(iEscCode);
           status = 0;
           continue;
         }
         break;
       case 3:
         if (ch >= '0' && ch <= '7') {
-          iEscCode = iEscCode * 8 + ch - '0';
+          iEscCode = iEscCode * 8 + FXSYS_toDecimalDigit(ch);
           buf.AppendChar(iEscCode);
           status = 0;
         } else {
           buf.AppendChar(iEscCode);
           status = 0;
           continue;
         }
         break;
       case 4:
         status = 0;
         if (ch != '\n') {
           continue;
         }
         break;
     }
     if (!GetNextChar(ch)) {
       break;
     }
   }
   GetNextChar(ch);
   return buf.GetByteString();
 }
 CFX_ByteString CPDF_SyntaxParser::ReadHexString() {
   uint8_t ch;
-  if (!GetNextChar(ch)) {
+  if (!GetNextChar(ch))
     return CFX_ByteString();
-  }
+
   CFX_BinaryBuf buf;
-  FX_BOOL bFirst = TRUE;
+  bool bFirst = true;
   uint8_t code = 0;
   while (1) {
-    if (ch == '>') {
+    if (ch == '>')
       break;
-    }
-    if (ch >= '0' && ch <= '9') {
+
+    if (std::isxdigit(ch)) {
+      int val = FXSYS_toHexDigit(ch);
       if (bFirst) {
-        code = (ch - '0') * 16;
+        code = val * 16;
       } else {
-        code += ch - '0';
-        buf.AppendByte((uint8_t)code);
-      }
-      bFirst = !bFirst;
-    } else if (ch >= 'A' && ch <= 'F') {
-      if (bFirst) {
-        code = (ch - 'A' + 10) * 16;
-      } else {
-        code += ch - 'A' + 10;
-        buf.AppendByte((uint8_t)code);
-      }
-      bFirst = !bFirst;
-    } else if (ch >= 'a' && ch <= 'f') {
-      if (bFirst) {
-        code = (ch - 'a' + 10) * 16;
-      } else {
-        code += ch - 'a' + 10;
+        code += val;
         buf.AppendByte((uint8_t)code);
       }
       bFirst = !bFirst;
     }
-    if (!GetNextChar(ch)) {
+
+    if (!GetNextChar(ch))
       break;
-    }
   }
-  if (!bFirst) {
+  if (!bFirst)
     buf.AppendByte((uint8_t)code);
-  }
+
   return buf.GetByteString();
 }
 void CPDF_SyntaxParser::ToNextLine() {
   uint8_t ch;
   while (GetNextChar(ch)) {
     if (ch == '\n') {
       break;
     }
     if (ch == '\r') {
       GetNextChar(ch);
@@ skipping 2978 matching lines @@
   if (!m_pLinearizedDict)
     return -1;
   CPDF_Array* pRange = m_pLinearizedDict->GetArray(FX_BSTRC("H"));
   if (!pRange)
     return -1;
   CPDF_Object* pStreamLen = pRange->GetElementValue(1);
   if (!pStreamLen)
     return -1;
   return pStreamLen->GetInteger();
 }