strtonum.h

Go to the documentation of this file.

 
#ifndef DMLC_STRTONUM_H_
#define DMLC_STRTONUM_H_
 
#if DMLC_USE_CXX11
#include <type_traits>
#endif
 
#include <string>
#include <limits>
#include <cstdint>
#include "./base.h"
#include "./logging.h"
 
namespace dmlc {
inline bool isspace(char c) {
  return (c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\f');
}
 
inline bool isblank(char c) {
  return (c == ' ' || c == '\t');
}
 
inline bool isdigit(char c) {
  return (c >= '0' && c <= '9');
}
 
inline bool isalpha(char c) {
  static_assert(
    static_cast<int>('A') == 65 && static_cast<int>('Z' - 'A') == 25,
    "Only system with ASCII character set is supported");
  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}
 
inline bool isdigitchars(char c) {
  return (c >= '0' && c <= '9')
    || c == '+' || c == '-'
    || c == '.'
    || c == 'e' || c == 'E';
}
 
const int kStrtofMaxDigits = 19;
 
template <typename FloatType, bool CheckRange = false>
inline FloatType ParseFloat(const char* nptr, char** endptr) {
#if DMLC_USE_CXX11
  static_assert(std::is_same<FloatType, double>::value
                || std::is_same<FloatType, float>::value,
               "ParseFloat is defined only for 'float' and 'double' types");
  constexpr unsigned kMaxExponent
    = (std::is_same<FloatType, double>::value ? 308U : 38U);
  constexpr FloatType kMaxSignificandForMaxExponent
    = static_cast<FloatType>(std::is_same<FloatType, double>::value
                             ? 1.79769313486231570 : 3.402823466);
    // If a floating-point value has kMaxExponent, what is
    //   the largest possible significand value?
  constexpr FloatType kMaxSignificandForNegMaxExponent
    = static_cast<FloatType>(std::is_same<FloatType, double>::value
                             ? 2.22507385850720139 : 1.175494351);
    // If a floating-point value has -kMaxExponent, what is
    //   the largest possible significand value?
#else
  const unsigned kMaxExponent
    = (sizeof(FloatType) == sizeof(double) ? 308U : 38U);
  const FloatType kMaxSignificandForMaxExponent
    = static_cast<FloatType>(sizeof(FloatType) == sizeof(double)
                             ? 1.79769313486231570 : 3.402823466);
  const FloatType kMaxSignificandForNegMaxExponent
    = static_cast<FloatType>(sizeof(FloatType) == sizeof(double)
                             ? 2.22507385850720139 : 1.175494351);
#endif
 
  const char *p = nptr;
  // Skip leading white space, if any. Not necessary
  while (isspace(*p) ) ++p;
 
  // Get sign, if any.
  bool sign = true;
  if (*p == '-') {
    sign = false; ++p;
  } else if (*p == '+') {
    ++p;
  }
 
  // Handle INF and NAN
  {
    int i = 0;
    // case-insensitive match for INF and INFINITY
    while (i < 8 && static_cast<char>((*p) | 32) == "infinity"[i]) {
      ++i; ++p;
    }
    if (i == 3 || i == 8) {
      if (endptr) *endptr = (char*)p;  // NOLINT(*)
      return sign ?  std::numeric_limits<FloatType>::infinity()
                  : -std::numeric_limits<FloatType>::infinity();
    } else {
      p -= i;
    }
 
    // case-insensitive match for NAN
    i = 0;
    while (i < 3 && static_cast<char>((*p) | 32) == "nan"[i]) {
      ++i; ++p;
    }
    if (i == 3) {
      // Got NAN; check if the value is of form NAN(char_sequence)
      if (*p == '(') {
        ++p;
        while (isdigit(*p) || isalpha(*p) || *p == '_') ++p;
        CHECK_EQ(*p, ')') << "Invalid NAN literal";
        ++p;
      }
      static_assert(std::numeric_limits<FloatType>::has_quiet_NaN,
        "Only system with quiet NaN is supported");
      if (endptr) *endptr = (char*)p;  // NOLINT(*)
      return std::numeric_limits<FloatType>::quiet_NaN();
    } else {
      p -= i;
    }
  }
 
  // Get digits before decimal point or exponent, if any.
  uint64_t predec;  // to store digits before decimal point
  for (predec = 0; isdigit(*p); ++p) {
    predec = predec * 10ULL + static_cast<uint64_t>(*p - '0');
  }
  FloatType value = static_cast<FloatType>(predec);
 
  // Get digits after decimal point, if any.
  if (*p == '.') {
    uint64_t pow10 = 1;
    uint64_t val2 = 0;
    int digit_cnt = 0;
    ++p;
    while (isdigit(*p)) {
      if (digit_cnt < kStrtofMaxDigits) {
        val2 = val2 * 10ULL + static_cast<uint64_t>(*p - '0');
        pow10 *= 10ULL;
      }  // when kStrtofMaxDigits is read, ignored following digits
      ++p;
      ++digit_cnt;
    }
    value += static_cast<FloatType>(
        static_cast<double>(val2) / static_cast<double>(pow10));
  }
 
  // Handle exponent, if any.
  if ((*p == 'e') || (*p == 'E')) {
    ++p;
    bool frac = false;
    FloatType scale = static_cast<FloatType>(1.0f);
    unsigned expon;
    // Get sign of exponent, if any.
    if (*p == '-') {
      frac = true;
      ++p;
    } else if (*p == '+') {
      ++p;
    }
    // Get digits of exponent, if any.
    for (expon = 0; isdigit(*p); ++p) {
      expon = expon * 10U + static_cast<unsigned>(*p - '0');
    }
    if (expon > kMaxExponent) {  // out of range, clip or raise error
      if (CheckRange) {
        errno = ERANGE;
        if (endptr) *endptr = (char*)p;  // NOLINT(*)
        return std::numeric_limits<FloatType>::infinity();
      } else {
        expon = kMaxExponent;
      }
    }
    // handle edge case where exponent is exactly kMaxExponent
    if (expon == kMaxExponent
        && ((!frac && value > kMaxSignificandForMaxExponent)
           || (frac && value < kMaxSignificandForNegMaxExponent))) {
      if (CheckRange) {
        errno = ERANGE;
        if (endptr) *endptr = (char*)p;  // NOLINT(*)
        return std::numeric_limits<FloatType>::infinity();
      } else {
        value = (frac ? kMaxSignificandForNegMaxExponent
                 : kMaxSignificandForMaxExponent);
      }
    }
    // Calculate scaling factor.
    while (expon >= 8U) { scale *= static_cast<FloatType>(1E8f);  expon -= 8U; }
    while (expon >  0U) { scale *= static_cast<FloatType>(10.0f); expon -= 1U; }
    // Return signed and scaled floating point result.
    value = frac ? (value / scale) : (value * scale);
  }
  // Consume 'f' suffix, if any
  if (*p == 'f' || *p == 'F') {
    ++p;
  }
 
  if (endptr) *endptr = (char*)p;  // NOLINT(*)
  return sign ? value : - value;
}
 
inline float strtof(const char* nptr, char** endptr) {
  return ParseFloat<float>(nptr, endptr);
}
 
inline float strtof_check_range(const char* nptr, char** endptr) {
  return ParseFloat<float, true>(nptr, endptr);
}
 
inline double strtod(const char* nptr, char** endptr) {
  return ParseFloat<double>(nptr, endptr);
}
 
inline double strtod_check_range(const char* nptr, char** endptr) {
  return ParseFloat<double, true>(nptr, endptr);
}
 
template <typename SignedIntType>
inline SignedIntType ParseSignedInt(const char* nptr, char** endptr, int base) {
#ifdef DMLC_USE_CXX11
  static_assert(std::is_signed<SignedIntType>::value
                && std::is_integral<SignedIntType>::value,
                "ParseSignedInt is defined for signed integers only");
#endif
  CHECK(base <= 10 && base >= 2);
  const char* p = nptr;
  // Skip leading white space, if any. Not necessary
  while (isspace(*p) ) ++p;
 
  // Get sign if any
  bool sign = true;
  if (*p == '-') {
    sign = false; ++p;
  } else if (*p == '+') {
    ++p;
  }
 
  SignedIntType value;
  const SignedIntType base_val = static_cast<SignedIntType>(base);
  for (value = 0; isdigit(*p); ++p) {
    value = value * base_val + static_cast<SignedIntType>(*p - '0');
  }
 
  if (endptr) *endptr = (char*)p;  // NOLINT(*)
  return sign ? value : - value;
}
 
template <typename UnsignedIntType>
inline UnsignedIntType ParseUnsignedInt(const char* nptr, char** endptr, int base) {
#ifdef DMLC_USE_CXX11
  static_assert(std::is_unsigned<UnsignedIntType>::value
                && std::is_integral<UnsignedIntType>::value,
                "ParseUnsignedInt is defined for unsigned integers only");
#endif
  CHECK(base <= 10 && base >= 2);
  const char *p = nptr;
  // Skip leading white space, if any. Not necessary
  while (isspace(*p)) ++p;
 
  // Get sign if any
  bool sign = true;
  if (*p == '-') {
    sign = false; ++p;
  } else if (*p == '+') {
    ++p;
  }
 
  // we are parsing unsigned, so no minus sign should be found
  CHECK_EQ(sign, true);
 
  UnsignedIntType value;
  const UnsignedIntType base_val = static_cast<UnsignedIntType>(base);
  for (value = 0; isdigit(*p); ++p) {
    value = value * base_val + static_cast<UnsignedIntType>(*p - '0');
  }
 
  if (endptr) *endptr = (char*)p; // NOLINT(*)
  return value;
}
 
inline uint64_t strtoull(const char* nptr, char **endptr, int base) {
  return ParseUnsignedInt<uint64_t>(nptr, endptr, base);
}
 
inline long atol(const char* p) {  // NOLINT(*)
  return ParseSignedInt<long>(p, 0, 10); // NOLINT(*)
}
 
inline float atof(const char* nptr) {
  return strtof(nptr, 0);
}
 
inline float stof(const std::string& value, size_t* pos = nullptr) {
  const char* str_source = value.c_str();
  char* endptr;
  const float parsed_value = dmlc::strtof_check_range(str_source, &endptr);
  if (errno == ERANGE && parsed_value == std::numeric_limits<float>::infinity()) {
    throw std::out_of_range("Out of range value");
  } else if (const_cast<const char*>(endptr) == str_source) {
    throw std::invalid_argument("No conversion could be performed");
  }
  if (pos) {
    *pos = static_cast<size_t>(const_cast<const char*>(endptr) - str_source);
  }
  return parsed_value;
}
 
inline double stod(const std::string& value, size_t* pos = nullptr) {
  const char* str_source = value.c_str();
  char* endptr;
  const double parsed_value = dmlc::strtod_check_range(str_source, &endptr);
  if (errno == ERANGE && parsed_value == std::numeric_limits<double>::infinity()) {
    throw std::out_of_range("Out of range value");
  } else if (const_cast<const char*>(endptr) == str_source) {
    throw std::invalid_argument("No conversion could be performed");
  }
  if (pos) {
    *pos = static_cast<size_t>(const_cast<const char*>(endptr) - str_source);
  }
  return parsed_value;
}
 
template<typename T>
class Str2T {
 public:
  static inline T get(const char * begin);
};
 
template<typename T>
inline T Str2Type(const char * begin) {
  return Str2T<T>::get(begin);
}
 
template<>
class Str2T<int32_t> {
 public:
  static inline int32_t get(const char * begin) {
    return ParseSignedInt<int32_t>(begin, NULL, 10);
  }
};
 
template<>
class Str2T<uint32_t> {
 public:
  static inline uint32_t get(const char* begin) {
    return ParseUnsignedInt<uint32_t>(begin, NULL, 10);
  }
};
 
template<>
class Str2T<int64_t> {
 public:
  static inline int64_t get(const char * begin) {
    return ParseSignedInt<int64_t>(begin, NULL, 10);
  }
};
 
template<>
class Str2T<uint64_t> {
 public:
  static inline uint64_t get(const char * begin) {
    return ParseUnsignedInt<uint64_t>(begin, NULL, 10);
  }
};
 
template<>
class Str2T<float> {
 public:
  static inline float get(const char * begin) {
    return atof(begin);
  }
};
 
template<>
class Str2T<double> {
 public:
  static inline double get(const char * begin) {
    return strtod(begin, 0);
  }
};
 
template<typename T1, typename T2>
inline int ParsePair(const char * begin, const char * end,
                     const char ** endptr, T1 &v1, T2 &v2) { // NOLINT(*)
  const char * p = begin;
  while (p != end && !isdigitchars(*p)) ++p;
  if (p == end) {
    *endptr = end;
    return 0;
  }
  const char * q = p;
  while (q != end && isdigitchars(*q)) ++q;
  v1 = Str2Type<T1>(p);
  p = q;
  while (p != end && isblank(*p)) ++p;
  if (p == end || *p != ':') {
    // only v1
    *endptr = p;
    return 1;
  }
  p++;
  while (p != end && !isdigitchars(*p)) ++p;
  q = p;
  while (q != end && isdigitchars(*q)) ++q;
  *endptr = q;
  v2 = Str2Type<T2>(p);
  return 2;
}
 
template<typename T1, typename T2, typename T3>
inline int ParseTriple(const char * begin, const char * end,
                       const char ** endptr, T1 &v1, T2 &v2, T3 &v3) { // NOLINT(*)
  const char * p = begin;
  while (p != end && !isdigitchars(*p)) ++p;
  if (p == end) {
    *endptr = end;
    return 0;
  }
  const char * q = p;
  while (q != end && isdigitchars(*q)) ++q;
  v1 = Str2Type<T1>(p);
  p = q;
  while (p != end && isblank(*p)) ++p;
  if (p == end || *p != ':') {
    // only v1
    *endptr = p;
    return 1;
  }
  p++;
  while (p != end && !isdigitchars(*p)) ++p;
  q = p;
  while (q != end && isdigitchars(*q)) ++q;
  v2 = Str2Type<T2>(p);
  p = q;
  while (p != end && isblank(*p)) ++p;
  if (p == end || *p != ':') {
    // only v1:v2
    *endptr = p;
    return 2;
  }
  p++;
  while (p != end && !isdigitchars(*p)) ++p;
  q = p;
  while (q != end && isdigitchars(*q)) ++q;
  *endptr = q;
  v3 = Str2Type<T3>(p);
  return 3;
}
}  // namespace dmlc
 
#endif  // DMLC_STRTONUM_H_