// Copyright 2011 the V8 project authors. All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following // disclaimer in the documentation and/or other materials provided // with the distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived // from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef V8_CONVERSIONS_H_ #define V8_CONVERSIONS_H_ #include "utils.h" namespace v8 { namespace internal { class UnicodeCache; // Maximum number of significant digits in decimal representation. // The longest possible double in decimal representation is // (2^53 - 1) * 2 ^ -1074 that is (2 ^ 53 - 1) * 5 ^ 1074 / 10 ^ 1074 // (768 digits). If we parse a number whose first digits are equal to a // mean of 2 adjacent doubles (that could have up to 769 digits) the result // must be rounded to the bigger one unless the tail consists of zeros, so // we don't need to preserve all the digits. const int kMaxSignificantDigits = 772; inline bool isDigit(int x, int radix) { return (x >= '0' && x <= '9' && x < '0' + radix) || (radix > 10 && x >= 'a' && x < 'a' + radix - 10) || (radix > 10 && x >= 'A' && x < 'A' + radix - 10); } inline bool isBinaryDigit(int x) { return x == '0' || x == '1'; } // The fast double-to-(unsigned-)int conversion routine does not guarantee // rounding towards zero. // For NaN and values outside the int range, return INT_MIN or INT_MAX. inline int FastD2IChecked(double x) { if (!(x >= INT_MIN)) return INT_MIN; // Negation to catch NaNs. if (x > INT_MAX) return INT_MAX; return static_cast<int>(x); } // The fast double-to-(unsigned-)int conversion routine does not guarantee // rounding towards zero. // The result is unspecified if x is infinite or NaN, or if the rounded // integer value is outside the range of type int. inline int FastD2I(double x) { return static_cast<int>(x); } inline unsigned int FastD2UI(double x); inline double FastI2D(int x) { // There is no rounding involved in converting an integer to a // double, so this code should compile to a few instructions without // any FPU pipeline stalls. return static_cast<double>(x); } inline double FastUI2D(unsigned x) { // There is no rounding involved in converting an unsigned integer to a // double, so this code should compile to a few instructions without // any FPU pipeline stalls. return static_cast<double>(x); } // This function should match the exact semantics of ECMA-262 9.4. inline double DoubleToInteger(double x); // This function should match the exact semantics of ECMA-262 9.5. inline int32_t DoubleToInt32(double x); // This function should match the exact semantics of ECMA-262 9.6. inline uint32_t DoubleToUint32(double x) { return static_cast<uint32_t>(DoubleToInt32(x)); } // Enumeration for allowing octals and ignoring junk when converting // strings to numbers. enum ConversionFlags { NO_FLAGS = 0, ALLOW_HEX = 1, ALLOW_OCTAL = 2, ALLOW_IMPLICIT_OCTAL = 4, ALLOW_BINARY = 8, ALLOW_TRAILING_JUNK = 16 }; // Converts a string into a double value according to ECMA-262 9.3.1 double StringToDouble(UnicodeCache* unicode_cache, Vector<const char> str, int flags, double empty_string_val = 0); double StringToDouble(UnicodeCache* unicode_cache, Vector<const uc16> str, int flags, double empty_string_val = 0); // This version expects a zero-terminated character array. double StringToDouble(UnicodeCache* unicode_cache, const char* str, int flags, double empty_string_val = 0); const int kDoubleToCStringMinBufferSize = 100; // Converts a double to a string value according to ECMA-262 9.8.1. // The buffer should be large enough for any floating point number. // 100 characters is enough. const char* DoubleToCString(double value, Vector<char> buffer); // Convert an int to a null-terminated string. The returned string is // located inside the buffer, but not necessarily at the start. const char* IntToCString(int n, Vector<char> buffer); // Additional number to string conversions for the number type. // The caller is responsible for calling free on the returned pointer. char* DoubleToFixedCString(double value, int f); char* DoubleToExponentialCString(double value, int f); char* DoubleToPrecisionCString(double value, int f); char* DoubleToRadixCString(double value, int radix); } } // namespace v8::internal #endif // V8_CONVERSIONS_H_