fast_atof.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine" and the "irrXML" project.
// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
 
#ifndef __FAST_ATOF_H_INCLUDED__
#define __FAST_ATOF_H_INCLUDED__
 
#include "irrMath.h"
 
 
namespace saga
{
namespace core
{
  // TODO: This should probably also be used in saga::core::string, but
  // the float-to-string code used there has to be rewritten first.
  extern std::string LOCALE_DECIMAL_POINTS;
 
#define IRR_ATOF_TABLE_SIZE 17
// we write [IRR_ATOF_TABLE_SIZE] here instead of [] to work around a swig bug
const float fast_atof_table[17] = {
  0.f,
  0.1f,
  0.01f,
  0.001f,
  0.0001f,
  0.00001f,
  0.000001f,
  0.0000001f,
  0.00000001f,
  0.000000001f,
  0.0000000001f,
  0.00000000001f,
  0.000000000001f,
  0.0000000000001f,
  0.00000000000001f,
  0.000000000000001f,
  0.0000000000000001f
};
 
 
inline std::uint32_t strtoul10(const char* in, const char** out= 0)
{
  if (!in)
  {
    if (out)
      *out = in;
    return 0;
  }
 
  bool overflow=false;
  std::uint32_t unsignedValue = 0;
  while ((*in >= '0') && (*in <= '9'))
  {
    const std::uint32_t tmp = (unsignedValue * 10) + (*in - '0');
    if (tmp<unsignedValue)
    {
      unsignedValue=(std::uint32_t)0xffffffff;
      overflow=true;
    }
    if (!overflow)
      unsignedValue = tmp;
    ++in;
  }
 
  if (out)
    *out = in;
 
  return unsignedValue;
}
 
 
inline std::int32_t strtol10(const char* in, const char** out= 0)
{
  if (!in)
  {
    if (out)
      *out = in;
    return 0;
  }
 
  const bool negative = ('-' == *in);
  if (negative || ('+' == *in))
    ++in;
 
  const std::uint32_t unsignedValue = strtoul10(in,out);
  if (unsignedValue > (std::uint32_t)INT_MAX)
  {
    if (negative)
      return (std::int32_t)INT_MIN;
    else
      return (std::int32_t)INT_MAX;
  }
  else
  {
    if (negative)
      return -((std::int32_t)unsignedValue);
    else
      return (std::int32_t)unsignedValue;
  }
}
 
 
inline std::uint32_t ctoul16(char in)
{
  if (in >= '0' && in <= '9')
    return in - '0';
  else if (in >= 'a' && in <= 'f')
    return 10u + in - 'a';
  else if (in >= 'A' && in <= 'F')
    return 10u + in - 'A';
  else
    return 0xffffffff;
}
 
 
inline std::uint32_t strtoul16(const char* in, const char** out= 0)
{
  if (!in)
  {
    if (out)
      *out = in;
    return 0;
  }
 
  bool overflow=false;
  std::uint32_t unsignedValue = 0;
  while (true)
  {
    std::uint32_t tmp = 0;
    if ((*in >= '0') && (*in <= '9'))
      tmp = (unsignedValue << 4u) + (*in - '0');
    else if ((*in >= 'A') && (*in <= 'F'))
      tmp = (unsignedValue << 4u) + (*in - 'A') + 10;
    else if ((*in >= 'a') && (*in <= 'f'))
      tmp = (unsignedValue << 4u) + (*in - 'a') + 10;
    else
      break;
    if (tmp<unsignedValue)
    {
      unsignedValue=(std::uint32_t)INT_MAX;
      overflow=true;
    }
    if (!overflow)
      unsignedValue = tmp;
    ++in;
  }
 
  if (out)
    *out = in;
 
  return unsignedValue;
}
 
 
inline std::uint32_t strtoul8(const char* in, const char** out= 0)
{
  if (!in)
  {
    if (out)
      *out = in;
    return 0;
  }
 
  bool overflow=false;
  std::uint32_t unsignedValue = 0;
  while (true)
  {
    std::uint32_t tmp = 0;
    if ((*in >= '0') && (*in <= '7'))
      tmp = (unsignedValue << 3u) + (*in - '0');
    else
      break;
    if (tmp<unsignedValue)
    {
      unsignedValue=(std::uint32_t)INT_MAX;
      overflow=true;
    }
    if (!overflow)
      unsignedValue = tmp;
    ++in;
  }
 
  if (out)
    *out = in;
 
  return unsignedValue;
}
 
 
inline std::uint32_t strtoul_prefix(const char* in, const char** out= 0)
{
  if (!in)
  {
    if (out)
      *out = in;
    return 0;
  }
  if ('0'==in[0])
    return ('x'==in[1] ? strtoul16(in+2,out) : strtoul8(in+1,out));
  return strtoul10(in,out);
}
 
 
inline float strtof10(const char* in, const char** out = 0)
{
  if (!in)
  {
    if (out)
      *out = in;
    return 0.f;
  }
 
  const std::uint32_t MAX_SAFE_U32_VALUE = UINT_MAX / 10 - 10;
  std::uint32_t intValue = 0;
 
  // Use integer arithmetic for as long as possible, for speed
  // and precision.
  while ((*in >= '0') && (*in <= '9'))
  {
    // If it looks like we're going to overflow, bail out
    // now and start using floating point.
    if (intValue >= MAX_SAFE_U32_VALUE)
      break;
 
    intValue = (intValue * 10) + (*in - '0');
    ++in;
  }
 
  float floatValue = (float)intValue;
 
  // If there are any digits left to parse, then we need to use
  // floating point arithmetic from here.
  while ((*in >= '0') && (*in <= '9'))
  {
    floatValue = (floatValue * 10.f) + (float)(*in - '0');
    ++in;
    if (floatValue > FLT_MAX) // Just give up.
      break;
  }
 
  if (out)
    *out = in;
 
  return floatValue;
}
 
 
inline const char* fast_atof_move(const char* in, float& result)
{
  // Please run the regression test when making any modifications to this function.
 
  result = 0.f;
  if (!in)
    return 0;
 
  const bool negative = ('-' == *in);
  if (negative || ('+'==*in))
    ++in;
 
  float value = strtof10(in, &in);
 
  const char* afterDecimal = ++in;
  float decimal = strtof10(in, &afterDecimal);
  size_t numDecimals = afterDecimal - in;
  if (numDecimals < IRR_ATOF_TABLE_SIZE)
  {
    value += decimal * fast_atof_table[numDecimals];
  }
  else
  {
    value += decimal * (float)pow(10.f, -(float)numDecimals);
  }
  in = afterDecimal;
 
  if ('e' == *in || 'E' == *in)
  {
    ++in;
    // Assume that the exponent is a whole number.
    // strtol10() will deal with both + and - signs,
    // but calculate as float to prevent overflow at FLT_MAX
    // Using pow with float cast instead of powf as otherwise accuracy decreases.
    value *= (float)pow(10.f, (float)strtol10(in, &in));
  }
 
  result = negative?-value:value;
  return in;
}
 
 
inline float fast_atof(const char* floatAsString, const char** out= 0)
{
  float ret;
  if (out)
    *out=fast_atof_move(floatAsString, ret);
  else
    fast_atof_move(floatAsString, ret);
  return ret;
}
 
} // namespace core
} // namespace saga
 
#endif