src/v8/src/conversions.h

   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
  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
  55 inline bool isBinaryDigit(int x) {
  56   return x == '0' || x == '1';
  57 }
  58
  59
  60 // The fast double-to-(unsigned-)int conversion routine does not guarantee
  61 // rounding towards zero.
  62 // For NaN and values outside the int range, return INT_MIN or INT_MAX.
  63 inline int FastD2IChecked(double x) {
  64   if (!(x >= INT_MIN)) return INT_MIN;  // Negation to catch NaNs.
  65   if (x > INT_MAX) return INT_MAX;
  66   return static_cast<int>(x);
  67 }
  68
  69
  70 // The fast double-to-(unsigned-)int conversion routine does not guarantee
  71 // rounding towards zero.
  72 // The result is unspecified if x is infinite or NaN, or if the rounded
  73 // integer value is outside the range of type int.
  74 inline int FastD2I(double x) {
  75   return static_cast<int32_t>(x);
  76 }
  77
  78 inline unsigned int FastD2UI(double x);
  79
  80
  81 inline double FastI2D(int x) {
  82   // There is no rounding involved in converting an 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 inline double FastUI2D(unsigned x) {
  90   // There is no rounding involved in converting an unsigned integer to a
  91   // double, so this code should compile to a few instructions without
  92   // any FPU pipeline stalls.
  93   return static_cast<double>(x);
  94 }
  95
  96
  97 // This function should match the exact semantics of ECMA-262 9.4.
  98 inline double DoubleToInteger(double x);
  99
 100
 101 // This function should match the exact semantics of ECMA-262 9.5.
 102 inline int32_t DoubleToInt32(double x);
 103
 104
 105 // This function should match the exact semantics of ECMA-262 9.6.
 106 inline uint32_t DoubleToUint32(double x) {
 107   return static_cast<uint32_t>(DoubleToInt32(x));
 108 }
 109
 110
 111 // Enumeration for allowing octals and ignoring junk when converting
 112 // strings to numbers.
 113 enum ConversionFlags {
 114   NO_FLAGS = 0,
 115   ALLOW_HEX = 1,
 116   ALLOW_OCTAL = 2,
 117   ALLOW_IMPLICIT_OCTAL = 4,
 118   ALLOW_BINARY = 8,
 119   ALLOW_TRAILING_JUNK = 16
 120 };
 121
 122
 123 // Converts a string into a double value according to ECMA-262 9.3.1
 124 double StringToDouble(UnicodeCache* unicode_cache,
 125                       Vector<const char> str,
 126                       int flags,
 127                       double empty_string_val = 0);
 128 double StringToDouble(UnicodeCache* unicode_cache,
 129                       Vector<const uc16> str,
 130                       int flags,
 131                       double empty_string_val = 0);
 132 // This version expects a zero-terminated character array.
 133 double StringToDouble(UnicodeCache* unicode_cache,
 134                       const char* str,
 135                       int flags,
 136                       double empty_string_val = 0);
 137
 138 const int kDoubleToCStringMinBufferSize = 100;
 139
 140 // Converts a double to a string value according to ECMA-262 9.8.1.
 141 // The buffer should be large enough for any floating point number.
 142 // 100 characters is enough.
 143 const char* DoubleToCString(double value, Vector<char> buffer);
 144
 145 // Convert an int to a null-terminated string. The returned string is
 146 // located inside the buffer, but not necessarily at the start.
 147 const char* IntToCString(int n, Vector<char> buffer);
 148
 149 // Additional number to string conversions for the number type.
 150 // The caller is responsible for calling free on the returned pointer.
 151 char* DoubleToFixedCString(double value, int f);
 152 char* DoubleToExponentialCString(double value, int f);
 153 char* DoubleToPrecisionCString(double value, int f);
 154 char* DoubleToRadixCString(double value, int radix);
 155
 156 } }  // namespace v8::internal
 157
 158 #endif  // V8_CONVERSIONS_H_