Add copyWithin function to TypedArray

The algorithm is based on ECMA-262 v6, 22.2.3.5

Co-authored-by: Tibor Dusnoki tdusnoki@inf.u-szeged.hu
JerryScript-DCO-1.0-Signed-off-by: Adam Szilagyi aszilagy@inf.u-szeged.hu

Author: szilagyiadam

jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.c

@@ -1601,6 +1601,191 @@ ecma_builtin_typedarray_prototype_find_index (ecma_value_t this_arg, /**< this a
   return ecma_builtin_typedarray_prototype_find_helper (this_arg, predicate, predicate_this_arg, false);
 } /* ecma_builtin_typedarray_prototype_find_index */
 
+/**
+ * The %TypedArray%.prototype object's 'copyWithin' routine helper
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static uint32_t
+ecma_builtin_typedarray_prototype_copy_within_helper (uint32_t length, /**< length of the typedarray */
+                                                      ecma_number_t index, /**< copyWithin target/start/end property */
+                                                      bool is_end_index) /**< true - normalize the end index */
+{
+  uint32_t ret_value;
+
+  if (!ecma_number_is_nan (index))
+  {
+    if (ecma_number_is_zero (index))
+    {
+      ret_value = 0;
+    }
+    else if (ecma_number_is_infinity (index))
+    {
+      ret_value = ecma_number_is_negative (index) ? 0 : length;
+    }
+    else
+    {
+      if (ecma_number_is_negative (index))
+      {
+        ecma_number_t index_neg = -index;
+        int32_t norm_index = (int32_t) ((int32_t) length - (int32_t) ecma_number_to_int32 (index_neg));
+        ret_value = norm_index > 0 ? (uint32_t) norm_index : 0;
+      }
+      else
+      {
+        ret_value = ecma_number_to_uint32 (index) > length ? length : ecma_number_to_uint32 (index);
+      }
+    }
+  }
+  else
+  {
+    ret_value = is_end_index ? length : 0;
+  }
+
+  return ret_value;
+} /* ecma_builtin_typedarray_prototype_copy_within_helper */
+
+/**
+ * The %TypedArray%.prototype object's 'copyWithin' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 22.2.3.5
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_typedarray_prototype_copy_within (ecma_value_t this_arg, /**< this argument */
+                                               const ecma_value_t args[], /**< arguments list */
+                                               ecma_length_t args_number) /**< number of arguments */
+{
+  if (!ecma_is_typedarray (this_arg))
+  {
+    return ecma_raise_type_error (ECMA_ERR_MSG ("Argument 'this' is not a TypedArray."));
+  }
+  ecma_object_t *typedarray_p = ecma_get_object_from_value (this_arg);
+  uint32_t length = ecma_typedarray_get_length (typedarray_p);
+  uint32_t target = 0;
+  uint32_t start = 0;
+  uint32_t end = length;
+  ecma_number_t num_var;
+  ecma_value_t ret_value = ECMA_VALUE_EMPTY;
+
+  if (args_number > 0)
+  {
+    ret_value = ecma_get_number (args[0], &num_var);
+
+    if (ECMA_IS_VALUE_ERROR (ret_value))
+    {
+      return ret_value;
+    }
+
+    target = ecma_builtin_typedarray_prototype_copy_within_helper (length, num_var, false);
+    if (args_number > 1)
+    {
+      ret_value = ecma_get_number (args[1], &num_var);
+
+      if (ECMA_IS_VALUE_ERROR (ret_value))
+      {
+        return ret_value;
+      }
+
+      start = ecma_builtin_typedarray_prototype_copy_within_helper (length, num_var, false);
+      if (args_number > 2)
+      {
+        ret_value = ecma_get_number (args[2], &num_var);
+
+        if (ECMA_IS_VALUE_ERROR (ret_value))
+        {
+          return ret_value;
+        }
+
+        end = ecma_builtin_typedarray_prototype_copy_within_helper (length, num_var, true);
+      }
+    }
+  }
+
+  int32_t distance = (int32_t) (end - start);
+  int32_t offset = (int32_t) (length - target);
+  int32_t count = distance > offset ? offset : distance;
+  int32_t direction;
+
+  if (start < target && target < start + (uint32_t) count)
+  {
+    direction = -1;
+    start += (uint32_t) count -1;
+    target += (uint32_t) count -1;
+  }
+  else
+  {
+    direction = 1;
+  }
+
+  while (count > 0)
+  {
+    ecma_value_t start_value = ecma_make_uint32_value (start);
+    ecma_value_t from_key = ecma_op_to_string (start_value);
+    if (ECMA_IS_VALUE_ERROR (from_key))
+    {
+      return from_key;
+    }
+    ecma_string_t *from_key_p = ecma_get_string_from_value (from_key);
+
+    ecma_value_t target_value = ecma_make_uint32_value (target);
+    ecma_value_t to_key = ecma_op_to_string (target_value);
+    if (ECMA_IS_VALUE_ERROR (to_key))
+    {
+      return to_key;
+    }
+    ecma_string_t *to_key_p = ecma_get_string_from_value (to_key);
+
+    ecma_value_t from_present = ecma_op_object_find (typedarray_p, from_key_p);
+
+    if (from_present != ECMA_VALUE_NOT_FOUND)
+    {
+      ecma_value_t from_val = ecma_op_object_get (typedarray_p, from_key_p);
+      ecma_value_t set_status = ecma_op_object_put (typedarray_p, to_key_p, from_val, true);
+
+      if (ECMA_IS_VALUE_ERROR (set_status))
+      {
+        return set_status;
+      }
+
+      ecma_free_value (from_val);
+      ecma_free_value (set_status);
+    }
+    else
+    {
+      ecma_value_t delete_status = ecma_op_object_delete (typedarray_p, to_key_p, true);
+
+      if (ECMA_IS_VALUE_ERROR (delete_status))
+      {
+        return delete_status;
+      }
+
+      ecma_free_value (delete_status);
+    }
+
+    ecma_deref_ecma_string (from_key_p);
+    ecma_deref_ecma_string (to_key_p);
+    ecma_free_value (from_present);
+    ecma_free_value (start_value);
+    ecma_free_value (target_value);
+
+    start += (uint32_t) direction;
+    target += (uint32_t) direction;
+    count--;
+  }
+
+  if (ecma_is_value_empty (ret_value))
+  {
+    ret_value = ecma_copy_value (this_arg);
+  }
+
+  return ret_value;
+} /* ecma_builtin_typedarray_prototype_copy_within */
+
 /**
  * @}
  * @}

jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.inc.h

@@ -70,6 +70,7 @@ ROUTINE (LIT_MAGIC_STRING_FILL, ecma_builtin_typedarray_prototype_fill, 3, 1)
 ROUTINE (LIT_MAGIC_STRING_SORT, ecma_builtin_typedarray_prototype_sort, 1, 1)
 ROUTINE (LIT_MAGIC_STRING_FIND, ecma_builtin_typedarray_prototype_find, 2, 1)
 ROUTINE (LIT_MAGIC_STRING_FIND_INDEX, ecma_builtin_typedarray_prototype_find_index, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_COPY_WITHIN, ecma_builtin_typedarray_prototype_copy_within, NON_FIXED, 2)
 
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
 

jerry-core/lit/lit-magic-strings.inc.h

@@ -545,6 +545,9 @@ LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_BYTE_OFFSET_UL, "byteOffset")
 #if ENABLED (JERRY_BUILTIN_STRING)
 LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_CHAR_CODE_AT_UL, "charCodeAt")
 #endif
+#if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_COPY_WITHIN, "copyWithin")
+#endif
 LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ENUMERABLE, "enumerable")
 #if ENABLED (JERRY_ES2015_BUILTIN_DATAVIEW)
 LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_FLOAT_32_UL, "getFloat32")
@@ -794,6 +797,8 @@ LIT_MAGIC_STRING_FIRST_STRING_WITH_SIZE (10, LIT_MAGIC_STRING_TYPED_ARRAY_UL)
 LIT_MAGIC_STRING_FIRST_STRING_WITH_SIZE (10, LIT_MAGIC_STRING_BYTE_LENGTH_UL)
 #elif ENABLED (JERRY_BUILTIN_STRING)
 LIT_MAGIC_STRING_FIRST_STRING_WITH_SIZE (10, LIT_MAGIC_STRING_CHAR_CODE_AT_UL)
+#elif ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
+LIT_MAGIC_STRING_FIRST_STRING_WITH_SIZE (10, LIT_MAGIC_STRING_COPY_WITHIN)
 #else
 LIT_MAGIC_STRING_FIRST_STRING_WITH_SIZE (10, LIT_MAGIC_STRING_ENUMERABLE)
 #endif

jerry-core/lit/lit-magic-strings.ini

@@ -236,6 +236,7 @@ LIT_MAGIC_STRING_UINT8_ARRAY_UL = "Uint8Array"
 LIT_MAGIC_STRING_BYTE_LENGTH_UL = "byteLength"
 LIT_MAGIC_STRING_BYTE_OFFSET_UL = "byteOffset"
 LIT_MAGIC_STRING_CHAR_CODE_AT_UL = "charCodeAt"
+LIT_MAGIC_STRING_COPY_WITHIN = "copyWithin"
 LIT_MAGIC_STRING_ENUMERABLE = "enumerable"
 LIT_MAGIC_STRING_GET_FLOAT_32_UL = "getFloat32"
 LIT_MAGIC_STRING_GET_FLOAT_64_UL = "getFloat64"

tests/jerry/es2015/typedarray-prototype-copy-within.js

@@ -0,0 +1,65 @@
+/* Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+var normal_typedarras = [
+    new Uint8Array([0, 1, 2, 3, 4, 5]),
+    new Uint16Array([0, 1, 2, 3, 4, 5]),
+    new Uint32Array([0, 1, 2, 3, 4, 5]),
+    new Float32Array([0, 1, 2, 3, 4, 5]),
+    new Float64Array([0, 1, 2, 3, 4, 5]),
+    new Int8Array([0, 1, 2, 3, 4, 5]),
+    new Int16Array([0, 1, 2, 3, 4, 5]),
+    new Int32Array([0, 1, 2, 3, 4, 5])
+  ];
+
+normal_typedarras.forEach(function(e){
+    try {
+        e.prototype.copyWithin.call (undefined);
+        assert (false);
+    } catch (e) {
+        assert (e instanceof TypeError);
+    }
+
+    // Test with normal inputs
+    assert(JSON.stringify(e.copyWithin(2, 1 ,4)) === '{"0":0,"1":1,"2":1,"3":2,"4":3,"5":5}');
+    assert(JSON.stringify(e.copyWithin(3, 4, 6)) === '{"0":0,"1":1,"2":1,"3":3,"4":5,"5":5}');
+    assert(JSON.stringify(e.copyWithin(5, 1, 3)) === '{"0":0,"1":1,"2":1,"3":3,"4":5,"5":1}');
+
+    // Test with negative inputs
+    assert(JSON.stringify(e.copyWithin(2, -10, 3)) === '{"0":0,"1":1,"2":0,"3":1,"4":1,"5":1}');
+    assert(JSON.stringify(e.copyWithin(-3, 1, 6)) === '{"0":0,"1":1,"2":0,"3":1,"4":0,"5":1}');
+    assert(JSON.stringify(e.copyWithin(2, 0, -3)) === '{"0":0,"1":1,"2":0,"3":1,"4":0,"5":1}');
+
+    // Test with default inputs
+    assert(JSON.stringify(e.copyWithin()) === '{"0":0,"1":1,"2":0,"3":1,"4":0,"5":1}');
+    assert(JSON.stringify(e.copyWithin(3)) === '{"0":0,"1":1,"2":0,"3":0,"4":1,"5":0}');
+    assert(JSON.stringify(e.copyWithin(1, 5)) === '{"0":0,"1":0,"2":0,"3":0,"4":1,"5":0}');
+
+    // Test with too big inputs
+    assert(JSON.stringify(e.copyWithin(2, 12, 21)) === '{"0":0,"1":0,"2":0,"3":0,"4":1,"5":0}');
+    assert(JSON.stringify(e.copyWithin(13, 2, 43)) === '{"0":0,"1":0,"2":0,"3":0,"4":1,"5":0}');
+
+    // Test with undefined inputs
+    assert(JSON.stringify(e.copyWithin(undefined, 2, 4)) === '{"0":0,"1":0,"2":0,"3":0,"4":1,"5":0}');
+    assert(JSON.stringify(e.copyWithin(undefined, undefined, 4)) === '{"0":0,"1":0,"2":0,"3":0,"4":1,"5":0}');
+    assert(JSON.stringify(e.copyWithin(3, undefined, 5)) === '{"0":0,"1":0,"2":0,"3":0,"4":0,"5":0}');
+
+    e.set([0, 2, 4, 2, 1, 5]);
+
+    // Test with NaN/+-Infinity
+    assert(JSON.stringify(e.copyWithin(NaN, 1, 5)) === '{"0":2,"1":4,"2":2,"3":1,"4":1,"5":5}');
+    assert(JSON.stringify(e.copyWithin(3, Infinity, 5)) === '{"0":2,"1":4,"2":2,"3":1,"4":1,"5":5}');
+    assert(JSON.stringify(e.copyWithin(5, 2, -Infinity)) === '{"0":2,"1":4,"2":2,"3":1,"4":1,"5":5}');
+});