Line data Source code
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/utils.h"
12 :
13 : namespace v8 {
14 : namespace internal {
15 :
16 : template <typename T>
17 : class Handle;
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 2501106 : inline bool isDigit(int x, int radix) {
31 3122553 : return (x >= '0' && x <= '9' && x < '0' + radix)
32 1879659 : || (radix > 10 && x >= 'a' && x < 'a' + radix - 10)
33 4345284 : || (radix > 10 && x >= 'A' && x < 'A' + radix - 10);
34 : }
35 :
36 :
37 : inline bool isBinaryDigit(int x) {
38 176 : 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 72 : inline int FastD2IChecked(double x) {
47 61533173 : if (!(x >= INT_MIN)) return INT_MIN; // Negation to catch NaNs.
48 56798441 : if (x > INT_MAX) return INT_MAX;
49 27831017 : 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 122 : inline int FastD2I(double x) {
58 27106537 : return static_cast<int32_t>(x);
59 : }
60 :
61 : inline unsigned int FastD2UI(double x);
62 :
63 :
64 122 : 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 30690466 : 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 1809537 : 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 :
95 :
96 : // Enumeration for allowing octals and ignoring junk when converting
97 : // strings to numbers.
98 : enum ConversionFlags {
99 : NO_FLAGS = 0,
100 : ALLOW_HEX = 1,
101 : ALLOW_OCTAL = 2,
102 : ALLOW_IMPLICIT_OCTAL = 4,
103 : ALLOW_BINARY = 8,
104 : ALLOW_TRAILING_JUNK = 16
105 : };
106 :
107 :
108 : // Converts a string into a double value according to ECMA-262 9.3.1
109 : double StringToDouble(UnicodeCache* unicode_cache,
110 : Vector<const uint8_t> str,
111 : int flags,
112 : double empty_string_val = 0);
113 : double StringToDouble(UnicodeCache* unicode_cache,
114 : Vector<const uc16> str,
115 : int flags,
116 : double empty_string_val = 0);
117 : // This version expects a zero-terminated character array.
118 : double StringToDouble(UnicodeCache* unicode_cache,
119 : const char* str,
120 : int flags,
121 : double empty_string_val = 0);
122 :
123 : // Converts a string into an integer.
124 : double StringToInt(UnicodeCache* unicode_cache,
125 : Vector<const uint8_t> vector,
126 : int radix);
127 :
128 :
129 : double StringToInt(UnicodeCache* unicode_cache,
130 : Vector<const uc16> vector,
131 : int radix);
132 :
133 : const int kDoubleToCStringMinBufferSize = 100;
134 :
135 : // Converts a double to a string value according to ECMA-262 9.8.1.
136 : // The buffer should be large enough for any floating point number.
137 : // 100 characters is enough.
138 : const char* DoubleToCString(double value, Vector<char> buffer);
139 :
140 : // Convert an int to a null-terminated string. The returned string is
141 : // located inside the buffer, but not necessarily at the start.
142 : const char* IntToCString(int n, Vector<char> buffer);
143 :
144 : // Additional number to string conversions for the number type.
145 : // The caller is responsible for calling free on the returned pointer.
146 : char* DoubleToFixedCString(double value, int f);
147 : char* DoubleToExponentialCString(double value, int f);
148 : char* DoubleToPrecisionCString(double value, int f);
149 : char* DoubleToRadixCString(double value, int radix);
150 :
151 4273 : static inline bool IsMinusZero(double value) {
152 4273 : return bit_cast<int64_t>(value) == bit_cast<int64_t>(-0.0);
153 : }
154 :
155 : // Returns true if value can be converted to a SMI, and returns the resulting
156 : // integer value of the SMI in |smi_int_value|.
157 : inline bool DoubleToSmiInteger(double value, int* smi_int_value);
158 :
159 : inline bool IsSmiDouble(double value);
160 :
161 : // Integer32 is an integer that can be represented as a signed 32-bit
162 : // integer. It has to be in the range [-2^31, 2^31 - 1].
163 : // We also have to check for negative 0 as it is not an Integer32.
164 : inline bool IsInt32Double(double value);
165 :
166 : // UInteger32 is an integer that can be represented as an unsigned 32-bit
167 : // integer. It has to be in the range [0, 2^32 - 1].
168 : // We also have to check for negative 0 as it is not a UInteger32.
169 : inline bool IsUint32Double(double value);
170 :
171 : // Tries to convert |value| to a uint32, setting the result in |uint32_value|.
172 : // If the output does not compare equal to the input, returns false and the
173 : // value in |uint32_value| is left unspecified.
174 : // Used for conversions such as in ECMA-262 15.4.2.2, which check "ToUint32(len)
175 : // is equal to len".
176 : inline bool DoubleToUint32IfEqualToSelf(double value, uint32_t* uint32_value);
177 :
178 : // Convert from Number object to C integer.
179 : inline uint32_t PositiveNumberToUint32(Object* number);
180 : inline int32_t NumberToInt32(Object* number);
181 : inline uint32_t NumberToUint32(Object* number);
182 : inline int64_t NumberToInt64(Object* number);
183 :
184 : double StringToDouble(UnicodeCache* unicode_cache, Handle<String> string,
185 : int flags, double empty_string_val = 0.0);
186 :
187 : inline bool TryNumberToSize(Object* number, size_t* result);
188 :
189 : // Converts a number into size_t.
190 : inline size_t NumberToSize(Object* number);
191 :
192 : // returns DoubleToString(StringToDouble(string)) == string
193 : bool IsSpecialIndex(UnicodeCache* unicode_cache, String* string);
194 :
195 : } // namespace internal
196 : } // namespace v8
197 :
198 : #endif // V8_CONVERSIONS_H_
|
