Revert "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)                 \

[Tom Sepez, 2015/11/04 18:42:45]

Later on, you can fix this, too.  I'd minimize it and then just instantiate in
both places, or make it into an inline function. Without actually checking, the
loop should be of the form 
  while (std::isdigit(*ptr)) {
    exp_ret = 10 * exp_ret +  FXSYS_toDecimalDigit(*ptr);
    ++ptr;
  }

or perhaps

  for (exp_ret = 0; std::isdigit(*ptr); ++ptr) ...

also the name is misleading as it doesn't detect exponents, its just anotehr
atoi() equivalent of which you have some elsewhere, right?

[dsinclair, 2015/11/04 20:16:24]

Acknowledged.

+  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 (*ptr >= '0' && *ptr <= '9') {
-      if (!e_number) {
+
+    if (std::isdigit(*ptr)) {
+      if (!e_number)
         e_number = 1;
-      }
+
       if (!e_point) {
         ret *= 10;
-        ret += (*ptr - '0');
+        ret += FXSYS_toDecimalDigit(*ptr);
       } else {
         fra_count++;
         fra_ret *= 10;
-        fra_ret += (*ptr - '0');
+        fra_ret += FXSYS_toDecimalDigit(*ptr);
       }
       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 (*ptr < '0' || *ptr > '9') {
+        if (!std::isdigit(*ptr)) {
           if (endptr) {
             *endptr = (char*)exp_ptr;
           }
           break;
         }
         EXPONENT_DETECT(ptr);
-      } else if (*ptr >= '0' && *ptr <= '9') {
+      } else if (std::isdigit(*ptr)) {
         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;
 }