1 // Copyright 2011 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 V8_CONVERSIONS_H_
29 #define V8_CONVERSIONS_H_
30
31 #include "utils.h"
32
33 namespace v8 {
34 namespace internal {
35
36 class UnicodeCache;
37
38 // Maximum number of significant digits in decimal representation.
39 // The longest possible double in decimal representation is
40 // (2^53 - 1) * 2 ^ -1074 that is (2 ^ 53 - 1) * 5 ^ 1074 / 10 ^ 1074
41 // (768 digits). If we parse a number whose first digits are equal to a
42 // mean of 2 adjacent doubles (that could have up to 769 digits) the result
43 // must be rounded to the bigger one unless the tail consists of zeros, so
44 // we don't need to preserve all the digits.
45 const int kMaxSignificantDigits = 772;
46
47
isDigit(int x,int radix)48 inline bool isDigit(int x, int radix) {
49 return (x >= '0' && x <= '9' && x < '0' + radix)
50 || (radix > 10 && x >= 'a' && x < 'a' + radix - 10)
51 || (radix > 10 && x >= 'A' && x < 'A' + radix - 10);
52 }
53
54
SignedZero(bool negative)55 inline double SignedZero(bool negative) {
56 return negative ? -0.0 : 0.0;
57 }
58
59
60 // The fast double-to-(unsigned-)int conversion routine does not guarantee
61 // rounding towards zero.
62 // The result is unspecified if x is infinite or NaN, or if the rounded
63 // integer value is outside the range of type int.
FastD2I(double x)64 inline int FastD2I(double x) {
65 // The static_cast convertion from double to int used to be slow, but
66 // as new benchmarks show, now it is much faster than lrint().
67 return static_cast<int>(x);
68 }
69
70 inline unsigned int FastD2UI(double x);
71
72
FastI2D(int x)73 inline double FastI2D(int x) {
74 // There is no rounding involved in converting an integer to a
75 // double, so this code should compile to a few instructions without
76 // any FPU pipeline stalls.
77 return static_cast<double>(x);
78 }
79
80
FastUI2D(unsigned x)81 inline double FastUI2D(unsigned x) {
82 // There is no rounding involved in converting an unsigned integer to a
83 // double, so this code should compile to a few instructions without
84 // any FPU pipeline stalls.
85 return static_cast<double>(x);
86 }
87
88
89 // This function should match the exact semantics of ECMA-262 9.4.
90 inline double DoubleToInteger(double x);
91
92
93 // This function should match the exact semantics of ECMA-262 9.5.
94 inline int32_t DoubleToInt32(double x);
95
96
97 // This function should match the exact semantics of ECMA-262 9.6.
DoubleToUint32(double x)98 inline uint32_t DoubleToUint32(double x) {
99 return static_cast<uint32_t>(DoubleToInt32(x));
100 }
101
102
103 // Enumeration for allowing octals and ignoring junk when converting
104 // strings to numbers.
105 enum ConversionFlags {
106 NO_FLAGS = 0,
107 ALLOW_HEX = 1,
108 ALLOW_OCTALS = 2,
109 ALLOW_TRAILING_JUNK = 4
110 };
111
112
113 // Converts a string into a double value according to ECMA-262 9.3.1
114 double StringToDouble(UnicodeCache* unicode_cache,
115 Vector<const char> str,
116 int flags,
117 double empty_string_val = 0);
118 double StringToDouble(UnicodeCache* unicode_cache,
119 Vector<const uc16> str,
120 int flags,
121 double empty_string_val = 0);
122 // This version expects a zero-terminated character array.
123 double StringToDouble(UnicodeCache* unicode_cache,
124 const char* str,
125 int flags,
126 double empty_string_val = 0);
127
128 const int kDoubleToCStringMinBufferSize = 100;
129
130 // Converts a double to a string value according to ECMA-262 9.8.1.
131 // The buffer should be large enough for any floating point number.
132 // 100 characters is enough.
133 const char* DoubleToCString(double value, Vector<char> buffer);
134
135 // Convert an int to a null-terminated string. The returned string is
136 // located inside the buffer, but not necessarily at the start.
137 const char* IntToCString(int n, Vector<char> buffer);
138
139 // Additional number to string conversions for the number type.
140 // The caller is responsible for calling free on the returned pointer.
141 char* DoubleToFixedCString(double value, int f);
142 char* DoubleToExponentialCString(double value, int f);
143 char* DoubleToPrecisionCString(double value, int f);
144 char* DoubleToRadixCString(double value, int radix);
145
146 } } // namespace v8::internal
147
148 #endif // V8_CONVERSIONS_H_
149