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
13namespace v8 {
14namespace internal {
15
16template <typename T>
17class Handle;
18class 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.
27const int kMaxSignificantDigits = 772;
28
29
30inline 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
37inline 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.
46inline 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.
57inline int FastD2I(double x) {
58  return static_cast<int32_t>(x);
59}
60
61inline unsigned int FastD2UI(double x);
62
63
64inline 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
72inline 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.
81inline float DoubleToFloat32(double x);
82
83
84// This function should match the exact semantics of ECMA-262 9.4.
85inline double DoubleToInteger(double x);
86
87
88// This function should match the exact semantics of ECMA-262 9.5.
89inline int32_t DoubleToInt32(double x);
90
91
92// This function should match the exact semantics of ECMA-262 9.6.
93inline uint32_t DoubleToUint32(double x);
94
95
96// Enumeration for allowing octals and ignoring junk when converting
97// strings to numbers.
98enum 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
109double StringToDouble(UnicodeCache* unicode_cache,
110                      Vector<const uint8_t> str,
111                      int flags,
112                      double empty_string_val = 0);
113double 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.
118double 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.
124double StringToInt(UnicodeCache* unicode_cache,
125                   Vector<const uint8_t> vector,
126                   int radix);
127
128
129double StringToInt(UnicodeCache* unicode_cache,
130                   Vector<const uc16> vector,
131                   int radix);
132
133const 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.
138const 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.
142const 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.
146char* DoubleToFixedCString(double value, int f);
147char* DoubleToExponentialCString(double value, int f);
148char* DoubleToPrecisionCString(double value, int f);
149char* DoubleToRadixCString(double value, int radix);
150
151static inline bool IsMinusZero(double value) {
152  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|.
157inline bool DoubleToSmiInteger(double value, int* smi_int_value);
158
159inline 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.
164inline 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.
169inline 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".
176inline bool DoubleToUint32IfEqualToSelf(double value, uint32_t* uint32_value);
177
178// Convert from Number object to C integer.
179inline uint32_t PositiveNumberToUint32(Object* number);
180inline int32_t NumberToInt32(Object* number);
181inline uint32_t NumberToUint32(Object* number);
182inline int64_t NumberToInt64(Object* number);
183
184double StringToDouble(UnicodeCache* unicode_cache, Handle<String> string,
185                      int flags, double empty_string_val = 0.0);
186
187inline bool TryNumberToSize(Object* number, size_t* result);
188
189// Converts a number into size_t.
190inline size_t NumberToSize(Object* number);
191
192// returns DoubleToString(StringToDouble(string)) == string
193bool IsSpecialIndex(UnicodeCache* unicode_cache, String* string);
194
195}  // namespace internal
196}  // namespace v8
197
198#endif  // V8_CONVERSIONS_H_
199