LCOV - code coverage report
Current view: top level - src - conversions.h (source / functions) Hit Total Coverage
Test: app.info Lines: 16 16 100.0 %
Date: 2017-04-26 Functions: 5 5 100.0 %

          Line data    Source code
       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             : 
      13             : namespace v8 {
      14             : namespace internal {
      15             : 
      16             : template <typename T>
      17             : class Handle;
      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     2501106 : inline bool isDigit(int x, int radix) {
      31     3122553 :   return (x >= '0' && x <= '9' && x < '0' + radix)
      32     1879659 :       || (radix > 10 && x >= 'a' && x < 'a' + radix - 10)
      33     4345284 :       || (radix > 10 && x >= 'A' && x < 'A' + radix - 10);
      34             : }
      35             : 
      36             : 
      37             : inline bool isBinaryDigit(int x) {
      38         176 :   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          72 : inline int FastD2IChecked(double x) {
      47    61533173 :   if (!(x >= INT_MIN)) return INT_MIN;  // Negation to catch NaNs.
      48    56798441 :   if (x > INT_MAX) return INT_MAX;
      49    27831017 :   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         122 : inline int FastD2I(double x) {
      58    27106537 :   return static_cast<int32_t>(x);
      59             : }
      60             : 
      61             : inline unsigned int FastD2UI(double x);
      62             : 
      63             : 
      64         122 : 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    30690466 :   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     1809537 :   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             : 
      95             : 
      96             : // Enumeration for allowing octals and ignoring junk when converting
      97             : // strings to numbers.
      98             : enum 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
     109             : double StringToDouble(UnicodeCache* unicode_cache,
     110             :                       Vector<const uint8_t> str,
     111             :                       int flags,
     112             :                       double empty_string_val = 0);
     113             : double 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.
     118             : double 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.
     124             : double StringToInt(UnicodeCache* unicode_cache,
     125             :                    Vector<const uint8_t> vector,
     126             :                    int radix);
     127             : 
     128             : 
     129             : double StringToInt(UnicodeCache* unicode_cache,
     130             :                    Vector<const uc16> vector,
     131             :                    int radix);
     132             : 
     133             : const 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.
     138             : const 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.
     142             : const 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.
     146             : char* DoubleToFixedCString(double value, int f);
     147             : char* DoubleToExponentialCString(double value, int f);
     148             : char* DoubleToPrecisionCString(double value, int f);
     149             : char* DoubleToRadixCString(double value, int radix);
     150             : 
     151        4273 : static inline bool IsMinusZero(double value) {
     152        4273 :   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|.
     157             : inline bool DoubleToSmiInteger(double value, int* smi_int_value);
     158             : 
     159             : inline 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.
     164             : inline 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.
     169             : inline 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".
     176             : inline bool DoubleToUint32IfEqualToSelf(double value, uint32_t* uint32_value);
     177             : 
     178             : // Convert from Number object to C integer.
     179             : inline uint32_t PositiveNumberToUint32(Object* number);
     180             : inline int32_t NumberToInt32(Object* number);
     181             : inline uint32_t NumberToUint32(Object* number);
     182             : inline int64_t NumberToInt64(Object* number);
     183             : 
     184             : double StringToDouble(UnicodeCache* unicode_cache, Handle<String> string,
     185             :                       int flags, double empty_string_val = 0.0);
     186             : 
     187             : inline bool TryNumberToSize(Object* number, size_t* result);
     188             : 
     189             : // Converts a number into size_t.
     190             : inline size_t NumberToSize(Object* number);
     191             : 
     192             : // returns DoubleToString(StringToDouble(string)) == string
     193             : bool IsSpecialIndex(UnicodeCache* unicode_cache, String* string);
     194             : 
     195             : }  // namespace internal
     196             : }  // namespace v8
     197             : 
     198             : #endif  // V8_CONVERSIONS_H_

Generated by: LCOV version 1.10