1// Copyright 2012 the V8 project authors. All rights reserved.
2// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6// * Redistributions of source code must retain the above copyright
7// notice, this list of conditions and the following disclaimer.
8// * Redistributions in binary form must reproduce the above
9// copyright notice, this list of conditions and the following
10// disclaimer in the documentation and/or other materials provided
11// with the distribution.
12// * Neither the name of Google Inc. nor the names of its
13// contributors may be used to endorse or promote products derived
14// from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#ifndef DOUBLE_CONVERSION_DOUBLE_CONVERSION_H_
29#define DOUBLE_CONVERSION_DOUBLE_CONVERSION_H_
30
31#include <wtf/dtoa/utils.h>
32
33namespace WTF {
34namespace double_conversion {
35
36class DoubleToStringConverter {
37 public:
38 // When calling ToFixed with a double > 10^kMaxFixedDigitsBeforePoint
39 // or a requested_digits parameter > kMaxFixedDigitsAfterPoint then the
40 // function returns false.
41 static const int kMaxFixedDigitsBeforePoint = 60;
42 static const int kMaxFixedDigitsAfterPoint = 60;
43
44 // When calling ToExponential with a requested_digits
45 // parameter > kMaxExponentialDigits then the function returns false.
46 static const int kMaxExponentialDigits = 120;
47
48 // When calling ToPrecision with a requested_digits
49 // parameter < kMinPrecisionDigits or requested_digits > kMaxPrecisionDigits
50 // then the function returns false.
51 static const int kMinPrecisionDigits = 1;
52 static const int kMaxPrecisionDigits = 120;
53
54 enum Flags {
55 NO_FLAGS = 0,
56 EMIT_POSITIVE_EXPONENT_SIGN = 1,
57 EMIT_TRAILING_DECIMAL_POINT = 2,
58 EMIT_TRAILING_ZERO_AFTER_POINT = 4,
59 UNIQUE_ZERO = 8
60 };
61
62 // Flags should be a bit-or combination of the possible Flags-enum.
63 // - NO_FLAGS: no special flags.
64 // - EMIT_POSITIVE_EXPONENT_SIGN: when the number is converted into exponent
65 // form, emits a '+' for positive exponents. Example: 1.2e+2.
66 // - EMIT_TRAILING_DECIMAL_POINT: when the input number is an integer and is
67 // converted into decimal format then a trailing decimal point is appended.
68 // Example: 2345.0 is converted to "2345.".
69 // - EMIT_TRAILING_ZERO_AFTER_POINT: in addition to a trailing decimal point
70 // emits a trailing '0'-character. This flag requires the
71 // EXMIT_TRAILING_DECIMAL_POINT flag.
72 // Example: 2345.0 is converted to "2345.0".
73 // - UNIQUE_ZERO: "-0.0" is converted to "0.0".
74 //
75 // Infinity symbol and nan_symbol provide the string representation for these
76 // special values. If the string is NULL and the special value is encountered
77 // then the conversion functions return false.
78 //
79 // The exponent_character is used in exponential representations. It is
80 // usually 'e' or 'E'.
81 //
82 // When converting to the shortest representation the converter will
83 // represent input numbers in decimal format if they are in the interval
84 // [10^decimal_in_shortest_low; 10^decimal_in_shortest_high[
85 // (lower boundary included, greater boundary excluded).
86 // Example: with decimal_in_shortest_low = -6 and
87 // decimal_in_shortest_high = 21:
88 // ToShortest(0.000001) -> "0.000001"
89 // ToShortest(0.0000001) -> "1e-7"
90 // ToShortest(111111111111111111111.0) -> "111111111111111110000"
91 // ToShortest(100000000000000000000.0) -> "100000000000000000000"
92 // ToShortest(1111111111111111111111.0) -> "1.1111111111111111e+21"
93 //
94 // When converting to precision mode the converter may add
95 // max_leading_padding_zeroes before returning the number in exponential
96 // format.
97 // Example with max_leading_padding_zeroes_in_precision_mode = 6.
98 // ToPrecision(0.0000012345, 2) -> "0.0000012"
99 // ToPrecision(0.00000012345, 2) -> "1.2e-7"
100 // Similarily the converter may add up to
101 // max_trailing_padding_zeroes_in_precision_mode in precision mode to avoid
102 // returning an exponential representation. A zero added by the
103 // EMIT_TRAILING_ZERO_AFTER_POINT flag is counted for this limit.
104 // Examples for max_trailing_padding_zeroes_in_precision_mode = 1:
105 // ToPrecision(230.0, 2) -> "230"
106 // ToPrecision(230.0, 2) -> "230." with EMIT_TRAILING_DECIMAL_POINT.
107 // ToPrecision(230.0, 2) -> "2.3e2" with EMIT_TRAILING_ZERO_AFTER_POINT.
108 DoubleToStringConverter(int flags,
109 const char* infinity_symbol,
110 const char* nan_symbol,
111 char exponent_character,
112 int decimal_in_shortest_low,
113 int decimal_in_shortest_high,
114 int max_leading_padding_zeroes_in_precision_mode,
115 int max_trailing_padding_zeroes_in_precision_mode)
116 : flags_(flags),
117 infinity_symbol_(infinity_symbol),
118 nan_symbol_(nan_symbol),
119 exponent_character_(exponent_character),
120 decimal_in_shortest_low_(decimal_in_shortest_low),
121 decimal_in_shortest_high_(decimal_in_shortest_high),
122 max_leading_padding_zeroes_in_precision_mode_(
123 max_leading_padding_zeroes_in_precision_mode),
124 max_trailing_padding_zeroes_in_precision_mode_(
125 max_trailing_padding_zeroes_in_precision_mode) {
126 // When 'trailing zero after the point' is set, then 'trailing point'
127 // must be set too.
128 ASSERT(((flags & EMIT_TRAILING_DECIMAL_POINT) != 0) ||
129 !((flags & EMIT_TRAILING_ZERO_AFTER_POINT) != 0));
130 }
131
132 // Returns a converter following the EcmaScript specification.
133 WTF_EXPORT_PRIVATE static const DoubleToStringConverter& EcmaScriptConverter();
134
135 // Computes the shortest string of digits that correctly represent the input
136 // number. Depending on decimal_in_shortest_low and decimal_in_shortest_high
137 // (see constructor) it then either returns a decimal representation, or an
138 // exponential representation.
139 // Example with decimal_in_shortest_low = -6,
140 // decimal_in_shortest_high = 21,
141 // EMIT_POSITIVE_EXPONENT_SIGN activated, and
142 // EMIT_TRAILING_DECIMAL_POINT deactived:
143 // ToShortest(0.000001) -> "0.000001"
144 // ToShortest(0.0000001) -> "1e-7"
145 // ToShortest(111111111111111111111.0) -> "111111111111111110000"
146 // ToShortest(100000000000000000000.0) -> "100000000000000000000"
147 // ToShortest(1111111111111111111111.0) -> "1.1111111111111111e+21"
148 //
149 // Note: the conversion may round the output if the returned string
150 // is accurate enough to uniquely identify the input-number.
151 // For example the most precise representation of the double 9e59 equals
152 // "899999999999999918767229449717619953810131273674690656206848", but
153 // the converter will return the shorter (but still correct) "9e59".
154 //
155 // Returns true if the conversion succeeds. The conversion always succeeds
156 // except when the input value is special and no infinity_symbol or
157 // nan_symbol has been given to the constructor.
158 bool ToShortest(double value, StringBuilder* result_builder) const {
159 return ToShortestIeeeNumber(value, result_builder, SHORTEST);
160 }
161
162 // Same as ToShortest, but for single-precision floats.
163 bool ToShortestSingle(float value, StringBuilder* result_builder) const {
164 return ToShortestIeeeNumber(value, result_builder, SHORTEST_SINGLE);
165 }
166
167
168 // Computes a decimal representation with a fixed number of digits after the
169 // decimal point. The last emitted digit is rounded.
170 //
171 // Examples:
172 // ToFixed(3.12, 1) -> "3.1"
173 // ToFixed(3.1415, 3) -> "3.142"
174 // ToFixed(1234.56789, 4) -> "1234.5679"
175 // ToFixed(1.23, 5) -> "1.23000"
176 // ToFixed(0.1, 4) -> "0.1000"
177 // ToFixed(1e30, 2) -> "1000000000000000019884624838656.00"
178 // ToFixed(0.1, 30) -> "0.100000000000000005551115123126"
179 // ToFixed(0.1, 17) -> "0.10000000000000001"
180 //
181 // If requested_digits equals 0, then the tail of the result depends on
182 // the EMIT_TRAILING_DECIMAL_POINT and EMIT_TRAILING_ZERO_AFTER_POINT.
183 // Examples, for requested_digits == 0,
184 // let EMIT_TRAILING_DECIMAL_POINT and EMIT_TRAILING_ZERO_AFTER_POINT be
185 // - false and false: then 123.45 -> 123
186 // 0.678 -> 1
187 // - true and false: then 123.45 -> 123.
188 // 0.678 -> 1.
189 // - true and true: then 123.45 -> 123.0
190 // 0.678 -> 1.0
191 //
192 // Returns true if the conversion succeeds. The conversion always succeeds
193 // except for the following cases:
194 // - the input value is special and no infinity_symbol or nan_symbol has
195 // been provided to the constructor,
196 // - 'value' > 10^kMaxFixedDigitsBeforePoint, or
197 // - 'requested_digits' > kMaxFixedDigitsAfterPoint.
198 // The last two conditions imply that the result will never contain more than
199 // 1 + kMaxFixedDigitsBeforePoint + 1 + kMaxFixedDigitsAfterPoint characters
200 // (one additional character for the sign, and one for the decimal point).
201 bool ToFixed(double value,
202 int requested_digits,
203 StringBuilder* result_builder) const;
204
205 // Computes a representation in exponential format with requested_digits
206 // after the decimal point. The last emitted digit is rounded.
207 // If requested_digits equals -1, then the shortest exponential representation
208 // is computed.
209 //
210 // Examples with EMIT_POSITIVE_EXPONENT_SIGN deactivated, and
211 // exponent_character set to 'e'.
212 // ToExponential(3.12, 1) -> "3.1e0"
213 // ToExponential(5.0, 3) -> "5.000e0"
214 // ToExponential(0.001, 2) -> "1.00e-3"
215 // ToExponential(3.1415, -1) -> "3.1415e0"
216 // ToExponential(3.1415, 4) -> "3.1415e0"
217 // ToExponential(3.1415, 3) -> "3.142e0"
218 // ToExponential(123456789000000, 3) -> "1.235e14"
219 // ToExponential(1000000000000000019884624838656.0, -1) -> "1e30"
220 // ToExponential(1000000000000000019884624838656.0, 32) ->
221 // "1.00000000000000001988462483865600e30"
222 // ToExponential(1234, 0) -> "1e3"
223 //
224 // Returns true if the conversion succeeds. The conversion always succeeds
225 // except for the following cases:
226 // - the input value is special and no infinity_symbol or nan_symbol has
227 // been provided to the constructor,
228 // - 'requested_digits' > kMaxExponentialDigits.
229 // The last condition implies that the result will never contain more than
230 // kMaxExponentialDigits + 8 characters (the sign, the digit before the
231 // decimal point, the decimal point, the exponent character, the
232 // exponent's sign, and at most 3 exponent digits).
233 WTF_EXPORT_PRIVATE bool ToExponential(double value,
234 int requested_digits,
235 StringBuilder* result_builder) const;
236
237 // Computes 'precision' leading digits of the given 'value' and returns them
238 // either in exponential or decimal format, depending on
239 // max_{leading|trailing}_padding_zeroes_in_precision_mode (given to the
240 // constructor).
241 // The last computed digit is rounded.
242 //
243 // Example with max_leading_padding_zeroes_in_precision_mode = 6.
244 // ToPrecision(0.0000012345, 2) -> "0.0000012"
245 // ToPrecision(0.00000012345, 2) -> "1.2e-7"
246 // Similarily the converter may add up to
247 // max_trailing_padding_zeroes_in_precision_mode in precision mode to avoid
248 // returning an exponential representation. A zero added by the
249 // EMIT_TRAILING_ZERO_AFTER_POINT flag is counted for this limit.
250 // Examples for max_trailing_padding_zeroes_in_precision_mode = 1:
251 // ToPrecision(230.0, 2) -> "230"
252 // ToPrecision(230.0, 2) -> "230." with EMIT_TRAILING_DECIMAL_POINT.
253 // ToPrecision(230.0, 2) -> "2.3e2" with EMIT_TRAILING_ZERO_AFTER_POINT.
254 // Examples for max_trailing_padding_zeroes_in_precision_mode = 3, and no
255 // EMIT_TRAILING_ZERO_AFTER_POINT:
256 // ToPrecision(123450.0, 6) -> "123450"
257 // ToPrecision(123450.0, 5) -> "123450"
258 // ToPrecision(123450.0, 4) -> "123500"
259 // ToPrecision(123450.0, 3) -> "123000"
260 // ToPrecision(123450.0, 2) -> "1.2e5"
261 //
262 // Returns true if the conversion succeeds. The conversion always succeeds
263 // except for the following cases:
264 // - the input value is special and no infinity_symbol or nan_symbol has
265 // been provided to the constructor,
266 // - precision < kMinPericisionDigits
267 // - precision > kMaxPrecisionDigits
268 // The last condition implies that the result will never contain more than
269 // kMaxPrecisionDigits + 7 characters (the sign, the decimal point, the
270 // exponent character, the exponent's sign, and at most 3 exponent digits).
271 bool ToPrecision(double value,
272 int precision,
273 StringBuilder* result_builder) const;
274
275 enum DtoaMode {
276 // Produce the shortest correct representation.
277 // For example the output of 0.299999999999999988897 is (the less accurate
278 // but correct) 0.3.
279 SHORTEST,
280 // Same as SHORTEST, but for single-precision floats.
281 SHORTEST_SINGLE,
282 // Produce a fixed number of digits after the decimal point.
283 // For instance fixed(0.1, 4) becomes 0.1000
284 // If the input number is big, the output will be big.
285 FIXED,
286 // Fixed number of digits (independent of the decimal point).
287 PRECISION
288 };
289
290 // The maximal number of digits that are needed to emit a double in base 10.
291 // A higher precision can be achieved by using more digits, but the shortest
292 // accurate representation of any double will never use more digits than
293 // kBase10MaximalLength.
294 // Note that DoubleToAscii null-terminates its input. So the given buffer
295 // should be at least kBase10MaximalLength + 1 characters long.
296 static const int kBase10MaximalLength = 17;
297
298 // Converts the given double 'v' to digit characters. 'v' must not be NaN,
299 // +Infinity, or -Infinity. In SHORTEST_SINGLE-mode this restriction also
300 // applies to 'v' after it has been casted to a single-precision float. That
301 // is, in this mode static_cast<float>(v) must not be NaN, +Infinity or
302 // -Infinity.
303 //
304 // The result should be interpreted as buffer * 10^(point-length).
305 //
306 // The digits are written to the buffer in the platform's charset, which is
307 // often UTF-8 (with ASCII-range digits) but may be another charset, such
308 // as EBCDIC.
309 //
310 // The output depends on the given mode:
311 // - SHORTEST: produce the least amount of digits for which the internal
312 // identity requirement is still satisfied. If the digits are printed
313 // (together with the correct exponent) then reading this number will give
314 // 'v' again. The buffer will choose the representation that is closest to
315 // 'v'. If there are two at the same distance, than the one farther away
316 // from 0 is chosen (halfway cases - ending with 5 - are rounded up).
317 // In this mode the 'requested_digits' parameter is ignored.
318 // - SHORTEST_SINGLE: same as SHORTEST but with single-precision.
319 // - FIXED: produces digits necessary to print a given number with
320 // 'requested_digits' digits after the decimal point. The produced digits
321 // might be too short in which case the caller has to fill the remainder
322 // with '0's.
323 // Example: toFixed(0.001, 5) is allowed to return buffer="1", point=-2.
324 // Halfway cases are rounded towards +/-Infinity (away from 0). The call
325 // toFixed(0.15, 2) thus returns buffer="2", point=0.
326 // The returned buffer may contain digits that would be truncated from the
327 // shortest representation of the input.
328 // - PRECISION: produces 'requested_digits' where the first digit is not '0'.
329 // Even though the length of produced digits usually equals
330 // 'requested_digits', the function is allowed to return fewer digits, in
331 // which case the caller has to fill the missing digits with '0's.
332 // Halfway cases are again rounded away from 0.
333 // DoubleToAscii expects the given buffer to be big enough to hold all
334 // digits and a terminating null-character. In SHORTEST-mode it expects a
335 // buffer of at least kBase10MaximalLength + 1. In all other modes the
336 // requested_digits parameter and the padding-zeroes limit the size of the
337 // output. Don't forget the decimal point, the exponent character and the
338 // terminating null-character when computing the maximal output size.
339 // The given length is only used in debug mode to ensure the buffer is big
340 // enough.
341 static void DoubleToAscii(double v,
342 DtoaMode mode,
343 int requested_digits,
344 char* buffer,
345 int buffer_length,
346 bool* sign,
347 int* length,
348 int* point);
349
350 private:
351 // Implementation for ToShortest and ToShortestSingle.
352 bool ToShortestIeeeNumber(double value,
353 StringBuilder* result_builder,
354 DtoaMode mode) const;
355
356 // If the value is a special value (NaN or Infinity) constructs the
357 // corresponding string using the configured infinity/nan-symbol.
358 // If either of them is NULL or the value is not special then the
359 // function returns false.
360 bool HandleSpecialValues(double value, StringBuilder* result_builder) const;
361 // Constructs an exponential representation (i.e. 1.234e56).
362 // The given exponent assumes a decimal point after the first decimal digit.
363 void CreateExponentialRepresentation(const char* decimal_digits,
364 int length,
365 int exponent,
366 StringBuilder* result_builder) const;
367 // Creates a decimal representation (i.e 1234.5678).
368 void CreateDecimalRepresentation(const char* decimal_digits,
369 int length,
370 int decimal_point,
371 int digits_after_point,
372 StringBuilder* result_builder) const;
373
374 const int flags_;
375 const char* const infinity_symbol_;
376 const char* const nan_symbol_;
377 const char exponent_character_;
378 const int decimal_in_shortest_low_;
379 const int decimal_in_shortest_high_;
380 const int max_leading_padding_zeroes_in_precision_mode_;
381 const int max_trailing_padding_zeroes_in_precision_mode_;
382
383 DC_DISALLOW_IMPLICIT_CONSTRUCTORS(DoubleToStringConverter);
384};
385
386
387class StringToDoubleConverter {
388 public:
389 // Performs the conversion.
390 // The output parameter 'processed_characters_count' is set to the number
391 // of characters that have been processed to read the number.
392 WTF_EXPORT_PRIVATE static double StringToDouble(const char* buffer,
393 size_t length,
394 size_t* processed_characters_count);
395
396 // Same as StringToDouble above but for 16 bit characters.
397 WTF_EXPORT_PRIVATE static double StringToDouble(const uc16* buffer,
398 size_t length,
399 size_t* processed_characters_count);
400
401 // Same as StringToDouble but reads a float.
402 // Note that this is not equivalent to static_cast<float>(StringToDouble(...))
403 // due to potential double-rounding.
404 WTF_EXPORT_PRIVATE static float StringToFloat(const char* buffer,
405 size_t length,
406 size_t* processed_characters_count);
407
408 // Same as StringToFloat above but for 16 bit characters.
409 WTF_EXPORT_PRIVATE static float StringToFloat(const uc16* buffer,
410 size_t length,
411 size_t* processed_characters_count);
412
413 private:
414 DC_DISALLOW_IMPLICIT_CONSTRUCTORS(StringToDoubleConverter);
415};
416
417} // namespace double_conversion
418} // namespace WTF
419
420#endif // DOUBLE_CONVERSION_DOUBLE_CONVERSION_H_
421