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.
5 #ifndef V8_CONVERSIONS_H_
6 #define V8_CONVERSIONS_H_
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;
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);
37 inline bool isBinaryDigit(int x) {
38 return x == '0' || x == '1';
42 // The fast double-to-(unsigned-)int conversion routine does not guarantee
43 // rounding towards zero.
44 // For NaN and values outside the int range, return INT_MIN or INT_MAX.
45 inline int FastD2IChecked(double x) {
46 if (!(x >= INT_MIN)) return INT_MIN; // Negation to catch NaNs.
47 if (x > INT_MAX) return INT_MAX;
48 return static_cast<int>(x);
52 // The fast double-to-(unsigned-)int conversion routine does not guarantee
53 // rounding towards zero.
54 // The result is unspecified if x is infinite or NaN, or if the rounded
55 // integer value is outside the range of type int.
56 inline int FastD2I(double x) {
57 return static_cast<int32_t>(x);
60 inline unsigned int FastD2UI(double x);
63 inline double FastI2D(int x) {
64 // There is no rounding involved in converting an integer to a
65 // double, so this code should compile to a few instructions without
66 // any FPU pipeline stalls.
67 return static_cast<double>(x);
71 inline double FastUI2D(unsigned x) {
72 // There is no rounding involved in converting an unsigned integer to a
73 // double, so this code should compile to a few instructions without
74 // any FPU pipeline stalls.
75 return static_cast<double>(x);
79 // This function should match the exact semantics of ECMA-262 9.4.
80 inline double DoubleToInteger(double x);
83 // This function should match the exact semantics of ECMA-262 9.5.
84 inline int32_t DoubleToInt32(double x);
87 // This function should match the exact semantics of ECMA-262 9.6.
88 inline uint32_t DoubleToUint32(double x) {
89 return static_cast<uint32_t>(DoubleToInt32(x));
93 // Enumeration for allowing octals and ignoring junk when converting
94 // strings to numbers.
95 enum ConversionFlags {
99 ALLOW_IMPLICIT_OCTAL = 4,
101 ALLOW_TRAILING_JUNK = 16
105 // Converts a string into a double value according to ECMA-262 9.3.1
106 double StringToDouble(UnicodeCache* unicode_cache,
107 Vector<const uint8_t> str,
109 double empty_string_val = 0);
110 double StringToDouble(UnicodeCache* unicode_cache,
111 Vector<const uc16> str,
113 double empty_string_val = 0);
114 // This version expects a zero-terminated character array.
115 double StringToDouble(UnicodeCache* unicode_cache,
118 double empty_string_val = 0);
120 // Converts a string into an integer.
121 double StringToInt(UnicodeCache* unicode_cache,
122 Vector<const uint8_t> vector,
126 double StringToInt(UnicodeCache* unicode_cache,
127 Vector<const uc16> vector,
130 const int kDoubleToCStringMinBufferSize = 100;
132 // Converts a double to a string value according to ECMA-262 9.8.1.
133 // The buffer should be large enough for any floating point number.
134 // 100 characters is enough.
135 const char* DoubleToCString(double value, Vector<char> buffer);
137 // Convert an int to a null-terminated string. The returned string is
138 // located inside the buffer, but not necessarily at the start.
139 const char* IntToCString(int n, Vector<char> buffer);
141 // Additional number to string conversions for the number type.
142 // The caller is responsible for calling free on the returned pointer.
143 char* DoubleToFixedCString(double value, int f);
144 char* DoubleToExponentialCString(double value, int f);
145 char* DoubleToPrecisionCString(double value, int f);
146 char* DoubleToRadixCString(double value, int radix);
149 static inline bool IsMinusZero(double value) {
150 static const DoubleRepresentation minus_zero(-0.0);
151 return DoubleRepresentation(value) == minus_zero;
155 // Integer32 is an integer that can be represented as a signed 32-bit
156 // integer. It has to be in the range [-2^31, 2^31 - 1].
157 // We also have to check for negative 0 as it is not an Integer32.
158 static inline bool IsInt32Double(double value) {
159 return !IsMinusZero(value) &&
162 value == FastI2D(FastD2I(value));
166 // Convert from Number object to C integer.
167 inline int32_t NumberToInt32(Object* number) {
168 if (number->IsSmi()) return Smi::cast(number)->value();
169 return DoubleToInt32(number->Number());
173 inline uint32_t NumberToUint32(Object* number) {
174 if (number->IsSmi()) return Smi::cast(number)->value();
175 return DoubleToUint32(number->Number());
179 double StringToDouble(UnicodeCache* unicode_cache,
182 double empty_string_val = 0.0);
185 inline bool TryNumberToSize(Isolate* isolate,
186 Object* number, size_t* result) {
187 SealHandleScope shs(isolate);
188 if (number->IsSmi()) {
189 int value = Smi::cast(number)->value();
190 ASSERT(static_cast<unsigned>(Smi::kMaxValue)
191 <= std::numeric_limits<size_t>::max());
193 *result = static_cast<size_t>(value);
198 ASSERT(number->IsHeapNumber());
199 double value = HeapNumber::cast(number)->value();
201 value <= std::numeric_limits<size_t>::max()) {
202 *result = static_cast<size_t>(value);
210 // Converts a number into size_t.
211 inline size_t NumberToSize(Isolate* isolate,
214 bool is_valid = TryNumberToSize(isolate, number, &result);
219 } } // namespace v8::internal
221 #endif // V8_CONVERSIONS_H_