anonymous_namespace{FromChars.cpp} Namespace Reference

Functions
unsigned	digitToInt (char c) noexcept
template<typename T >
bool	safeMul10Add (T &result, T a, T b)
template<typename ResultType >
FromCharsResult	FastStringToInt (const char *first, const char *last, ResultType &value, bool isNegative) noexcept
template<typename ResultType >
FromCharsResult	IntFromChars (const char *buffer, const char *last, ResultType &value) noexcept

Function Documentation

digitToInt()

unsigned anonymous_namespace{FromChars.cpp}::digitToInt ( char  c )

noexcept

Definition at line 21 of file FromChars.cpp.

{
   return static_cast<unsigned>(c) - '0';
}

Referenced by FastStringToInt().

Here is the caller graph for this function:

FastStringToInt()

template<typename ResultType >

FromCharsResult anonymous_namespace{FromChars.cpp}::FastStringToInt ( const char *  first, const char *  last, ResultType &  value, bool  isNegative  )

noexcept

Definition at line 58 of file FromChars.cpp.

{
   using UnsignedResultType = std::make_unsigned_t<ResultType>;
 
   const auto availableBytes = last - first;
 
   if (availableBytes <= 0)
      return { first, std::errc::invalid_argument };
 
   UnsignedResultType result = digitToInt(*first);
 
   if (result > 10)
      return { first, std::errc::invalid_argument };
 
   constexpr auto maxSafeDigits = std::numeric_limits<ResultType>::digits10;
 
   const char* ptr = first;
   const char* safeLast =
      first + std::min<decltype(availableBytes)>(availableBytes, maxSafeDigits);
 
   unsigned d;
 
   // No integer overflow here
   while (++ptr < safeLast && (d = digitToInt(*ptr)) <= 9)
   {
      result = result * 10 + d;
   }
 
   // But here live dragons
   while (ptr < last && (d = digitToInt(*ptr)) <= 9)
   {
      if (!safeMul10Add<UnsignedResultType>(result, result, d))
         return { ptr, std::errc::result_out_of_range };
 
      // Even if there were no unsigned overflow,
      // signed overflow is still possible
      if constexpr (std::is_signed_v<ResultType>)
      {
         const UnsignedResultType max =
            static_cast<UnsignedResultType>(
               std::numeric_limits<ResultType>::max()) +
            (isNegative ? 1 : 0);
 
         if (result > max)
            return { ptr, std::errc::result_out_of_range };
      }
 
      
      ++ptr;
   }
 
   if constexpr (std::is_signed_v<ResultType>)
   {
      value = isNegative ?
                 // Unary minus on unsigned type makes MSVC unhappy
                 static_cast<ResultType>(0 - result) :
                 static_cast<ResultType>(result);
   }
   else
      value = static_cast<ResultType>(result);
 
   return { ptr, std::errc() };
}

References digitToInt().

Referenced by IntFromChars().

Here is the call graph for this function:

Here is the caller graph for this function:

IntFromChars()

template<typename ResultType >

FromCharsResult anonymous_namespace{FromChars.cpp}::IntFromChars ( const char *  buffer, const char *  last, ResultType &  value  )

noexcept

Definition at line 126 of file FromChars.cpp.

{
   const char* origin = buffer;
 
   if (buffer >= last)
      return { buffer, std::errc::invalid_argument };
 
   const bool isNegative = *buffer == '-';
 
   if (isNegative)
   {
      if constexpr (std::is_signed_v<ResultType>)
         ++buffer;
      else
         return { origin, std::errc::invalid_argument };
   }
 
   const auto fastStringResult =
      FastStringToInt(buffer, last, value, isNegative);
 
   if (fastStringResult.ec == std::errc::invalid_argument)
      return { origin, std::errc::invalid_argument };
 
   return fastStringResult;
}

References FastStringToInt().

Referenced by FromChars().

Here is the call graph for this function:

Here is the caller graph for this function:

safeMul10Add()

template<typename T >

bool anonymous_namespace{FromChars.cpp}::safeMul10Add	(	T &	result,
		T	a,
		T	b
	)

Definition at line 27 of file FromChars.cpp.

{
   static_assert(std::is_unsigned_v<T>);
 
   constexpr auto bits = sizeof(a) * 8 - 3;
   // Check for the top 3 bits of a
   if (a >> bits)
      return false;
 
   const T times8 = a << 3;
   // a << 1 won't overflow
   const T times2 = a << 1;
 
   // timesX are all unsigned values, if overflow occurs - times10 will be <
   // times8
   const T times10 = times8 + times2;
 
   if (times10 < times8)
      return false;
 
   const T tempResult = times10 + b;
 
   if (tempResult < times10)
      return false;
 
   result = tempResult;
 
   return true;
}