src/v8/src/conversions.h

   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_