double_conversion::DoubleToStringConverter Class Reference

#include <double-to-string.h>

Public Types
enum	Flags {   NO_FLAGS = 0 , EMIT_POSITIVE_EXPONENT_SIGN = 1 , EMIT_TRAILING_DECIMAL_POINT = 2 , EMIT_TRAILING_ZERO_AFTER_POINT = 4 ,   UNIQUE_ZERO = 8 , NO_TRAILING_ZERO = 16 , EMIT_TRAILING_DECIMAL_POINT_IN_EXPONENTIAL = 32 , EMIT_TRAILING_ZERO_AFTER_POINT_IN_EXPONENTIAL = 64 }
enum	DtoaMode { SHORTEST , SHORTEST_SINGLE , FIXED , PRECISION }

Public Member Functions
	DoubleToStringConverter (int flags, const char *infinity_symbol, const char *nan_symbol, char exponent_character, int decimal_in_shortest_low, int decimal_in_shortest_high, int max_leading_padding_zeroes_in_precision_mode, int max_trailing_padding_zeroes_in_precision_mode, int min_exponent_width=0)
bool	ToShortest (double value, StringBuilder *result_builder) const
bool	ToShortestSingle (float value, StringBuilder *result_builder) const
bool	ToFixed (double value, int requested_digits, StringBuilder *result_builder) const
bool	ToExponential (double value, int requested_digits, StringBuilder *result_builder) const
bool	ToPrecision (double value, int precision, StringBuilder *result_builder) const

Static Public Member Functions
static const DoubleToStringConverter &	EcmaScriptConverter ()
static void	DoubleToAscii (double v, DtoaMode mode, int requested_digits, char *buffer, int buffer_length, bool *sign, int *length, int *point)

Static Public Attributes
static const int	kMaxFixedDigitsBeforePoint = 60
static const int	kMaxFixedDigitsAfterPoint = 100
static const int	kMaxExponentialDigits = 120
static const int	kMinPrecisionDigits = 1
static const int	kMaxPrecisionDigits = 120
static const int	kBase10MaximalLength = 17
static const int	kBase10MaximalLengthSingle = 9
static const int	kMaxCharsEcmaScriptShortest = 25

Detailed Description

Definition at line 35 of file double-to-string.h.

Member Enumeration Documentation

DtoaMode

enum double_conversion::DoubleToStringConverter::DtoaMode

Enumerator
SHORTEST
SHORTEST_SINGLE
FIXED
PRECISION

Definition at line 364 of file double-to-string.h.

                {
    // Produce the shortest correct representation.
    // For example the output of 0.299999999999999988897 is (the less accurate
    // but correct) 0.3.
    SHORTEST,
    // Same as SHORTEST, but for single-precision floats.
    SHORTEST_SINGLE,
    // Produce a fixed number of digits after the decimal point.
    // For instance fixed(0.1, 4) becomes 0.1000
    // If the input number is big, the output will be big.
    FIXED,
    // Fixed number of digits (independent of the decimal point).
    PRECISION
  };

Flags

enum double_conversion::DoubleToStringConverter::Flags

Enumerator
NO_FLAGS
EMIT_POSITIVE_EXPONENT_SIGN
EMIT_TRAILING_DECIMAL_POINT
EMIT_TRAILING_ZERO_AFTER_POINT
UNIQUE_ZERO
NO_TRAILING_ZERO
EMIT_TRAILING_DECIMAL_POINT_IN_EXPONENTIAL
EMIT_TRAILING_ZERO_AFTER_POINT_IN_EXPONENTIAL

Definition at line 75 of file double-to-string.h.

             {
    NO_FLAGS = 0,
    EMIT_POSITIVE_EXPONENT_SIGN = 1,
    EMIT_TRAILING_DECIMAL_POINT = 2,
    EMIT_TRAILING_ZERO_AFTER_POINT = 4,
    UNIQUE_ZERO = 8,
    NO_TRAILING_ZERO = 16,
    EMIT_TRAILING_DECIMAL_POINT_IN_EXPONENTIAL = 32,
    EMIT_TRAILING_ZERO_AFTER_POINT_IN_EXPONENTIAL = 64
  };

Constructor & Destructor Documentation

DoubleToStringConverter()

double_conversion::DoubleToStringConverter::DoubleToStringConverter ( int  flags, const char *  infinity_symbol, const char *  nan_symbol, char  exponent_character, int  decimal_in_shortest_low, int  decimal_in_shortest_high, int  max_leading_padding_zeroes_in_precision_mode, int  max_trailing_padding_zeroes_in_precision_mode, int  min_exponent_width = 0  )

inline

Definition at line 165 of file double-to-string.h.

      : flags_(flags),
        infinity_symbol_(infinity_symbol),
        nan_symbol_(nan_symbol),
        exponent_character_(exponent_character),
        decimal_in_shortest_low_(decimal_in_shortest_low),
        decimal_in_shortest_high_(decimal_in_shortest_high),
        max_leading_padding_zeroes_in_precision_mode_(
            max_leading_padding_zeroes_in_precision_mode),
        max_trailing_padding_zeroes_in_precision_mode_(
            max_trailing_padding_zeroes_in_precision_mode),
        min_exponent_width_(min_exponent_width) {
    // When 'trailing zero after the point' is set, then 'trailing point'
    // must be set too.
    DOUBLE_CONVERSION_ASSERT(((flags & EMIT_TRAILING_DECIMAL_POINT) != 0) ||
        !((flags & EMIT_TRAILING_ZERO_AFTER_POINT) != 0));
  }

Member Function Documentation

DoubleToAscii()

void double_conversion::DoubleToStringConverter::DoubleToAscii ( double  v, DtoaMode  mode, int  requested_digits, char *  buffer, int  buffer_length, bool *  sign, int *  length, int *  point  )

static

Definition at line 386 of file double-to-string.cc.

                                                        {
  Vector<char> vector(buffer, buffer_length);
  DOUBLE_CONVERSION_ASSERT(!Double(v).IsSpecial());
  DOUBLE_CONVERSION_ASSERT(mode == SHORTEST || mode == SHORTEST_SINGLE || requested_digits >= 0);
 
  if (Double(v).Sign() < 0) {
    *sign = true;
    v = -v;
  } else {
    *sign = false;
  }
 
  if (mode == PRECISION && requested_digits == 0) {
    vector[0] = '\0';
    *length = 0;
    return;
  }
 
  if (v == 0) {
    vector[0] = '0';
    vector[1] = '\0';
    *length = 1;
    *point = 1;
    return;
  }
 
  bool fast_worked;
  switch (mode) {
    case SHORTEST:
      fast_worked = FastDtoa(v, FAST_DTOA_SHORTEST, 0, vector, length, point);
      break;
    case SHORTEST_SINGLE:
      fast_worked = FastDtoa(v, FAST_DTOA_SHORTEST_SINGLE, 0,
                             vector, length, point);
      break;
    case FIXED:
      fast_worked = FastFixedDtoa(v, requested_digits, vector, length, point);
      break;
    case PRECISION:
      fast_worked = FastDtoa(v, FAST_DTOA_PRECISION, requested_digits,
                             vector, length, point);
      break;
    default:
      fast_worked = false;
      DOUBLE_CONVERSION_UNREACHABLE();
  }
  if (fast_worked) return;
 
  // If the fast dtoa didn't succeed use the slower bignum version.
  BignumDtoaMode bignum_mode = DtoaToBignumDtoaMode(mode);
  BignumDtoa(v, bignum_mode, requested_digits, vector, length, point);
  vector[*length] = '\0';
}

EcmaScriptConverter()

const DoubleToStringConverter & double_conversion::DoubleToStringConverter::EcmaScriptConverter ( )

static

Definition at line 42 of file double-to-string.cc.

                                                                            {
  int flags = UNIQUE_ZERO | EMIT_POSITIVE_EXPONENT_SIGN;
  static DoubleToStringConverter converter(flags,
                                           "Infinity",
                                           "NaN",
                                           'e',
                                           -6, 21,
                                           6, 0);
  return converter;
}

ToExponential()

bool double_conversion::DoubleToStringConverter::ToExponential	(	double	value,
		int	requested_digits,
		StringBuilder *	result_builder
	)		const

Definition at line 248 of file double-to-string.cc.

                                         {
  if (Double(value).IsSpecial()) {
    return HandleSpecialValues(value, result_builder);
  }
 
  if (requested_digits < -1) return false;
  if (requested_digits > kMaxExponentialDigits) return false;
 
  int decimal_point;
  bool sign;
  // Add space for digit before the decimal point and the '\0' character.
  const int kDecimalRepCapacity = kMaxExponentialDigits + 2;
  DOUBLE_CONVERSION_ASSERT(kDecimalRepCapacity > kBase10MaximalLength);
  char decimal_rep[kDecimalRepCapacity];
#ifndef NDEBUG
  // Problem: there is an assert in StringBuilder::AddSubstring() that
  // will pass this buffer to strlen(), and this buffer is not generally
  // null-terminated.
  memset(decimal_rep, 0, sizeof(decimal_rep));
#endif
  int decimal_rep_length;
 
  if (requested_digits == -1) {
    DoubleToAscii(value, SHORTEST, 0,
                  decimal_rep, kDecimalRepCapacity,
                  &sign, &decimal_rep_length, &decimal_point);
  } else {
    DoubleToAscii(value, PRECISION, requested_digits + 1,
                  decimal_rep, kDecimalRepCapacity,
                  &sign, &decimal_rep_length, &decimal_point);
    DOUBLE_CONVERSION_ASSERT(decimal_rep_length <= requested_digits + 1);
 
    for (int i = decimal_rep_length; i < requested_digits + 1; ++i) {
      decimal_rep[i] = '0';
    }
    decimal_rep_length = requested_digits + 1;
  }
 
  bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0);
  if (sign && (value != 0.0 || !unique_zero)) {
    result_builder->AddCharacter('-');
  }
 
  int exponent = decimal_point - 1;
  CreateExponentialRepresentation(decimal_rep,
                                  decimal_rep_length,
                                  exponent,
                                  result_builder);
  return true;
}

ToFixed()

bool double_conversion::DoubleToStringConverter::ToFixed	(	double	value,
		int	requested_digits,
		StringBuilder *	result_builder
	)		const

Definition at line 212 of file double-to-string.cc.

                                                                           {
  DOUBLE_CONVERSION_ASSERT(kMaxFixedDigitsBeforePoint == 60);
  const double kFirstNonFixed = 1e60;
 
  if (Double(value).IsSpecial()) {
    return HandleSpecialValues(value, result_builder);
  }
 
  if (requested_digits > kMaxFixedDigitsAfterPoint) return false;
  if (value >= kFirstNonFixed || value <= -kFirstNonFixed) return false;
 
  // Find a sufficiently precise decimal representation of n.
  int decimal_point;
  bool sign;
  // Add space for the '\0' byte.
  const int kDecimalRepCapacity =
      kMaxFixedDigitsBeforePoint + kMaxFixedDigitsAfterPoint + 1;
  char decimal_rep[kDecimalRepCapacity];
  int decimal_rep_length;
  DoubleToAscii(value, FIXED, requested_digits,
                decimal_rep, kDecimalRepCapacity,
                &sign, &decimal_rep_length, &decimal_point);
 
  bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0);
  if (sign && (value != 0.0 || !unique_zero)) {
    result_builder->AddCharacter('-');
  }
 
  CreateDecimalRepresentation(decimal_rep, decimal_rep_length, decimal_point,
                              requested_digits, result_builder);
  return true;
}

ToPrecision()

bool double_conversion::DoubleToStringConverter::ToPrecision	(	double	value,
		int	precision,
		StringBuilder *	result_builder
	)		const

Definition at line 303 of file double-to-string.cc.

                                                                               {
  if (Double(value).IsSpecial()) {
    return HandleSpecialValues(value, result_builder);
  }
 
  if (precision < kMinPrecisionDigits || precision > kMaxPrecisionDigits) {
    return false;
  }
 
  // Find a sufficiently precise decimal representation of n.
  int decimal_point;
  bool sign;
  // Add one for the terminating null character.
  const int kDecimalRepCapacity = kMaxPrecisionDigits + 1;
  char decimal_rep[kDecimalRepCapacity];
  int decimal_rep_length;
 
  DoubleToAscii(value, PRECISION, precision,
                decimal_rep, kDecimalRepCapacity,
                &sign, &decimal_rep_length, &decimal_point);
  DOUBLE_CONVERSION_ASSERT(decimal_rep_length <= precision);
 
  bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0);
  if (sign && (value != 0.0 || !unique_zero)) {
    result_builder->AddCharacter('-');
  }
 
  // The exponent if we print the number as x.xxeyyy. That is with the
  // decimal point after the first digit.
  int exponent = decimal_point - 1;
 
  int extra_zero = ((flags_ & EMIT_TRAILING_ZERO_AFTER_POINT) != 0) ? 1 : 0;
  bool as_exponential =
      (-decimal_point + 1 > max_leading_padding_zeroes_in_precision_mode_) ||
      (decimal_point - precision + extra_zero >
       max_trailing_padding_zeroes_in_precision_mode_);
  if ((flags_ & NO_TRAILING_ZERO) != 0) {
    // Truncate trailing zeros that occur after the decimal point (if exponential,
    // that is everything after the first digit).
    int stop = as_exponential ? 1 : std::max(1, decimal_point);
    while (decimal_rep_length > stop && decimal_rep[decimal_rep_length - 1] == '0') {
      --decimal_rep_length;
    }
    // Clamp precision to avoid the code below re-adding the zeros.
    precision = std::min(precision, decimal_rep_length);
  }
  if (as_exponential) {
    // Fill buffer to contain 'precision' digits.
    // Usually the buffer is already at the correct length, but 'DoubleToAscii'
    // is allowed to return less characters.
    for (int i = decimal_rep_length; i < precision; ++i) {
      decimal_rep[i] = '0';
    }
 
    CreateExponentialRepresentation(decimal_rep,
                                    precision,
                                    exponent,
                                    result_builder);
  } else {
    CreateDecimalRepresentation(decimal_rep, decimal_rep_length, decimal_point,
                                (std::max)(0, precision - decimal_point),
                                result_builder);
  }
  return true;
}

ToShortest()

bool double_conversion::DoubleToStringConverter::ToShortest ( double  value, StringBuilder *  result_builder  ) const

inline

Definition at line 240 of file double-to-string.h.

                                                                     {
    return ToShortestIeeeNumber(value, result_builder, SHORTEST);
  }

ToShortestSingle()

bool double_conversion::DoubleToStringConverter::ToShortestSingle ( float  value, StringBuilder *  result_builder  ) const

inline

Definition at line 245 of file double-to-string.h.

                                                                          {
    return ToShortestIeeeNumber(value, result_builder, SHORTEST_SINGLE);
  }

Member Data Documentation

kBase10MaximalLength

const int double_conversion::DoubleToStringConverter::kBase10MaximalLength = 17

static

Definition at line 59 of file double-to-string.h.

kBase10MaximalLengthSingle

const int double_conversion::DoubleToStringConverter::kBase10MaximalLengthSingle = 9

static

Definition at line 65 of file double-to-string.h.

kMaxCharsEcmaScriptShortest

const int double_conversion::DoubleToStringConverter::kMaxCharsEcmaScriptShortest = 25

static

Definition at line 73 of file double-to-string.h.

kMaxExponentialDigits

const int double_conversion::DoubleToStringConverter::kMaxExponentialDigits = 120

static

Definition at line 45 of file double-to-string.h.

kMaxFixedDigitsAfterPoint

const int double_conversion::DoubleToStringConverter::kMaxFixedDigitsAfterPoint = 100

static

Definition at line 41 of file double-to-string.h.

kMaxFixedDigitsBeforePoint

const int double_conversion::DoubleToStringConverter::kMaxFixedDigitsBeforePoint = 60

static

Definition at line 40 of file double-to-string.h.

kMaxPrecisionDigits

const int double_conversion::DoubleToStringConverter::kMaxPrecisionDigits = 120

static

Definition at line 51 of file double-to-string.h.

kMinPrecisionDigits

const int double_conversion::DoubleToStringConverter::kMinPrecisionDigits = 1

static

Definition at line 50 of file double-to-string.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/third_party/double-conversion/src/double-to-string.h
• third_party/dart-lang/sdk/third_party/double-conversion/src/double-to-string.cc