Revert "Revert "Revert "Cleanup some numeric code."""

core/src/fxcodec/codec/fx_codec.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 "../../../include/fxcodec/fx_codec.h"
 
 #include <cmath>
 
 #include "../../../../third_party/base/logging.h"
-#include "../../../include/fxcrt/fx_ext.h"
 #include "../../../include/fxcrt/fx_safe_types.h"
 #include "codec_int.h"
 
 CCodec_ModuleMgr::CCodec_ModuleMgr()
     : m_pBasicModule(new CCodec_BasicModule),
       m_pFaxModule(new CCodec_FaxModule),
       m_pJpegModule(new CCodec_JpegModule),
       m_pJpxModule(new CCodec_JpxModule),
       m_pJbig2Module(new CCodec_Jbig2Module),
       m_pIccModule(new CCodec_IccModule),
@@ skipping 118 matching lines @@
 
   m_pDataCache = nonstd::move(cache);
 }
 
 FX_BOOL CCodec_BasicModule::RunLengthEncode(const uint8_t* src_buf,
                                             FX_DWORD src_size,
                                             uint8_t*& dest_buf,
                                             FX_DWORD& dest_size) {
   return FALSE;
 }
-
-#define EXPONENT_DETECT(ptr)                 \
-  for (;; ptr++) {                           \
-    if (!std::isdigit(*ptr)) {               \
-      if (endptr)                            \
-        *endptr = (char*)ptr;                \
-      break;                                 \
-    } else {                                 \
-      exp_ret *= 10;                         \
-      exp_ret += FXSYS_toDecimalDigit(*ptr); \
-      continue;                              \
-    }                                        \
-  }
-
 extern "C" double FXstrtod(const char* nptr, char** endptr) {
   double ret = 0.0;
   const char* ptr = nptr;
   const char* exp_ptr = NULL;
   int e_number = 0, e_signal = 0, e_point = 0, is_negative = 0;
   int exp_ret = 0, exp_sig = 1, fra_ret = 0, fra_count = 0, fra_base = 1;
   if (nptr == NULL) {
     return 0.0;
   }
   for (;; ptr++) {
-    if (!e_number && !e_point && (*ptr == '\t' || *ptr == ' '))
+    if (!e_number && !e_point && (*ptr == '\t' || *ptr == ' ')) {
       continue;
-
-    if (std::isdigit(*ptr)) {
-      if (!e_number)
+    }
+    if (*ptr >= '0' && *ptr <= '9') {
+      if (!e_number) {
         e_number = 1;
-
+      }
       if (!e_point) {
         ret *= 10;
-        ret += FXSYS_toDecimalDigit(*ptr);
+        ret += (*ptr - '0');
       } else {
         fra_count++;
         fra_ret *= 10;
-        fra_ret += FXSYS_toDecimalDigit(*ptr);
+        fra_ret += (*ptr - '0');
       }
       continue;
     }
     if (!e_point && *ptr == '.') {
       e_point = 1;
       continue;
     }
     if (!e_number && !e_point && !e_signal) {
       switch (*ptr) {
         case '-':
           is_negative = 1;
         case '+':
           e_signal = 1;
           continue;
       }
     }
     if (e_number && (*ptr == 'e' || *ptr == 'E')) {
+#define EXPONENT_DETECT(ptr)        \
+  for (;; ptr++) {                  \
+    if (*ptr < '0' || *ptr > '9') { \
+      if (endptr)                   \
+        *endptr = (char*)ptr;       \
+      break;                        \
+    } else {                        \
+      exp_ret *= 10;                \
+      exp_ret += (*ptr - '0');      \
+      continue;                     \
+    }                               \
+  }
       exp_ptr = ptr++;
       if (*ptr == '+' || *ptr == '-') {
         exp_sig = (*ptr++ == '+') ? 1 : -1;
-        if (!std::isdigit(*ptr)) {
+        if (*ptr < '0' || *ptr > '9') {
           if (endptr) {
             *endptr = (char*)exp_ptr;
           }
           break;
         }
         EXPONENT_DETECT(ptr);
-      } else if (std::isdigit(*ptr)) {
+      } else if (*ptr >= '0' && *ptr <= '9') {
         EXPONENT_DETECT(ptr);
       } else {
         if (endptr) {
           *endptr = (char*)exp_ptr;
         }
         break;
       }
+#undef EXPONENT_DETECT
       break;
     }
     if (ptr != nptr && !e_number) {
       if (endptr) {
         *endptr = (char*)nptr;
       }
       break;
     }
     if (endptr) {
       *endptr = (char*)ptr;
     }
     break;
   }
   while (fra_count--) {
     fra_base *= 10;
   }
   ret += (double)fra_ret / (double)fra_base;
   if (exp_sig == 1) {
     while (exp_ret--) {
       ret *= 10.0;
     }
   } else {
     while (exp_ret--) {
       ret /= 10.0;
     }
   }
   return is_negative ? -ret : ret;
 }
-#undef EXPONENT_DETECT
-
 FX_BOOL CCodec_BasicModule::A85Encode(const uint8_t* src_buf,
                                       FX_DWORD src_size,
                                       uint8_t*& dest_buf,
                                       FX_DWORD& dest_size) {
   return FALSE;
 }
 class CCodec_RLScanlineDecoder : public CCodec_ScanlineDecoder {
  public:
   CCodec_RLScanlineDecoder();
   ~CCodec_RLScanlineDecoder() override;
@@ skipping 179 matching lines @@
     int nComps,
     int bpc) {
   CCodec_RLScanlineDecoder* pRLScanlineDecoder = new CCodec_RLScanlineDecoder;
   if (!pRLScanlineDecoder->Create(src_buf, src_size, width, height, nComps,
                                   bpc)) {
     delete pRLScanlineDecoder;
     return NULL;
   }
   return pRLScanlineDecoder;
 }