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,159 @@ 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);
+  lit_magic_string_id_t class_id = ecma_object_get_class_name (typedarray_p);
+  lit_utf8_byte_t *typedarray_buffer_p = ecma_typedarray_get_buffer (typedarray_p);
+  uint8_t shift = ecma_typedarray_get_element_size_shift (typedarray_p);
+  uint8_t element_size = (uint8_t) (1 << shift);
+  uint32_t limit = length * element_size;
+  uint32_t target = 0;
+  uint32_t start = 0;
+  uint32_t end = limit;
+  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) * element_size;
+    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) * element_size;
+      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) * element_size;
+      }
+    }
+  }
+
+  int32_t distance = (int32_t) (end - start);
+  int32_t offset = (int32_t) (limit - target);
+  int32_t count = distance > offset ? offset : distance;
+  count /= element_size;
+  int32_t direction = element_size;
+  uint32_t counter = (uint32_t) ((count - 1) * element_size);
+
+  if (start < target && target < start + (uint32_t) (count * element_size))
+  {
+    direction *= -1;
+    start += counter;
+    target += counter;
+  }
+
+  while (count > 0)
+  {
+    ecma_number_t target_element = ecma_get_typedarray_element (typedarray_buffer_p + start,
+                                                                class_id);
+
+    ecma_set_typedarray_element (typedarray_buffer_p + target, target_element, class_id);
+
+    if (direction < 0)
+    {
+      start -= element_size;
+      target -= element_size;
+    }
+    else
+    {
+      start += element_size;
+      target += element_size;
+    }
+
+    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}');
+});