mirror of https://github.com/lukechilds/node.git
Ryan Dahl
15 years ago
104 changed files with 107895 additions and 1104 deletions
@ -0,0 +1,119 @@ |
|||||
|
// Copyright 2010 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_CACHED_POWERS_H_ |
||||
|
#define V8_CACHED_POWERS_H_ |
||||
|
|
||||
|
#include "diy_fp.h" |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
struct CachedPower { |
||||
|
uint64_t significand; |
||||
|
int16_t binary_exponent; |
||||
|
int16_t decimal_exponent; |
||||
|
}; |
||||
|
|
||||
|
// The following defines implement the interface between this file and the
|
||||
|
// generated 'powers_ten.h'.
|
||||
|
// GRISU_CACHE_NAME(1) contains all possible cached powers.
|
||||
|
// GRISU_CACHE_NAME(i) contains GRISU_CACHE_NAME(1) where only every 'i'th
|
||||
|
// element is kept. More formally GRISU_CACHE_NAME(i) contains the elements j*i
|
||||
|
// with 0 <= j < k with k such that j*k < the size of GRISU_CACHE_NAME(1).
|
||||
|
// The higher 'i' is the fewer elements we use.
|
||||
|
// Given that there are less elements, the exponent-distance between two
|
||||
|
// elements in the cache grows. The variable GRISU_CACHE_MAX_DISTANCE(i) stores
|
||||
|
// the maximum distance between two elements.
|
||||
|
#define GRISU_CACHE_STRUCT CachedPower |
||||
|
#define GRISU_CACHE_NAME(i) kCachedPowers##i |
||||
|
#define GRISU_CACHE_MAX_DISTANCE(i) kCachedPowersMaxDistance##i |
||||
|
#define GRISU_CACHE_OFFSET kCachedPowerOffset |
||||
|
#define GRISU_UINT64_C V8_2PART_UINT64_C |
||||
|
// The following include imports the precompiled cached powers.
|
||||
|
#include "powers_ten.h" // NOLINT |
||||
|
|
||||
|
static const double kD_1_LOG2_10 = 0.30102999566398114; // 1 / lg(10)
|
||||
|
|
||||
|
// We can't use a function since we reference variables depending on the 'i'.
|
||||
|
// This way the compiler is able to see at compile time that only one
|
||||
|
// cache-array variable is used and thus can remove all the others.
|
||||
|
#define COMPUTE_FOR_CACHE(i) \ |
||||
|
if (!found && (gamma - alpha + 1 >= GRISU_CACHE_MAX_DISTANCE(i))) { \ |
||||
|
int kQ = DiyFp::kSignificandSize; \ |
||||
|
double k = ceiling((alpha - e + kQ - 1) * kD_1_LOG2_10); \ |
||||
|
int index = (GRISU_CACHE_OFFSET + static_cast<int>(k) - 1) / i + 1; \ |
||||
|
cached_power = GRISU_CACHE_NAME(i)[index]; \ |
||||
|
found = true; \ |
||||
|
} \ |
||||
|
|
||||
|
static void GetCachedPower(int e, int alpha, int gamma, int* mk, DiyFp* c_mk) { |
||||
|
// The following if statement should be optimized by the compiler so that only
|
||||
|
// one array is referenced and the others are not included in the object file.
|
||||
|
bool found = false; |
||||
|
CachedPower cached_power; |
||||
|
COMPUTE_FOR_CACHE(20); |
||||
|
COMPUTE_FOR_CACHE(19); |
||||
|
COMPUTE_FOR_CACHE(18); |
||||
|
COMPUTE_FOR_CACHE(17); |
||||
|
COMPUTE_FOR_CACHE(16); |
||||
|
COMPUTE_FOR_CACHE(15); |
||||
|
COMPUTE_FOR_CACHE(14); |
||||
|
COMPUTE_FOR_CACHE(13); |
||||
|
COMPUTE_FOR_CACHE(12); |
||||
|
COMPUTE_FOR_CACHE(11); |
||||
|
COMPUTE_FOR_CACHE(10); |
||||
|
COMPUTE_FOR_CACHE(9); |
||||
|
COMPUTE_FOR_CACHE(8); |
||||
|
COMPUTE_FOR_CACHE(7); |
||||
|
COMPUTE_FOR_CACHE(6); |
||||
|
COMPUTE_FOR_CACHE(5); |
||||
|
COMPUTE_FOR_CACHE(4); |
||||
|
COMPUTE_FOR_CACHE(3); |
||||
|
COMPUTE_FOR_CACHE(2); |
||||
|
COMPUTE_FOR_CACHE(1); |
||||
|
if (!found) { |
||||
|
UNIMPLEMENTED(); |
||||
|
// Silence compiler warnings.
|
||||
|
cached_power.significand = 0; |
||||
|
cached_power.binary_exponent = 0; |
||||
|
cached_power.decimal_exponent = 0; |
||||
|
} |
||||
|
*c_mk = DiyFp(cached_power.significand, cached_power.binary_exponent); |
||||
|
*mk = cached_power.decimal_exponent; |
||||
|
ASSERT((alpha <= c_mk->e() + e) && (c_mk->e() + e <= gamma)); |
||||
|
} |
||||
|
#undef GRISU_REDUCTION |
||||
|
#undef GRISU_CACHE_STRUCT |
||||
|
#undef GRISU_CACHE_NAME |
||||
|
#undef GRISU_CACHE_MAX_DISTANCE |
||||
|
#undef GRISU_CACHE_OFFSET |
||||
|
#undef GRISU_UINT64_C |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_CACHED_POWERS_H_
|
||||
File diff suppressed because it is too large
@ -0,0 +1,136 @@ |
|||||
|
// Copyright 2010 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_DIY_FP_H_ |
||||
|
#define V8_DIY_FP_H_ |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
// This "Do It Yourself Floating Point" class implements a floating-point number
|
||||
|
// with a uint64 significand and an int exponent. Normalized DiyFp numbers will
|
||||
|
// have the most significant bit of the significand set.
|
||||
|
// Multiplication and Subtraction do not normalize their results.
|
||||
|
// DiyFp are not designed to contain special doubles (NaN and Infinity).
|
||||
|
class DiyFp { |
||||
|
public: |
||||
|
static const int kSignificandSize = 64; |
||||
|
|
||||
|
DiyFp() : f_(0), e_(0) {} |
||||
|
DiyFp(uint64_t f, int e) : f_(f), e_(e) {} |
||||
|
|
||||
|
// this = this - other.
|
||||
|
// The exponents of both numbers must be the same and the significand of this
|
||||
|
// must be bigger than the significand of other.
|
||||
|
// The result will not be normalized.
|
||||
|
void Subtract(const DiyFp& other) { |
||||
|
ASSERT(e_ == other.e_); |
||||
|
ASSERT(f_ >= other.f_); |
||||
|
f_ -= other.f_; |
||||
|
} |
||||
|
|
||||
|
// Returns a - b.
|
||||
|
// The exponents of both numbers must be the same and this must be bigger
|
||||
|
// than other. The result will not be normalized.
|
||||
|
static DiyFp Minus(const DiyFp& a, const DiyFp& b) { |
||||
|
DiyFp result = a; |
||||
|
result.Subtract(b); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// this = this * other.
|
||||
|
void Multiply(const DiyFp& other) { |
||||
|
// Simply "emulates" a 128 bit multiplication.
|
||||
|
// However: the resulting number only contains 64 bits. The least
|
||||
|
// significant 64 bits are only used for rounding the most significant 64
|
||||
|
// bits.
|
||||
|
const uint64_t kM32 = 0xFFFFFFFFu; |
||||
|
uint64_t a = f_ >> 32; |
||||
|
uint64_t b = f_ & kM32; |
||||
|
uint64_t c = other.f_ >> 32; |
||||
|
uint64_t d = other.f_ & kM32; |
||||
|
uint64_t ac = a * c; |
||||
|
uint64_t bc = b * c; |
||||
|
uint64_t ad = a * d; |
||||
|
uint64_t bd = b * d; |
||||
|
uint64_t tmp = (bd >> 32) + (ad & kM32) + (bc & kM32); |
||||
|
tmp += 1U << 31; // round
|
||||
|
uint64_t result_f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32); |
||||
|
e_ += other.e_ + 64; |
||||
|
f_ = result_f; |
||||
|
} |
||||
|
|
||||
|
// returns a * b;
|
||||
|
static DiyFp Times(const DiyFp& a, const DiyFp& b) { |
||||
|
DiyFp result = a; |
||||
|
result.Multiply(b); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
void Normalize() { |
||||
|
ASSERT(f_ != 0); |
||||
|
uint64_t f = f_; |
||||
|
int e = e_; |
||||
|
|
||||
|
// This method is mainly called for normalizing boundaries. In general
|
||||
|
// boundaries need to be shifted by 10 bits. We thus optimize for this case.
|
||||
|
const uint64_t k10MSBits = V8_2PART_UINT64_C(0xFFC00000, 00000000); |
||||
|
while ((f & k10MSBits) == 0) { |
||||
|
f <<= 10; |
||||
|
e -= 10; |
||||
|
} |
||||
|
while ((f & kUint64MSB) == 0) { |
||||
|
f <<= 1; |
||||
|
e--; |
||||
|
} |
||||
|
f_ = f; |
||||
|
e_ = e; |
||||
|
} |
||||
|
|
||||
|
static DiyFp Normalize(const DiyFp& a) { |
||||
|
DiyFp result = a; |
||||
|
result.Normalize(); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
uint64_t f() const { return f_; } |
||||
|
int e() const { return e_; } |
||||
|
|
||||
|
void set_f(uint64_t new_value) { f_ = new_value; } |
||||
|
void set_e(int new_value) { e_ = new_value; } |
||||
|
|
||||
|
private: |
||||
|
static const uint64_t kUint64MSB = V8_2PART_UINT64_C(0x80000000, 00000000); |
||||
|
|
||||
|
uint64_t f_; |
||||
|
int e_; |
||||
|
}; |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_DIY_FP_H_
|
||||
@ -0,0 +1,169 @@ |
|||||
|
// Copyright 2010 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_DOUBLE_H_ |
||||
|
#define V8_DOUBLE_H_ |
||||
|
|
||||
|
#include "diy_fp.h" |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
// We assume that doubles and uint64_t have the same endianness.
|
||||
|
static uint64_t double_to_uint64(double d) { return BitCast<uint64_t>(d); } |
||||
|
static double uint64_to_double(uint64_t d64) { return BitCast<double>(d64); } |
||||
|
|
||||
|
// Helper functions for doubles.
|
||||
|
class Double { |
||||
|
public: |
||||
|
static const uint64_t kSignMask = V8_2PART_UINT64_C(0x80000000, 00000000); |
||||
|
static const uint64_t kExponentMask = V8_2PART_UINT64_C(0x7FF00000, 00000000); |
||||
|
static const uint64_t kSignificandMask = |
||||
|
V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
||||
|
static const uint64_t kHiddenBit = V8_2PART_UINT64_C(0x00100000, 00000000); |
||||
|
|
||||
|
Double() : d64_(0) {} |
||||
|
explicit Double(double d) : d64_(double_to_uint64(d)) {} |
||||
|
explicit Double(uint64_t d64) : d64_(d64) {} |
||||
|
|
||||
|
DiyFp AsDiyFp() const { |
||||
|
ASSERT(!IsSpecial()); |
||||
|
return DiyFp(Significand(), Exponent()); |
||||
|
} |
||||
|
|
||||
|
// this->Significand() must not be 0.
|
||||
|
DiyFp AsNormalizedDiyFp() const { |
||||
|
uint64_t f = Significand(); |
||||
|
int e = Exponent(); |
||||
|
|
||||
|
ASSERT(f != 0); |
||||
|
|
||||
|
// The current double could be a denormal.
|
||||
|
while ((f & kHiddenBit) == 0) { |
||||
|
f <<= 1; |
||||
|
e--; |
||||
|
} |
||||
|
// Do the final shifts in one go. Don't forget the hidden bit (the '-1').
|
||||
|
f <<= DiyFp::kSignificandSize - kSignificandSize - 1; |
||||
|
e -= DiyFp::kSignificandSize - kSignificandSize - 1; |
||||
|
return DiyFp(f, e); |
||||
|
} |
||||
|
|
||||
|
// Returns the double's bit as uint64.
|
||||
|
uint64_t AsUint64() const { |
||||
|
return d64_; |
||||
|
} |
||||
|
|
||||
|
int Exponent() const { |
||||
|
if (IsDenormal()) return kDenormalExponent; |
||||
|
|
||||
|
uint64_t d64 = AsUint64(); |
||||
|
int biased_e = static_cast<int>((d64 & kExponentMask) >> kSignificandSize); |
||||
|
return biased_e - kExponentBias; |
||||
|
} |
||||
|
|
||||
|
uint64_t Significand() const { |
||||
|
uint64_t d64 = AsUint64(); |
||||
|
uint64_t significand = d64 & kSignificandMask; |
||||
|
if (!IsDenormal()) { |
||||
|
return significand + kHiddenBit; |
||||
|
} else { |
||||
|
return significand; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// Returns true if the double is a denormal.
|
||||
|
bool IsDenormal() const { |
||||
|
uint64_t d64 = AsUint64(); |
||||
|
return (d64 & kExponentMask) == 0; |
||||
|
} |
||||
|
|
||||
|
// We consider denormals not to be special.
|
||||
|
// Hence only Infinity and NaN are special.
|
||||
|
bool IsSpecial() const { |
||||
|
uint64_t d64 = AsUint64(); |
||||
|
return (d64 & kExponentMask) == kExponentMask; |
||||
|
} |
||||
|
|
||||
|
bool IsNan() const { |
||||
|
uint64_t d64 = AsUint64(); |
||||
|
return ((d64 & kExponentMask) == kExponentMask) && |
||||
|
((d64 & kSignificandMask) != 0); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
bool IsInfinite() const { |
||||
|
uint64_t d64 = AsUint64(); |
||||
|
return ((d64 & kExponentMask) == kExponentMask) && |
||||
|
((d64 & kSignificandMask) == 0); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
int Sign() const { |
||||
|
uint64_t d64 = AsUint64(); |
||||
|
return (d64 & kSignMask) == 0? 1: -1; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// Returns the two boundaries of this.
|
||||
|
// The bigger boundary (m_plus) is normalized. The lower boundary has the same
|
||||
|
// exponent as m_plus.
|
||||
|
void NormalizedBoundaries(DiyFp* out_m_minus, DiyFp* out_m_plus) const { |
||||
|
DiyFp v = this->AsDiyFp(); |
||||
|
bool significand_is_zero = (v.f() == kHiddenBit); |
||||
|
DiyFp m_plus = DiyFp::Normalize(DiyFp((v.f() << 1) + 1, v.e() - 1)); |
||||
|
DiyFp m_minus; |
||||
|
if (significand_is_zero && v.e() != kDenormalExponent) { |
||||
|
// The boundary is closer. Think of v = 1000e10 and v- = 9999e9.
|
||||
|
// Then the boundary (== (v - v-)/2) is not just at a distance of 1e9 but
|
||||
|
// at a distance of 1e8.
|
||||
|
// The only exception is for the smallest normal: the largest denormal is
|
||||
|
// at the same distance as its successor.
|
||||
|
// Note: denormals have the same exponent as the smallest normals.
|
||||
|
m_minus = DiyFp((v.f() << 2) - 1, v.e() - 2); |
||||
|
} else { |
||||
|
m_minus = DiyFp((v.f() << 1) - 1, v.e() - 1); |
||||
|
} |
||||
|
m_minus.set_f(m_minus.f() << (m_minus.e() - m_plus.e())); |
||||
|
m_minus.set_e(m_plus.e()); |
||||
|
*out_m_plus = m_plus; |
||||
|
*out_m_minus = m_minus; |
||||
|
} |
||||
|
|
||||
|
double value() const { return uint64_to_double(d64_); } |
||||
|
|
||||
|
private: |
||||
|
static const int kSignificandSize = 52; // Excludes the hidden bit.
|
||||
|
static const int kExponentBias = 0x3FF + kSignificandSize; |
||||
|
static const int kDenormalExponent = -kExponentBias + 1; |
||||
|
|
||||
|
uint64_t d64_; |
||||
|
}; |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_DOUBLE_H_
|
||||
@ -0,0 +1,494 @@ |
|||||
|
// Copyright 2010 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.
|
||||
|
|
||||
|
#include "v8.h" |
||||
|
|
||||
|
#include "grisu3.h" |
||||
|
|
||||
|
#include "cached_powers.h" |
||||
|
#include "diy_fp.h" |
||||
|
#include "double.h" |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
template <int alpha = -60, int gamma = -32> |
||||
|
class Grisu3 { |
||||
|
public: |
||||
|
// Provides a decimal representation of v.
|
||||
|
// Returns true if it succeeds, otherwise the result can not be trusted.
|
||||
|
// There will be *length digits inside the buffer (not null-terminated).
|
||||
|
// If the function returns true then
|
||||
|
// v == (double) (buffer * 10^decimal_exponent).
|
||||
|
// The digits in the buffer are the shortest representation possible: no
|
||||
|
// 0.099999999999 instead of 0.1.
|
||||
|
// The last digit will be closest to the actual v. That is, even if several
|
||||
|
// digits might correctly yield 'v' when read again, the closest will be
|
||||
|
// computed.
|
||||
|
static bool grisu3(double v, |
||||
|
char* buffer, int* length, int* decimal_exponent); |
||||
|
|
||||
|
private: |
||||
|
// Rounds the buffer according to the rest.
|
||||
|
// If there is too much imprecision to round then false is returned.
|
||||
|
// Similarily false is returned when the buffer is not within Delta.
|
||||
|
static bool RoundWeed(char* buffer, int len, uint64_t wp_W, uint64_t Delta, |
||||
|
uint64_t rest, uint64_t ten_kappa, uint64_t ulp); |
||||
|
// Dispatches to the a specialized digit-generation routine. The chosen
|
||||
|
// routine depends on w.e (which in turn depends on alpha and gamma).
|
||||
|
// Currently there is only one digit-generation routine, but it would be easy
|
||||
|
// to add others.
|
||||
|
static bool DigitGen(DiyFp low, DiyFp w, DiyFp high, |
||||
|
char* buffer, int* len, int* kappa); |
||||
|
// Generates w's digits. The result is the shortest in the interval low-high.
|
||||
|
// All DiyFp are assumed to be imprecise and this function takes this
|
||||
|
// imprecision into account. If the function cannot compute the best
|
||||
|
// representation (due to the imprecision) then false is returned.
|
||||
|
static bool DigitGen_m60_m32(DiyFp low, DiyFp w, DiyFp high, |
||||
|
char* buffer, int* length, int* kappa); |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
template<int alpha, int gamma> |
||||
|
bool Grisu3<alpha, gamma>::grisu3(double v, |
||||
|
char* buffer, |
||||
|
int* length, |
||||
|
int* decimal_exponent) { |
||||
|
DiyFp w = Double(v).AsNormalizedDiyFp(); |
||||
|
// boundary_minus and boundary_plus are the boundaries between v and its
|
||||
|
// neighbors. Any number strictly between boundary_minus and boundary_plus
|
||||
|
// will round to v when read as double.
|
||||
|
// Grisu3 will never output representations that lie exactly on a boundary.
|
||||
|
DiyFp boundary_minus, boundary_plus; |
||||
|
Double(v).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
||||
|
ASSERT(boundary_plus.e() == w.e()); |
||||
|
DiyFp ten_mk; // Cached power of ten: 10^-k
|
||||
|
int mk; // -k
|
||||
|
GetCachedPower(w.e() + DiyFp::kSignificandSize, alpha, gamma, &mk, &ten_mk); |
||||
|
ASSERT(alpha <= w.e() + ten_mk.e() + DiyFp::kSignificandSize && |
||||
|
gamma >= w.e() + ten_mk.e() + DiyFp::kSignificandSize); |
||||
|
// Note that ten_mk is only an approximation of 10^-k. A DiyFp only contains a
|
||||
|
// 64 bit significand and ten_mk is thus only precise up to 64 bits.
|
||||
|
|
||||
|
// The DiyFp::Times procedure rounds its result, and ten_mk is approximated
|
||||
|
// too. The variable scaled_w (as well as scaled_boundary_minus/plus) are now
|
||||
|
// off by a small amount.
|
||||
|
// In fact: scaled_w - w*10^k < 1ulp (unit in the last place) of scaled_w.
|
||||
|
// In other words: let f = scaled_w.f() and e = scaled_w.e(), then
|
||||
|
// (f-1) * 2^e < w*10^k < (f+1) * 2^e
|
||||
|
DiyFp scaled_w = DiyFp::Times(w, ten_mk); |
||||
|
ASSERT(scaled_w.e() == |
||||
|
boundary_plus.e() + ten_mk.e() + DiyFp::kSignificandSize); |
||||
|
// In theory it would be possible to avoid some recomputations by computing
|
||||
|
// the difference between w and boundary_minus/plus (a power of 2) and to
|
||||
|
// compute scaled_boundary_minus/plus by subtracting/adding from
|
||||
|
// scaled_w. However the code becomes much less readable and the speed
|
||||
|
// enhancements are not terriffic.
|
||||
|
DiyFp scaled_boundary_minus = DiyFp::Times(boundary_minus, ten_mk); |
||||
|
DiyFp scaled_boundary_plus = DiyFp::Times(boundary_plus, ten_mk); |
||||
|
|
||||
|
// DigitGen will generate the digits of scaled_w. Therefore we have
|
||||
|
// v == (double) (scaled_w * 10^-mk).
|
||||
|
// Set decimal_exponent == -mk and pass it to DigitGen. If scaled_w is not an
|
||||
|
// integer than it will be updated. For instance if scaled_w == 1.23 then
|
||||
|
// the buffer will be filled with "123" und the decimal_exponent will be
|
||||
|
// decreased by 2.
|
||||
|
int kappa; |
||||
|
bool result = DigitGen(scaled_boundary_minus, scaled_w, scaled_boundary_plus, |
||||
|
buffer, length, &kappa); |
||||
|
*decimal_exponent = -mk + kappa; |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
// Generates the digits of input number w.
|
||||
|
// w is a floating-point number (DiyFp), consisting of a significand and an
|
||||
|
// exponent. Its exponent is bounded by alpha and gamma. Typically alpha >= -63
|
||||
|
// and gamma <= 3.
|
||||
|
// Returns false if it fails, in which case the generated digits in the buffer
|
||||
|
// should not be used.
|
||||
|
// Preconditions:
|
||||
|
// * low, w and high are correct up to 1 ulp (unit in the last place). That
|
||||
|
// is, their error must be less that a unit of their last digits.
|
||||
|
// * low.e() == w.e() == high.e()
|
||||
|
// * low < w < high, and taking into account their error: low~ <= high~
|
||||
|
// * alpha <= w.e() <= gamma
|
||||
|
// Postconditions: returns false if procedure fails.
|
||||
|
// otherwise:
|
||||
|
// * buffer is not null-terminated, but len contains the number of digits.
|
||||
|
// * buffer contains the shortest possible decimal digit-sequence
|
||||
|
// such that LOW < buffer * 10^kappa < HIGH, where LOW and HIGH are the
|
||||
|
// correct values of low and high (without their error).
|
||||
|
// * if more than one decimal representation gives the minimal number of
|
||||
|
// decimal digits then the one closest to W (where W is the correct value
|
||||
|
// of w) is chosen.
|
||||
|
// Remark: this procedure takes into account the imprecision of its input
|
||||
|
// numbers. If the precision is not enough to guarantee all the postconditions
|
||||
|
// then false is returned. This usually happens rarely (~0.5%).
|
||||
|
template<int alpha, int gamma> |
||||
|
bool Grisu3<alpha, gamma>::DigitGen(DiyFp low, |
||||
|
DiyFp w, |
||||
|
DiyFp high, |
||||
|
char* buffer, |
||||
|
int* len, |
||||
|
int* kappa) { |
||||
|
ASSERT(low.e() == w.e() && w.e() == high.e()); |
||||
|
ASSERT(low.f() + 1 <= high.f() - 1); |
||||
|
ASSERT(alpha <= w.e() && w.e() <= gamma); |
||||
|
// The following tests use alpha and gamma to avoid unnecessary dynamic tests.
|
||||
|
if ((alpha >= -60 && gamma <= -32) || // -60 <= w.e() <= -32
|
||||
|
(alpha <= -32 && gamma >= -60 && // Alpha/gamma overlaps -60/-32 region.
|
||||
|
-60 <= w.e() && w.e() <= -32)) { |
||||
|
return DigitGen_m60_m32(low, w, high, buffer, len, kappa); |
||||
|
} else { |
||||
|
// A simple adaption of the special case -60/-32 would allow greater ranges
|
||||
|
// of alpha/gamma and thus reduce the number of precomputed cached powers of
|
||||
|
// ten.
|
||||
|
UNIMPLEMENTED(); |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
static const uint32_t kTen4 = 10000; |
||||
|
static const uint32_t kTen5 = 100000; |
||||
|
static const uint32_t kTen6 = 1000000; |
||||
|
static const uint32_t kTen7 = 10000000; |
||||
|
static const uint32_t kTen8 = 100000000; |
||||
|
static const uint32_t kTen9 = 1000000000; |
||||
|
|
||||
|
// Returns the biggest power of ten that is <= than the given number. We
|
||||
|
// furthermore receive the maximum number of bits 'number' has.
|
||||
|
// If number_bits == 0 then 0^-1 is returned
|
||||
|
// The number of bits must be <= 32.
|
||||
|
static void BiggestPowerTen(uint32_t number, |
||||
|
int number_bits, |
||||
|
uint32_t* power, |
||||
|
int* exponent) { |
||||
|
switch (number_bits) { |
||||
|
case 32: |
||||
|
case 31: |
||||
|
case 30: |
||||
|
if (kTen9 <= number) { |
||||
|
*power = kTen9; |
||||
|
*exponent = 9; |
||||
|
break; |
||||
|
} // else fallthrough
|
||||
|
case 29: |
||||
|
case 28: |
||||
|
case 27: |
||||
|
if (kTen8 <= number) { |
||||
|
*power = kTen8; |
||||
|
*exponent = 8; |
||||
|
break; |
||||
|
} // else fallthrough
|
||||
|
case 26: |
||||
|
case 25: |
||||
|
case 24: |
||||
|
if (kTen7 <= number) { |
||||
|
*power = kTen7; |
||||
|
*exponent = 7; |
||||
|
break; |
||||
|
} // else fallthrough
|
||||
|
case 23: |
||||
|
case 22: |
||||
|
case 21: |
||||
|
case 20: |
||||
|
if (kTen6 <= number) { |
||||
|
*power = kTen6; |
||||
|
*exponent = 6; |
||||
|
break; |
||||
|
} // else fallthrough
|
||||
|
case 19: |
||||
|
case 18: |
||||
|
case 17: |
||||
|
if (kTen5 <= number) { |
||||
|
*power = kTen5; |
||||
|
*exponent = 5; |
||||
|
break; |
||||
|
} // else fallthrough
|
||||
|
case 16: |
||||
|
case 15: |
||||
|
case 14: |
||||
|
if (kTen4 <= number) { |
||||
|
*power = kTen4; |
||||
|
*exponent = 4; |
||||
|
break; |
||||
|
} // else fallthrough
|
||||
|
case 13: |
||||
|
case 12: |
||||
|
case 11: |
||||
|
case 10: |
||||
|
if (1000 <= number) { |
||||
|
*power = 1000; |
||||
|
*exponent = 3; |
||||
|
break; |
||||
|
} // else fallthrough
|
||||
|
case 9: |
||||
|
case 8: |
||||
|
case 7: |
||||
|
if (100 <= number) { |
||||
|
*power = 100; |
||||
|
*exponent = 2; |
||||
|
break; |
||||
|
} // else fallthrough
|
||||
|
case 6: |
||||
|
case 5: |
||||
|
case 4: |
||||
|
if (10 <= number) { |
||||
|
*power = 10; |
||||
|
*exponent = 1; |
||||
|
break; |
||||
|
} // else fallthrough
|
||||
|
case 3: |
||||
|
case 2: |
||||
|
case 1: |
||||
|
if (1 <= number) { |
||||
|
*power = 1; |
||||
|
*exponent = 0; |
||||
|
break; |
||||
|
} // else fallthrough
|
||||
|
case 0: |
||||
|
*power = 0; |
||||
|
*exponent = -1; |
||||
|
break; |
||||
|
default: |
||||
|
// Following assignments are here to silence compiler warnings.
|
||||
|
*power = 0; |
||||
|
*exponent = 0; |
||||
|
UNREACHABLE(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// Same comments as for DigitGen but with additional precondition:
|
||||
|
// -60 <= w.e() <= -32
|
||||
|
//
|
||||
|
// Say, for the sake of example, that
|
||||
|
// w.e() == -48, and w.f() == 0x1234567890abcdef
|
||||
|
// w's value can be computed by w.f() * 2^w.e()
|
||||
|
// We can obtain w's integral digits by simply shifting w.f() by -w.e().
|
||||
|
// -> w's integral part is 0x1234
|
||||
|
// w's fractional part is therefore 0x567890abcdef.
|
||||
|
// Printing w's integral part is easy (simply print 0x1234 in decimal).
|
||||
|
// In order to print its fraction we repeatedly multiply the fraction by 10 and
|
||||
|
// get each digit. Example the first digit after the comma would be computed by
|
||||
|
// (0x567890abcdef * 10) >> 48. -> 3
|
||||
|
// The whole thing becomes slightly more complicated because we want to stop
|
||||
|
// once we have enough digits. That is, once the digits inside the buffer
|
||||
|
// represent 'w' we can stop. Everything inside the interval low - high
|
||||
|
// represents w. However we have to pay attention to low, high and w's
|
||||
|
// imprecision.
|
||||
|
template<int alpha, int gamma> |
||||
|
bool Grisu3<alpha, gamma>::DigitGen_m60_m32(DiyFp low, |
||||
|
DiyFp w, |
||||
|
DiyFp high, |
||||
|
char* buffer, |
||||
|
int* length, |
||||
|
int* kappa) { |
||||
|
// low, w and high are imprecise, but by less than one ulp (unit in the last
|
||||
|
// place).
|
||||
|
// If we remove (resp. add) 1 ulp from low (resp. high) we are certain that
|
||||
|
// the new numbers are outside of the interval we want the final
|
||||
|
// representation to lie in.
|
||||
|
// Inversely adding (resp. removing) 1 ulp from low (resp. high) would yield
|
||||
|
// numbers that are certain to lie in the interval. We will use this fact
|
||||
|
// later on.
|
||||
|
// We will now start by generating the digits within the uncertain
|
||||
|
// interval. Later we will weed out representations that lie outside the safe
|
||||
|
// interval and thus _might_ lie outside the correct interval.
|
||||
|
uint64_t unit = 1; |
||||
|
DiyFp too_low = DiyFp(low.f() - unit, low.e()); |
||||
|
DiyFp too_high = DiyFp(high.f() + unit, high.e()); |
||||
|
// too_low and too_high are guaranteed to lie outside the interval we want the
|
||||
|
// generated number in.
|
||||
|
DiyFp unsafe_interval = DiyFp::Minus(too_high, too_low); |
||||
|
// We now cut the input number into two parts: the integral digits and the
|
||||
|
// fractionals. We will not write any decimal separator though, but adapt
|
||||
|
// kappa instead.
|
||||
|
// Reminder: we are currently computing the digits (stored inside the buffer)
|
||||
|
// such that: too_low < buffer * 10^kappa < too_high
|
||||
|
// We use too_high for the digit_generation and stop as soon as possible.
|
||||
|
// If we stop early we effectively round down.
|
||||
|
DiyFp one = DiyFp(static_cast<uint64_t>(1) << -w.e(), w.e()); |
||||
|
// Division by one is a shift.
|
||||
|
uint32_t integrals = static_cast<uint32_t>(too_high.f() >> -one.e()); |
||||
|
// Modulo by one is an and.
|
||||
|
uint64_t fractionals = too_high.f() & (one.f() - 1); |
||||
|
uint32_t divider; |
||||
|
int divider_exponent; |
||||
|
BiggestPowerTen(integrals, DiyFp::kSignificandSize - (-one.e()), |
||||
|
÷r, ÷r_exponent); |
||||
|
*kappa = divider_exponent + 1; |
||||
|
*length = 0; |
||||
|
// Loop invariant: buffer = too_high / 10^kappa (integer division)
|
||||
|
// The invariant holds for the first iteration: kappa has been initialized
|
||||
|
// with the divider exponent + 1. And the divider is the biggest power of ten
|
||||
|
// that is smaller than integrals.
|
||||
|
while (*kappa > 0) { |
||||
|
int digit = integrals / divider; |
||||
|
buffer[*length] = '0' + digit; |
||||
|
(*length)++; |
||||
|
integrals %= divider; |
||||
|
(*kappa)--; |
||||
|
// Note that kappa now equals the exponent of the divider and that the
|
||||
|
// invariant thus holds again.
|
||||
|
uint64_t rest = |
||||
|
(static_cast<uint64_t>(integrals) << -one.e()) + fractionals; |
||||
|
// Invariant: too_high = buffer * 10^kappa + DiyFp(rest, one.e())
|
||||
|
// Reminder: unsafe_interval.e() == one.e()
|
||||
|
if (rest < unsafe_interval.f()) { |
||||
|
// Rounding down (by not emitting the remaining digits) yields a number
|
||||
|
// that lies within the unsafe interval.
|
||||
|
return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f(), |
||||
|
unsafe_interval.f(), rest, |
||||
|
static_cast<uint64_t>(divider) << -one.e(), unit); |
||||
|
} |
||||
|
divider /= 10; |
||||
|
} |
||||
|
|
||||
|
// The integrals have been generated. We are at the point of the decimal
|
||||
|
// separator. In the following loop we simply multiply the remaining digits by
|
||||
|
// 10 and divide by one. We just need to pay attention to multiply associated
|
||||
|
// data (like the interval or 'unit'), too.
|
||||
|
// Instead of multiplying by 10 we multiply by 5 (cheaper operation) and
|
||||
|
// increase its (imaginary) exponent. At the same time we decrease the
|
||||
|
// divider's (one's) exponent and shift its significand.
|
||||
|
// Basically, if fractionals was a DiyFp (with fractionals.e == one.e):
|
||||
|
// fractionals.f *= 10;
|
||||
|
// fractionals.f >>= 1; fractionals.e++; // value remains unchanged.
|
||||
|
// one.f >>= 1; one.e++; // value remains unchanged.
|
||||
|
// and we have again fractionals.e == one.e which allows us to divide
|
||||
|
// fractionals.f() by one.f()
|
||||
|
// We simply combine the *= 10 and the >>= 1.
|
||||
|
while (true) { |
||||
|
fractionals *= 5; |
||||
|
unit *= 5; |
||||
|
unsafe_interval.set_f(unsafe_interval.f() * 5); |
||||
|
unsafe_interval.set_e(unsafe_interval.e() + 1); // Will be optimized out.
|
||||
|
one.set_f(one.f() >> 1); |
||||
|
one.set_e(one.e() + 1); |
||||
|
// Integer division by one.
|
||||
|
int digit = static_cast<int>(fractionals >> -one.e()); |
||||
|
buffer[*length] = '0' + digit; |
||||
|
(*length)++; |
||||
|
fractionals &= one.f() - 1; // Modulo by one.
|
||||
|
(*kappa)--; |
||||
|
if (fractionals < unsafe_interval.f()) { |
||||
|
return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f() * unit, |
||||
|
unsafe_interval.f(), fractionals, one.f(), unit); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
// Rounds the given generated digits in the buffer and weeds out generated
|
||||
|
// digits that are not in the safe interval, or where we cannot find a rounded
|
||||
|
// representation.
|
||||
|
// Input: * buffer containing the digits of too_high / 10^kappa
|
||||
|
// * the buffer's length
|
||||
|
// * distance_too_high_w == (too_high - w).f() * unit
|
||||
|
// * unsafe_interval == (too_high - too_low).f() * unit
|
||||
|
// * rest = (too_high - buffer * 10^kappa).f() * unit
|
||||
|
// * ten_kappa = 10^kappa * unit
|
||||
|
// * unit = the common multiplier
|
||||
|
// Output: returns true on success.
|
||||
|
// Modifies the generated digits in the buffer to approach (round towards) w.
|
||||
|
template<int alpha, int gamma> |
||||
|
bool Grisu3<alpha, gamma>::RoundWeed(char* buffer, |
||||
|
int length, |
||||
|
uint64_t distance_too_high_w, |
||||
|
uint64_t unsafe_interval, |
||||
|
uint64_t rest, |
||||
|
uint64_t ten_kappa, |
||||
|
uint64_t unit) { |
||||
|
uint64_t small_distance = distance_too_high_w - unit; |
||||
|
uint64_t big_distance = distance_too_high_w + unit; |
||||
|
// Let w- = too_high - big_distance, and
|
||||
|
// w+ = too_high - small_distance.
|
||||
|
// Note: w- < w < w+
|
||||
|
//
|
||||
|
// The real w (* unit) must lie somewhere inside the interval
|
||||
|
// ]w-; w+[ (often written as "(w-; w+)")
|
||||
|
|
||||
|
// Basically the buffer currently contains a number in the unsafe interval
|
||||
|
// ]too_low; too_high[ with too_low < w < too_high
|
||||
|
//
|
||||
|
// By generating the digits of too_high we got the biggest last digit.
|
||||
|
// In the case that w+ < buffer < too_high we try to decrement the buffer.
|
||||
|
// This way the buffer approaches (rounds towards) w.
|
||||
|
// There are 3 conditions that stop the decrementation process:
|
||||
|
// 1) the buffer is already below w+
|
||||
|
// 2) decrementing the buffer would make it leave the unsafe interval
|
||||
|
// 3) decrementing the buffer would yield a number below w+ and farther away
|
||||
|
// than the current number. In other words:
|
||||
|
// (buffer{-1} < w+) && w+ - buffer{-1} > buffer - w+
|
||||
|
// Instead of using the buffer directly we use its distance to too_high.
|
||||
|
// Conceptually rest ~= too_high - buffer
|
||||
|
while (rest < small_distance && // Negated condition 1
|
||||
|
unsafe_interval - rest >= ten_kappa && // Negated condition 2
|
||||
|
(rest + ten_kappa < small_distance || // buffer{-1} > w+
|
||||
|
small_distance - rest >= rest + ten_kappa - small_distance)) { |
||||
|
buffer[length - 1]--; |
||||
|
rest += ten_kappa; |
||||
|
} |
||||
|
|
||||
|
// We have approached w+ as much as possible. We now test if approaching w-
|
||||
|
// would require changing the buffer. If yes, then we have two possible
|
||||
|
// representations close to w, but we cannot decide which one is closer.
|
||||
|
if (rest < big_distance && |
||||
|
unsafe_interval - rest >= ten_kappa && |
||||
|
(rest + ten_kappa < big_distance || |
||||
|
big_distance - rest > rest + ten_kappa - big_distance)) { |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// Weeding test.
|
||||
|
// The safe interval is [too_low + 2 ulp; too_high - 2 ulp]
|
||||
|
// Since too_low = too_high - unsafe_interval this is equivalent too
|
||||
|
// [too_high - unsafe_interval + 4 ulp; too_high - 2 ulp]
|
||||
|
// Conceptually we have: rest ~= too_high - buffer
|
||||
|
return (2 * unit <= rest) && (rest <= unsafe_interval - 4 * unit); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
bool grisu3(double v, char* buffer, int* sign, int* length, int* point) { |
||||
|
ASSERT(v != 0); |
||||
|
ASSERT(!Double(v).IsSpecial()); |
||||
|
|
||||
|
if (v < 0) { |
||||
|
v = -v; |
||||
|
*sign = 1; |
||||
|
} else { |
||||
|
*sign = 0; |
||||
|
} |
||||
|
int decimal_exponent; |
||||
|
bool result = Grisu3<-60, -32>::grisu3(v, buffer, length, &decimal_exponent); |
||||
|
*point = *length + decimal_exponent; |
||||
|
buffer[*length] = '\0'; |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
@ -0,0 +1,55 @@ |
|||||
|
// Copyright 2010 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_GRISU3_H_ |
||||
|
#define V8_GRISU3_H_ |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
// Grisu3 will produce at most kGrisu3MaximalLength digits. This does not
|
||||
|
// include the terminating '\0' character.
|
||||
|
static const int kGrisu3MaximalLength = 17; |
||||
|
|
||||
|
// Provides a decimal representation of v.
|
||||
|
// v must satisfy v != 0 and it must not be Infinity or NaN.
|
||||
|
// Returns true if it succeeds, otherwise the result can not be trusted.
|
||||
|
// There will be *length digits inside the buffer followed by a null terminator.
|
||||
|
// If the function returns true then
|
||||
|
// v == (double) (buffer * 10^(decimal-point - length)).
|
||||
|
// The digits in the buffer are the shortest representation possible: no
|
||||
|
// 0.099999999999 instead of 0.1.
|
||||
|
// The last digit will be closest to the actual v. That is, even if several
|
||||
|
// digits might correctly yield 'v' when read again, the buffer will contain the
|
||||
|
// one closest to v.
|
||||
|
// The variable 'sign' will be '0' if the given number is positive, and '1'
|
||||
|
// otherwise.
|
||||
|
bool grisu3(double d, char* buffer, int* sign, int* length, int* decimal_point); |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // V8_GRISU3_H_
|
||||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,44 @@ |
|||||
|
// Copyright 2006-2008 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 GAY_SHORTEST_H_ |
||||
|
#define GAY_SHORTEST_H_ |
||||
|
|
||||
|
namespace v8 { |
||||
|
namespace internal { |
||||
|
|
||||
|
struct GayShortest { |
||||
|
double v; |
||||
|
const char* representation; |
||||
|
int decimal_point; |
||||
|
}; |
||||
|
|
||||
|
Vector<const GayShortest> PrecomputedShortestRepresentations(); |
||||
|
|
||||
|
} } // namespace v8::internal
|
||||
|
|
||||
|
#endif // GAY_SHORTEST_H_
|
||||
@ -0,0 +1,67 @@ |
|||||
|
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
||||
|
|
||||
|
#include <stdlib.h> |
||||
|
|
||||
|
#include "v8.h" |
||||
|
|
||||
|
#include "platform.h" |
||||
|
#include "cctest.h" |
||||
|
#include "diy_fp.h" |
||||
|
|
||||
|
|
||||
|
using namespace v8::internal; |
||||
|
|
||||
|
|
||||
|
TEST(Subtract) { |
||||
|
DiyFp diy_fp1 = DiyFp(3, 0); |
||||
|
DiyFp diy_fp2 = DiyFp(1, 0); |
||||
|
DiyFp diff = DiyFp::Minus(diy_fp1, diy_fp2); |
||||
|
|
||||
|
CHECK(2 == diff.f()); // NOLINT
|
||||
|
CHECK_EQ(0, diff.e()); |
||||
|
diy_fp1.Subtract(diy_fp2); |
||||
|
CHECK(2 == diy_fp1.f()); // NOLINT
|
||||
|
CHECK_EQ(0, diy_fp1.e()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(Multiply) { |
||||
|
DiyFp diy_fp1 = DiyFp(3, 0); |
||||
|
DiyFp diy_fp2 = DiyFp(2, 0); |
||||
|
DiyFp product = DiyFp::Times(diy_fp1, diy_fp2); |
||||
|
|
||||
|
CHECK(0 == product.f()); // NOLINT
|
||||
|
CHECK_EQ(64, product.e()); |
||||
|
diy_fp1.Multiply(diy_fp2); |
||||
|
CHECK(0 == diy_fp1.f()); // NOLINT
|
||||
|
CHECK_EQ(64, diy_fp1.e()); |
||||
|
|
||||
|
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x80000000, 00000000), 11); |
||||
|
diy_fp2 = DiyFp(2, 13); |
||||
|
product = DiyFp::Times(diy_fp1, diy_fp2); |
||||
|
CHECK(1 == product.f()); // NOLINT
|
||||
|
CHECK_EQ(11 + 13 + 64, product.e()); |
||||
|
|
||||
|
// Test rounding.
|
||||
|
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x80000000, 00000001), 11); |
||||
|
diy_fp2 = DiyFp(1, 13); |
||||
|
product = DiyFp::Times(diy_fp1, diy_fp2); |
||||
|
CHECK(1 == product.f()); // NOLINT
|
||||
|
CHECK_EQ(11 + 13 + 64, product.e()); |
||||
|
|
||||
|
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0x7fffffff, ffffffff), 11); |
||||
|
diy_fp2 = DiyFp(1, 13); |
||||
|
product = DiyFp::Times(diy_fp1, diy_fp2); |
||||
|
CHECK(0 == product.f()); // NOLINT
|
||||
|
CHECK_EQ(11 + 13 + 64, product.e()); |
||||
|
|
||||
|
// Halfway cases are allowed to round either way. So don't check for it.
|
||||
|
|
||||
|
// Big numbers.
|
||||
|
diy_fp1 = DiyFp(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF), 11); |
||||
|
diy_fp2 = DiyFp(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF), 13); |
||||
|
// 128bit result: 0xfffffffffffffffe0000000000000001
|
||||
|
product = DiyFp::Times(diy_fp1, diy_fp2); |
||||
|
CHECK(V8_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFe) == product.f()); |
||||
|
CHECK_EQ(11 + 13 + 64, product.e()); |
||||
|
} |
||||
@ -0,0 +1,204 @@ |
|||||
|
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
||||
|
|
||||
|
#include <stdlib.h> |
||||
|
|
||||
|
#include "v8.h" |
||||
|
|
||||
|
#include "platform.h" |
||||
|
#include "cctest.h" |
||||
|
#include "diy_fp.h" |
||||
|
#include "double.h" |
||||
|
|
||||
|
|
||||
|
using namespace v8::internal; |
||||
|
|
||||
|
|
||||
|
TEST(Uint64Conversions) { |
||||
|
// Start by checking the byte-order.
|
||||
|
uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF); |
||||
|
CHECK_EQ(3512700564088504e-318, Double(ordered).value()); |
||||
|
|
||||
|
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
||||
|
CHECK_EQ(5e-324, Double(min_double64).value()); |
||||
|
|
||||
|
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
||||
|
CHECK_EQ(1.7976931348623157e308, Double(max_double64).value()); |
||||
|
} |
||||
|
|
||||
|
TEST(AsDiyFp) { |
||||
|
uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF); |
||||
|
DiyFp diy_fp = Double(ordered).AsDiyFp(); |
||||
|
CHECK_EQ(0x12 - 0x3FF - 52, diy_fp.e()); |
||||
|
// The 52 mantissa bits, plus the implicit 1 in bit 52 as a UINT64.
|
||||
|
CHECK(V8_2PART_UINT64_C(0x00134567, 89ABCDEF) == diy_fp.f()); // NOLINT
|
||||
|
|
||||
|
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
||||
|
diy_fp = Double(min_double64).AsDiyFp(); |
||||
|
CHECK_EQ(-0x3FF - 52 + 1, diy_fp.e()); |
||||
|
// This is a denormal; so no hidden bit.
|
||||
|
CHECK(1 == diy_fp.f()); // NOLINT
|
||||
|
|
||||
|
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
||||
|
diy_fp = Double(max_double64).AsDiyFp(); |
||||
|
CHECK_EQ(0x7FE - 0x3FF - 52, diy_fp.e()); |
||||
|
CHECK(V8_2PART_UINT64_C(0x001fffff, ffffffff) == diy_fp.f()); // NOLINT
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(AsNormalizedDiyFp) { |
||||
|
uint64_t ordered = V8_2PART_UINT64_C(0x01234567, 89ABCDEF); |
||||
|
DiyFp diy_fp = Double(ordered).AsNormalizedDiyFp(); |
||||
|
CHECK_EQ(0x12 - 0x3FF - 52 - 11, diy_fp.e()); |
||||
|
CHECK((V8_2PART_UINT64_C(0x00134567, 89ABCDEF) << 11) == |
||||
|
diy_fp.f()); // NOLINT
|
||||
|
|
||||
|
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
||||
|
diy_fp = Double(min_double64).AsNormalizedDiyFp(); |
||||
|
CHECK_EQ(-0x3FF - 52 + 1 - 63, diy_fp.e()); |
||||
|
// This is a denormal; so no hidden bit.
|
||||
|
CHECK(V8_2PART_UINT64_C(0x80000000, 00000000) == diy_fp.f()); // NOLINT
|
||||
|
|
||||
|
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
||||
|
diy_fp = Double(max_double64).AsNormalizedDiyFp(); |
||||
|
CHECK_EQ(0x7FE - 0x3FF - 52 - 11, diy_fp.e()); |
||||
|
CHECK((V8_2PART_UINT64_C(0x001fffff, ffffffff) << 11) == |
||||
|
diy_fp.f()); // NOLINT
|
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(IsDenormal) { |
||||
|
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
||||
|
CHECK(Double(min_double64).IsDenormal()); |
||||
|
uint64_t bits = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
||||
|
CHECK(Double(bits).IsDenormal()); |
||||
|
bits = V8_2PART_UINT64_C(0x00100000, 00000000); |
||||
|
CHECK(!Double(bits).IsDenormal()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(IsSpecial) { |
||||
|
CHECK(Double(V8_INFINITY).IsSpecial()); |
||||
|
CHECK(Double(-V8_INFINITY).IsSpecial()); |
||||
|
CHECK(Double(OS::nan_value()).IsSpecial()); |
||||
|
uint64_t bits = V8_2PART_UINT64_C(0xFFF12345, 00000000); |
||||
|
CHECK(Double(bits).IsSpecial()); |
||||
|
// Denormals are not special:
|
||||
|
CHECK(!Double(5e-324).IsSpecial()); |
||||
|
CHECK(!Double(-5e-324).IsSpecial()); |
||||
|
// And some random numbers:
|
||||
|
CHECK(!Double(0.0).IsSpecial()); |
||||
|
CHECK(!Double(-0.0).IsSpecial()); |
||||
|
CHECK(!Double(1.0).IsSpecial()); |
||||
|
CHECK(!Double(-1.0).IsSpecial()); |
||||
|
CHECK(!Double(1000000.0).IsSpecial()); |
||||
|
CHECK(!Double(-1000000.0).IsSpecial()); |
||||
|
CHECK(!Double(1e23).IsSpecial()); |
||||
|
CHECK(!Double(-1e23).IsSpecial()); |
||||
|
CHECK(!Double(1.7976931348623157e308).IsSpecial()); |
||||
|
CHECK(!Double(-1.7976931348623157e308).IsSpecial()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(IsInfinite) { |
||||
|
CHECK(Double(V8_INFINITY).IsInfinite()); |
||||
|
CHECK(Double(-V8_INFINITY).IsInfinite()); |
||||
|
CHECK(!Double(OS::nan_value()).IsInfinite()); |
||||
|
CHECK(!Double(0.0).IsInfinite()); |
||||
|
CHECK(!Double(-0.0).IsInfinite()); |
||||
|
CHECK(!Double(1.0).IsInfinite()); |
||||
|
CHECK(!Double(-1.0).IsInfinite()); |
||||
|
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
||||
|
CHECK(!Double(min_double64).IsInfinite()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(IsNan) { |
||||
|
CHECK(Double(OS::nan_value()).IsNan()); |
||||
|
uint64_t other_nan = V8_2PART_UINT64_C(0xFFFFFFFF, 00000001); |
||||
|
CHECK(Double(other_nan).IsNan()); |
||||
|
CHECK(!Double(V8_INFINITY).IsNan()); |
||||
|
CHECK(!Double(-V8_INFINITY).IsNan()); |
||||
|
CHECK(!Double(0.0).IsNan()); |
||||
|
CHECK(!Double(-0.0).IsNan()); |
||||
|
CHECK(!Double(1.0).IsNan()); |
||||
|
CHECK(!Double(-1.0).IsNan()); |
||||
|
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
||||
|
CHECK(!Double(min_double64).IsNan()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(Sign) { |
||||
|
CHECK_EQ(1, Double(1.0).Sign()); |
||||
|
CHECK_EQ(1, Double(V8_INFINITY).Sign()); |
||||
|
CHECK_EQ(-1, Double(-V8_INFINITY).Sign()); |
||||
|
CHECK_EQ(1, Double(0.0).Sign()); |
||||
|
CHECK_EQ(-1, Double(-0.0).Sign()); |
||||
|
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
||||
|
CHECK_EQ(1, Double(min_double64).Sign()); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(NormalizedBoundaries) { |
||||
|
DiyFp boundary_plus; |
||||
|
DiyFp boundary_minus; |
||||
|
DiyFp diy_fp = Double(1.5).AsNormalizedDiyFp(); |
||||
|
Double(1.5).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
||||
|
// 1.5 does not have a significand of the form 2^p (for some p).
|
||||
|
// Therefore its boundaries are at the same distance.
|
||||
|
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
||||
|
CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
||||
|
|
||||
|
diy_fp = Double(1.0).AsNormalizedDiyFp(); |
||||
|
Double(1.0).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
||||
|
// 1.0 does have a significand of the form 2^p (for some p).
|
||||
|
// Therefore its lower boundary is twice as close as the upper boundary.
|
||||
|
CHECK_GT(boundary_plus.f() - diy_fp.f(), diy_fp.f() - boundary_minus.f()); |
||||
|
CHECK((1 << 9) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
||||
|
CHECK((1 << 10) == boundary_plus.f() - diy_fp.f()); // NOLINT
|
||||
|
|
||||
|
uint64_t min_double64 = V8_2PART_UINT64_C(0x00000000, 00000001); |
||||
|
diy_fp = Double(min_double64).AsNormalizedDiyFp(); |
||||
|
Double(min_double64).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
||||
|
// min-value does not have a significand of the form 2^p (for some p).
|
||||
|
// Therefore its boundaries are at the same distance.
|
||||
|
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
||||
|
// Denormals have their boundaries much closer.
|
||||
|
CHECK((static_cast<uint64_t>(1) << 62) == |
||||
|
diy_fp.f() - boundary_minus.f()); // NOLINT
|
||||
|
|
||||
|
uint64_t smallest_normal64 = V8_2PART_UINT64_C(0x00100000, 00000000); |
||||
|
diy_fp = Double(smallest_normal64).AsNormalizedDiyFp(); |
||||
|
Double(smallest_normal64).NormalizedBoundaries(&boundary_minus, |
||||
|
&boundary_plus); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
||||
|
// Even though the significand is of the form 2^p (for some p), its boundaries
|
||||
|
// are at the same distance. (This is the only exception).
|
||||
|
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
||||
|
CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
||||
|
|
||||
|
uint64_t largest_denormal64 = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
||||
|
diy_fp = Double(largest_denormal64).AsNormalizedDiyFp(); |
||||
|
Double(largest_denormal64).NormalizedBoundaries(&boundary_minus, |
||||
|
&boundary_plus); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
||||
|
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
||||
|
CHECK((1 << 11) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
||||
|
|
||||
|
uint64_t max_double64 = V8_2PART_UINT64_C(0x7fefffff, ffffffff); |
||||
|
diy_fp = Double(max_double64).AsNormalizedDiyFp(); |
||||
|
Double(max_double64).NormalizedBoundaries(&boundary_minus, &boundary_plus); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_minus.e()); |
||||
|
CHECK_EQ(diy_fp.e(), boundary_plus.e()); |
||||
|
// max-value does not have a significand of the form 2^p (for some p).
|
||||
|
// Therefore its boundaries are at the same distance.
|
||||
|
CHECK(diy_fp.f() - boundary_minus.f() == boundary_plus.f() - diy_fp.f()); |
||||
|
CHECK((1 << 10) == diy_fp.f() - boundary_minus.f()); // NOLINT
|
||||
|
} |
||||
@ -0,0 +1,116 @@ |
|||||
|
// Copyright 2006-2008 the V8 project authors. All rights reserved.
|
||||
|
|
||||
|
#include <stdlib.h> |
||||
|
|
||||
|
#include "v8.h" |
||||
|
|
||||
|
#include "platform.h" |
||||
|
#include "cctest.h" |
||||
|
#include "diy_fp.h" |
||||
|
#include "double.h" |
||||
|
#include "gay_shortest.h" |
||||
|
#include "grisu3.h" |
||||
|
|
||||
|
using namespace v8::internal; |
||||
|
|
||||
|
static const int kBufferSize = 100; |
||||
|
|
||||
|
TEST(GrisuVariousDoubles) { |
||||
|
char buffer[kBufferSize]; |
||||
|
int sign; |
||||
|
int length; |
||||
|
int point; |
||||
|
int status; |
||||
|
|
||||
|
double min_double = 5e-324; |
||||
|
status = grisu3(min_double, buffer, &sign, &length, &point); |
||||
|
CHECK(status); |
||||
|
CHECK_EQ(0, sign); |
||||
|
CHECK_EQ("5", buffer); |
||||
|
CHECK_EQ(-323, point); |
||||
|
|
||||
|
double max_double = 1.7976931348623157e308; |
||||
|
status = grisu3(max_double, buffer, &sign, &length, &point); |
||||
|
CHECK(status); |
||||
|
CHECK_EQ(0, sign); |
||||
|
CHECK_EQ("17976931348623157", buffer); |
||||
|
CHECK_EQ(309, point); |
||||
|
|
||||
|
status = grisu3(4294967272.0, buffer, &sign, &length, &point); |
||||
|
CHECK(status); |
||||
|
CHECK_EQ(0, sign); |
||||
|
CHECK_EQ("4294967272", buffer); |
||||
|
CHECK_EQ(10, point); |
||||
|
|
||||
|
status = grisu3(4.1855804968213567e298, buffer, &sign, &length, &point); |
||||
|
CHECK(status); |
||||
|
CHECK_EQ(0, sign); |
||||
|
CHECK_EQ("4185580496821357", buffer); |
||||
|
CHECK_EQ(299, point); |
||||
|
|
||||
|
status = grisu3(5.5626846462680035e-309, buffer, &sign, &length, &point); |
||||
|
CHECK(status); |
||||
|
CHECK_EQ(0, sign); |
||||
|
CHECK_EQ("5562684646268003", buffer); |
||||
|
CHECK_EQ(-308, point); |
||||
|
|
||||
|
status = grisu3(2147483648.0, buffer, &sign, &length, &point); |
||||
|
CHECK(status); |
||||
|
CHECK_EQ(0, sign); |
||||
|
CHECK_EQ("2147483648", buffer); |
||||
|
CHECK_EQ(10, point); |
||||
|
|
||||
|
status = grisu3(3.5844466002796428e+298, buffer, &sign, &length, &point); |
||||
|
if (status) { // Not all grisu3 variants manage to compute this number.
|
||||
|
CHECK_EQ("35844466002796428", buffer); |
||||
|
CHECK_EQ(0, sign); |
||||
|
CHECK_EQ(299, point); |
||||
|
} |
||||
|
|
||||
|
uint64_t smallest_normal64 = V8_2PART_UINT64_C(0x00100000, 00000000); |
||||
|
double v = Double(smallest_normal64).value(); |
||||
|
status = grisu3(v, buffer, &sign, &length, &point); |
||||
|
if (status) { |
||||
|
CHECK_EQ(0, sign); |
||||
|
CHECK_EQ("22250738585072014", buffer); |
||||
|
CHECK_EQ(-307, point); |
||||
|
} |
||||
|
|
||||
|
uint64_t largest_denormal64 = V8_2PART_UINT64_C(0x000FFFFF, FFFFFFFF); |
||||
|
v = Double(largest_denormal64).value(); |
||||
|
status = grisu3(v, buffer, &sign, &length, &point); |
||||
|
if (status) { |
||||
|
CHECK_EQ(0, sign); |
||||
|
CHECK_EQ("2225073858507201", buffer); |
||||
|
CHECK_EQ(-307, point); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
TEST(GrisuGayShortest) { |
||||
|
char buffer[kBufferSize]; |
||||
|
bool status; |
||||
|
int sign; |
||||
|
int length; |
||||
|
int point; |
||||
|
int succeeded = 0; |
||||
|
int total = 0; |
||||
|
bool needed_max_length = false; |
||||
|
|
||||
|
Vector<const GayShortest> precomputed = PrecomputedShortestRepresentations(); |
||||
|
for (int i = 0; i < precomputed.length(); ++i) { |
||||
|
const GayShortest current_test = precomputed[i]; |
||||
|
total++; |
||||
|
double v = current_test.v; |
||||
|
status = grisu3(v, buffer, &sign, &length, &point); |
||||
|
CHECK_GE(kGrisu3MaximalLength, length); |
||||
|
if (!status) continue; |
||||
|
if (length == kGrisu3MaximalLength) needed_max_length = true; |
||||
|
succeeded++; |
||||
|
CHECK_EQ(0, sign); // All precomputed numbers are positive.
|
||||
|
CHECK_EQ(current_test.decimal_point, point); |
||||
|
CHECK_EQ(current_test.representation, buffer); |
||||
|
} |
||||
|
CHECK_GT(succeeded*1.0/total, 0.99); |
||||
|
CHECK(needed_max_length); |
||||
|
} |
||||
@ -0,0 +1,48 @@ |
|||||
|
// Copyright 2010 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.
|
||||
|
|
||||
|
// Test Math.sin and Math.abs.
|
||||
|
|
||||
|
assertEquals(1, Math.abs(1)); // Positive SMI.
|
||||
|
assertEquals(1, Math.abs(-1)); // Negative SMI.
|
||||
|
assertEquals(0.5, Math.abs(0.5)); // Positive double.
|
||||
|
assertEquals(0.5, Math.abs(-0.5)); // Negative double.
|
||||
|
assertEquals('Infinity', Math.abs(Number('+Infinity').toString())); |
||||
|
assertEquals('Infinity', Math.abs(Number('-Infinity').toString())); |
||||
|
assertEquals('NaN', Math.abs(NaN).toString()); |
||||
|
assertEquals('NaN', Math.abs(-NaN).toString()); |
||||
|
|
||||
|
var minusZero = 1 / (-1 / 0); |
||||
|
function isMinusZero(x) { |
||||
|
return x === 0 && 1 / x < 0; |
||||
|
} |
||||
|
|
||||
|
assertTrue(!isMinusZero(0)); |
||||
|
assertTrue(isMinusZero(minusZero)); |
||||
|
assertEquals(0, Math.abs(minusZero)); |
||||
|
assertTrue(!isMinusZero(Math.abs(minusZero))); |
||||
|
assertTrue(!isMinusZero(Math.abs(0.0))); |
||||
@ -0,0 +1,61 @@ |
|||||
|
// Copyright 2010 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.
|
||||
|
|
||||
|
// Check pops with various number of arguments.
|
||||
|
(function() { |
||||
|
var a = []; |
||||
|
for (var i = 0; i < 7; i++) { |
||||
|
a = [7, 6, 5, 4, 3, 2, 1]; |
||||
|
|
||||
|
assertEquals(1, a.pop(), "1st pop"); |
||||
|
assertEquals(6, a.length, "length 1st pop"); |
||||
|
|
||||
|
assertEquals(2, a.pop(1), "2nd pop"); |
||||
|
assertEquals(5, a.length, "length 2nd pop"); |
||||
|
|
||||
|
assertEquals(3, a.pop(1, 2), "3rd pop"); |
||||
|
assertEquals(4, a.length, "length 3rd pop"); |
||||
|
|
||||
|
assertEquals(4, a.pop(1, 2, 3), "4th pop"); |
||||
|
assertEquals(3, a.length, "length 4th pop"); |
||||
|
|
||||
|
assertEquals(5, a.pop(), "5th pop"); |
||||
|
assertEquals(2, a.length, "length 5th pop"); |
||||
|
|
||||
|
assertEquals(6, a.pop(), "6th pop"); |
||||
|
assertEquals(1, a.length, "length 6th pop"); |
||||
|
|
||||
|
assertEquals(7, a.pop(), "7th pop"); |
||||
|
assertEquals(0, a.length, "length 7th pop"); |
||||
|
|
||||
|
assertEquals(undefined, a.pop(), "8th pop"); |
||||
|
assertEquals(0, a.length, "length 8th pop"); |
||||
|
|
||||
|
assertEquals(undefined, a.pop(1, 2, 3), "9th pop"); |
||||
|
assertEquals(0, a.length, "length 9th pop"); |
||||
|
} |
||||
|
})(); |
||||
@ -0,0 +1,68 @@ |
|||||
|
// Copyright 2010 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.
|
||||
|
|
||||
|
// Check pushes with various number of arguments.
|
||||
|
(function() { |
||||
|
var a = []; |
||||
|
for (var i = 0; i < 7; i++) { |
||||
|
a = []; |
||||
|
|
||||
|
assertEquals(0, a.push()); |
||||
|
assertEquals([], a, "after .push()"); |
||||
|
|
||||
|
assertEquals(1, a.push(1), "length after .push(1)"); |
||||
|
assertEquals([1], a, "after .push(1)"); |
||||
|
|
||||
|
assertEquals(3, a.push(2, 3), "length after .push(2, 3)"); |
||||
|
assertEquals([1, 2, 3], a, "after .push(2, 3)"); |
||||
|
|
||||
|
assertEquals(6, a.push(4, 5, 6), |
||||
|
"length after .push(4, 5, 6)"); |
||||
|
assertEquals([1, 2, 3, 4, 5, 6], a, |
||||
|
"after .push(4, 5, 5)"); |
||||
|
|
||||
|
assertEquals(10, a.push(7, 8, 9, 10), |
||||
|
"length after .push(7, 8, 9, 10)"); |
||||
|
assertEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], a, |
||||
|
"after .push(7, 8, 9, 10)"); |
||||
|
|
||||
|
assertEquals(15, a.push(11, 12, 13, 14, 15), |
||||
|
"length after .push(11, 12, 13, 14, 15)"); |
||||
|
assertEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], a, |
||||
|
"after .push(11, 12, 13, 14, 15)"); |
||||
|
|
||||
|
assertEquals(21, a.push(16, 17, 18, 19, 20, 21), |
||||
|
"length after .push(16, 17, 18, 19, 20, 21)"); |
||||
|
assertEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21], a, |
||||
|
"after .push(16, 17, 18, 19, 20, 21)"); |
||||
|
|
||||
|
assertEquals(28, a.push(22, 23, 24, 25, 26, 27, 28), |
||||
|
"length hafter .push(22, 23, 24, 25, 26, 27, 28)"); |
||||
|
assertEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], a, |
||||
|
"after .push(22, 23, 24, 25, 26, 27, 28)"); |
||||
|
} |
||||
|
})(); |
||||
@ -0,0 +1,42 @@ |
|||||
|
// Copyright 2008 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.
|
||||
|
|
||||
|
// Test that we don't cache the result of a regexp match across a
|
||||
|
// compile event.
|
||||
|
var re = /x/; |
||||
|
assertEquals("a.yb", "axyb".replace(re, ".")); |
||||
|
|
||||
|
re.compile("y") |
||||
|
assertEquals("ax.b", "axyb".replace(re, ".")); |
||||
|
|
||||
|
re.compile("(x)"); |
||||
|
|
||||
|
assertEquals("x,x", re.exec("axyb")); |
||||
|
|
||||
|
re.compile("(y)"); |
||||
|
|
||||
|
assertEquals("y,y", re.exec("axyb")); |
||||
@ -0,0 +1,35 @@ |
|||||
|
// Copyright 2010 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.
|
||||
|
|
||||
|
// Regression test for http://code.google.com/p/v8/issues/detail?id=641.
|
||||
|
|
||||
|
function f(){ |
||||
|
while (window + 1) { |
||||
|
const window=[,]; |
||||
|
} |
||||
|
} |
||||
|
f() |
||||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue