1 // Copyright 2011 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef V8_CONVERSIONS_H_
6 #define V8_CONVERSIONS_H_
7
8 #include <limits>
9
10 #include "src/base/logging.h"
11 #include "src/handles.h"
12 #include "src/objects.h"
13 #include "src/utils.h"
14
15 namespace v8 {
16 namespace internal {
17
18 class UnicodeCache;
19
20 // Maximum number of significant digits in decimal representation.
21 // The longest possible double in decimal representation is
22 // (2^53 - 1) * 2 ^ -1074 that is (2 ^ 53 - 1) * 5 ^ 1074 / 10 ^ 1074
23 // (768 digits). If we parse a number whose first digits are equal to a
24 // mean of 2 adjacent doubles (that could have up to 769 digits) the result
25 // must be rounded to the bigger one unless the tail consists of zeros, so
26 // we don't need to preserve all the digits.
27 const int kMaxSignificantDigits = 772;
28
29
isDigit(int x,int radix)30 inline bool isDigit(int x, int radix) {
31 return (x >= '0' && x <= '9' && x < '0' + radix)
32 || (radix > 10 && x >= 'a' && x < 'a' + radix - 10)
33 || (radix > 10 && x >= 'A' && x < 'A' + radix - 10);
34 }
35
36
isBinaryDigit(int x)37 inline bool isBinaryDigit(int x) {
38 return x == '0' || x == '1';
39 }
40
41
42 // The fast double-to-(unsigned-)int conversion routine does not guarantee
43 // rounding towards zero.
44 // If x is NaN, the result is INT_MIN. Otherwise the result is the argument x,
45 // clamped to [INT_MIN, INT_MAX] and then rounded to an integer.
FastD2IChecked(double x)46 inline int FastD2IChecked(double x) {
47 if (!(x >= INT_MIN)) return INT_MIN; // Negation to catch NaNs.
48 if (x > INT_MAX) return INT_MAX;
49 return static_cast<int>(x);
50 }
51
52
53 // The fast double-to-(unsigned-)int conversion routine does not guarantee
54 // rounding towards zero.
55 // The result is unspecified if x is infinite or NaN, or if the rounded
56 // integer value is outside the range of type int.
FastD2I(double x)57 inline int FastD2I(double x) {
58 return static_cast<int32_t>(x);
59 }
60
61 inline unsigned int FastD2UI(double x);
62
63
FastI2D(int x)64 inline double FastI2D(int x) {
65 // There is no rounding involved in converting an integer to a
66 // double, so this code should compile to a few instructions without
67 // any FPU pipeline stalls.
68 return static_cast<double>(x);
69 }
70
71
FastUI2D(unsigned x)72 inline double FastUI2D(unsigned x) {
73 // There is no rounding involved in converting an unsigned integer to a
74 // double, so this code should compile to a few instructions without
75 // any FPU pipeline stalls.
76 return static_cast<double>(x);
77 }
78
79
80 // This function should match the exact semantics of ECMA-262 20.2.2.17.
81 inline float DoubleToFloat32(double x);
82
83
84 // This function should match the exact semantics of ECMA-262 9.4.
85 inline double DoubleToInteger(double x);
86
87
88 // This function should match the exact semantics of ECMA-262 9.5.
89 inline int32_t DoubleToInt32(double x);
90
91
92 // This function should match the exact semantics of ECMA-262 9.6.
DoubleToUint32(double x)93 inline uint32_t DoubleToUint32(double x) {
94 return static_cast<uint32_t>(DoubleToInt32(x));
95 }
96
97
98 // Enumeration for allowing octals and ignoring junk when converting
99 // strings to numbers.
100 enum ConversionFlags {
101 NO_FLAGS = 0,
102 ALLOW_HEX = 1,
103 ALLOW_OCTAL = 2,
104 ALLOW_IMPLICIT_OCTAL = 4,
105 ALLOW_BINARY = 8,
106 ALLOW_TRAILING_JUNK = 16
107 };
108
109
110 // Converts a string into a double value according to ECMA-262 9.3.1
111 double StringToDouble(UnicodeCache* unicode_cache,
112 Vector<const uint8_t> str,
113 int flags,
114 double empty_string_val = 0);
115 double StringToDouble(UnicodeCache* unicode_cache,
116 Vector<const uc16> str,
117 int flags,
118 double empty_string_val = 0);
119 // This version expects a zero-terminated character array.
120 double StringToDouble(UnicodeCache* unicode_cache,
121 const char* str,
122 int flags,
123 double empty_string_val = 0);
124
125 // Converts a string into an integer.
126 double StringToInt(UnicodeCache* unicode_cache,
127 Vector<const uint8_t> vector,
128 int radix);
129
130
131 double StringToInt(UnicodeCache* unicode_cache,
132 Vector<const uc16> vector,
133 int radix);
134
135 const int kDoubleToCStringMinBufferSize = 100;
136
137 // Converts a double to a string value according to ECMA-262 9.8.1.
138 // The buffer should be large enough for any floating point number.
139 // 100 characters is enough.
140 const char* DoubleToCString(double value, Vector<char> buffer);
141
142 // Convert an int to a null-terminated string. The returned string is
143 // located inside the buffer, but not necessarily at the start.
144 const char* IntToCString(int n, Vector<char> buffer);
145
146 // Additional number to string conversions for the number type.
147 // The caller is responsible for calling free on the returned pointer.
148 char* DoubleToFixedCString(double value, int f);
149 char* DoubleToExponentialCString(double value, int f);
150 char* DoubleToPrecisionCString(double value, int f);
151 char* DoubleToRadixCString(double value, int radix);
152
153
IsMinusZero(double value)154 static inline bool IsMinusZero(double value) {
155 static const DoubleRepresentation minus_zero(-0.0);
156 return DoubleRepresentation(value) == minus_zero;
157 }
158
159
IsSmiDouble(double value)160 static inline bool IsSmiDouble(double value) {
161 return !IsMinusZero(value) && value >= Smi::kMinValue &&
162 value <= Smi::kMaxValue && value == FastI2D(FastD2I(value));
163 }
164
165
166 // Integer32 is an integer that can be represented as a signed 32-bit
167 // integer. It has to be in the range [-2^31, 2^31 - 1].
168 // We also have to check for negative 0 as it is not an Integer32.
IsInt32Double(double value)169 static inline bool IsInt32Double(double value) {
170 return !IsMinusZero(value) &&
171 value >= kMinInt &&
172 value <= kMaxInt &&
173 value == FastI2D(FastD2I(value));
174 }
175
176
177 // UInteger32 is an integer that can be represented as an unsigned 32-bit
178 // integer. It has to be in the range [0, 2^32 - 1].
179 // We also have to check for negative 0 as it is not a UInteger32.
IsUint32Double(double value)180 static inline bool IsUint32Double(double value) {
181 return !IsMinusZero(value) &&
182 value >= 0 &&
183 value <= kMaxUInt32 &&
184 value == FastUI2D(FastD2UI(value));
185 }
186
187
188 // Convert from Number object to C integer.
NumberToInt32(Object * number)189 inline int32_t NumberToInt32(Object* number) {
190 if (number->IsSmi()) return Smi::cast(number)->value();
191 return DoubleToInt32(number->Number());
192 }
193
194
NumberToUint32(Object * number)195 inline uint32_t NumberToUint32(Object* number) {
196 if (number->IsSmi()) return Smi::cast(number)->value();
197 return DoubleToUint32(number->Number());
198 }
199
200
201 double StringToDouble(UnicodeCache* unicode_cache,
202 String* string,
203 int flags,
204 double empty_string_val = 0.0);
205
206
TryNumberToSize(Isolate * isolate,Object * number,size_t * result)207 inline bool TryNumberToSize(Isolate* isolate,
208 Object* number, size_t* result) {
209 SealHandleScope shs(isolate);
210 if (number->IsSmi()) {
211 int value = Smi::cast(number)->value();
212 DCHECK(static_cast<unsigned>(Smi::kMaxValue)
213 <= std::numeric_limits<size_t>::max());
214 if (value >= 0) {
215 *result = static_cast<size_t>(value);
216 return true;
217 }
218 return false;
219 } else {
220 DCHECK(number->IsHeapNumber());
221 double value = HeapNumber::cast(number)->value();
222 if (value >= 0 &&
223 value <= std::numeric_limits<size_t>::max()) {
224 *result = static_cast<size_t>(value);
225 return true;
226 } else {
227 return false;
228 }
229 }
230 }
231
232 // Converts a number into size_t.
NumberToSize(Isolate * isolate,Object * number)233 inline size_t NumberToSize(Isolate* isolate,
234 Object* number) {
235 size_t result = 0;
236 bool is_valid = TryNumberToSize(isolate, number, &result);
237 CHECK(is_valid);
238 return result;
239 }
240
241 } } // namespace v8::internal
242
243 #endif // V8_CONVERSIONS_H_
244