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 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 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. 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. 57 inline int FastD2I(double x) { 58 return static_cast<int32_t>(x); 59 } 60 61 inline unsigned int FastD2UI(double x); 62 63 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 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. 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 154 static inline bool IsMinusZero(double value) { 155 static const DoubleRepresentation minus_zero(-0.0); 156 return DoubleRepresentation(value) == minus_zero; 157 } 158 159 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. 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. 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. 189 inline int32_t NumberToInt32(Object* number) { 190 if (number->IsSmi()) return Smi::cast(number)->value(); 191 return DoubleToInt32(number->Number()); 192 } 193 194 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 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. 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
