mirror of https://github.com/lukechilds/node.git
Ryan Dahl
15 years ago
92 changed files with 103888 additions and 860 deletions
@ -0,0 +1,77 @@ |
|||
// 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 <math.h> |
|||
|
|||
#include "v8.h" |
|||
#include "dtoa.h" |
|||
|
|||
#include "double.h" |
|||
#include "fast-dtoa.h" |
|||
#include "fixed-dtoa.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
bool DoubleToAscii(double v, DtoaMode mode, int requested_digits, |
|||
Vector<char> buffer, int* sign, int* length, int* point) { |
|||
ASSERT(!Double(v).IsSpecial()); |
|||
ASSERT(mode == DTOA_SHORTEST || requested_digits >= 0); |
|||
|
|||
if (Double(v).Sign() < 0) { |
|||
*sign = 1; |
|||
v = -v; |
|||
} else { |
|||
*sign = 0; |
|||
} |
|||
|
|||
if (v == 0) { |
|||
buffer[0] = '0'; |
|||
buffer[1] = '\0'; |
|||
*length = 1; |
|||
*point = 1; |
|||
return true; |
|||
} |
|||
|
|||
if (mode == DTOA_PRECISION && requested_digits == 0) { |
|||
buffer[0] = '\0'; |
|||
*length = 0; |
|||
return true; |
|||
} |
|||
|
|||
switch (mode) { |
|||
case DTOA_SHORTEST: |
|||
return FastDtoa(v, buffer, length, point); |
|||
case DTOA_FIXED: |
|||
return FastFixedDtoa(v, requested_digits, buffer, length, point); |
|||
default: |
|||
break; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
} } // namespace v8::internal
|
|||
@ -0,0 +1,81 @@ |
|||
// 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_DTOA_H_ |
|||
#define V8_DTOA_H_ |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
enum DtoaMode { |
|||
// 0.9999999999999999 becomes 0.1
|
|||
DTOA_SHORTEST, |
|||
// Fixed number of digits after the decimal point.
|
|||
// For instance fixed(0.1, 4) becomes 0.1000
|
|||
// If the input number is big, the output will be big.
|
|||
DTOA_FIXED, |
|||
// Fixed number of digits (independent of the decimal point).
|
|||
DTOA_PRECISION |
|||
}; |
|||
|
|||
// The maximal length of digits a double can have in base 10.
|
|||
// Note that DoubleToAscii null-terminates its input. So the given buffer should
|
|||
// be at least kBase10MaximalLength + 1 characters long.
|
|||
static const int kBase10MaximalLength = 17; |
|||
|
|||
// Converts the given double 'v' to ascii.
|
|||
// The result should be interpreted as buffer * 10^(point-length).
|
|||
//
|
|||
// The output depends on the given mode:
|
|||
// - SHORTEST: produce the least amount of digits for which the internal
|
|||
// identity requirement is still satisfied. If the digits are printed
|
|||
// (together with the correct exponent) then reading this number will give
|
|||
// 'v' again. The buffer will choose the representation that is closest to
|
|||
// 'v'. If there are two at the same distance, than the one farther away
|
|||
// from 0 is chosen (halfway cases - ending with 5 - are rounded up).
|
|||
// In this mode the 'requested_digits' parameter is ignored.
|
|||
// - FIXED: produces digits necessary to print a given number with
|
|||
// 'requested_digits' digits after the decimal point. The produced digits
|
|||
// might be too short in which case the caller has to fill the gaps with '0's.
|
|||
// Example: toFixed(0.001, 5) is allowed to return buffer="1", point=-2.
|
|||
// Halfway cases are rounded towards +/-Infinity (away from 0). The call
|
|||
// toFixed(0.15, 2) thus returns buffer="2", point=0.
|
|||
// The returned buffer may contain digits that would be truncated from the
|
|||
// shortest representation of the input.
|
|||
// - PRECISION: produces 'requested_digits' where the first digit is not '0'.
|
|||
// Even though the length of produced digits usually equals
|
|||
// 'requested_digits', the function is allowed to return fewer digits, in
|
|||
// which case the caller has to fill the missing digits with '0's.
|
|||
// Halfway cases are again rounded away from 0.
|
|||
// 'DoubleToAscii' expects the given buffer to be big enough to hold all digits
|
|||
// and a terminating null-character.
|
|||
bool DoubleToAscii(double v, DtoaMode mode, int requested_digits, |
|||
Vector<char> buffer, int* sign, int* length, int* point); |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_DTOA_H_
|
|||
@ -0,0 +1,405 @@ |
|||
// 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 <math.h> |
|||
|
|||
#include "v8.h" |
|||
|
|||
#include "double.h" |
|||
#include "fixed-dtoa.h" |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// Represents a 128bit type. This class should be replaced by a native type on
|
|||
// platforms that support 128bit integers.
|
|||
class UInt128 { |
|||
public: |
|||
UInt128() : high_bits_(0), low_bits_(0) { } |
|||
UInt128(uint64_t high, uint64_t low) : high_bits_(high), low_bits_(low) { } |
|||
|
|||
void Multiply(uint32_t multiplicand) { |
|||
uint64_t accumulator; |
|||
|
|||
accumulator = (low_bits_ & kMask32) * multiplicand; |
|||
uint32_t part = static_cast<uint32_t>(accumulator & kMask32); |
|||
accumulator >>= 32; |
|||
accumulator = accumulator + (low_bits_ >> 32) * multiplicand; |
|||
low_bits_ = (accumulator << 32) + part; |
|||
accumulator >>= 32; |
|||
accumulator = accumulator + (high_bits_ & kMask32) * multiplicand; |
|||
part = static_cast<uint32_t>(accumulator & kMask32); |
|||
accumulator >>= 32; |
|||
accumulator = accumulator + (high_bits_ >> 32) * multiplicand; |
|||
high_bits_ = (accumulator << 32) + part; |
|||
ASSERT((accumulator >> 32) == 0); |
|||
} |
|||
|
|||
void Shift(int shift_amount) { |
|||
ASSERT(-64 <= shift_amount && shift_amount <= 64); |
|||
if (shift_amount == 0) { |
|||
return; |
|||
} else if (shift_amount == -64) { |
|||
high_bits_ = low_bits_; |
|||
low_bits_ = 0; |
|||
} else if (shift_amount == 64) { |
|||
low_bits_ = high_bits_; |
|||
high_bits_ = 0; |
|||
} else if (shift_amount <= 0) { |
|||
high_bits_ <<= -shift_amount; |
|||
high_bits_ += low_bits_ >> (64 + shift_amount); |
|||
low_bits_ <<= -shift_amount; |
|||
} else { |
|||
low_bits_ >>= shift_amount; |
|||
low_bits_ += high_bits_ << (64 - shift_amount); |
|||
high_bits_ >>= shift_amount; |
|||
} |
|||
} |
|||
|
|||
// Modifies *this to *this MOD (2^power).
|
|||
// Returns *this DIV (2^power).
|
|||
int DivModPowerOf2(int power) { |
|||
if (power >= 64) { |
|||
int result = static_cast<int>(high_bits_ >> (power - 64)); |
|||
high_bits_ -= static_cast<uint64_t>(result) << (power - 64); |
|||
return result; |
|||
} else { |
|||
uint64_t part_low = low_bits_ >> power; |
|||
uint64_t part_high = high_bits_ << (64 - power); |
|||
int result = static_cast<int>(part_low + part_high); |
|||
high_bits_ = 0; |
|||
low_bits_ -= part_low << power; |
|||
return result; |
|||
} |
|||
} |
|||
|
|||
bool IsZero() const { |
|||
return high_bits_ == 0 && low_bits_ == 0; |
|||
} |
|||
|
|||
int BitAt(int position) { |
|||
if (position >= 64) { |
|||
return static_cast<int>(high_bits_ >> (position - 64)) & 1; |
|||
} else { |
|||
return static_cast<int>(low_bits_ >> position) & 1; |
|||
} |
|||
} |
|||
|
|||
private: |
|||
static const uint64_t kMask32 = 0xFFFFFFFF; |
|||
// Value == (high_bits_ << 64) + low_bits_
|
|||
uint64_t high_bits_; |
|||
uint64_t low_bits_; |
|||
}; |
|||
|
|||
|
|||
static const int kDoubleSignificandSize = 53; // Includes the hidden bit.
|
|||
|
|||
|
|||
static void FillDigits32FixedLength(uint32_t number, int requested_length, |
|||
Vector<char> buffer, int* length) { |
|||
for (int i = requested_length - 1; i >= 0; --i) { |
|||
buffer[(*length) + i] = '0' + number % 10; |
|||
number /= 10; |
|||
} |
|||
*length += requested_length; |
|||
} |
|||
|
|||
|
|||
static void FillDigits32(uint32_t number, Vector<char> buffer, int* length) { |
|||
int number_length = 0; |
|||
// We fill the digits in reverse order and exchange them afterwards.
|
|||
while (number != 0) { |
|||
int digit = number % 10; |
|||
number /= 10; |
|||
buffer[(*length) + number_length] = '0' + digit; |
|||
number_length++; |
|||
} |
|||
// Exchange the digits.
|
|||
int i = *length; |
|||
int j = *length + number_length - 1; |
|||
while (i < j) { |
|||
char tmp = buffer[i]; |
|||
buffer[i] = buffer[j]; |
|||
buffer[j] = tmp; |
|||
i++; |
|||
j--; |
|||
} |
|||
*length += number_length; |
|||
} |
|||
|
|||
|
|||
static void FillDigits64FixedLength(uint64_t number, int requested_length, |
|||
Vector<char> buffer, int* length) { |
|||
const uint32_t kTen7 = 10000000; |
|||
// For efficiency cut the number into 3 uint32_t parts, and print those.
|
|||
uint32_t part2 = static_cast<uint32_t>(number % kTen7); |
|||
number /= kTen7; |
|||
uint32_t part1 = static_cast<uint32_t>(number % kTen7); |
|||
uint32_t part0 = static_cast<uint32_t>(number / kTen7); |
|||
|
|||
FillDigits32FixedLength(part0, 3, buffer, length); |
|||
FillDigits32FixedLength(part1, 7, buffer, length); |
|||
FillDigits32FixedLength(part2, 7, buffer, length); |
|||
} |
|||
|
|||
|
|||
static void FillDigits64(uint64_t number, Vector<char> buffer, int* length) { |
|||
const uint32_t kTen7 = 10000000; |
|||
// For efficiency cut the number into 3 uint32_t parts, and print those.
|
|||
uint32_t part2 = static_cast<uint32_t>(number % kTen7); |
|||
number /= kTen7; |
|||
uint32_t part1 = static_cast<uint32_t>(number % kTen7); |
|||
uint32_t part0 = static_cast<uint32_t>(number / kTen7); |
|||
|
|||
if (part0 != 0) { |
|||
FillDigits32(part0, buffer, length); |
|||
FillDigits32FixedLength(part1, 7, buffer, length); |
|||
FillDigits32FixedLength(part2, 7, buffer, length); |
|||
} else if (part1 != 0) { |
|||
FillDigits32(part1, buffer, length); |
|||
FillDigits32FixedLength(part2, 7, buffer, length); |
|||
} else { |
|||
FillDigits32(part2, buffer, length); |
|||
} |
|||
} |
|||
|
|||
|
|||
static void RoundUp(Vector<char> buffer, int* length, int* decimal_point) { |
|||
// An empty buffer represents 0.
|
|||
if (*length == 0) { |
|||
buffer[0] = '1'; |
|||
*decimal_point = 1; |
|||
*length = 1; |
|||
return; |
|||
} |
|||
// Round the last digit until we either have a digit that was not '9' or until
|
|||
// we reached the first digit.
|
|||
buffer[(*length) - 1]++; |
|||
for (int i = (*length) - 1; i > 0; --i) { |
|||
if (buffer[i] != '0' + 10) { |
|||
return; |
|||
} |
|||
buffer[i] = '0'; |
|||
buffer[i - 1]++; |
|||
} |
|||
// If the first digit is now '0' + 10, we would need to set it to '0' and add
|
|||
// a '1' in front. However we reach the first digit only if all following
|
|||
// digits had been '9' before rounding up. Now all trailing digits are '0' and
|
|||
// we simply switch the first digit to '1' and update the decimal-point
|
|||
// (indicating that the point is now one digit to the right).
|
|||
if (buffer[0] == '0' + 10) { |
|||
buffer[0] = '1'; |
|||
(*decimal_point)++; |
|||
} |
|||
} |
|||
|
|||
|
|||
// The given fractionals number represents a fixed-point number with binary
|
|||
// point at bit (-exponent).
|
|||
// Preconditions:
|
|||
// -128 <= exponent <= 0.
|
|||
// 0 <= fractionals * 2^exponent < 1
|
|||
// The buffer holds the result.
|
|||
// The function will round its result. During the rounding-process digits not
|
|||
// generated by this function might be updated, and the decimal-point variable
|
|||
// might be updated. If this function generates the digits 99 and the buffer
|
|||
// already contained "199" (thus yielding a buffer of "19999") then a
|
|||
// rounding-up will change the contents of the buffer to "20000".
|
|||
static void FillFractionals(uint64_t fractionals, int exponent, |
|||
int fractional_count, Vector<char> buffer, |
|||
int* length, int* decimal_point) { |
|||
ASSERT(-128 <= exponent && exponent <= 0); |
|||
// 'fractionals' is a fixed-point number, with binary point at bit
|
|||
// (-exponent). Inside the function the non-converted remainder of fractionals
|
|||
// is a fixed-point number, with binary point at bit 'point'.
|
|||
if (-exponent <= 64) { |
|||
// One 64 bit number is sufficient.
|
|||
ASSERT(fractionals >> 56 == 0); |
|||
int point = -exponent; |
|||
for (int i = 0; i < fractional_count; ++i) { |
|||
if (fractionals == 0) break; |
|||
// Instead of multiplying by 10 we multiply by 5 and adjust the point
|
|||
// location. This way the fractionals variable will not overflow.
|
|||
// Invariant at the beginning of the loop: fractionals < 2^point.
|
|||
// Initially we have: point <= 64 and fractionals < 2^56
|
|||
// After each iteration the point is decremented by one.
|
|||
// Note that 5^3 = 125 < 128 = 2^7.
|
|||
// Therefore three iterations of this loop will not overflow fractionals
|
|||
// (even without the subtraction at the end of the loop body). At this
|
|||
// time point will satisfy point <= 61 and therefore fractionals < 2^point
|
|||
// and any further multiplication of fractionals by 5 will not overflow.
|
|||
fractionals *= 5; |
|||
point--; |
|||
int digit = static_cast<int>(fractionals >> point); |
|||
buffer[*length] = '0' + digit; |
|||
(*length)++; |
|||
fractionals -= static_cast<uint64_t>(digit) << point; |
|||
} |
|||
// If the first bit after the point is set we have to round up.
|
|||
if (((fractionals >> (point - 1)) & 1) == 1) { |
|||
RoundUp(buffer, length, decimal_point); |
|||
} |
|||
} else { // We need 128 bits.
|
|||
ASSERT(64 < -exponent && -exponent <= 128); |
|||
UInt128 fractionals128 = UInt128(fractionals, 0); |
|||
fractionals128.Shift(-exponent - 64); |
|||
int point = 128; |
|||
for (int i = 0; i < fractional_count; ++i) { |
|||
if (fractionals128.IsZero()) break; |
|||
// As before: instead of multiplying by 10 we multiply by 5 and adjust the
|
|||
// point location.
|
|||
// This multiplication will not overflow for the same reasons as before.
|
|||
fractionals128.Multiply(5); |
|||
point--; |
|||
int digit = fractionals128.DivModPowerOf2(point); |
|||
buffer[*length] = '0' + digit; |
|||
(*length)++; |
|||
} |
|||
if (fractionals128.BitAt(point - 1) == 1) { |
|||
RoundUp(buffer, length, decimal_point); |
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
// Removes leading and trailing zeros.
|
|||
// If leading zeros are removed then the decimal point position is adjusted.
|
|||
static void TrimZeros(Vector<char> buffer, int* length, int* decimal_point) { |
|||
while (*length > 0 && buffer[(*length) - 1] == '0') { |
|||
(*length)--; |
|||
} |
|||
int first_non_zero = 0; |
|||
while (first_non_zero < *length && buffer[first_non_zero] == '0') { |
|||
first_non_zero++; |
|||
} |
|||
if (first_non_zero != 0) { |
|||
for (int i = first_non_zero; i < *length; ++i) { |
|||
buffer[i - first_non_zero] = buffer[i]; |
|||
} |
|||
*length -= first_non_zero; |
|||
*decimal_point -= first_non_zero; |
|||
} |
|||
} |
|||
|
|||
|
|||
bool FastFixedDtoa(double v, |
|||
int fractional_count, |
|||
Vector<char> buffer, |
|||
int* length, |
|||
int* decimal_point) { |
|||
const uint32_t kMaxUInt32 = 0xFFFFFFFF; |
|||
uint64_t significand = Double(v).Significand(); |
|||
int exponent = Double(v).Exponent(); |
|||
// v = significand * 2^exponent (with significand a 53bit integer).
|
|||
// If the exponent is larger than 20 (i.e. we may have a 73bit number) then we
|
|||
// don't know how to compute the representation. 2^73 ~= 9.5*10^21.
|
|||
// If necessary this limit could probably be increased, but we don't need
|
|||
// more.
|
|||
if (exponent > 20) return false; |
|||
if (fractional_count > 20) return false; |
|||
*length = 0; |
|||
// At most kDoubleSignificandSize bits of the significand are non-zero.
|
|||
// Given a 64 bit integer we have 11 0s followed by 53 potentially non-zero
|
|||
// bits: 0..11*..0xxx..53*..xx
|
|||
if (exponent + kDoubleSignificandSize > 64) { |
|||
// The exponent must be > 11.
|
|||
//
|
|||
// We know that v = significand * 2^exponent.
|
|||
// And the exponent > 11.
|
|||
// We simplify the task by dividing v by 10^17.
|
|||
// The quotient delivers the first digits, and the remainder fits into a 64
|
|||
// bit number.
|
|||
// Dividing by 10^17 is equivalent to dividing by 5^17*2^17.
|
|||
const uint64_t kFive17 = V8_2PART_UINT64_C(0xB1, A2BC2EC5); // 5^17
|
|||
uint64_t divisor = kFive17; |
|||
int divisor_power = 17; |
|||
uint64_t dividend = significand; |
|||
uint32_t quotient; |
|||
uint64_t remainder; |
|||
// Let v = f * 2^e with f == significand and e == exponent.
|
|||
// Then need q (quotient) and r (remainder) as follows:
|
|||
// v = q * 10^17 + r
|
|||
// f * 2^e = q * 10^17 + r
|
|||
// f * 2^e = q * 5^17 * 2^17 + r
|
|||
// If e > 17 then
|
|||
// f * 2^(e-17) = q * 5^17 + r/2^17
|
|||
// else
|
|||
// f = q * 5^17 * 2^(17-e) + r/2^e
|
|||
if (exponent > divisor_power) { |
|||
// We only allow exponents of up to 20 and therefore (17 - e) <= 3
|
|||
dividend <<= exponent - divisor_power; |
|||
quotient = static_cast<uint32_t>(dividend / divisor); |
|||
remainder = (dividend % divisor) << divisor_power; |
|||
} else { |
|||
divisor <<= divisor_power - exponent; |
|||
quotient = static_cast<uint32_t>(dividend / divisor); |
|||
remainder = (dividend % divisor) << exponent; |
|||
} |
|||
FillDigits32(quotient, buffer, length); |
|||
FillDigits64FixedLength(remainder, divisor_power, buffer, length); |
|||
*decimal_point = *length; |
|||
} else if (exponent >= 0) { |
|||
// 0 <= exponent <= 11
|
|||
significand <<= exponent; |
|||
FillDigits64(significand, buffer, length); |
|||
*decimal_point = *length; |
|||
} else if (exponent > -kDoubleSignificandSize) { |
|||
// We have to cut the number.
|
|||
uint64_t integrals = significand >> -exponent; |
|||
uint64_t fractionals = significand - (integrals << -exponent); |
|||
if (integrals > kMaxUInt32) { |
|||
FillDigits64(integrals, buffer, length); |
|||
} else { |
|||
FillDigits32(static_cast<uint32_t>(integrals), buffer, length); |
|||
} |
|||
*decimal_point = *length; |
|||
FillFractionals(fractionals, exponent, fractional_count, |
|||
buffer, length, decimal_point); |
|||
} else if (exponent < -128) { |
|||
// This configuration (with at most 20 digits) means that all digits must be
|
|||
// 0.
|
|||
ASSERT(fractional_count <= 20); |
|||
buffer[0] = '\0'; |
|||
*length = 0; |
|||
*decimal_point = -fractional_count; |
|||
} else { |
|||
*decimal_point = 0; |
|||
FillFractionals(significand, exponent, fractional_count, |
|||
buffer, length, decimal_point); |
|||
} |
|||
TrimZeros(buffer, length, decimal_point); |
|||
buffer[*length] = '\0'; |
|||
if ((*length) == 0) { |
|||
// The string is empty and the decimal_point thus has no importance. Mimick
|
|||
// Gay's dtoa and and set it to -fractional_count.
|
|||
*decimal_point = -fractional_count; |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
} } // 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_FIXED_DTOA_H_ |
|||
#define V8_FIXED_DTOA_H_ |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
// Produces digits necessary to print a given number with
|
|||
// 'fractional_count' digits after the decimal point.
|
|||
// The buffer must be big enough to hold the result plus one terminating null
|
|||
// character.
|
|||
//
|
|||
// The produced digits might be too short in which case the caller has to fill
|
|||
// the gaps with '0's.
|
|||
// Example: FastFixedDtoa(0.001, 5, ...) is allowed to return buffer = "1", and
|
|||
// decimal_point = -2.
|
|||
// Halfway cases are rounded towards +/-Infinity (away from 0). The call
|
|||
// FastFixedDtoa(0.15, 2, ...) thus returns buffer = "2", decimal_point = 0.
|
|||
// The returned buffer may contain digits that would be truncated from the
|
|||
// shortest representation of the input.
|
|||
//
|
|||
// This method only works for some parameters. If it can't handle the input it
|
|||
// returns false. The output is null-terminated when the function succeeds.
|
|||
bool FastFixedDtoa(double v, int fractional_count, |
|||
Vector<char> buffer, int* length, int* decimal_point); |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // V8_FIXED_DTOA_H_
|
|||
File diff suppressed because it is too large
@ -0,0 +1,47 @@ |
|||
// 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_FIXED_H_ |
|||
#define GAY_FIXED_H_ |
|||
|
|||
namespace v8 { |
|||
namespace internal { |
|||
|
|||
struct PrecomputedFixed { |
|||
double v; |
|||
int number_digits; |
|||
const char* representation; |
|||
int decimal_point; |
|||
}; |
|||
|
|||
// Returns precomputed values of dtoa. The strings have been generated using
|
|||
// Gay's dtoa in mode "fixed".
|
|||
Vector<const PrecomputedFixed> PrecomputedFixedRepresentations(); |
|||
|
|||
} } // namespace v8::internal
|
|||
|
|||
#endif // GAY_FIXED_H_
|
|||
@ -0,0 +1,512 @@ |
|||
// 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 <stdlib.h> |
|||
|
|||
#include "v8.h" |
|||
|
|||
#include "platform.h" |
|||
#include "cctest.h" |
|||
#include "double.h" |
|||
#include "fixed-dtoa.h" |
|||
#include "gay-fixed.h" |
|||
|
|||
using namespace v8::internal; |
|||
|
|||
static const int kBufferSize = 500; |
|||
|
|||
TEST(FastFixedVariousDoubles) { |
|||
char buffer_container[kBufferSize]; |
|||
Vector<char> buffer(buffer_container, kBufferSize); |
|||
int length; |
|||
int point; |
|||
|
|||
CHECK(FastFixedDtoa(1.0, 1, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(1.0, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(1.0, 0, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0xFFFFFFFF, 5, buffer, &length, &point)); |
|||
CHECK_EQ("4294967295", buffer.start()); |
|||
CHECK_EQ(10, point); |
|||
|
|||
CHECK(FastFixedDtoa(4294967296.0, 5, buffer, &length, &point)); |
|||
CHECK_EQ("4294967296", buffer.start()); |
|||
CHECK_EQ(10, point); |
|||
|
|||
CHECK(FastFixedDtoa(1e21, 5, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
// CHECK_EQ(22, point);
|
|||
CHECK_EQ(22, point); |
|||
|
|||
CHECK(FastFixedDtoa(999999999999999868928.00, 2, buffer, &length, &point)); |
|||
CHECK_EQ("999999999999999868928", buffer.start()); |
|||
CHECK_EQ(21, point); |
|||
|
|||
CHECK(FastFixedDtoa(6.9999999999999989514240000e+21, 5, buffer, |
|||
&length, &point)); |
|||
CHECK_EQ("6999999999999998951424", buffer.start()); |
|||
CHECK_EQ(22, point); |
|||
|
|||
CHECK(FastFixedDtoa(1.5, 5, buffer, &length, &point)); |
|||
CHECK_EQ("15", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(1.55, 5, buffer, &length, &point)); |
|||
CHECK_EQ("155", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(1.55, 1, buffer, &length, &point)); |
|||
CHECK_EQ("16", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(1.00000001, 15, buffer, &length, &point)); |
|||
CHECK_EQ("100000001", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.1, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(0, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.01, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.001, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-2, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0001, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-3, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00001, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-4, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000001, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-5, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000001, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-6, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000001, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-7, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000001, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-8, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000001, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-9, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000000001, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-10, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000001, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-11, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000000001, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-12, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000000000001, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-13, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000001, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-14, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000000000001, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-15, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000000000000001, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-16, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000000001, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-17, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000000000000001, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-18, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000000000000000001, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-19, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.10000000004, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(0, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.01000000004, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00100000004, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-2, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00010000004, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-3, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00001000004, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-4, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000100004, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-5, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000010004, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-6, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000001004, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-7, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000000104, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-8, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000001000004, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-9, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000000100004, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-10, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000000010004, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-11, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000000001004, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-12, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000000000104, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-13, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000001000004, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-14, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000000100004, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-15, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000000010004, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-16, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000000001004, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-17, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000000000104, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-18, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000000000014, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-19, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.10000000006, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1000000001", buffer.start()); |
|||
CHECK_EQ(0, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.01000000006, 10, buffer, &length, &point)); |
|||
CHECK_EQ("100000001", buffer.start()); |
|||
CHECK_EQ(-1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00100000006, 10, buffer, &length, &point)); |
|||
CHECK_EQ("10000001", buffer.start()); |
|||
CHECK_EQ(-2, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00010000006, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1000001", buffer.start()); |
|||
CHECK_EQ(-3, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00001000006, 10, buffer, &length, &point)); |
|||
CHECK_EQ("100001", buffer.start()); |
|||
CHECK_EQ(-4, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000100006, 10, buffer, &length, &point)); |
|||
CHECK_EQ("10001", buffer.start()); |
|||
CHECK_EQ(-5, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000010006, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1001", buffer.start()); |
|||
CHECK_EQ(-6, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000001006, 10, buffer, &length, &point)); |
|||
CHECK_EQ("101", buffer.start()); |
|||
CHECK_EQ(-7, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000000106, 10, buffer, &length, &point)); |
|||
CHECK_EQ("11", buffer.start()); |
|||
CHECK_EQ(-8, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000001000006, 15, buffer, &length, &point)); |
|||
CHECK_EQ("100001", buffer.start()); |
|||
CHECK_EQ(-9, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000000100006, 15, buffer, &length, &point)); |
|||
CHECK_EQ("10001", buffer.start()); |
|||
CHECK_EQ(-10, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000000010006, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1001", buffer.start()); |
|||
CHECK_EQ(-11, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000000001006, 15, buffer, &length, &point)); |
|||
CHECK_EQ("101", buffer.start()); |
|||
CHECK_EQ(-12, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000000000000106, 15, buffer, &length, &point)); |
|||
CHECK_EQ("11", buffer.start()); |
|||
CHECK_EQ(-13, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000001000006, 20, buffer, &length, &point)); |
|||
CHECK_EQ("100001", buffer.start()); |
|||
CHECK_EQ(-14, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000000100006, 20, buffer, &length, &point)); |
|||
CHECK_EQ("10001", buffer.start()); |
|||
CHECK_EQ(-15, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000000010006, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1001", buffer.start()); |
|||
CHECK_EQ(-16, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000000001006, 20, buffer, &length, &point)); |
|||
CHECK_EQ("101", buffer.start()); |
|||
CHECK_EQ(-17, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000000000106, 20, buffer, &length, &point)); |
|||
CHECK_EQ("11", buffer.start()); |
|||
CHECK_EQ(-18, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000000000000000016, 20, buffer, &length, &point)); |
|||
CHECK_EQ("2", buffer.start()); |
|||
CHECK_EQ(-19, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.6, 0, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.96, 1, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.996, 2, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.9996, 3, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.99996, 4, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.999996, 5, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.9999996, 6, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.99999996, 7, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.999999996, 8, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.9999999996, 9, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.99999999996, 10, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.999999999996, 11, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.9999999999996, 12, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.99999999999996, 13, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.999999999999996, 14, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.9999999999999996, 15, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00999999999999996, 16, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-1, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000999999999999996, 17, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-2, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.0000999999999999996, 18, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-3, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.00000999999999999996, 19, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-4, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.000000999999999999996, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-5, point); |
|||
|
|||
CHECK(FastFixedDtoa(323423.234234, 10, buffer, &length, &point)); |
|||
CHECK_EQ("323423234234", buffer.start()); |
|||
CHECK_EQ(6, point); |
|||
|
|||
CHECK(FastFixedDtoa(12345678.901234, 4, buffer, &length, &point)); |
|||
CHECK_EQ("123456789012", buffer.start()); |
|||
CHECK_EQ(8, point); |
|||
|
|||
CHECK(FastFixedDtoa(98765.432109, 5, buffer, &length, &point)); |
|||
CHECK_EQ("9876543211", buffer.start()); |
|||
CHECK_EQ(5, point); |
|||
|
|||
CHECK(FastFixedDtoa(42, 20, buffer, &length, &point)); |
|||
CHECK_EQ("42", buffer.start()); |
|||
CHECK_EQ(2, point); |
|||
|
|||
CHECK(FastFixedDtoa(0.5, 0, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(1, point); |
|||
|
|||
CHECK(FastFixedDtoa(1e-23, 10, buffer, &length, &point)); |
|||
CHECK_EQ("", buffer.start()); |
|||
CHECK_EQ(-10, point); |
|||
|
|||
CHECK(FastFixedDtoa(1e-123, 2, buffer, &length, &point)); |
|||
CHECK_EQ("", buffer.start()); |
|||
CHECK_EQ(-2, point); |
|||
|
|||
CHECK(FastFixedDtoa(1e-123, 0, buffer, &length, &point)); |
|||
CHECK_EQ("", buffer.start()); |
|||
CHECK_EQ(0, point); |
|||
|
|||
CHECK(FastFixedDtoa(1e-23, 20, buffer, &length, &point)); |
|||
CHECK_EQ("", buffer.start()); |
|||
CHECK_EQ(-20, point); |
|||
|
|||
CHECK(FastFixedDtoa(1e-21, 20, buffer, &length, &point)); |
|||
CHECK_EQ("", buffer.start()); |
|||
CHECK_EQ(-20, point); |
|||
|
|||
CHECK(FastFixedDtoa(1e-22, 20, buffer, &length, &point)); |
|||
CHECK_EQ("", buffer.start()); |
|||
CHECK_EQ(-20, point); |
|||
|
|||
CHECK(FastFixedDtoa(6e-21, 20, buffer, &length, &point)); |
|||
CHECK_EQ("1", buffer.start()); |
|||
CHECK_EQ(-19, point); |
|||
|
|||
CHECK(FastFixedDtoa(9.1193616301674545152000000e+19, 0, |
|||
buffer, &length, &point)); |
|||
CHECK_EQ("91193616301674545152", buffer.start()); |
|||
CHECK_EQ(20, point); |
|||
|
|||
CHECK(FastFixedDtoa(4.8184662102767651659096515e-04, 19, |
|||
buffer, &length, &point)); |
|||
CHECK_EQ("4818466210276765", buffer.start()); |
|||
CHECK_EQ(-3, point); |
|||
|
|||
CHECK(FastFixedDtoa(1.9023164229540652612705182e-23, 8, |
|||
buffer, &length, &point)); |
|||
CHECK_EQ("", buffer.start()); |
|||
CHECK_EQ(-8, point); |
|||
|
|||
CHECK(FastFixedDtoa(1000000000000000128.0, 0, |
|||
buffer, &length, &point)); |
|||
CHECK_EQ("1000000000000000128", buffer.start()); |
|||
CHECK_EQ(19, point); |
|||
} |
|||
|
|||
|
|||
TEST(FastFixedDtoaGayFixed) { |
|||
char buffer_container[kBufferSize]; |
|||
Vector<char> buffer(buffer_container, kBufferSize); |
|||
bool status; |
|||
int length; |
|||
int point; |
|||
|
|||
Vector<const PrecomputedFixed> precomputed = |
|||
PrecomputedFixedRepresentations(); |
|||
for (int i = 0; i < precomputed.length(); ++i) { |
|||
const PrecomputedFixed current_test = precomputed[i]; |
|||
double v = current_test.v; |
|||
int number_digits = current_test.number_digits; |
|||
status = FastFixedDtoa(v, number_digits, |
|||
buffer, &length, &point); |
|||
CHECK(status); |
|||
CHECK_EQ(current_test.decimal_point, point); |
|||
CHECK_GE(number_digits, length - point); |
|||
CHECK_EQ(current_test.representation, buffer.start()); |
|||
} |
|||
} |
|||
@ -0,0 +1,329 @@ |
|||
// 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.
|
|||
|
|||
var except = "exception"; |
|||
|
|||
var correct_answer_index = 0; |
|||
var correct_answers = [ |
|||
false, false, true, true, false, false, true, true, |
|||
true, false, false, true, true, false, false, true, |
|||
false, true, true, false, false, true, true, false, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, false, true, |
|||
except, except, true, false, except, except, true, false, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, false, false, except, except, |
|||
true, false, except, except, true, false, except, except, |
|||
false, true, except, except, false, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, false, false, true, true, |
|||
true, false, false, true, false, false, true, true, |
|||
false, true, true, false, false, true, true, false, |
|||
true, true, false, false, false, true, true, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, true, false, |
|||
except, except, false, false, except, except, true, false, |
|||
false, false, except, except, false, false, except, except, |
|||
true, false, except, except, true, false, except, except, |
|||
false, true, except, except, false, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, false, true, true, false, |
|||
true, false, false, true, true, true, false, false, |
|||
false, true, true, false, false, true, true, false, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, false, true, |
|||
except, except, true, false, except, except, true, false, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, false, true, except, except, |
|||
true, false, except, except, true, true, except, except, |
|||
false, true, except, except, false, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, false, true, true, false, |
|||
true, false, false, true, false, true, true, false, |
|||
false, true, true, false, false, true, true, false, |
|||
true, true, false, false, false, true, true, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, true, false, |
|||
except, except, false, false, except, except, true, false, |
|||
false, false, except, except, false, true, except, except, |
|||
true, false, except, except, true, true, except, except, |
|||
false, true, except, except, false, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, false, false, true, true, |
|||
true, false, false, true, false, false, true, true, |
|||
false, true, true, false, true, true, false, false, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, false, false, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, false, false, except, except, |
|||
true, false, except, except, false, false, except, except, |
|||
false, true, except, except, true, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, false, false, true, true, |
|||
true, false, false, true, false, false, true, true, |
|||
false, true, true, false, true, true, false, false, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, false, false, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, false, false, except, except, |
|||
true, false, except, except, false, false, except, except, |
|||
false, true, except, except, true, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, true, true, false, false, |
|||
true, false, false, true, true, true, false, false, |
|||
false, true, true, false, true, true, false, false, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, false, false, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, true, true, except, except, |
|||
true, false, except, except, true, true, except, except, |
|||
false, true, except, except, true, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, true, true, false, false, |
|||
true, false, false, true, true, true, false, false, |
|||
false, true, true, false, true, true, false, false, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, false, false, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, true, true, except, except, |
|||
true, false, except, except, true, true, except, except, |
|||
false, true, except, except, true, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, false, false, true, true, |
|||
true, false, false, true, true, true, false, false, |
|||
false, true, true, false, false, false, true, true, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, false, false, |
|||
except, except, true, false, except, except, true, true, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, false, false, except, except, |
|||
true, false, except, except, true, true, except, except, |
|||
false, true, except, except, false, false, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, false, false, true, true, |
|||
true, false, false, true, false, false, true, true, |
|||
false, true, true, false, false, false, true, true, |
|||
true, true, false, false, false, false, true, true, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, true, true, |
|||
except, except, false, false, except, except, true, true, |
|||
false, false, except, except, false, false, except, except, |
|||
true, false, except, except, true, true, except, except, |
|||
false, true, except, except, false, false, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, false, false, true, true, |
|||
true, false, false, true, true, true, false, false, |
|||
false, true, true, false, false, false, true, true, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, false, false, |
|||
except, except, true, false, except, except, true, true, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, false, false, except, except, |
|||
true, false, except, except, true, true, except, except, |
|||
false, true, except, except, false, false, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, false, false, true, true, |
|||
true, false, false, true, false, false, true, true, |
|||
false, true, true, false, false, false, true, true, |
|||
true, true, false, false, false, false, true, true, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, true, true, |
|||
except, except, false, false, except, except, true, true, |
|||
false, false, except, except, false, false, except, except, |
|||
true, false, except, except, true, true, except, except, |
|||
false, true, except, except, false, false, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, false, false, true, true, |
|||
true, false, false, true, false, false, true, true, |
|||
false, true, true, false, true, true, false, false, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, false, false, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, false, false, except, except, |
|||
true, false, except, except, false, false, except, except, |
|||
false, true, except, except, true, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, false, false, true, true, |
|||
true, false, false, true, false, false, true, true, |
|||
false, true, true, false, true, true, false, false, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, false, false, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, false, false, except, except, |
|||
true, false, except, except, false, false, except, except, |
|||
false, true, except, except, true, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, true, true, false, false, |
|||
true, false, false, true, true, true, false, false, |
|||
false, true, true, false, true, true, false, false, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, false, false, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, true, true, except, except, |
|||
true, false, except, except, true, true, except, except, |
|||
false, true, except, except, true, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
false, false, true, true, true, true, false, false, |
|||
true, false, false, true, true, true, false, false, |
|||
false, true, true, false, true, true, false, false, |
|||
true, true, false, false, true, true, false, false, |
|||
except, except, true, true, except, except, true, true, |
|||
except, except, false, true, except, except, true, true, |
|||
except, except, true, false, except, except, false, false, |
|||
except, except, false, false, except, except, false, false, |
|||
false, false, except, except, true, true, except, except, |
|||
true, false, except, except, true, true, except, except, |
|||
false, true, except, except, true, true, except, except, |
|||
true, true, except, except, true, true, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except, |
|||
except, except, except, except, except, except, except, except]; |
|||
|
|||
for (var i = 0; i < 256; i++) { |
|||
Test(i & 1, i & 2, i & 4, i & 8, i & 0x10, i & 0x20, i & 0x40, i & 0x80); |
|||
} |
|||
|
|||
|
|||
function InstanceTest(x, func) { |
|||
try { |
|||
var answer = (x instanceof func); |
|||
assertEquals(correct_answers[correct_answer_index], answer); |
|||
} catch (e) { |
|||
assertTrue(/prototype/.test(e)); |
|||
assertEquals(correct_answers[correct_answer_index], except); |
|||
} |
|||
correct_answer_index++; |
|||
} |
|||
|
|||
|
|||
function Test(a, b, c, d, e, f, g, h) { |
|||
var Foo = function() { } |
|||
var Bar = function() { } |
|||
|
|||
if (c) Foo.prototype = 12; |
|||
if (d) Bar.prototype = 13; |
|||
var x = a ? new Foo() : new Bar(); |
|||
var y = b ? new Foo() : new Bar(); |
|||
InstanceTest(x, Foo); |
|||
InstanceTest(y, Foo); |
|||
InstanceTest(x, Bar); |
|||
InstanceTest(y, Bar); |
|||
if (e) x.__proto__ = Bar.prototype; |
|||
if (f) y.__proto__ = Foo.prototype; |
|||
if (g) { |
|||
x.__proto__ = y; |
|||
} else { |
|||
if (h) y.__proto__ = x |
|||
} |
|||
InstanceTest(x, Foo); |
|||
InstanceTest(y, Foo); |
|||
InstanceTest(x, Bar); |
|||
InstanceTest(y, Bar); |
|||
} |
|||
@ -0,0 +1,36 @@ |
|||
// 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.
|
|||
|
|||
// See: http://code.google.com/p/v8/issues/detail?id=696
|
|||
// Because of the change in dateparser in revision 4557 to support time
|
|||
// only strings in Date.parse we also misleadingly supported strings with non
|
|||
// leading numbers.
|
|||
|
|||
assertTrue(isNaN(Date.parse('x'))); |
|||
assertTrue(isNaN(Date.parse('1x'))); |
|||
assertTrue(isNaN(Date.parse('xT10:00:00'))); |
|||
assertTrue(isNaN(Date.parse('This is a relatively long string'))); |
|||
@ -0,0 +1,34 @@ |
|||
// 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.
|
|||
|
|||
// See: http://code.google.com/p/v8/issues/detail?id=697
|
|||
|
|||
try { |
|||
Object.create(function(){}); |
|||
} catch (e) { |
|||
assertTrue(false); |
|||
} |
|||
Loading…
Reference in new issue