Add copyWithin and slice function to TypedArray

The algorithm's are based on ECMA-262 v6, 22.2.3.5 and 22.2.3.23

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

@@ -1687,6 +1687,248 @@ 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 */
 
+/**
+ * Helper function to normalizing an array index
+ *
+ * The function clamps the given argument to the [0, length] range.
+ *
+ * See also:
+ *          - ECMA-262 v6, 22.1.3.3 steps 7,10,13
+ *          - ECMA-262 v6, 22.2.3.23 steps 7,10
+ * Used by:
+ *          - The %TypedArray%.prototype.copyWithin routine.
+ *          - The %TypedArray%.prototype.slice routine.
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static uint32_t
+ecma_builtin_typedarray_prototype_index_helper (uint32_t length, /**< length of the typedarray */
+                                                ecma_number_t index, /**< index */
+                                                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))
+    {
+      int32_t norm_index = (int32_t) length + ecma_number_to_int32 (index);
+      ret_value = (uint32_t) JERRY_MAX (norm_index, 0);
+    }
+    else
+    {
+      ret_value = JERRY_MIN (ecma_number_to_uint32 (index), length);
+    }
+  }
+  else
+  {
+    ret_value = is_end_index ? length : 0;
+  }
+
+  return ret_value;
+} /* ecma_builtin_typedarray_prototype_index_helper */
+
+/**
+ * Helper function to get the uint32_t value from an argument.
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static uint32_t
+ecma_builtin_get_uint32_value_from_argument (ecma_value_t arg_value, /**< this argument */
+                                             ecma_value_t ret_value, /**< base function's ret_value */
+                                             uint32_t length, /**< length of the TypedArray */
+                                             bool is_end_index) /**< true - normalize the end index */
+{
+  ecma_number_t num_var;
+  uint32_t index;
+
+  ret_value = ecma_get_number (arg_value, &num_var);
+
+  if (ECMA_IS_VALUE_ERROR (ret_value))
+  {
+    return ret_value;
+  }
+
+  index = ecma_builtin_typedarray_prototype_index_helper (length, num_var, is_end_index);
+
+  return index;
+} /* ecma_builtin_get_uint32_value_from_argument */
+
+/**
+ * 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_value_t ret_value = ECMA_VALUE_EMPTY;
+
+  if (args_number > 0)
+  {
+    target = ecma_builtin_get_uint32_value_from_argument (args[0], ret_value, length, false) * element_size;
+    if (args_number > 1)
+    {
+      start = ecma_builtin_get_uint32_value_from_argument (args[1], ret_value, length, false) * element_size;
+      if (args_number > 2)
+      {
+        end = ecma_builtin_get_uint32_value_from_argument (args[2], ret_value, length, true) * element_size;
+      }
+    }
+  }
+
+  int32_t distance = (int32_t) (end - start);
+  int32_t offset = (int32_t) (limit - target);
+  int32_t count = JERRY_MIN (distance, offset);
+  count /= element_size;
+  int32_t direction = 1;
+  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 */
+
+/**
+ * The %TypedArray%.prototype object's 'slice' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 22.2.3.23
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_typedarray_prototype_slice (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 start = 0;
+  uint32_t end = length;
+  ecma_value_t ret_value = ECMA_VALUE_EMPTY;
+
+  if (args_number > 0)
+  {
+    start = ecma_builtin_get_uint32_value_from_argument (args[0], ret_value, length, false);
+    if (args_number > 1)
+    {
+      end = ecma_builtin_get_uint32_value_from_argument (args[1], ret_value, length, true);
+    }
+  }
+
+  int32_t distance = (int32_t) (end - start);
+  uint32_t count = distance > 0 ? (uint32_t) distance : 0;
+
+  ecma_value_t new_typedarray = ecma_op_create_typedarray_with_type_and_length (typedarray_p, count);
+
+  if (ECMA_IS_VALUE_ERROR (new_typedarray))
+  {
+    return new_typedarray;
+  }
+
+  ecma_object_t *new_typedarray_p = ecma_get_object_from_value (new_typedarray);
+  lit_magic_string_id_t new_class_id = ecma_object_get_class_name (new_typedarray_p);
+  lit_utf8_byte_t *new_typedarray_buffer_p = ecma_typedarray_get_buffer (new_typedarray_p);
+
+  if (count > 0)
+  {
+    ecma_length_t src_byte_offset = ecma_typedarray_get_offset (typedarray_p);
+    uint32_t target_byte_index = 0;
+    uint32_t src_byte_index = (start * element_size) + src_byte_offset;
+
+    while (target_byte_index < count * element_size)
+    {
+      ecma_number_t value = ecma_get_typedarray_element (typedarray_buffer_p + src_byte_index,
+                                                         class_id);
+
+      ecma_set_typedarray_element (new_typedarray_buffer_p + target_byte_index, value, new_class_id);
+
+      src_byte_index += element_size;
+      target_byte_index += element_size;
+    }
+  }
+
+  if (ecma_is_value_empty (ret_value))
+  {
+    ret_value = new_typedarray;
+  }
+
+  return ret_value;
+} /* ecma_builtin_typedarray_prototype_slice */
+
 /**
  * @}
  * @}

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

@@ -70,6 +70,8 @@ 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)
+ROUTINE (LIT_MAGIC_STRING_SLICE, ecma_builtin_typedarray_prototype_slice, NON_FIXED, 2)
 
 #if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
 

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

@@ -547,6 +547,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")
@@ -796,6 +799,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,73 @@
+/* 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(e.copyWithin(2, 1 ,4).toString() === '0,1,1,2,3,5');
+    assert(e.copyWithin(3, 4, 6).toString() === '0,1,1,3,5,5');
+    assert(e.copyWithin(4, 1, 3).toString() === '0,1,1,3,1,1');
+
+    e.set([5, 2, 1, 3, 4, 4]);
+
+    // Test with negative inputs
+    assert(e.copyWithin(2, -10, 3).toString() === '5,2,5,2,1,4');
+    assert(e.copyWithin(-3, 1, 6).toString() === '5,2,5,2,5,2');
+    assert(e.copyWithin(2, 0, -3).toString() === '5,2,5,2,5,2');
+
+    e.set([9, 3, 4, 5, 1, 7]);
+
+    // Test with default inputs
+    assert(e.copyWithin().toString() === '9,3,4,5,1,7');
+    assert(e.copyWithin(3).toString() === '9,3,4,9,3,4');
+    assert(e.copyWithin(1, 5).toString() === '9,4,4,9,3,4');
+
+    e.set([12, 3, 1, 43, 2, 9]);
+
+    // Test with too big inputs
+    assert(e.copyWithin(2, 12, 21).toString() === '12,3,1,43,2,9');
+    assert(e.copyWithin(4, 5, 13).toString() === '12,3,1,43,9,9');
+
+    e.set([1, 2, 3, 1, 2, 1]);
+
+    // Test with undefined inputs
+    assert(e.copyWithin(undefined, 2, 4).toString() === '3,1,3,1,2,1');
+    assert(e.copyWithin(undefined, undefined, 2).toString() === '3,1,3,1,2,1');
+    assert(e.copyWithin(3, undefined, 5).toString() === '3,1,3,3,1,3');
+
+    e.set([0, 2, 4, 2, 1, 5]);
+
+    // Test with NaN/+-Infinity
+    assert(e.copyWithin(NaN, 3, 5).toString() === '2,1,4,2,1,5');
+    assert(e.copyWithin(3, Infinity, 5).toString() === '2,1,4,2,1,5');
+    assert(e.copyWithin(1, 3, -Infinity).toString() === '2,1,4,2,1,5');
+});