• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2011 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 //     * Redistributions of source code must retain the above copyright
7 //       notice, this list of conditions and the following disclaimer.
8 //     * Redistributions in binary form must reproduce the above
9 //       copyright notice, this list of conditions and the following
10 //       disclaimer in the documentation and/or other materials provided
11 //       with the distribution.
12 //     * Neither the name of Google Inc. nor the names of its
13 //       contributors may be used to endorse or promote products derived
14 //       from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
28 #ifndef V8_CONVERSIONS_H_
29 #define V8_CONVERSIONS_H_
30 
31 #include "utils.h"
32 
33 namespace v8 {
34 namespace internal {
35 
36 class UnicodeCache;
37 
38 // Maximum number of significant digits in decimal representation.
39 // The longest possible double in decimal representation is
40 // (2^53 - 1) * 2 ^ -1074 that is (2 ^ 53 - 1) * 5 ^ 1074 / 10 ^ 1074
41 // (768 digits). If we parse a number whose first digits are equal to a
42 // mean of 2 adjacent doubles (that could have up to 769 digits) the result
43 // must be rounded to the bigger one unless the tail consists of zeros, so
44 // we don't need to preserve all the digits.
45 const int kMaxSignificantDigits = 772;
46 
47 
isDigit(int x,int radix)48 inline bool isDigit(int x, int radix) {
49   return (x >= '0' && x <= '9' && x < '0' + radix)
50       || (radix > 10 && x >= 'a' && x < 'a' + radix - 10)
51       || (radix > 10 && x >= 'A' && x < 'A' + radix - 10);
52 }
53 
54 
SignedZero(bool negative)55 inline double SignedZero(bool negative) {
56   return negative ? -0.0 : 0.0;
57 }
58 
59 
60 // The fast double-to-(unsigned-)int conversion routine does not guarantee
61 // rounding towards zero.
62 // The result is unspecified if x is infinite or NaN, or if the rounded
63 // integer value is outside the range of type int.
FastD2I(double x)64 inline int FastD2I(double x) {
65   // The static_cast convertion from double to int used to be slow, but
66   // as new benchmarks show, now it is much faster than lrint().
67   return static_cast<int>(x);
68 }
69 
70 inline unsigned int FastD2UI(double x);
71 
72 
FastI2D(int x)73 inline double FastI2D(int x) {
74   // There is no rounding involved in converting an integer to a
75   // double, so this code should compile to a few instructions without
76   // any FPU pipeline stalls.
77   return static_cast<double>(x);
78 }
79 
80 
FastUI2D(unsigned x)81 inline double FastUI2D(unsigned x) {
82   // There is no rounding involved in converting an unsigned integer to a
83   // double, so this code should compile to a few instructions without
84   // any FPU pipeline stalls.
85   return static_cast<double>(x);
86 }
87 
88 
89 // This function should match the exact semantics of ECMA-262 9.4.
90 inline double DoubleToInteger(double x);
91 
92 
93 // This function should match the exact semantics of ECMA-262 9.5.
94 inline int32_t DoubleToInt32(double x);
95 
96 
97 // This function should match the exact semantics of ECMA-262 9.6.
DoubleToUint32(double x)98 inline uint32_t DoubleToUint32(double x) {
99   return static_cast<uint32_t>(DoubleToInt32(x));
100 }
101 
102 
103 // Enumeration for allowing octals and ignoring junk when converting
104 // strings to numbers.
105 enum ConversionFlags {
106   NO_FLAGS = 0,
107   ALLOW_HEX = 1,
108   ALLOW_OCTALS = 2,
109   ALLOW_TRAILING_JUNK = 4
110 };
111 
112 
113 // Converts a string into a double value according to ECMA-262 9.3.1
114 double StringToDouble(UnicodeCache* unicode_cache,
115                       Vector<const char> str,
116                       int flags,
117                       double empty_string_val = 0);
118 double StringToDouble(UnicodeCache* unicode_cache,
119                       Vector<const uc16> str,
120                       int flags,
121                       double empty_string_val = 0);
122 // This version expects a zero-terminated character array.
123 double StringToDouble(UnicodeCache* unicode_cache,
124                       const char* str,
125                       int flags,
126                       double empty_string_val = 0);
127 
128 const int kDoubleToCStringMinBufferSize = 100;
129 
130 // Converts a double to a string value according to ECMA-262 9.8.1.
131 // The buffer should be large enough for any floating point number.
132 // 100 characters is enough.
133 const char* DoubleToCString(double value, Vector<char> buffer);
134 
135 // Convert an int to a null-terminated string. The returned string is
136 // located inside the buffer, but not necessarily at the start.
137 const char* IntToCString(int n, Vector<char> buffer);
138 
139 // Additional number to string conversions for the number type.
140 // The caller is responsible for calling free on the returned pointer.
141 char* DoubleToFixedCString(double value, int f);
142 char* DoubleToExponentialCString(double value, int f);
143 char* DoubleToPrecisionCString(double value, int f);
144 char* DoubleToRadixCString(double value, int radix);
145 
146 } }  // namespace v8::internal
147 
148 #endif  // V8_CONVERSIONS_H_
149