Changeset 184863 in webkit for trunk/Source/JavaScriptCore/builtins

Timestamp:

May 26, 2015, 11:23:59 AM (10 years ago)

Author:

Yusuke Suzuki

Message:

[ES6] Implement Array.prototype.copyWithin
​https://bugs.webkit.org/show_bug.cgi?id=145107

Reviewed by Darin Adler.

Source/JavaScriptCore:

This patch implements ES6 Array.prototype.copyWithin.
It is intended to be used for copying the region to the other region
in the callee array itself safely (like memmove, not memcpy).
This function is proposed in the context of WebGL.

• builtins/Array.prototype.js:

(.maxWithPositives):
(.minWithMaybeNegativeZeroAndPositive):
(copyWithin):

• runtime/ArrayPrototype.cpp:

(JSC::ArrayPrototype::finishCreation):

• tests/stress/array-copywithin.js: Added.

(shouldBe):
(shouldBeArray):
(shouldThrow):
(arrayToObject):
(valueOf):

LayoutTests:

• js/Object-getOwnPropertyNames-expected.txt:
• js/script-tests/Object-getOwnPropertyNames.js:

File:

• trunk/Source/JavaScriptCore/builtins/Array.prototype.js (modified) (1 diff)

trunk/Source/JavaScriptCore/builtins/Array.prototype.js

@@ -456 +456 @@
     return array;
 }
+
+function copyWithin(target, start)
+{
+    "use strict";
+
+    function maxWithPositives(a, b)
+    {
+        return (a < b) ? b : a;
+    }
+
+    function minWithMaybeNegativeZeroAndPositive(maybeNegativeZero, positive)
+    {
+        return (maybeNegativeZero < positive) ? maybeNegativeZero : positive;
+    }
+
+    var thisValue = this;
+    if (thisValue === null || thisValue === undefined)
+        throw new @TypeError("Array.copyWithin requires that |this| be not null or undefined");
+    var thisObject = @Object(thisValue);
+
+    var length = @ToLength(thisObject.length);
+
+    var relativeTarget = @ToInteger(target);
+    var to = (relativeTarget < 0) ? maxWithPositives(length + relativeTarget, 0) : minWithMaybeNegativeZeroAndPositive(relativeTarget, length);
+
+    var relativeStart = @ToInteger(start);
+    var from = (relativeStart < 0) ? maxWithPositives(length + relativeStart, 0) : minWithMaybeNegativeZeroAndPositive(relativeStart, length);
+
+    var relativeEnd;
+    if (arguments.length >= 3) {
+        var end = arguments[2];
+        if (end === undefined)
+            relativeEnd = length;
+        else
+            relativeEnd = @ToInteger(end);
+    } else
+        relativeEnd = length;
+
+    var finalValue = (relativeEnd < 0) ? maxWithPositives(length + relativeEnd, 0) : minWithMaybeNegativeZeroAndPositive(relativeEnd, length);
+
+    var count = minWithMaybeNegativeZeroAndPositive(finalValue - from, length - to);
+
+    var direction = 1;
+    if (from < to && to < from + count) {
+        direction = -1;
+        from = from + count - 1;
+        to = to + count - 1;
+    }
+
+    for (var i = 0; i < count; ++i, from += direction, to += direction) {
+        if (from in thisObject)
+            thisObject[to] = thisObject[from];
+        else
+            delete thisObject[to];
+    }
+
+    return thisObject;
+}