Retire legacy dtoa function and DecimalNumber class
authordarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 3 Mar 2019 20:43:01 +0000 (20:43 +0000)
committerdarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 3 Mar 2019 20:43:01 +0000 (20:43 +0000)
https://bugs.webkit.org/show_bug.cgi?id=195253

Reviewed by Daniel Bates.

LayoutTests/imported/w3c:

* web-platform-tests/web-animations/animation-model/keyframe-effects/effect-value-iteration-composite-operation-expected.txt:
Rebaseline still-failing part of this test that dumps super-small numbers that are formatted
differently by the new code (exponential style).

Source/JavaScriptCore:

* runtime/NumberPrototype.cpp:
(JSC::numberProtoFuncToExponential): Removed dependency on NumberToStringBufferLength,
using NumberToStringBuffer instead. Also tweaked style of implementation a bit.

Source/WebCore:

* css/CSSPrimitiveValue.cpp:
(WebCore::CSSPrimitiveValue::formatNumberValue const): Use makeString instead
of DecimalNumber. Also changed return type to String and use StringView and
removed special handling of literals.
(WebCore::CSSPrimitiveValue::formatNumberForCustomCSSText const): Removed an
unnecessary use of StringBuilder.

* css/CSSPrimitiveValue.h: Updated for changes to formatNumberValue.

Source/WTF:

* WTF.xcodeproj/project.pbxproj: Removed DecimalNumber.cpp/h.
* wtf/CMakeLists.txt: Ditto.

* wtf/DecimalNumber.cpp: Removed.
* wtf/DecimalNumber.h: Removed.

* wtf/JSONValues.cpp:
(WTF::JSONImpl::Value::writeJSON const): Use
StringBuilder::appendECMAScriptNumber instead of custom logic
using the DecimalNumber class.

* wtf/dtoa.cpp:
(WTF::storeInc): Deleted.
(WTF::BigInt): Deleted.
(WTF::multadd): Deleted.
(WTF::hi0bits): Deleted.
(WTF::lo0bits): Deleted.
(WTF::i2b): Deleted.
(WTF::mult): Deleted.
(WTF::P5Node::P5Node): Deleted.
(WTF::pow5mult): Deleted.
(WTF::lshift): Deleted.
(WTF::cmp): Deleted.
(WTF::diff): Deleted.
(WTF::d2b): Deleted.
(WTF::quorem): Deleted.
(WTF::dtoa): Deleted.

* wtf/dtoa.h: Removed DtoaBuffer, dtoa, and NumberToStringBufferLength.

LayoutTests:

* fast/css/large-value-csstext-expected.txt:
* media/modern-media-controls/macos-inline-media-controls/macos-inline-media-controls-volume-styles-expected.txt:
* media/modern-media-controls/macos-inline-media-controls/macos-inline-media-controls-volume-styles.html:
Updated expected value to expect exponential syntax for super-small numbers that are formatted
differently by the new code.

* platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
* platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
* platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/interpolation-per-property-expected.txt:
* platform/mac/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
* platform/mac/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
* platform/mac/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/interpolation-per-property-expected.txt:
Rebaseline still-failing parts of these tests that dump super-small numbers that are formatted
differently by the new code. Still probably needs to be done for 4 other platforms.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@242330 268f45cc-cd09-0410-ab3c-d52691b4dbfc

25 files changed:
LayoutTests/ChangeLog
LayoutTests/fast/css/large-value-csstext-expected.txt
LayoutTests/imported/w3c/ChangeLog
LayoutTests/imported/w3c/web-platform-tests/web-animations/animation-model/keyframe-effects/effect-value-iteration-composite-operation-expected.txt
LayoutTests/media/modern-media-controls/macos-inline-media-controls/macos-inline-media-controls-volume-styles-expected.txt
LayoutTests/media/modern-media-controls/macos-inline-media-controls/macos-inline-media-controls-volume-styles.html
LayoutTests/platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt
LayoutTests/platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt
LayoutTests/platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/interpolation-per-property-expected.txt
LayoutTests/platform/mac/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt
LayoutTests/platform/mac/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt
LayoutTests/platform/mac/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/interpolation-per-property-expected.txt
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/runtime/NumberPrototype.cpp
Source/WTF/ChangeLog
Source/WTF/WTF.xcodeproj/project.pbxproj
Source/WTF/wtf/CMakeLists.txt
Source/WTF/wtf/DecimalNumber.cpp [deleted file]
Source/WTF/wtf/DecimalNumber.h [deleted file]
Source/WTF/wtf/JSONValues.cpp
Source/WTF/wtf/dtoa.cpp
Source/WTF/wtf/dtoa.h
Source/WebCore/ChangeLog
Source/WebCore/css/CSSPrimitiveValue.cpp
Source/WebCore/css/CSSPrimitiveValue.h

index 0d1eef3..bb582f9 100644 (file)
@@ -1,3 +1,25 @@
+2019-03-02  Darin Adler  <darin@apple.com>
+
+        Retire legacy dtoa function and DecimalNumber class
+        https://bugs.webkit.org/show_bug.cgi?id=195253
+
+        Reviewed by Daniel Bates.
+
+        * fast/css/large-value-csstext-expected.txt:
+        * media/modern-media-controls/macos-inline-media-controls/macos-inline-media-controls-volume-styles-expected.txt:
+        * media/modern-media-controls/macos-inline-media-controls/macos-inline-media-controls-volume-styles.html:
+        Updated expected value to expect exponential syntax for super-small numbers that are formatted
+        differently by the new code.
+
+        * platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
+        * platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
+        * platform/ios/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/interpolation-per-property-expected.txt:
+        * platform/mac/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/accumulation-per-property-expected.txt:
+        * platform/mac/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/addition-per-property-expected.txt:
+        * platform/mac/imported/w3c/web-platform-tests/web-animations/animation-model/animation-types/interpolation-per-property-expected.txt:
+        Rebaseline still-failing parts of these tests that dump super-small numbers that are formatted
+        differently by the new code. Still probably needs to be done for 4 other platforms.
+
 2019-03-03  Tim Horton  <timothy_horton@apple.com>
 
         Remove some more unused 32-bit code
index 23daf14..63f49f6 100644 (file)
@@ -1,4 +1,4 @@
 This test should not crash.
 
-100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000%
-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009%
+1e+254%
+9e-249%
index 594bc9f..801d98e 100644 (file)
@@ -1,3 +1,14 @@
+2019-03-02  Darin Adler  <darin@apple.com>
+
+        Retire legacy dtoa function and DecimalNumber class
+        https://bugs.webkit.org/show_bug.cgi?id=195253
+
+        Reviewed by Daniel Bates.
+
+        * web-platform-tests/web-animations/animation-model/keyframe-effects/effect-value-iteration-composite-operation-expected.txt:
+        Rebaseline still-failing part of this test that dumps super-small numbers that are formatted
+        differently by the new code (exponential style).
+
 2019-03-01  Rob Buis  <rbuis@igalia.com>
 
         Adjust XMLHttpRequest Content-Type handling
index b77ca34..ba702e2 100644 (file)
@@ -22,9 +22,9 @@ PASS iteration composition of transform: [ scale(0), scale(1) ] animation
 FAIL iteration composition of transform: [ scale(1), scale(2) ] animation assert_approx_equals: expected matrix(3, 0, 0, 3, 0, 0) but got matrix(1, 0, 0, 1, 0, 0): Animated transform(scale) style at 0s of the third iteration expected 3 +/- 0.0001 but got 1
 FAIL iteration composition of transform: scale(2) animation assert_approx_equals: expected matrix(2, 0, 0, 2, 0, 0) but got matrix(0, 0, 0, 0, 0, 0): Animated transform(scale) style at 0s of the third iteration expected 2 +/- 0.0001 but got 0
 FAIL iteration composition of transform list animation assert_approx_equals: expected matrix(1, 0, 0, 1, 20, 0) but got matrix(1, 0, 0, 1, 0, 0): Animated transform list at 0s of the third iteration expected 20 +/- 0.0001 but got 0
-FAIL iteration composition of transform of matrix function assert_approx_equals: expected matrix(6, 0, 0, 6, 60, 0) but got matrix(2, -0.0000000000000004898587196589413, 0.0000000000000004898587196589413, 2, 0, 0): Animated transform of matrix function at 0s of the third iteration expected 6 +/- 0.0001 but got 2
-FAIL iteration composition of transform list animation whose order is mismatched assert_approx_equals: expected matrix(6, 0, 0, 6, 60, 0) but got matrix(2, -0.0000000000000004898587196589413, 0.0000000000000004898587196589413, 2, 0, 0): Animated transform list at 0s of the third iteration expected 6 +/- 0.0001 but got 2
-FAIL iteration composition of transform list animation whose order is mismatched because of missing functions assert_approx_equals: expected matrix(3, 0, 0, 3, 40, 0) but got matrix(1, -0.00000000000000024492935982947064, 0.00000000000000024492935982947064, 1, 0, 0): Animated transform list at 0s of the third iteration expected 3 +/- 0.0001 but got 1
+FAIL iteration composition of transform of matrix function assert_approx_equals: expected matrix(6, 0, 0, 6, 60, 0) but got matrix(2, -4.898587196589413e-16, 4.898587196589413e-16, 2, 0, 0): Animated transform of matrix function at 0s of the third iteration expected 6 +/- 0.0001 but got 2
+FAIL iteration composition of transform list animation whose order is mismatched assert_approx_equals: expected matrix(6, 0, 0, 6, 60, 0) but got matrix(2, -4.898587196589413e-16, 4.898587196589413e-16, 2, 0, 0): Animated transform list at 0s of the third iteration expected 6 +/- 0.0001 but got 2
+FAIL iteration composition of transform list animation whose order is mismatched because of missing functions assert_approx_equals: expected matrix(3, 0, 0, 3, 40, 0) but got matrix(1, -2.4492935982947064e-16, 2.4492935982947064e-16, 1, 0, 0): Animated transform list at 0s of the third iteration expected 3 +/- 0.0001 but got 1
 FAIL iteration composition of transform from none to translate assert_approx_equals: expected matrix(1, 0, 0, 1, 20, 0) but got matrix(1, 0, 0, 1, 0, 0): Animated transform list at 0s of the third iteration expected 20 +/- 0.0001 but got 0
 FAIL iteration composition of transform of matrix3d function assert_approx_equals: expected matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 130, 1) but got matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 30, 1): Animated transform of matrix3d function at 0s of the third iteration expected 130 +/- 0.0001 but got 30
 FAIL iteration composition of transform of rotate3d function assert_equals: dimension of the matrix: Animated transform of rotate3d function at 0s of the third iteration expected 16 but got 6
index e67ec91..6bb5551 100644 (file)
@@ -9,7 +9,7 @@ PASS volumeSliderContainerStyle.left is "566px"
 PASS volumeSliderContainerStyle.top is "226px"
 PASS volumeSliderContainerStyle.width is "94px"
 PASS volumeSliderContainerStyle.height is "31px"
-PASS volumeSliderContainerStyle.transform is "matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, -30, -26.000000000000004)"
+PASS volumeSliderContainerStyle.transform is "matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, -30, -26.000000000000004)"
 PASS volumeSliderStyle.marginLeft is "6px"
 PASS volumeSliderStyle.width is "60px"
 PASS volumeSliderStyle.height is "16px"
index 8d77236..ef8695b 100644 (file)
@@ -20,7 +20,7 @@ shouldBecomeEqual("mediaControls.volumeSlider.parent.element.parentNode", "media
     shouldBeEqualToString("volumeSliderContainerStyle.top", "226px");
     shouldBeEqualToString("volumeSliderContainerStyle.width", "94px");
     shouldBeEqualToString("volumeSliderContainerStyle.height", "31px");
-    shouldBeEqualToString("volumeSliderContainerStyle.transform", "matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, -30, -26.000000000000004)");
+    shouldBeEqualToString("volumeSliderContainerStyle.transform", "matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, -30, -26.000000000000004)");
 
     volumeSliderStyle = window.getComputedStyle(mediaControls.volumeSlider.element);
     shouldBeEqualToString("volumeSliderStyle.marginLeft", "6px");
index df93e79..9e4c783 100644 (file)
@@ -199,20 +199,20 @@ PASS text-shadow (type: textShadowList) has testAccumulation function
 FAIL text-shadow: shadow assert_equals: The value should be rgb(240, 240, 240) 20px 20px 20px at 0ms expected "rgb(240, 240, 240) 20px 20px 20px" but got "rgb(120, 120, 120) 10px 10px 10px"
 PASS transform (type: transformList) has testAccumulation function 
 FAIL transform: translate assert_approx_equals: expected matrix(1,0,0,1,-100,0) but got matrix(1, 0, 0, 1, -200, 0): The value should be matrix(1,0,0,1,-100,0) at 0ms but got matrix(1, 0, 0, 1, -200, 0) expected -100 +/- 0.0001 but got -200
-FAIL transform: rotate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) at 0ms but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
+FAIL transform: rotate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) at 0ms but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
 FAIL transform: scale assert_approx_equals: expected matrix(-2,0,0,-2,0,0) but got matrix(-3, 0, 0, -3, 0, 0): The value should be matrix(-2,0,0,-2,0,0) at 0ms but got matrix(-3, 0, 0, -3, 0, 0) expected -2 +/- 0.0001 but got -3
 FAIL transform: skew assert_approx_equals: expected matrix(1,0.5773502691896256,-0.36397023426620234,1,0,0) but got matrix(1, 0.36397023426620234, -0.5773502691896256, 1, 0, 0): The value should be matrix(1,0.5773502691896256,-0.36397023426620234,1,0,0) at 0ms but got matrix(1, 0.36397023426620234, -0.5773502691896256, 1, 0, 0) expected 0.5773502691896256 +/- 0.0001 but got 0.36397023426620234
-FAIL transform: rotate on translate assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(0.00000000000000006123233995736766, 1, -1, 0.00000000000000006123233995736766, 0, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(0.00000000000000006123233995736766, 1, -1, 0.00000000000000006123233995736766, 0, 0) expected 100 +/- 0.0001 but got 0
+FAIL transform: rotate on translate assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(6.123233995736766e-17, 1, -1, 6.123233995736766e-17, 0, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(6.123233995736766e-17, 1, -1, 6.123233995736766e-17, 0, 0) expected 100 +/- 0.0001 but got 0
 FAIL transform: translate on rotate assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(1, 0, 0, 1, 100, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(1, 0, 0, 1, 100, 0) expected 0 +/- 0.0001 but got 1
 FAIL transform: rotate and translate on rotate assert_approx_equals: expected matrix(6.123233995736766e-17,1,-1,6.123233995736766e-17,0,0) but got matrix(0.7071067811865476, 0.7071067811865475, -0.7071067811865475, 0.7071067811865476, 0, 0): The value should be matrix(6.123233995736766e-17,1,-1,6.123233995736766e-17,0,0) at 0ms but got matrix(0.7071067811865476, 0.7071067811865475, -0.7071067811865475, 0.7071067811865476, 0, 0) expected 6.123233995736766e-17 +/- 0.0001 but got 0.7071067811865476
 FAIL transform: rotate on roate and translate assert_approx_equals: expected matrix(6.123233995736766e-17,1,-1,6.123233995736766e-17,6.123233995736766e-15,100) but got matrix(0.7071067811865476, 0.7071067811865475, -0.7071067811865475, 0.7071067811865476, 0, 0): The value should be matrix(6.123233995736766e-17,1,-1,6.123233995736766e-17,6.123233995736766e-15,100) at 0ms but got matrix(0.7071067811865476, 0.7071067811865475, -0.7071067811865475, 0.7071067811865476, 0, 0) expected 6.123233995736766e-17 +/- 0.0001 but got 0.7071067811865476
-FAIL transform: matrix assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(1, -0.00000000000000024492935982947064, 0.00000000000000024492935982947064, 1, 100, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(1, -0.00000000000000024492935982947064, 0.00000000000000024492935982947064, 1, 100, 0) expected 0 +/- 0.0001 but got 1
-FAIL transform: rotate3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 0.00000000000000006123233995736766, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 0.00000000000000006123233995736766, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.4999999999999999
-FAIL transform: matrix3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 0.000000000000000404259158300213, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 0.000000000000000404259158300213, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.5000000000000001
+FAIL transform: matrix assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(1, -2.4492935982947064e-16, 2.4492935982947064e-16, 1, 100, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(1, -2.4492935982947064e-16, 2.4492935982947064e-16, 1, 100, 0) expected 0 +/- 0.0001 but got 1
+FAIL transform: rotate3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 6.123233995736766e-17, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 6.123233995736766e-17, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.4999999999999999
+FAIL transform: matrix3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 4.04259158300213e-16, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 4.04259158300213e-16, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.5000000000000001
 FAIL transform: none assert_equals: dimension of the matrix: The value should be matrix3d(1,0,0,0,0,1,0,0,0,0,1,0,0,0,1,1) at 0ms but got matrix(1, 0, 0, 1, 0, 0) expected 16 but got 6
 FAIL transform: non-invertible matrices (non-invertible onto invertible) assert_approx_equals: expected matrix(1,1,0,0,0,100) but got matrix(1, 1, 0, 0, 49.999999999999986, 49.999999999999986): The value should be matrix(1,1,0,0,0,100) at 0ms but got matrix(1, 1, 0, 0, 49.999999999999986, 49.999999999999986) expected 0 +/- 0.0001 but got 49.999999999999986
 PASS transform: non-invertible matrices (invertible onto non-invertible) 
-FAIL transform: non-invertible matrices in matched transform lists (non-invertible onto invertible) assert_approx_equals: expected matrix(-1,-1,0,0,100,100) but got matrix(-1, -1, -0.00000000000000012246467991473532, -0.00000000000000012246467991473532, 150, 49.999999999999986): The value should be matrix(-1,-1,0,0,100,100) at 0ms but got matrix(-1, -1, -0.00000000000000012246467991473532, -0.00000000000000012246467991473532, 150, 49.999999999999986) expected 100 +/- 0.0001 but got 150
+FAIL transform: non-invertible matrices in matched transform lists (non-invertible onto invertible) assert_approx_equals: expected matrix(-1,-1,0,0,100,100) but got matrix(-1, -1, -1.2246467991473532e-16, -1.2246467991473532e-16, 150, 49.999999999999986): The value should be matrix(-1,-1,0,0,100,100) at 0ms but got matrix(-1, -1, -1.2246467991473532e-16, -1.2246467991473532e-16, 150, 49.999999999999986) expected 100 +/- 0.0001 but got 150
 PASS transform: non-invertible matrices in matched transform lists (invertible onto non-invertible) 
 FAIL transform: non-invertible matrices in mismatched transform lists (non-invertible onto invertible) assert_approx_equals: expected matrix(1,1,1,1,100,100) but got matrix(1, 1, 0.9999999999999999, 0.9999999999999999, 150, 49.999999999999986): The value should be matrix(1,1,1,1,100,100) at 0ms but got matrix(1, 1, 0.9999999999999999, 0.9999999999999999, 150, 49.999999999999986) expected 100 +/- 0.0001 but got 150
 PASS transform: non-invertible matrices in mismatched transform lists (invertible onto non-invertible) 
index f51b6b9..4848b56 100644 (file)
@@ -199,18 +199,18 @@ PASS text-shadow (type: textShadowList) has testAddition function
 FAIL text-shadow: shadow assert_equals: The value should be rgb(0, 0, 0) 0px 0px 0px, rgb(120, 120, 120) 10px 10px 10px at 0ms expected "rgb(0, 0, 0) 0px 0px 0px, rgb(120, 120, 120) 10px 10px 10px" but got "rgb(120, 120, 120) 10px 10px 10px"
 PASS transform (type: transformList) has testAddition function 
 FAIL transform: translate assert_approx_equals: expected matrix(1,0,0,1,-100,0) but got matrix(1, 0, 0, 1, -200, 0): The value should be matrix(1,0,0,1,-100,0) at 0ms but got matrix(1, 0, 0, 1, -200, 0) expected -100 +/- 0.0001 but got -200
-FAIL transform: rotate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) at 0ms but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
+FAIL transform: rotate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) at 0ms but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
 FAIL transform: scale assert_approx_equals: expected matrix(-6,0,0,-6,0,0) but got matrix(-3, 0, 0, -3, 0, 0): The value should be matrix(-6,0,0,-6,0,0) at 0ms but got matrix(-3, 0, 0, -3, 0, 0) expected -6 +/- 0.0001 but got -3
 FAIL transform: skew assert_approx_equals: expected matrix(1.064177772475912,0.5402972149746673,-0.40102328848116064,0.8981975702225738,0,0) but got matrix(1, 0.36397023426620234, -0.5773502691896256, 1, 0, 0): The value should be matrix(1.064177772475912,0.5402972149746673,-0.40102328848116064,0.8981975702225738,0,0) at 0ms but got matrix(1, 0.36397023426620234, -0.5773502691896256, 1, 0, 0) expected 1.064177772475912 +/- 0.0001 but got 1
-FAIL transform: rotate on translate assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(0.00000000000000006123233995736766, 1, -1, 0.00000000000000006123233995736766, 0, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(0.00000000000000006123233995736766, 1, -1, 0.00000000000000006123233995736766, 0, 0) expected 100 +/- 0.0001 but got 0
+FAIL transform: rotate on translate assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(6.123233995736766e-17, 1, -1, 6.123233995736766e-17, 0, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(6.123233995736766e-17, 1, -1, 6.123233995736766e-17, 0, 0) expected 100 +/- 0.0001 but got 0
 FAIL transform: translate on rotate assert_approx_equals: expected matrix(0,1,-1,0,0,100) but got matrix(1, 0, 0, 1, 100, 0): The value should be matrix(0,1,-1,0,0,100) at 0ms but got matrix(1, 0, 0, 1, 100, 0) expected 0 +/- 0.0001 but got 1
-FAIL transform: rotate on rotate and translate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,70.71067811865476,70.71067811865474) but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,70.71067811865476,70.71067811865474) at 0ms but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
-FAIL transform: matrix assert_approx_equals: expected matrix(0,1,-1,0,0,100) but got matrix(1, -0.00000000000000024492935982947064, 0.00000000000000024492935982947064, 1, 100, 0): The value should be matrix(0,1,-1,0,0,100) at 0ms but got matrix(1, -0.00000000000000024492935982947064, 0.00000000000000024492935982947064, 1, 100, 0) expected 0 +/- 0.0001 but got 1
-FAIL transform: rotate3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 0.00000000000000006123233995736766, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 0.00000000000000006123233995736766, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.4999999999999999
-FAIL transform: matrix3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 0.000000000000000404259158300213, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 0.000000000000000404259158300213, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.5000000000000001
-FAIL transform: non-invertible matrices assert_approx_equals: expected matrix(-1,0,0,-1,250,0) but got matrix(-1, 0.00000000000000012246467991473532, -0.00000000000000012246467991473532, -1, 200, 0): The value should be matrix(-1,0,0,-1,250,0) at 0ms but got matrix(-1, 0.00000000000000012246467991473532, -0.00000000000000012246467991473532, -1, 200, 0) expected 250 +/- 0.0001 but got 200
-FAIL transform: non-invertible matrices in matched transform lists assert_approx_equals: expected matrix(0,-1,1,0,250,0) but got matrix(-0.00000000000000018369701987210297, -1, 1, -0.00000000000000018369701987210297, 200, 0): The value should be matrix(0,-1,1,0,250,0) at 0ms but got matrix(-0.00000000000000018369701987210297, -1, 1, -0.00000000000000018369701987210297, 200, 0) expected 250 +/- 0.0001 but got 200
-FAIL transform: non-invertible matrices in mismatched transform lists assert_approx_equals: expected matrix(-2,0,0,-2,250,0) but got matrix(-2, 0.00000000000000024492935982947064, -0.00000000000000024492935982947064, -2, 200, 0): The value should be matrix(-2,0,0,-2,250,0) at 0ms but got matrix(-2, 0.00000000000000024492935982947064, -0.00000000000000024492935982947064, -2, 200, 0) expected 250 +/- 0.0001 but got 200
+FAIL transform: rotate on rotate and translate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,70.71067811865476,70.71067811865474) but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,70.71067811865476,70.71067811865474) at 0ms but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
+FAIL transform: matrix assert_approx_equals: expected matrix(0,1,-1,0,0,100) but got matrix(1, -2.4492935982947064e-16, 2.4492935982947064e-16, 1, 100, 0): The value should be matrix(0,1,-1,0,0,100) at 0ms but got matrix(1, -2.4492935982947064e-16, 2.4492935982947064e-16, 1, 100, 0) expected 0 +/- 0.0001 but got 1
+FAIL transform: rotate3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 6.123233995736766e-17, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 6.123233995736766e-17, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.4999999999999999
+FAIL transform: matrix3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 4.04259158300213e-16, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 4.04259158300213e-16, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.5000000000000001
+FAIL transform: non-invertible matrices assert_approx_equals: expected matrix(-1,0,0,-1,250,0) but got matrix(-1, 1.2246467991473532e-16, -1.2246467991473532e-16, -1, 200, 0): The value should be matrix(-1,0,0,-1,250,0) at 0ms but got matrix(-1, 1.2246467991473532e-16, -1.2246467991473532e-16, -1, 200, 0) expected 250 +/- 0.0001 but got 200
+FAIL transform: non-invertible matrices in matched transform lists assert_approx_equals: expected matrix(0,-1,1,0,250,0) but got matrix(-1.8369701987210297e-16, -1, 1, -1.8369701987210297e-16, 200, 0): The value should be matrix(0,-1,1,0,250,0) at 0ms but got matrix(-1.8369701987210297e-16, -1, 1, -1.8369701987210297e-16, 200, 0) expected 250 +/- 0.0001 but got 200
+FAIL transform: non-invertible matrices in mismatched transform lists assert_approx_equals: expected matrix(-2,0,0,-2,250,0) but got matrix(-2, 2.4492935982947064e-16, -2.4492935982947064e-16, -2, 200, 0): The value should be matrix(-2,0,0,-2,250,0) at 0ms but got matrix(-2, 2.4492935982947064e-16, -2.4492935982947064e-16, -2, 200, 0) expected 250 +/- 0.0001 but got 200
 PASS visibility (type: visibility) has testAddition function 
 FAIL visibility: onto "visible" assert_equals: The value should be visible at 1000ms expected "visible" but got "hidden"
 PASS visibility: onto "hidden" 
index b2863cc..a6546a8 100644 (file)
@@ -242,8 +242,8 @@ PASS transform: scale
 PASS transform: skew 
 PASS transform: rotate and translate 
 PASS transform: translate and rotate 
-FAIL transform: extend shorter list (from) assert_approx_equals: expected matrix(-1,0,0,-1,-50,0) but got matrix(1, -0.00000000000000036739403974420594, 0.00000000000000036739403974420594, 1, 50, -0.000000000000036739403974420595): The value should be matrix(-1,0,0,-1,-50,0) at 500ms but got matrix(1, -0.00000000000000036739403974420594, 0.00000000000000036739403974420594, 1, 50, -0.000000000000036739403974420595) expected -1 +/- 0.0001 but got 1
-FAIL transform: extend shorter list (to) assert_approx_equals: expected matrix(-1,0,0,-1,-50,0) but got matrix(1, -0.00000000000000036739403974420594, 0.00000000000000036739403974420594, 1, 50, 0): The value should be matrix(-1,0,0,-1,-50,0) at 500ms but got matrix(1, -0.00000000000000036739403974420594, 0.00000000000000036739403974420594, 1, 50, 0) expected -1 +/- 0.0001 but got 1
+FAIL transform: extend shorter list (from) assert_approx_equals: expected matrix(-1,0,0,-1,-50,0) but got matrix(1, -3.6739403974420594e-16, 3.6739403974420594e-16, 1, 50, -3.6739403974420595e-14): The value should be matrix(-1,0,0,-1,-50,0) at 500ms but got matrix(1, -3.6739403974420594e-16, 3.6739403974420594e-16, 1, 50, -3.6739403974420595e-14) expected -1 +/- 0.0001 but got 1
+FAIL transform: extend shorter list (to) assert_approx_equals: expected matrix(-1,0,0,-1,-50,0) but got matrix(1, -3.6739403974420594e-16, 3.6739403974420594e-16, 1, 50, 0): The value should be matrix(-1,0,0,-1,-50,0) at 500ms but got matrix(1, -3.6739403974420594e-16, 3.6739403974420594e-16, 1, 50, 0) expected -1 +/- 0.0001 but got 1
 PASS transform: mismatch order of translate and rotate 
 PASS transform: matrix 
 FAIL transform: rotate3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,-0.5,0,0.1464466094067262,0.8535533905932737,0.5,0,0.5,-0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.8660254037844386, 0.28867513459481287, -0.40824829046386296, 0, 0, 0.816496580927726, 0.5773502691896256, 0, 0.49999999999999994, -0.4999999999999999, 0.7071067811865476, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,-0.5,0,0.1464466094067262,0.8535533905932737,0.5,0,0.5,-0.5,0.7071067811865476,0,0,0,0,1) at 500ms but got matrix3d(0.8660254037844386, 0.28867513459481287, -0.40824829046386296, 0, 0, 0.816496580927726, 0.5773502691896256, 0, 0.49999999999999994, -0.4999999999999999, 0.7071067811865476, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.8660254037844386
index df93e79..9e4c783 100644 (file)
@@ -199,20 +199,20 @@ PASS text-shadow (type: textShadowList) has testAccumulation function
 FAIL text-shadow: shadow assert_equals: The value should be rgb(240, 240, 240) 20px 20px 20px at 0ms expected "rgb(240, 240, 240) 20px 20px 20px" but got "rgb(120, 120, 120) 10px 10px 10px"
 PASS transform (type: transformList) has testAccumulation function 
 FAIL transform: translate assert_approx_equals: expected matrix(1,0,0,1,-100,0) but got matrix(1, 0, 0, 1, -200, 0): The value should be matrix(1,0,0,1,-100,0) at 0ms but got matrix(1, 0, 0, 1, -200, 0) expected -100 +/- 0.0001 but got -200
-FAIL transform: rotate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) at 0ms but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
+FAIL transform: rotate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) at 0ms but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
 FAIL transform: scale assert_approx_equals: expected matrix(-2,0,0,-2,0,0) but got matrix(-3, 0, 0, -3, 0, 0): The value should be matrix(-2,0,0,-2,0,0) at 0ms but got matrix(-3, 0, 0, -3, 0, 0) expected -2 +/- 0.0001 but got -3
 FAIL transform: skew assert_approx_equals: expected matrix(1,0.5773502691896256,-0.36397023426620234,1,0,0) but got matrix(1, 0.36397023426620234, -0.5773502691896256, 1, 0, 0): The value should be matrix(1,0.5773502691896256,-0.36397023426620234,1,0,0) at 0ms but got matrix(1, 0.36397023426620234, -0.5773502691896256, 1, 0, 0) expected 0.5773502691896256 +/- 0.0001 but got 0.36397023426620234
-FAIL transform: rotate on translate assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(0.00000000000000006123233995736766, 1, -1, 0.00000000000000006123233995736766, 0, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(0.00000000000000006123233995736766, 1, -1, 0.00000000000000006123233995736766, 0, 0) expected 100 +/- 0.0001 but got 0
+FAIL transform: rotate on translate assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(6.123233995736766e-17, 1, -1, 6.123233995736766e-17, 0, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(6.123233995736766e-17, 1, -1, 6.123233995736766e-17, 0, 0) expected 100 +/- 0.0001 but got 0
 FAIL transform: translate on rotate assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(1, 0, 0, 1, 100, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(1, 0, 0, 1, 100, 0) expected 0 +/- 0.0001 but got 1
 FAIL transform: rotate and translate on rotate assert_approx_equals: expected matrix(6.123233995736766e-17,1,-1,6.123233995736766e-17,0,0) but got matrix(0.7071067811865476, 0.7071067811865475, -0.7071067811865475, 0.7071067811865476, 0, 0): The value should be matrix(6.123233995736766e-17,1,-1,6.123233995736766e-17,0,0) at 0ms but got matrix(0.7071067811865476, 0.7071067811865475, -0.7071067811865475, 0.7071067811865476, 0, 0) expected 6.123233995736766e-17 +/- 0.0001 but got 0.7071067811865476
 FAIL transform: rotate on roate and translate assert_approx_equals: expected matrix(6.123233995736766e-17,1,-1,6.123233995736766e-17,6.123233995736766e-15,100) but got matrix(0.7071067811865476, 0.7071067811865475, -0.7071067811865475, 0.7071067811865476, 0, 0): The value should be matrix(6.123233995736766e-17,1,-1,6.123233995736766e-17,6.123233995736766e-15,100) at 0ms but got matrix(0.7071067811865476, 0.7071067811865475, -0.7071067811865475, 0.7071067811865476, 0, 0) expected 6.123233995736766e-17 +/- 0.0001 but got 0.7071067811865476
-FAIL transform: matrix assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(1, -0.00000000000000024492935982947064, 0.00000000000000024492935982947064, 1, 100, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(1, -0.00000000000000024492935982947064, 0.00000000000000024492935982947064, 1, 100, 0) expected 0 +/- 0.0001 but got 1
-FAIL transform: rotate3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 0.00000000000000006123233995736766, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 0.00000000000000006123233995736766, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.4999999999999999
-FAIL transform: matrix3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 0.000000000000000404259158300213, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 0.000000000000000404259158300213, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.5000000000000001
+FAIL transform: matrix assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(1, -2.4492935982947064e-16, 2.4492935982947064e-16, 1, 100, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(1, -2.4492935982947064e-16, 2.4492935982947064e-16, 1, 100, 0) expected 0 +/- 0.0001 but got 1
+FAIL transform: rotate3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 6.123233995736766e-17, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 6.123233995736766e-17, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.4999999999999999
+FAIL transform: matrix3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 4.04259158300213e-16, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 4.04259158300213e-16, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.5000000000000001
 FAIL transform: none assert_equals: dimension of the matrix: The value should be matrix3d(1,0,0,0,0,1,0,0,0,0,1,0,0,0,1,1) at 0ms but got matrix(1, 0, 0, 1, 0, 0) expected 16 but got 6
 FAIL transform: non-invertible matrices (non-invertible onto invertible) assert_approx_equals: expected matrix(1,1,0,0,0,100) but got matrix(1, 1, 0, 0, 49.999999999999986, 49.999999999999986): The value should be matrix(1,1,0,0,0,100) at 0ms but got matrix(1, 1, 0, 0, 49.999999999999986, 49.999999999999986) expected 0 +/- 0.0001 but got 49.999999999999986
 PASS transform: non-invertible matrices (invertible onto non-invertible) 
-FAIL transform: non-invertible matrices in matched transform lists (non-invertible onto invertible) assert_approx_equals: expected matrix(-1,-1,0,0,100,100) but got matrix(-1, -1, -0.00000000000000012246467991473532, -0.00000000000000012246467991473532, 150, 49.999999999999986): The value should be matrix(-1,-1,0,0,100,100) at 0ms but got matrix(-1, -1, -0.00000000000000012246467991473532, -0.00000000000000012246467991473532, 150, 49.999999999999986) expected 100 +/- 0.0001 but got 150
+FAIL transform: non-invertible matrices in matched transform lists (non-invertible onto invertible) assert_approx_equals: expected matrix(-1,-1,0,0,100,100) but got matrix(-1, -1, -1.2246467991473532e-16, -1.2246467991473532e-16, 150, 49.999999999999986): The value should be matrix(-1,-1,0,0,100,100) at 0ms but got matrix(-1, -1, -1.2246467991473532e-16, -1.2246467991473532e-16, 150, 49.999999999999986) expected 100 +/- 0.0001 but got 150
 PASS transform: non-invertible matrices in matched transform lists (invertible onto non-invertible) 
 FAIL transform: non-invertible matrices in mismatched transform lists (non-invertible onto invertible) assert_approx_equals: expected matrix(1,1,1,1,100,100) but got matrix(1, 1, 0.9999999999999999, 0.9999999999999999, 150, 49.999999999999986): The value should be matrix(1,1,1,1,100,100) at 0ms but got matrix(1, 1, 0.9999999999999999, 0.9999999999999999, 150, 49.999999999999986) expected 100 +/- 0.0001 but got 150
 PASS transform: non-invertible matrices in mismatched transform lists (invertible onto non-invertible) 
index f51b6b9..4848b56 100644 (file)
@@ -199,18 +199,18 @@ PASS text-shadow (type: textShadowList) has testAddition function
 FAIL text-shadow: shadow assert_equals: The value should be rgb(0, 0, 0) 0px 0px 0px, rgb(120, 120, 120) 10px 10px 10px at 0ms expected "rgb(0, 0, 0) 0px 0px 0px, rgb(120, 120, 120) 10px 10px 10px" but got "rgb(120, 120, 120) 10px 10px 10px"
 PASS transform (type: transformList) has testAddition function 
 FAIL transform: translate assert_approx_equals: expected matrix(1,0,0,1,-100,0) but got matrix(1, 0, 0, 1, -200, 0): The value should be matrix(1,0,0,1,-100,0) at 0ms but got matrix(1, 0, 0, 1, -200, 0) expected -100 +/- 0.0001 but got -200
-FAIL transform: rotate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) at 0ms but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
+FAIL transform: rotate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,0,0) at 0ms but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
 FAIL transform: scale assert_approx_equals: expected matrix(-6,0,0,-6,0,0) but got matrix(-3, 0, 0, -3, 0, 0): The value should be matrix(-6,0,0,-6,0,0) at 0ms but got matrix(-3, 0, 0, -3, 0, 0) expected -6 +/- 0.0001 but got -3
 FAIL transform: skew assert_approx_equals: expected matrix(1.064177772475912,0.5402972149746673,-0.40102328848116064,0.8981975702225738,0,0) but got matrix(1, 0.36397023426620234, -0.5773502691896256, 1, 0, 0): The value should be matrix(1.064177772475912,0.5402972149746673,-0.40102328848116064,0.8981975702225738,0,0) at 0ms but got matrix(1, 0.36397023426620234, -0.5773502691896256, 1, 0, 0) expected 1.064177772475912 +/- 0.0001 but got 1
-FAIL transform: rotate on translate assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(0.00000000000000006123233995736766, 1, -1, 0.00000000000000006123233995736766, 0, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(0.00000000000000006123233995736766, 1, -1, 0.00000000000000006123233995736766, 0, 0) expected 100 +/- 0.0001 but got 0
+FAIL transform: rotate on translate assert_approx_equals: expected matrix(0,1,-1,0,100,0) but got matrix(6.123233995736766e-17, 1, -1, 6.123233995736766e-17, 0, 0): The value should be matrix(0,1,-1,0,100,0) at 0ms but got matrix(6.123233995736766e-17, 1, -1, 6.123233995736766e-17, 0, 0) expected 100 +/- 0.0001 but got 0
 FAIL transform: translate on rotate assert_approx_equals: expected matrix(0,1,-1,0,0,100) but got matrix(1, 0, 0, 1, 100, 0): The value should be matrix(0,1,-1,0,0,100) at 0ms but got matrix(1, 0, 0, 1, 100, 0) expected 0 +/- 0.0001 but got 1
-FAIL transform: rotate on rotate and translate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,70.71067811865476,70.71067811865474) but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,70.71067811865476,70.71067811865474) at 0ms but got matrix(0.00000000000000006123233995736766, -1, 1, 0.00000000000000006123233995736766, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
-FAIL transform: matrix assert_approx_equals: expected matrix(0,1,-1,0,0,100) but got matrix(1, -0.00000000000000024492935982947064, 0.00000000000000024492935982947064, 1, 100, 0): The value should be matrix(0,1,-1,0,0,100) at 0ms but got matrix(1, -0.00000000000000024492935982947064, 0.00000000000000024492935982947064, 1, 100, 0) expected 0 +/- 0.0001 but got 1
-FAIL transform: rotate3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 0.00000000000000006123233995736766, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 0.00000000000000006123233995736766, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.4999999999999999
-FAIL transform: matrix3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 0.000000000000000404259158300213, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 0.000000000000000404259158300213, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.5000000000000001
-FAIL transform: non-invertible matrices assert_approx_equals: expected matrix(-1,0,0,-1,250,0) but got matrix(-1, 0.00000000000000012246467991473532, -0.00000000000000012246467991473532, -1, 200, 0): The value should be matrix(-1,0,0,-1,250,0) at 0ms but got matrix(-1, 0.00000000000000012246467991473532, -0.00000000000000012246467991473532, -1, 200, 0) expected 250 +/- 0.0001 but got 200
-FAIL transform: non-invertible matrices in matched transform lists assert_approx_equals: expected matrix(0,-1,1,0,250,0) but got matrix(-0.00000000000000018369701987210297, -1, 1, -0.00000000000000018369701987210297, 200, 0): The value should be matrix(0,-1,1,0,250,0) at 0ms but got matrix(-0.00000000000000018369701987210297, -1, 1, -0.00000000000000018369701987210297, 200, 0) expected 250 +/- 0.0001 but got 200
-FAIL transform: non-invertible matrices in mismatched transform lists assert_approx_equals: expected matrix(-2,0,0,-2,250,0) but got matrix(-2, 0.00000000000000024492935982947064, -0.00000000000000024492935982947064, -2, 200, 0): The value should be matrix(-2,0,0,-2,250,0) at 0ms but got matrix(-2, 0.00000000000000024492935982947064, -0.00000000000000024492935982947064, -2, 200, 0) expected 250 +/- 0.0001 but got 200
+FAIL transform: rotate on rotate and translate assert_approx_equals: expected matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,70.71067811865476,70.71067811865474) but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0): The value should be matrix(0.7071067811865476,-0.7071067811865475,0.7071067811865475,0.7071067811865476,70.71067811865476,70.71067811865474) at 0ms but got matrix(6.123233995736766e-17, -1, 1, 6.123233995736766e-17, 0, 0) expected 0.7071067811865476 +/- 0.0001 but got 6.123233995736766e-17
+FAIL transform: matrix assert_approx_equals: expected matrix(0,1,-1,0,0,100) but got matrix(1, -2.4492935982947064e-16, 2.4492935982947064e-16, 1, 100, 0): The value should be matrix(0,1,-1,0,0,100) at 0ms but got matrix(1, -2.4492935982947064e-16, 2.4492935982947064e-16, 1, 100, 0) expected 0 +/- 0.0001 but got 1
+FAIL transform: rotate3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 6.123233995736766e-17, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.4999999999999999, 0.49999999999999994, 0.7071067811865476, 0, 0.49999999999999994, 0.5000000000000001, -0.7071067811865475, 0, -0.7071067811865476, 0.7071067811865475, 6.123233995736766e-17, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.4999999999999999
+FAIL transform: matrix3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 4.04259158300213e-16, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,0.5,0,0.1464466094067262,0.8535533905932737,-0.5,0,-0.5,0.5,0.7071067811865476,0,0,0,0,1) at 0ms but got matrix3d(0.5000000000000001, 0.49999999999999983, 0.7071067811865474, 0, 0.4999999999999997, 0.5000000000000002, -0.7071067811865476, 0, -0.7071067811865476, 0.7071067811865474, 4.04259158300213e-16, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.5000000000000001
+FAIL transform: non-invertible matrices assert_approx_equals: expected matrix(-1,0,0,-1,250,0) but got matrix(-1, 1.2246467991473532e-16, -1.2246467991473532e-16, -1, 200, 0): The value should be matrix(-1,0,0,-1,250,0) at 0ms but got matrix(-1, 1.2246467991473532e-16, -1.2246467991473532e-16, -1, 200, 0) expected 250 +/- 0.0001 but got 200
+FAIL transform: non-invertible matrices in matched transform lists assert_approx_equals: expected matrix(0,-1,1,0,250,0) but got matrix(-1.8369701987210297e-16, -1, 1, -1.8369701987210297e-16, 200, 0): The value should be matrix(0,-1,1,0,250,0) at 0ms but got matrix(-1.8369701987210297e-16, -1, 1, -1.8369701987210297e-16, 200, 0) expected 250 +/- 0.0001 but got 200
+FAIL transform: non-invertible matrices in mismatched transform lists assert_approx_equals: expected matrix(-2,0,0,-2,250,0) but got matrix(-2, 2.4492935982947064e-16, -2.4492935982947064e-16, -2, 200, 0): The value should be matrix(-2,0,0,-2,250,0) at 0ms but got matrix(-2, 2.4492935982947064e-16, -2.4492935982947064e-16, -2, 200, 0) expected 250 +/- 0.0001 but got 200
 PASS visibility (type: visibility) has testAddition function 
 FAIL visibility: onto "visible" assert_equals: The value should be visible at 1000ms expected "visible" but got "hidden"
 PASS visibility: onto "hidden" 
index b2863cc..a6546a8 100644 (file)
@@ -242,8 +242,8 @@ PASS transform: scale
 PASS transform: skew 
 PASS transform: rotate and translate 
 PASS transform: translate and rotate 
-FAIL transform: extend shorter list (from) assert_approx_equals: expected matrix(-1,0,0,-1,-50,0) but got matrix(1, -0.00000000000000036739403974420594, 0.00000000000000036739403974420594, 1, 50, -0.000000000000036739403974420595): The value should be matrix(-1,0,0,-1,-50,0) at 500ms but got matrix(1, -0.00000000000000036739403974420594, 0.00000000000000036739403974420594, 1, 50, -0.000000000000036739403974420595) expected -1 +/- 0.0001 but got 1
-FAIL transform: extend shorter list (to) assert_approx_equals: expected matrix(-1,0,0,-1,-50,0) but got matrix(1, -0.00000000000000036739403974420594, 0.00000000000000036739403974420594, 1, 50, 0): The value should be matrix(-1,0,0,-1,-50,0) at 500ms but got matrix(1, -0.00000000000000036739403974420594, 0.00000000000000036739403974420594, 1, 50, 0) expected -1 +/- 0.0001 but got 1
+FAIL transform: extend shorter list (from) assert_approx_equals: expected matrix(-1,0,0,-1,-50,0) but got matrix(1, -3.6739403974420594e-16, 3.6739403974420594e-16, 1, 50, -3.6739403974420595e-14): The value should be matrix(-1,0,0,-1,-50,0) at 500ms but got matrix(1, -3.6739403974420594e-16, 3.6739403974420594e-16, 1, 50, -3.6739403974420595e-14) expected -1 +/- 0.0001 but got 1
+FAIL transform: extend shorter list (to) assert_approx_equals: expected matrix(-1,0,0,-1,-50,0) but got matrix(1, -3.6739403974420594e-16, 3.6739403974420594e-16, 1, 50, 0): The value should be matrix(-1,0,0,-1,-50,0) at 500ms but got matrix(1, -3.6739403974420594e-16, 3.6739403974420594e-16, 1, 50, 0) expected -1 +/- 0.0001 but got 1
 PASS transform: mismatch order of translate and rotate 
 PASS transform: matrix 
 FAIL transform: rotate3d assert_approx_equals: expected matrix3d(0.8535533905932737,0.1464466094067262,-0.5,0,0.1464466094067262,0.8535533905932737,0.5,0,0.5,-0.5,0.7071067811865476,0,0,0,0,1) but got matrix3d(0.8660254037844386, 0.28867513459481287, -0.40824829046386296, 0, 0, 0.816496580927726, 0.5773502691896256, 0, 0.49999999999999994, -0.4999999999999999, 0.7071067811865476, 0, 0, 0, 0, 1): The value should be matrix3d(0.8535533905932737,0.1464466094067262,-0.5,0,0.1464466094067262,0.8535533905932737,0.5,0,0.5,-0.5,0.7071067811865476,0,0,0,0,1) at 500ms but got matrix3d(0.8660254037844386, 0.28867513459481287, -0.40824829046386296, 0, 0, 0.816496580927726, 0.5773502691896256, 0, 0.49999999999999994, -0.4999999999999999, 0.7071067811865476, 0, 0, 0, 0, 1) expected 0.8535533905932737 +/- 0.0001 but got 0.8660254037844386
index 200a049..093748b 100644 (file)
@@ -1,3 +1,14 @@
+2019-03-02  Darin Adler  <darin@apple.com>
+
+        Retire legacy dtoa function and DecimalNumber class
+        https://bugs.webkit.org/show_bug.cgi?id=195253
+
+        Reviewed by Daniel Bates.
+
+        * runtime/NumberPrototype.cpp:
+        (JSC::numberProtoFuncToExponential): Removed dependency on NumberToStringBufferLength,
+        using NumberToStringBuffer instead. Also tweaked style of implementation a bit.
+
 2019-03-01  Darin Adler  <darin@apple.com>
 
         Finish removing String::format
index 74f9c36..04d98e6 100644 (file)
@@ -428,14 +428,14 @@ EncodedJSValue JSC_HOST_CALL numberProtoFuncToExponential(ExecState* exec)
         return throwVMError(exec, scope, createRangeError(exec, "toExponential() argument must be between 0 and 20"_s));
 
     // Round if the argument is not undefined, always format as exponential.
-    char buffer[WTF::NumberToStringBufferLength];
-    DoubleConversionStringBuilder builder(buffer, WTF::NumberToStringBufferLength);
+    NumberToStringBuffer buffer;
+    DoubleConversionStringBuilder builder { &buffer[0], sizeof(buffer) };
     const DoubleToStringConverter& converter = DoubleToStringConverter::EcmaScriptConverter();
     builder.Reset();
     isUndefined
         ? converter.ToExponential(x, -1, &builder)
         : converter.ToExponential(x, decimalPlacesInExponent, &builder);
-    return JSValue::encode(jsString(exec, String(builder.Finalize())));
+    return JSValue::encode(jsString(exec, builder.Finalize()));
 }
 
 // toFixed converts a number to a string, always formatting as an a decimal fraction.
index b31a3b7..f0d8f82 100644 (file)
@@ -1,3 +1,40 @@
+2019-03-02  Darin Adler  <darin@apple.com>
+
+        Retire legacy dtoa function and DecimalNumber class
+        https://bugs.webkit.org/show_bug.cgi?id=195253
+
+        Reviewed by Daniel Bates.
+
+        * WTF.xcodeproj/project.pbxproj: Removed DecimalNumber.cpp/h.
+        * wtf/CMakeLists.txt: Ditto.
+
+        * wtf/DecimalNumber.cpp: Removed.
+        * wtf/DecimalNumber.h: Removed.
+
+        * wtf/JSONValues.cpp:
+        (WTF::JSONImpl::Value::writeJSON const): Use
+        StringBuilder::appendECMAScriptNumber instead of custom logic
+        using the DecimalNumber class.
+
+        * wtf/dtoa.cpp:
+        (WTF::storeInc): Deleted.
+        (WTF::BigInt): Deleted.
+        (WTF::multadd): Deleted.
+        (WTF::hi0bits): Deleted.
+        (WTF::lo0bits): Deleted.
+        (WTF::i2b): Deleted.
+        (WTF::mult): Deleted.
+        (WTF::P5Node::P5Node): Deleted.
+        (WTF::pow5mult): Deleted.
+        (WTF::lshift): Deleted.
+        (WTF::cmp): Deleted.
+        (WTF::diff): Deleted.
+        (WTF::d2b): Deleted.
+        (WTF::quorem): Deleted.
+        (WTF::dtoa): Deleted.
+
+        * wtf/dtoa.h: Removed DtoaBuffer, dtoa, and NumberToStringBufferLength.
+
 2019-02-27  Darin Adler  <darin@apple.com>
 
         Fixed makeString(float) to do shortest-form serialization without first converting to double
index 178ea89..0da16bf 100644 (file)
                A8A4739C151A825B004123FF /* CurrentTime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A8A47275151A825A004123FF /* CurrentTime.cpp */; };
                A8A4739E151A825B004123FF /* DataLog.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A8A47277151A825A004123FF /* DataLog.cpp */; };
                A8A473A0151A825B004123FF /* DateMath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A8A47279151A825A004123FF /* DateMath.cpp */; };
-               A8A473A2151A825B004123FF /* DecimalNumber.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A8A4727B151A825A004123FF /* DecimalNumber.cpp */; };
                A8A473A8151A825B004123FF /* bignum-dtoa.cc in Sources */ = {isa = PBXBuildFile; fileRef = A8A47282151A825A004123FF /* bignum-dtoa.cc */; };
                A8A473AA151A825B004123FF /* bignum.cc in Sources */ = {isa = PBXBuildFile; fileRef = A8A47284151A825A004123FF /* bignum.cc */; };
                A8A473AC151A825B004123FF /* cached-powers.cc in Sources */ = {isa = PBXBuildFile; fileRef = A8A47286151A825A004123FF /* cached-powers.cc */; };
                A8A47278151A825A004123FF /* DataLog.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DataLog.h; sourceTree = "<group>"; };
                A8A47279151A825A004123FF /* DateMath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DateMath.cpp; sourceTree = "<group>"; };
                A8A4727A151A825A004123FF /* DateMath.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DateMath.h; sourceTree = "<group>"; };
-               A8A4727B151A825A004123FF /* DecimalNumber.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DecimalNumber.cpp; sourceTree = "<group>"; };
-               A8A4727C151A825A004123FF /* DecimalNumber.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DecimalNumber.h; sourceTree = "<group>"; };
                A8A4727E151A825A004123FF /* Deque.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Deque.h; sourceTree = "<group>"; };
                A8A47280151A825A004123FF /* DoublyLinkedList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DoublyLinkedList.h; sourceTree = "<group>"; };
                A8A47282151A825A004123FF /* bignum-dtoa.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = "bignum-dtoa.cc"; sourceTree = "<group>"; };
                                A8A47279151A825A004123FF /* DateMath.cpp */,
                                A8A4727A151A825A004123FF /* DateMath.h */,
                                996B17841EBA441C007E10EB /* DebugUtilities.h */,
-                               A8A4727B151A825A004123FF /* DecimalNumber.cpp */,
-                               A8A4727C151A825A004123FF /* DecimalNumber.h */,
                                0F2B66A417B6B4F700A7AE3F /* DeferrableRefCounted.h */,
                                A561F30F1DF2642100FF675D /* DeprecatedOptional.h */,
                                A8A4727E151A825A004123FF /* Deque.h */,
                                7C137941222326C700D7A824 /* AUTHORS */,
                                A8A47288151A825A004123FF /* COPYING */,
                                A8A47292151A825A004123FF /* LICENSE */,
-                               7C137943222326D500D7A824 /* README.md */,
                                A8A47282151A825A004123FF /* bignum-dtoa.cc */,
                                A8A47283151A825A004123FF /* bignum-dtoa.h */,
                                A8A47284151A825A004123FF /* bignum.cc */,
                                A8A47290151A825A004123FF /* fixed-dtoa.cc */,
                                A8A47291151A825A004123FF /* fixed-dtoa.h */,
                                7C137942222326D500D7A824 /* ieee.h */,
+                               7C137943222326D500D7A824 /* README.md */,
                                A8A47294151A825A004123FF /* strtod.cc */,
                                A8A47295151A825A004123FF /* strtod.h */,
                                A8A47296151A825A004123FF /* utils.h */,
                                A8A4739C151A825B004123FF /* CurrentTime.cpp in Sources */,
                                A8A4739E151A825B004123FF /* DataLog.cpp in Sources */,
                                A8A473A0151A825B004123FF /* DateMath.cpp in Sources */,
-                               A8A473A2151A825B004123FF /* DecimalNumber.cpp in Sources */,
                                1ACADD841884480100D8B71D /* DeprecatedSymbolsUsedBySafari.mm in Sources */,
                                A8A473AE151A825B004123FF /* diy-fp.cc in Sources */,
                                A8A473B0151A825B004123FF /* double-conversion.cc in Sources */,
index 20f00f9..27ef231 100644 (file)
@@ -45,7 +45,6 @@ set(WTF_PUBLIC_HEADERS
     DataLog.h
     DateMath.h
     DebugUtilities.h
-    DecimalNumber.h
     DeferrableRefCounted.h
     DeprecatedOptional.h
     Deque.h
@@ -351,7 +350,6 @@ set(WTF_SOURCES
     CurrentTime.cpp
     DataLog.cpp
     DateMath.cpp
-    DecimalNumber.cpp
     FastBitVector.cpp
     FastMalloc.cpp
     FilePrintStream.cpp
diff --git a/Source/WTF/wtf/DecimalNumber.cpp b/Source/WTF/wtf/DecimalNumber.cpp
deleted file mode 100644 (file)
index c722ce5..0000000
+++ /dev/null
@@ -1,198 +0,0 @@
-/*
- * Copyright (C) 2010 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``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 APPLE INC. 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 "config.h"
-#include <wtf/DecimalNumber.h>
-
-#include <wtf/MathExtras.h>
-
-namespace WTF {
-
-unsigned DecimalNumber::bufferLengthForStringDecimal() const
-{
-    unsigned length = 0;
-    // if the exponent is negative the number decimal representation is of the form:
-    // [<sign>]0.[<zeros>]<significand>
-    if (m_exponent < 0) {
-        if (m_sign)
-            ++length;
-        length += 2; // for "0."
-        length += -m_exponent - 1;
-        length += m_precision;
-        return length;
-    }
-
-    unsigned digitsBeforeDecimalPoint = m_exponent + 1;
-
-    // If the precision is <= than the number of digits to get up to the decimal
-    // point, then there is no fractional part, number is of the form:
-    // [<sign>]<significand>[<zeros>]
-    if (m_precision <= digitsBeforeDecimalPoint) {
-        if (m_sign)
-            ++length;
-        length += m_precision;
-        length += digitsBeforeDecimalPoint - m_precision;
-        return length;
-    }
-
-    // If we get here, number starts before the decimal point, and ends after it,
-    // as such is of the form:
-    // [<sign>]<significand-begin>.<significand-end>
-    if (m_sign)
-        ++length;
-    length += digitsBeforeDecimalPoint;
-    ++length; // for decimal point
-    length += m_precision - digitsBeforeDecimalPoint;
-
-    return length;
-}
-
-unsigned DecimalNumber::bufferLengthForStringExponential() const
-{
-    unsigned length = 0;
-    if (m_sign)
-        ++length;
-
-    // Add the significand
-    ++length;
-
-    if (m_precision > 1) {
-        ++length; // for decimal point
-        length += m_precision - 1;
-    }
-
-    // Add "e+" or "e-"
-    length += 2;
-
-    int exponent = (m_exponent >= 0) ? m_exponent : -m_exponent;
-
-    // Add the exponent
-    if (exponent >= 100)
-        ++length;
-    if (exponent >= 10)
-        ++length;
-    ++length;
-
-    return length;
-}
-
-unsigned DecimalNumber::toStringDecimal(LChar* buffer, unsigned bufferLength) const
-{
-    ASSERT_UNUSED(bufferLength, bufferLength >= bufferLengthForStringDecimal());
-
-    // Should always be at least one digit to add to the string!
-    ASSERT(m_precision);
-    LChar* next = buffer;
-
-    // if the exponent is negative the number decimal representation is of the form:
-    // [<sign>]0.[<zeros>]<significand>
-    if (m_exponent < 0) {
-        unsigned zeros = -m_exponent - 1;
-
-        if (m_sign)
-            *next++ = '-';
-        *next++ = '0';
-        *next++ = '.';
-        for (unsigned i = 0; i < zeros; ++i)
-            *next++ = '0';
-        for (unsigned i = 0; i < m_precision; ++i)
-            *next++ = m_significand[i];
-
-        return next - buffer;
-    }
-
-    unsigned digitsBeforeDecimalPoint = m_exponent + 1;
-
-    // If the precision is <= than the number of digits to get up to the decimal
-    // point, then there is no fractional part, number is of the form:
-    // [<sign>]<significand>[<zeros>]
-    if (m_precision <= digitsBeforeDecimalPoint) {
-        if (m_sign)
-            *next++ = '-';
-        for (unsigned i = 0; i < m_precision; ++i)
-            *next++ = m_significand[i];
-        for (unsigned i = 0; i < (digitsBeforeDecimalPoint - m_precision); ++i)
-            *next++ = '0';
-
-        return next - buffer;
-    }
-
-    // If we get here, number starts before the decimal point, and ends after it,
-    // as such is of the form:
-    // [<sign>]<significand-begin>.<significand-end>
-
-    if (m_sign)
-        *next++ = '-';
-    for (unsigned i = 0; i < digitsBeforeDecimalPoint; ++i)
-        *next++ = m_significand[i];
-    *next++ = '.';
-    for (unsigned i = digitsBeforeDecimalPoint; i < m_precision; ++i)
-        *next++ = m_significand[i];
-
-    return next - buffer;
-}
-
-unsigned DecimalNumber::toStringExponential(LChar* buffer, unsigned bufferLength) const
-{
-    ASSERT_UNUSED(bufferLength, bufferLength >= bufferLengthForStringExponential());
-
-    // Should always be at least one digit to add to the string!
-    ASSERT(m_precision);
-    LChar* next = buffer;
-
-    // Add the sign
-    if (m_sign)
-        *next++ = '-';
-
-    // Add the significand
-    *next++ = m_significand[0];
-    if (m_precision > 1) {
-        *next++ = '.';
-        for (unsigned i = 1; i < m_precision; ++i)
-            *next++ = m_significand[i];
-    }
-
-    // Add "e+" or "e-"
-    *next++ = 'e';
-    int exponent;
-    if (m_exponent >= 0) {
-        *next++ = '+';
-        exponent = m_exponent;
-    } else {
-        *next++ = '-';
-        exponent = -m_exponent;
-    }
-
-    // Add the exponent
-    if (exponent >= 100)
-        *next++ = '0' + exponent / 100;
-    if (exponent >= 10)
-        *next++ = '0' + (exponent % 100) / 10;
-    *next++ = '0' + exponent % 10;
-
-    return next - buffer;
-}
-
-} // namespace WTF
diff --git a/Source/WTF/wtf/DecimalNumber.h b/Source/WTF/wtf/DecimalNumber.h
deleted file mode 100644 (file)
index ac4eff7..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Copyright (C) 2010 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``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 APPLE INC. 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. 
- */
-
-#pragma once
-
-#include <cmath>
-#include <wtf/dtoa.h>
-
-namespace WTF {
-
-class DecimalNumber {
-public:
-    explicit DecimalNumber(double d)
-    {
-        ASSERT(std::isfinite(d));
-        dtoa(m_significand, d, m_sign, m_exponent, m_precision);
-
-        ASSERT(m_precision);
-        // Zero should always have exponent 0.
-        ASSERT(m_significand[0] != '0' || !m_exponent);
-        // No values other than zero should have a leading zero.
-        ASSERT(m_significand[0] != '0' || m_precision == 1);
-        // No values other than zero should have trailing zeros.
-        ASSERT(m_significand[0] == '0' || m_significand[m_precision - 1] != '0');
-    }
-
-    WTF_EXPORT_PRIVATE unsigned bufferLengthForStringDecimal() const;
-    WTF_EXPORT_PRIVATE unsigned bufferLengthForStringExponential() const;
-
-    WTF_EXPORT_PRIVATE unsigned toStringDecimal(LChar* buffer, unsigned bufferLength) const;
-    WTF_EXPORT_PRIVATE unsigned toStringExponential(LChar* buffer, unsigned bufferLength) const;
-
-private:
-    bool m_sign;
-    int m_exponent;
-    DtoaBuffer m_significand;
-    unsigned m_precision;
-};
-
-} // namespace WTF
-
-using WTF::DecimalNumber;
index a0ee101..9fe0086 100644 (file)
@@ -33,8 +33,6 @@
 #include "config.h"
 #include <wtf/JSONValues.h>
 
-#include <wtf/DecimalNumber.h>
-#include <wtf/dtoa.h>
 #include <wtf/text/StringBuilder.h>
 
 namespace WTF {
@@ -673,24 +671,10 @@ void Value::writeJSON(StringBuilder& output) const
         break;
     case Type::Double:
     case Type::Integer: {
-        if (!std::isfinite(m_value.number)) {
+        if (!std::isfinite(m_value.number))
             output.appendLiteral("null");
-            return;
-        }
-        DecimalNumber decimal { m_value.number };
-        NumberToStringBuffer buffer;
-        unsigned length = 0;
-        if (decimal.bufferLengthForStringDecimal() > sizeof(buffer)) {
-            // Not enough room for decimal. Use exponential format.
-            if (decimal.bufferLengthForStringExponential() > sizeof(buffer)) {
-                // Fallback for an abnormal case if it's too little even for exponential.
-                output.appendLiteral("NaN");
-                return;
-            }
-            length = decimal.toStringExponential(reinterpret_cast<LChar*>(&buffer[0]), sizeof(buffer));
-        } else
-            length = decimal.toStringDecimal(reinterpret_cast<LChar*>(&buffer[0]), sizeof(buffer));
-        output.append(&buffer[0], length);
+        else
+            output.appendECMAScriptNumber(m_value.number);
         break;
     }
     default:
index f91051e..26a6c75 100644 (file)
-/****************************************************************
+/*
+ *  Copyright (C) 2003-2019 Apple Inc. All rights reserved.
  *
- * The author of this software is David M. Gay.
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
  *
- * Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
- * Copyright (C) 2002-2019 Apple Inc. All rights reserved.
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
  *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose without fee is hereby granted, provided that this entire notice
- * is included in all copies of any software which is or includes a copy
- * or modification of this software and in all copies of the supporting
- * documentation for such software.
+ *  You should have received a copy of the GNU Library General Public License
+ *  along with this library; see the file COPYING.LIB.  If not, write to
+ *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ *  Boston, MA 02110-1301, USA.
  *
- * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
- * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
- * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
- * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
- *
- ***************************************************************/
-
-/* Please send bug reports to David M. Gay (dmg at acm dot org,
- * with " at " changed at "@" and " dot " changed to ".").    */
-
-/* On a machine with IEEE extended-precision registers, it is
- * necessary to specify double-precision (53-bit) rounding precision
- * before invoking strtod or dtoa.  If the machine uses (the equivalent
- * of) Intel 80x87 arithmetic, the call
- *    _control87(PC_53, MCW_PC);
- * does this with many compilers.  Whether this or another call is
- * appropriate depends on the compiler; for this to work, it may be
- * necessary to #include "float.h" or another system-dependent header
- * file.
  */
 
 #include "config.h"
 #include <wtf/dtoa.h>
 
-#include <stdio.h>
-#include <wtf/Lock.h>
-#include <wtf/MathExtras.h>
-#include <wtf/Threading.h>
-#include <wtf/Vector.h>
-
-#if COMPILER(MSVC)
-#pragma warning(disable: 4244)
-#pragma warning(disable: 4245)
-#pragma warning(disable: 4554)
-#endif
-
-#if CPU(PPC64) || CPU(X86_64) || CPU(ARM64)
-// FIXME: should we enable this on all 64-bit CPUs?
-// 64-bit emulation provided by the compiler is likely to be slower than dtoa own code on 32-bit hardware.
-#define USE_LONG_LONG
-#endif
-
 namespace WTF {
 
-static Lock s_dtoaP5Mutex;
-
-typedef union {
-    double d;
-    uint32_t L[2];
-} U;
-
-#if CPU(BIG_ENDIAN) || CPU(MIDDLE_ENDIAN)
-#define word0(x) (x)->L[0]
-#define word1(x) (x)->L[1]
-#else
-#define word0(x) (x)->L[1]
-#define word1(x) (x)->L[0]
-#endif
-#define dval(x) (x)->d
-
-#ifndef USE_LONG_LONG
-/* The following definition of Storeinc is appropriate for MIPS processors.
- * An alternative that might be better on some machines is
- *  *p++ = high << 16 | low & 0xffff;
- */
-static ALWAYS_INLINE uint32_t* storeInc(uint32_t* p, uint16_t high, uint16_t low)
-{
-    uint16_t* p16 = reinterpret_cast<uint16_t*>(p);
-#if CPU(BIG_ENDIAN)
-    p16[0] = high;
-    p16[1] = low;
-#else
-    p16[1] = high;
-    p16[0] = low;
-#endif
-    return p + 1;
-}
-
-#endif // USE_LONG_LONG
-
-#define Exp_shift  20
-#define Exp_shift1 20
-#define Exp_msk1    0x100000
-#define Exp_msk11   0x100000
-#define Exp_mask  0x7ff00000
-#define P 53
-#define Bias 1023
-#define Emin (-1022)
-#define Exp_1  0x3ff00000
-#define Exp_11 0x3ff00000
-#define Ebits 11
-#define Frac_mask  0xfffff
-#define Frac_mask1 0xfffff
-#define Ten_pmax 22
-#define Bletch 0x10
-#define Bndry_mask  0xfffff
-#define Bndry_mask1 0xfffff
-#define LSB 1
-#define Sign_bit 0x80000000
-#define Log2P 1
-#define Tiny0 0
-#define Tiny1 1
-#define Quick_max 14
-#define Int_max 14
-
-#define rounded_product(a, b) a *= b
-#define rounded_quotient(a, b) a /= b
-
-#define Big0 (Frac_mask1 | Exp_msk1 * (DBL_MAX_EXP + Bias - 1))
-#define Big1 0xffffffff
-
-struct BigInt {
-    BigInt() : sign(0) { }
-    int sign;
-
-    void clear()
-    {
-        sign = 0;
-        m_words.clear();
-    }
-
-    size_t size() const
-    {
-        return m_words.size();
-    }
-
-    void resize(size_t s)
-    {
-        m_words.resize(s);
-    }
-
-    uint32_t* words()
-    {
-        return m_words.data();
-    }
-
-    const uint32_t* words() const
-    {
-        return m_words.data();
-    }
-
-    void append(uint32_t w)
-    {
-        m_words.append(w);
-    }
-
-    Vector<uint32_t, 16> m_words;
-};
-
-static void multadd(BigInt& b, int m, int a)    /* multiply by m and add a */
-{
-#ifdef USE_LONG_LONG
-    unsigned long long carry;
-#else
-    uint32_t carry;
-#endif
-
-    int wds = b.size();
-    uint32_t* x = b.words();
-    int i = 0;
-    carry = a;
-    do {
-#ifdef USE_LONG_LONG
-        unsigned long long y = *x * (unsigned long long)m + carry;
-        carry = y >> 32;
-        *x++ = (uint32_t)y & 0xffffffffUL;
-#else
-        uint32_t xi = *x;
-        uint32_t y = (xi & 0xffff) * m + carry;
-        uint32_t z = (xi >> 16) * m + (y >> 16);
-        carry = z >> 16;
-        *x++ = (z << 16) + (y & 0xffff);
-#endif
-    } while (++i < wds);
-
-    if (carry)
-        b.append((uint32_t)carry);
-}
-
-static int hi0bits(uint32_t x)
-{
-    int k = 0;
-
-    if (!(x & 0xffff0000)) {
-        k = 16;
-        x <<= 16;
-    }
-    if (!(x & 0xff000000)) {
-        k += 8;
-        x <<= 8;
-    }
-    if (!(x & 0xf0000000)) {
-        k += 4;
-        x <<= 4;
-    }
-    if (!(x & 0xc0000000)) {
-        k += 2;
-        x <<= 2;
-    }
-    if (!(x & 0x80000000)) {
-        k++;
-        if (!(x & 0x40000000))
-            return 32;
-    }
-    return k;
-}
-
-static int lo0bits(uint32_t* y)
-{
-    int k;
-    uint32_t x = *y;
-
-    if (x & 7) {
-        if (x & 1)
-            return 0;
-        if (x & 2) {
-            *y = x >> 1;
-            return 1;
-        }
-        *y = x >> 2;
-        return 2;
-    }
-    k = 0;
-    if (!(x & 0xffff)) {
-        k = 16;
-        x >>= 16;
-    }
-    if (!(x & 0xff)) {
-        k += 8;
-        x >>= 8;
-    }
-    if (!(x & 0xf)) {
-        k += 4;
-        x >>= 4;
-    }
-    if (!(x & 0x3)) {
-        k += 2;
-        x >>= 2;
-    }
-    if (!(x & 1)) {
-        k++;
-        x >>= 1;
-        if (!x)
-            return 32;
-    }
-    *y = x;
-    return k;
-}
-
-static void i2b(BigInt& b, int i)
-{
-    b.sign = 0;
-    b.resize(1);
-    b.words()[0] = i;
-}
-
-static void mult(BigInt& aRef, const BigInt& bRef)
-{
-    const BigInt* a = &aRef;
-    const BigInt* b = &bRef;
-    BigInt c;
-    int wa, wb, wc;
-    const uint32_t* x = 0;
-    const uint32_t* xa;
-    const uint32_t* xb;
-    const uint32_t* xae;
-    const uint32_t* xbe;
-    uint32_t* xc;
-    uint32_t* xc0;
-    uint32_t y;
-#ifdef USE_LONG_LONG
-    unsigned long long carry, z;
-#else
-    uint32_t carry, z;
-#endif
-
-    if (a->size() < b->size()) {
-        const BigInt* tmp = a;
-        a = b;
-        b = tmp;
-    }
-
-    wa = a->size();
-    wb = b->size();
-    wc = wa + wb;
-    c.resize(wc);
-
-    for (xc = c.words(), xa = xc + wc; xc < xa; xc++)
-        *xc = 0;
-    xa = a->words();
-    xae = xa + wa;
-    xb = b->words();
-    xbe = xb + wb;
-    xc0 = c.words();
-#ifdef USE_LONG_LONG
-    for (; xb < xbe; xc0++) {
-        if ((y = *xb++)) {
-            x = xa;
-            xc = xc0;
-            carry = 0;
-            do {
-                z = *x++ * (unsigned long long)y + *xc + carry;
-                carry = z >> 32;
-                *xc++ = (uint32_t)z & 0xffffffffUL;
-            } while (x < xae);
-            *xc = (uint32_t)carry;
-        }
-    }
-#else
-    for (; xb < xbe; xb++, xc0++) {
-        if ((y = *xb & 0xffff)) {
-            x = xa;
-            xc = xc0;
-            carry = 0;
-            do {
-                z = (*x & 0xffff) * y + (*xc & 0xffff) + carry;
-                carry = z >> 16;
-                uint32_t z2 = (*x++ >> 16) * y + (*xc >> 16) + carry;
-                carry = z2 >> 16;
-                xc = storeInc(xc, z2, z);
-            } while (x < xae);
-            *xc = carry;
-        }
-        if ((y = *xb >> 16)) {
-            x = xa;
-            xc = xc0;
-            carry = 0;
-            uint32_t z2 = *xc;
-            do {
-                z = (*x & 0xffff) * y + (*xc >> 16) + carry;
-                carry = z >> 16;
-                xc = storeInc(xc, z, z2);
-                z2 = (*x++ >> 16) * y + (*xc & 0xffff) + carry;
-                carry = z2 >> 16;
-            } while (x < xae);
-            *xc = z2;
-        }
-    }
-#endif
-    for (xc0 = c.words(), xc = xc0 + wc; wc > 0 && !*--xc; --wc) { }
-    c.resize(wc);
-    aRef = c;
-}
-
-struct P5Node {
-    WTF_MAKE_NONCOPYABLE(P5Node); WTF_MAKE_FAST_ALLOCATED;
-public:
-    P5Node() { }
-    BigInt val;
-    P5Node* next { nullptr };
-};
-
-static P5Node* p5s;
-static int p5sCount;
-
-static ALWAYS_INLINE void pow5mult(BigInt& b, int k)
-{
-    static const int p05[3] = { 5, 25, 125 };
-
-    if (int i = k & 3)
-        multadd(b, p05[i - 1], 0);
-
-    if (!(k >>= 2))
-        return;
-
-    s_dtoaP5Mutex.lock();
-    P5Node* p5 = p5s;
-
-    if (!p5) {
-        /* first time */
-        p5 = new P5Node;
-        i2b(p5->val, 625);
-        p5->next = 0;
-        p5s = p5;
-        p5sCount = 1;
-    }
-
-    int p5sCountLocal = p5sCount;
-    s_dtoaP5Mutex.unlock();
-    int p5sUsed = 0;
-
-    for (;;) {
-        if (k & 1)
-            mult(b, p5->val);
-
-        if (!(k >>= 1))
-            break;
-
-        if (++p5sUsed == p5sCountLocal) {
-            s_dtoaP5Mutex.lock();
-            if (p5sUsed == p5sCount) {
-                ASSERT(!p5->next);
-                p5->next = new P5Node;
-                p5->next->next = 0;
-                p5->next->val = p5->val;
-                mult(p5->next->val, p5->next->val);
-                ++p5sCount;
-            }
-
-            p5sCountLocal = p5sCount;
-            s_dtoaP5Mutex.unlock();
-        }
-        p5 = p5->next;
-    }
-}
-
-static ALWAYS_INLINE void lshift(BigInt& b, int k)
-{
-    int n = k >> 5;
-
-    int origSize = b.size();
-    int n1 = n + origSize + 1;
-
-    if (k &= 0x1f)
-        b.resize(b.size() + n + 1);
-    else
-        b.resize(b.size() + n);
-
-    const uint32_t* srcStart = b.words();
-    uint32_t* dstStart = b.words();
-    const uint32_t* src = srcStart + origSize - 1;
-    uint32_t* dst = dstStart + n1 - 1;
-    if (k) {
-        uint32_t hiSubword = 0;
-        int s = 32 - k;
-        for (; src >= srcStart; --src) {
-            *dst-- = hiSubword | *src >> s;
-            hiSubword = *src << k;
-        }
-        *dst = hiSubword;
-        ASSERT(dst == dstStart + n);
-
-        b.resize(origSize + n + !!b.words()[n1 - 1]);
-    }
-    else {
-        do {
-            *--dst = *src--;
-        } while (src >= srcStart);
-    }
-    for (dst = dstStart + n; dst != dstStart; )
-        *--dst = 0;
-
-    ASSERT(b.size() <= 1 || b.words()[b.size() - 1]);
-}
-
-static int cmp(const BigInt& a, const BigInt& b)
-{
-    const uint32_t *xa, *xa0, *xb, *xb0;
-    int i, j;
-
-    i = a.size();
-    j = b.size();
-    ASSERT(i <= 1 || a.words()[i - 1]);
-    ASSERT(j <= 1 || b.words()[j - 1]);
-    if (i -= j)
-        return i;
-    xa0 = a.words();
-    xa = xa0 + j;
-    xb0 = b.words();
-    xb = xb0 + j;
-    for (;;) {
-        if (*--xa != *--xb)
-            return *xa < *xb ? -1 : 1;
-        if (xa <= xa0)
-            break;
-    }
-    return 0;
-}
-
-static ALWAYS_INLINE void diff(BigInt& c, const BigInt& aRef, const BigInt& bRef)
-{
-    const BigInt* a = &aRef;
-    const BigInt* b = &bRef;
-    int i, wa, wb;
-    uint32_t* xc;
-
-    i = cmp(*a, *b);
-    if (!i) {
-        c.sign = 0;
-        c.resize(1);
-        c.words()[0] = 0;
-        return;
-    }
-    if (i < 0) {
-        const BigInt* tmp = a;
-        a = b;
-        b = tmp;
-        i = 1;
-    } else
-        i = 0;
-
-    wa = a->size();
-    const uint32_t* xa = a->words();
-    const uint32_t* xae = xa + wa;
-    wb = b->size();
-    const uint32_t* xb = b->words();
-    const uint32_t* xbe = xb + wb;
-
-    c.resize(wa);
-    c.sign = i;
-    xc = c.words();
-#ifdef USE_LONG_LONG
-    unsigned long long borrow = 0;
-    do {
-        unsigned long long y = (unsigned long long)*xa++ - *xb++ - borrow;
-        borrow = y >> 32 & (uint32_t)1;
-        *xc++ = (uint32_t)y & 0xffffffffUL;
-    } while (xb < xbe);
-    while (xa < xae) {
-        unsigned long long y = *xa++ - borrow;
-        borrow = y >> 32 & (uint32_t)1;
-        *xc++ = (uint32_t)y & 0xffffffffUL;
-    }
-#else
-    uint32_t borrow = 0;
-    do {
-        uint32_t y = (*xa & 0xffff) - (*xb & 0xffff) - borrow;
-        borrow = (y & 0x10000) >> 16;
-        uint32_t z = (*xa++ >> 16) - (*xb++ >> 16) - borrow;
-        borrow = (z & 0x10000) >> 16;
-        xc = storeInc(xc, z, y);
-    } while (xb < xbe);
-    while (xa < xae) {
-        uint32_t y = (*xa & 0xffff) - borrow;
-        borrow = (y & 0x10000) >> 16;
-        uint32_t z = (*xa++ >> 16) - borrow;
-        borrow = (z & 0x10000) >> 16;
-        xc = storeInc(xc, z, y);
-    }
-#endif
-    while (!*--xc)
-        wa--;
-    c.resize(wa);
-}
-
-static ALWAYS_INLINE void d2b(BigInt& b, U* d, int* e, int* bits)
-{
-    int de, k;
-    uint32_t* x;
-    uint32_t y, z;
-    int i;
-#define d0 word0(d)
-#define d1 word1(d)
-
-    b.sign = 0;
-    b.resize(1);
-    x = b.words();
-
-    z = d0 & Frac_mask;
-    d0 &= 0x7fffffff;    /* clear sign bit, which we ignore */
-    if ((de = (int)(d0 >> Exp_shift)))
-        z |= Exp_msk1;
-    if ((y = d1)) {
-        if ((k = lo0bits(&y))) {
-            x[0] = y | (z << (32 - k));
-            z >>= k;
-        } else
-            x[0] = y;
-        if (z) {
-            b.resize(2);
-            x[1] = z;
-        }
-
-        i = b.size();
-    } else {
-        k = lo0bits(&z);
-        x[0] = z;
-        i = 1;
-        b.resize(1);
-        k += 32;
-    }
-    if (de) {
-        *e = de - Bias - (P - 1) + k;
-        *bits = P - k;
-    } else {
-        *e = 0 - Bias - (P - 1) + 1 + k;
-        *bits = (32 * i) - hi0bits(x[i - 1]);
-    }
-}
-#undef d0
-#undef d1
-
-static const double tens[] = {
-    1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
-    1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
-    1e20, 1e21, 1e22
-};
-
-static const double bigtens[] = { 1e16, 1e32, 1e64, 1e128, 1e256 };
-
-#define Scale_Bit 0x10
-#define n_bigtens 5
-
-static ALWAYS_INLINE int quorem(BigInt& b, BigInt& S)
-{
-    size_t n;
-    uint32_t* bx;
-    uint32_t* bxe;
-    uint32_t q;
-    uint32_t* sx;
-    uint32_t* sxe;
-#ifdef USE_LONG_LONG
-    unsigned long long borrow, carry, y, ys;
-#else
-    uint32_t borrow, carry, y, ys;
-    uint32_t si, z, zs;
-#endif
-    ASSERT(b.size() <= 1 || b.words()[b.size() - 1]);
-    ASSERT(S.size() <= 1 || S.words()[S.size() - 1]);
-
-    n = S.size();
-    ASSERT_WITH_MESSAGE(b.size() <= n, "oversize b in quorem");
-    if (b.size() < n)
-        return 0;
-    sx = S.words();
-    sxe = sx + --n;
-    bx = b.words();
-    bxe = bx + n;
-    q = *bxe / (*sxe + 1);    /* ensure q <= true quotient */
-    ASSERT_WITH_MESSAGE(q <= 9, "oversized quotient in quorem");
-    if (q) {
-        borrow = 0;
-        carry = 0;
-        do {
-#ifdef USE_LONG_LONG
-            ys = *sx++ * (unsigned long long)q + carry;
-            carry = ys >> 32;
-            y = *bx - (ys & 0xffffffffUL) - borrow;
-            borrow = y >> 32 & (uint32_t)1;
-            *bx++ = (uint32_t)y & 0xffffffffUL;
-#else
-            si = *sx++;
-            ys = (si & 0xffff) * q + carry;
-            zs = (si >> 16) * q + (ys >> 16);
-            carry = zs >> 16;
-            y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
-            borrow = (y & 0x10000) >> 16;
-            z = (*bx >> 16) - (zs & 0xffff) - borrow;
-            borrow = (z & 0x10000) >> 16;
-            bx = storeInc(bx, z, y);
-#endif
-        } while (sx <= sxe);
-        if (!*bxe) {
-            bx = b.words();
-            while (--bxe > bx && !*bxe)
-                --n;
-            b.resize(n);
-        }
-    }
-    if (cmp(b, S) >= 0) {
-        q++;
-        borrow = 0;
-        carry = 0;
-        bx = b.words();
-        sx = S.words();
-        do {
-#ifdef USE_LONG_LONG
-            ys = *sx++ + carry;
-            carry = ys >> 32;
-            y = *bx - (ys & 0xffffffffUL) - borrow;
-            borrow = y >> 32 & (uint32_t)1;
-            *bx++ = (uint32_t)y & 0xffffffffUL;
-#else
-            si = *sx++;
-            ys = (si & 0xffff) + carry;
-            zs = (si >> 16) + (ys >> 16);
-            carry = zs >> 16;
-            y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
-            borrow = (y & 0x10000) >> 16;
-            z = (*bx >> 16) - (zs & 0xffff) - borrow;
-            borrow = (z & 0x10000) >> 16;
-            bx = storeInc(bx, z, y);
-#endif
-        } while (sx <= sxe);
-        bx = b.words();
-        bxe = bx + n;
-        if (!*bxe) {
-            while (--bxe > bx && !*bxe)
-                --n;
-            b.resize(n);
-        }
-    }
-    return q;
-}
-
-/* dtoa for IEEE arithmetic (dmg): convert double to ASCII string.
- *
- * Inspired by "How to Print Floating-Point Numbers Accurately" by
- * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90, pp. 112-126].
- *
- * Modifications:
- *    1. Rather than iterating, we use a simple numeric overestimate
- *       to determine k = floor(log10(d)).  We scale relevant
- *       quantities using O(log2(k)) rather than O(k) multiplications.
- *    2. For some modes > 2 (corresponding to ecvt and fcvt), we don't
- *       try to generate digits strictly left to right.  Instead, we
- *       compute with fewer bits and propagate the carry if necessary
- *       when rounding the final digit up.  This is often faster.
- *    3. Under the assumption that input will be rounded nearest,
- *       mode 0 renders 1e23 as 1e23 rather than 9.999999999999999e22.
- *       That is, we allow equality in stopping tests when the
- *       round-nearest rule will give the same floating-point value
- *       as would satisfaction of the stopping test with strict
- *       inequality.
- *    4. We remove common factors of powers of 2 from relevant
- *       quantities.
- *    5. When converting floating-point integers less than 1e16,
- *       we use floating-point arithmetic rather than resorting
- *       to multiple-precision integers.
- *    6. When asked to produce fewer than 15 digits, we first try
- *       to get by with floating-point arithmetic; we resort to
- *       multiple-precision integer arithmetic only if we cannot
- *       guarantee that the floating-point calculation has given
- *       the correctly rounded result.  For k requested digits and
- *       "uniformly" distributed input, the probability is
- *       something like 10^(k-15) that we must resort to the int32_t
- *       calculation.
- */
-void dtoa(DtoaBuffer& result, double dd, bool& signOut, int& exponentOut, unsigned& precisionOut)
-{
-    ASSERT(std::isfinite(dd));
-
-    int bbits, b2, b5, be, dig, i, ieps, ilim = 0, ilim0, ilim1 = 0,
-        j, j1, k, k0, k_check, m2, m5, s2, s5,
-        spec_case;
-    int32_t L;
-    int denorm;
-    uint32_t x;
-    BigInt b, delta, mlo, mhi, S;
-    U d2, eps, u;
-    double ds;
-    char* s;
-    char* s0;
-
-    u.d = dd;
-
-    /* Infinity or NaN */
-    ASSERT((word0(&u) & Exp_mask) != Exp_mask);
-
-    // JavaScript toString conversion treats -0 as 0.
-    if (!dval(&u)) {
-        signOut = false;
-        exponentOut = 0;
-        precisionOut = 1;
-        result[0] = '0';
-        result[1] = '\0';
-        return;
-    }
-
-    if (word0(&u) & Sign_bit) {
-        signOut = true;
-        word0(&u) &= ~Sign_bit; // clear sign bit
-    } else
-        signOut = false;
-
-    d2b(b, &u, &be, &bbits);
-    if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask >> Exp_shift1)))) {
-        dval(&d2) = dval(&u);
-        word0(&d2) &= Frac_mask1;
-        word0(&d2) |= Exp_11;
-
-        /* log(x)    ~=~ log(1.5) + (x-1.5)/1.5
-         * log10(x)     =  log(x) / log(10)
-         *        ~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
-         * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
-         *
-         * This suggests computing an approximation k to log10(d) by
-         *
-         * k = (i - Bias)*0.301029995663981
-         *    + ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
-         *
-         * We want k to be too large rather than too small.
-         * The error in the first-order Taylor series approximation
-         * is in our favor, so we just round up the constant enough
-         * to compensate for any error in the multiplication of
-         * (i - Bias) by 0.301029995663981; since |i - Bias| <= 1077,
-         * and 1077 * 0.30103 * 2^-52 ~=~ 7.2e-14,
-         * adding 1e-13 to the constant term more than suffices.
-         * Hence we adjust the constant term to 0.1760912590558.
-         * (We could get a more accurate k by invoking log10,
-         *  but this is probably not worthwhile.)
-         */
-
-        i -= Bias;
-        denorm = 0;
-    } else {
-        /* d is denormalized */
-
-        i = bbits + be + (Bias + (P - 1) - 1);
-        x = (i > 32) ? (word0(&u) << (64 - i)) | (word1(&u) >> (i - 32))
-                : word1(&u) << (32 - i);
-        dval(&d2) = x;
-        word0(&d2) -= 31 * Exp_msk1; /* adjust exponent */
-        i -= (Bias + (P - 1) - 1) + 1;
-        denorm = 1;
-    }
-    ds = (dval(&d2) - 1.5) * 0.289529654602168 + 0.1760912590558 + (i * 0.301029995663981);
-    k = (int)ds;
-    if (ds < 0. && ds != k)
-        k--;    /* want k = floor(ds) */
-    k_check = 1;
-    if (k >= 0 && k <= Ten_pmax) {
-        if (dval(&u) < tens[k])
-            k--;
-        k_check = 0;
-    }
-    j = bbits - i - 1;
-    if (j >= 0) {
-        b2 = 0;
-        s2 = j;
-    } else {
-        b2 = -j;
-        s2 = 0;
-    }
-    if (k >= 0) {
-        b5 = 0;
-        s5 = k;
-        s2 += k;
-    } else {
-        b2 -= k;
-        b5 = -k;
-        s5 = 0;
-    }
-
-    ilim = ilim1 = -1;
-    i = 18;
-
-    s = s0 = &result[0];
-
-    if (ilim >= 0 && ilim <= Quick_max) {
-        /* Try to get by with floating-point arithmetic. */
-
-        i = 0;
-        dval(&d2) = dval(&u);
-        k0 = k;
-        ilim0 = ilim;
-        ieps = 2; /* conservative */
-        if (k > 0) {
-            ds = tens[k & 0xf];
-            j = k >> 4;
-            if (j & Bletch) {
-                /* prevent overflows */
-                j &= Bletch - 1;
-                dval(&u) /= bigtens[n_bigtens - 1];
-                ieps++;
-            }
-            for (; j; j >>= 1, i++) {
-                if (j & 1) {
-                    ieps++;
-                    ds *= bigtens[i];
-                }
-            }
-            dval(&u) /= ds;
-        } else if ((j1 = -k)) {
-            dval(&u) *= tens[j1 & 0xf];
-            for (j = j1 >> 4; j; j >>= 1, i++) {
-                if (j & 1) {
-                    ieps++;
-                    dval(&u) *= bigtens[i];
-                }
-            }
-        }
-        if (k_check && dval(&u) < 1. && ilim > 0) {
-            if (ilim1 <= 0)
-                goto fastFailed;
-            ilim = ilim1;
-            k--;
-            dval(&u) *= 10.;
-            ieps++;
-        }
-        dval(&eps) = (ieps * dval(&u)) + 7.;
-        word0(&eps) -= (P - 1) * Exp_msk1;
-        if (!ilim) {
-            S.clear();
-            mhi.clear();
-            dval(&u) -= 5.;
-            if (dval(&u) > dval(&eps))
-                goto oneDigit;
-            if (dval(&u) < -dval(&eps))
-                goto noDigits;
-            goto fastFailed;
-        }
-        /* Use Steele & White method of only
-         * generating digits needed.
-         */
-        dval(&eps) = (0.5 / tens[ilim - 1]) - dval(&eps);
-        for (i = 0;;) {
-            L = (long int)dval(&u);
-            dval(&u) -= L;
-            *s++ = '0' + (int)L;
-            if (dval(&u) < dval(&eps))
-                goto ret;
-            if (1. - dval(&u) < dval(&eps))
-                goto bumpUp;
-            if (++i >= ilim)
-                break;
-            dval(&eps) *= 10.;
-            dval(&u) *= 10.;
-        }
-fastFailed:
-        s = s0;
-        dval(&u) = dval(&d2);
-        k = k0;
-        ilim = ilim0;
-    }
-
-    /* Do we have a "small" integer? */
-
-    if (be >= 0 && k <= Int_max) {
-        /* Yes. */
-        ds = tens[k];
-        for (i = 1;; i++, dval(&u) *= 10.) {
-            L = (int32_t)(dval(&u) / ds);
-            dval(&u) -= L * ds;
-            *s++ = '0' + (int)L;
-            if (!dval(&u)) {
-                break;
-            }
-            if (i == ilim) {
-                dval(&u) += dval(&u);
-                if (dval(&u) > ds || (dval(&u) == ds && (L & 1))) {
-bumpUp:
-                    while (*--s == '9')
-                        if (s == s0) {
-                            k++;
-                            *s = '0';
-                            break;
-                        }
-                    ++*s++;
-                }
-                break;
-            }
-        }
-        goto ret;
-    }
-
-    m2 = b2;
-    m5 = b5;
-    mhi.clear();
-    mlo.clear();
-    i = denorm ? be + (Bias + (P - 1) - 1 + 1) : 1 + P - bbits;
-    b2 += i;
-    s2 += i;
-    i2b(mhi, 1);
-    if (m2 > 0 && s2 > 0) {
-        i = m2 < s2 ? m2 : s2;
-        b2 -= i;
-        m2 -= i;
-        s2 -= i;
-    }
-    if (b5 > 0) {
-        if (m5 > 0) {
-            pow5mult(mhi, m5);
-            mult(b, mhi);
-        }
-        if ((j = b5 - m5))
-            pow5mult(b, j);
-    }
-    i2b(S, 1);
-    if (s5 > 0)
-        pow5mult(S, s5);
-
-    /* Check for special case that d is a normalized power of 2. */
-
-    spec_case = 0;
-    if ((!word1(&u) && !(word0(&u) & Bndry_mask) && word0(&u) & (Exp_mask & ~Exp_msk1))) {
-        /* The special case */
-        b2 += Log2P;
-        s2 += Log2P;
-        spec_case = 1;
-    }
-
-    /* Arrange for convenient computation of quotients:
-     * shift left if necessary so divisor has 4 leading 0 bits.
-     *
-     * Perhaps we should just compute leading 28 bits of S once
-     * and for all and pass them and a shift to quorem, so it
-     * can do shifts and ors to compute the numerator for q.
-     */
-    if ((i = ((s5 ? 32 - hi0bits(S.words()[S.size() - 1]) : 1) + s2) & 0x1f))
-        i = 32 - i;
-    if (i > 4) {
-        i -= 4;
-        b2 += i;
-        m2 += i;
-        s2 += i;
-    } else if (i < 4) {
-        i += 28;
-        b2 += i;
-        m2 += i;
-        s2 += i;
-    }
-    if (b2 > 0)
-        lshift(b, b2);
-    if (s2 > 0)
-        lshift(S, s2);
-    if (k_check) {
-        if (cmp(b, S) < 0) {
-            k--;
-            multadd(b, 10, 0);    /* we botched the k estimate */
-            multadd(mhi, 10, 0);
-            ilim = ilim1;
-        }
-    }
-    if (m2 > 0)
-        lshift(mhi, m2);
-
-    /* Compute mlo -- check for special case
-     * that d is a normalized power of 2.
-     */
-
-    mlo = mhi;
-    if (spec_case)
-        lshift(mhi, Log2P);
-
-    for (i = 1;;i++) {
-        dig = quorem(b, S) + '0';
-        /* Do we yet have the shortest decimal string
-         * that will round to d?
-         */
-        j = cmp(b, mlo);
-        diff(delta, S, mhi);
-        j1 = delta.sign ? 1 : cmp(b, delta);
-#ifdef DTOA_ROUND_BIASED
-        if (j < 0 || !j) {
-#else
-        // FIXME: ECMA-262 specifies that equidistant results round away from
-        // zero, which probably means we shouldn't be on the unbiased code path
-        // (the (word1(&u) & 1) clause is looking highly suspicious). I haven't
-        // yet understood this code well enough to make the call, but we should
-        // probably be enabling DTOA_ROUND_BIASED. I think the interesting corner
-        // case to understand is probably "Math.pow(0.5, 24).toString()".
-        // I believe this value is interesting because I think it is precisely
-        // representable in binary floating point, and its decimal representation
-        // has a single digit that Steele & White reduction can remove, with the
-        // value 5 (thus equidistant from the next numbers above and below).
-        // We produce the correct answer using either codepath, and I don't as
-        // yet understand why. :-)
-        if (!j1 && !(word1(&u) & 1)) {
-            if (dig == '9')
-                goto round9up;
-            if (j > 0)
-                dig++;
-            *s++ = dig;
-            goto ret;
-        }
-        if (j < 0 || (!j && !(word1(&u) & 1))) {
-#endif
-            if ((b.words()[0] || b.size() > 1) && (j1 > 0)) {
-                lshift(b, 1);
-                j1 = cmp(b, S);
-                // For IEEE-754 round-to-even, this check should be (j1 > 0 || (!j1 && (dig & 1))),
-                // but ECMA-262 specifies that equidistant values (e.g. (.5).toFixed()) should
-                // be rounded away from zero.
-                if (j1 >= 0) {
-                    if (dig == '9')
-                        goto round9up;
-                    dig++;
-                }
-            }
-            *s++ = dig;
-            goto ret;
-        }
-        if (j1 > 0) {
-            if (dig == '9') { /* possible if i == 1 */
-round9up:
-                *s++ = '9';
-                goto roundoff;
-            }
-            *s++ = dig + 1;
-            goto ret;
-        }
-        *s++ = dig;
-        if (i == ilim)
-            break;
-        multadd(b, 10, 0);
-        multadd(mlo, 10, 0);
-        multadd(mhi, 10, 0);
-    }
-
-    /* Round off last digit */
-
-    lshift(b, 1);
-    j = cmp(b, S);
-    // For IEEE-754 round-to-even, this check should be (j > 0 || (!j && (dig & 1))),
-    // but ECMA-262 specifies that equidistant values (e.g. (.5).toFixed()) should
-    // be rounded away from zero.
-    if (j >= 0) {
-roundoff:
-        while (*--s == '9')
-            if (s == s0) {
-                k++;
-                *s++ = '1';
-                goto ret;
-            }
-        ++*s++;
-    } else {
-        while (*--s == '0') { }
-        s++;
-    }
-    goto ret;
-noDigits:
-    exponentOut = 0;
-    precisionOut = 1;
-    result[0] = '0';
-    result[1] = '\0';
-    return;
-oneDigit:
-    *s++ = '1';
-    k++;
-    goto ret;
-ret:
-    ASSERT(s > &result[0]);
-    *s = 0;
-    exponentOut = k;
-    precisionOut = s - &result[0];
-}
-
 const char* numberToString(float number, NumberToStringBuffer& buffer)
 {
     double_conversion::StringBuilder builder(&buffer[0], sizeof(buffer));
index d38289d..90a7dd5 100644 (file)
 
 namespace WTF {
 
-using DtoaBuffer = std::array<char, 80>;
-
-WTF_EXPORT_PRIVATE void dtoa(DtoaBuffer& result, double dd, bool& sign, int& exponent, unsigned& precision);
-
-constexpr unsigned NumberToStringBufferLength = 96;
-using NumberToStringBuffer = std::array<char, NumberToStringBufferLength>;
+using NumberToStringBuffer = std::array<char, 96>;
 
 WTF_EXPORT_PRIVATE const char* numberToString(float, NumberToStringBuffer&);
 WTF_EXPORT_PRIVATE const char* numberToFixedPrecisionString(float, unsigned significantFigures, NumberToStringBuffer&, bool truncateTrailingZeros = false);
index b7ea323..a73a8a5 100644 (file)
@@ -1,3 +1,19 @@
+2019-03-02  Darin Adler  <darin@apple.com>
+
+        Retire legacy dtoa function and DecimalNumber class
+        https://bugs.webkit.org/show_bug.cgi?id=195253
+
+        Reviewed by Daniel Bates.
+
+        * css/CSSPrimitiveValue.cpp:
+        (WebCore::CSSPrimitiveValue::formatNumberValue const): Use makeString instead
+        of DecimalNumber. Also changed return type to String and use StringView and
+        removed special handling of literals.
+        (WebCore::CSSPrimitiveValue::formatNumberForCustomCSSText const): Removed an
+        unnecessary use of StringBuilder.
+
+        * css/CSSPrimitiveValue.h: Updated for changes to formatNumberValue.
+
 2019-03-03  Michael Catanzaro  <mcatanzaro@igalia.com>
 
         [SOUP] Cleanups in SoupNetworkSession
index 25688db..e29c289 100644 (file)
 #include "RGBColor.h"
 #include "Rect.h"
 #include "RenderStyle.h"
-#include <wtf/DecimalNumber.h>
 #include <wtf/NeverDestroyed.h>
 #include <wtf/StdLibExtras.h>
 #include <wtf/text/StringBuilder.h>
+#include <wtf/text/StringConcatenateNumbers.h>
 
 #if ENABLE(DASHBOARD_SUPPORT)
 #include "DashboardRegion.h"
@@ -934,26 +934,9 @@ ExceptionOr<Ref<RGBColor>> CSSPrimitiveValue::getRGBColorValue() const
     return RGBColor::create(m_value.color->rgb());
 }
 
-NEVER_INLINE Ref<StringImpl> CSSPrimitiveValue::formatNumberValue(const char* suffix, unsigned suffixLength) const
+NEVER_INLINE String CSSPrimitiveValue::formatNumberValue(StringView suffix) const
 {
-    DecimalNumber decimal(m_value.num);
-
-    unsigned bufferLength = decimal.bufferLengthForStringDecimal() + suffixLength;
-    LChar* buffer;
-    auto string = StringImpl::createUninitialized(bufferLength, buffer);
-
-    unsigned length = decimal.toStringDecimal(buffer, bufferLength);
-
-    for (unsigned i = 0; i < suffixLength; ++i)
-        buffer[length + i] = static_cast<LChar>(suffix[i]);
-
-    return string;
-}
-
-template <unsigned characterCount>
-ALWAYS_INLINE Ref<StringImpl> CSSPrimitiveValue::formatNumberValue(const char (&characters)[characterCount]) const
-{
-    return formatNumberValue(characters, characterCount - 1);
+    return makeString(m_value.num, suffix);
 }
 
 ALWAYS_INLINE String CSSPrimitiveValue::formatNumberForCustomCSSText() const
@@ -1028,15 +1011,8 @@ ALWAYS_INLINE String CSSPrimitiveValue::formatNumberForCustomCSSText() const
         return valueName(m_value.valueID);
     case CSS_PROPERTY_ID:
         return propertyName(m_value.propertyID);
-    case CSS_ATTR: {
-        StringBuilder result;
-        result.reserveCapacity(6 + m_value.string->length());
-        result.appendLiteral("attr(");
-        result.append(String(m_value.string));
-        result.append(')');
-
-        return result.toString();
-    }
+    case CSS_ATTR:
+        return "attr(" + String(m_value.string) + ')';
     case CSS_COUNTER_NAME:
         return "counter(" + String(m_value.string) + ')';
     case CSS_COUNTER: {
index 28fdbab..347e4b9 100644 (file)
@@ -330,8 +330,7 @@ private:
     double computeLengthDouble(const CSSToLengthConversionData&) const;
 
     ALWAYS_INLINE String formatNumberForCustomCSSText() const;
-    template<unsigned characterCount> ALWAYS_INLINE Ref<StringImpl> formatNumberValue(const char (&characters)[characterCount]) const;
-    NEVER_INLINE Ref<StringImpl> formatNumberValue(const char* suffix, unsigned suffixLength) const;
+    NEVER_INLINE String formatNumberValue(StringView) const;
 
     union {
         CSSPropertyID propertyID;