Add keys, values, entires functions for typedArray

Extended the typedArray functionality based on ES2015

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

@@ -29,6 +29,7 @@
 #include "jrt-libc-includes.h"
 #include "ecma-gc.h"
 #include "jmem.h"
+#include "ecma-iterator-object.h"
 
 #if ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY)
 
@@ -312,6 +313,104 @@ ecma_builtin_typedarray_prototype_for_each (ecma_value_t this_arg, /**< this arg
                                                          TYPEDARRAY_ROUTINE_FOREACH);
 } /* ecma_builtin_typedarray_prototype_for_each */
 
+
+#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+/**
+ * Helper function for typedArray.prototype object's {'keys', 'values', 'entries', '@@iterator'}
+ * routines common parts.
+ *
+ * See also:
+ *          ECMA-262 v6, 22.2.3.15
+ *          ECMA-262 v6, 22.2.3.29
+ *          ECMA-262 v6, 22.2.3.6
+ *          ECMA-262 v6, 22.1.3.30
+ *
+ * Note:
+ *      Returned value must be freed with ecma_free_value.
+ *
+ * @return iterator result object, if success
+ *         error - otherwise
+ */
+static ecma_value_t
+ecma_builtin_typedarray_iterators_helper (ecma_value_t this_arg, /**< this argument */
+                                          uint8_t type) /**< any combination of ecma_iterator_type_t bits */
+{
+
+  if (!ecma_is_typedarray (this_arg))
+  {
+    return ecma_raise_type_error (ECMA_ERR_MSG ("Argument 'this' is not a TypedArray."));
+  }
+
+  ecma_value_t this_obj = ecma_op_to_object (this_arg);
+
+  if (ECMA_IS_VALUE_ERROR (this_obj))
+  {
+    return this_obj;
+  }
+
+  ecma_object_t *obj_p = ecma_get_object_from_value (this_obj);
+
+  ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_ARRAY_ITERATOR_PROTOTYPE);
+
+  ecma_value_t ret_value = ecma_op_create_iterator_object (this_obj,
+                                                           prototype_obj_p,
+                                                           ECMA_PSEUDO_ARRAY_ITERATOR,
+                                                           type);
+  ecma_deref_object (obj_p);
+
+  return ret_value;
+} /* ecma_builtin_typedarray_iterators_helper */
+
+/**
+ * The %TypedArray%.prototype object's 'keys' routine using @@iterator
+ *
+ * See also:
+ *          ES2015, 22.2.3.15
+ *          ES2015, 22.1.3.30
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_typedarray_prototype_keys (ecma_value_t this_arg) /**< this argument */
+{
+  return ecma_builtin_typedarray_iterators_helper (this_arg, ECMA_ITERATOR_KEYS);
+} /* ecma_builtin_typedarray_prototype_keys */
+
+/**
+ * The %TypedArray%.prototype object's 'values' routine using @@iterator
+ *
+ * See also:
+ *          ES2015, 22.2.3.29
+ *          ES2015, 22.1.3.30
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_typedarray_prototype_values (ecma_value_t this_arg) /**< this argument */
+{
+  return ecma_builtin_typedarray_iterators_helper (this_arg, ECMA_ITERATOR_VALUES);
+} /* ecma_builtin_typedarray_prototype_values */
+
+/**
+ * The %TypedArray%.prototype object's 'entries' routine using @@iterator
+ *
+ * See also:
+ *          ES2015, 22.2.3.6
+ *          ES2015, 22.1.3.30
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_typedarray_prototype_entries (ecma_value_t this_arg) /**< this argument */
+{
+  return ecma_builtin_typedarray_iterators_helper (this_arg, ECMA_ITERATOR_KEYS_VALUES);
+} /* ecma_builtin_typedarray_prototype_entries */
+
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+
 /**
  * The %TypedArray%.prototype object's 'map' routine
  *

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

@@ -71,6 +71,15 @@ 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)
 
+#if ENABLED (JERRY_ES2015_BUILTIN_ITERATOR)
+
+ROUTINE (LIT_MAGIC_STRING_KEYS, ecma_builtin_typedarray_prototype_keys, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_VALUES, ecma_builtin_typedarray_prototype_values, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_ENTRIES, ecma_builtin_typedarray_prototype_entries, 0, 0)
+ROUTINE (LIT_GLOBAL_SYMBOL_ITERATOR, ecma_builtin_typedarray_prototype_values, 0, 0)
+
+#endif /* ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) */
+
 #endif /* ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) */
 
 #include "ecma-builtin-helpers-macro-undefs.inc.h"

tests/jerry/es2015/typedarray-prototype-entires.js

@@ -0,0 +1,59 @@
+// 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 array = [Uint8Array, Uint16Array, Uint32Array, 
+             Float32Array, Float64Array, 
+             Int8Array, Int16Array, Int32Array];
+
+array.forEach (function(e){
+  try {
+    e.prototype.entries.call (undefined);
+    assert (false);
+  }
+  catch (e) {
+    assert (e instanceof TypeError)
+  }
+});
+
+var buffer = new ArrayBuffer(8);
+var array = new Uint8Array(buffer);
+array.set([1, 2, 3, 4, 5, 6, 7, 8]);
+
+var iterator = array.entries ();
+
+var current_item = iterator.next ();
+
+for (var i = 0; i < array.length; i++) {
+  assert (current_item.value[0] === i);
+  assert (current_item.value[1] === array[i]);
+  assert (current_item.done === false);
+
+  current_item = iterator.next ();
+}
+
+assert (current_item.value === undefined);
+assert (current_item.done === true);
+
+/* Test empty typedArray */
+var buffer = new ArrayBuffer(0);
+var array = new Uint8Array(buffer);
+array.set([]);
+
+iterator = array.entries ();
+current_item = iterator.next ();
+
+assert (current_item.value === undefined);
+assert (current_item.done === true);
+
+assert ([].entries ().toString () === "[object Array Iterator]");

tests/jerry/es2015/typedarray-prototype-keys.js

@@ -0,0 +1,58 @@
+// 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 array = [Uint8Array, Uint16Array, Uint32Array, 
+             Float32Array, Float64Array, 
+             Int8Array, Int16Array, Int32Array];
+
+array.forEach (function(e){
+  try {
+    e.prototype.keys.call (undefined);
+    assert (false);
+  }
+  catch (e) {
+    assert (e instanceof TypeError)
+  }
+});
+
+var buffer = new ArrayBuffer(8);
+var array = new Uint8Array(buffer);
+array.set([1, 2, 3, 4, 5, 6, 7, 8]);
+
+var iterator = array.keys ();
+
+var current_item = iterator.next ();
+
+for (var i = 0; i < array.length; i++) {
+  assert (current_item.value === i);
+  assert (current_item.done === false);
+
+  current_item = iterator.next ();
+}
+
+assert (current_item.value === undefined);
+assert (current_item.done === true);
+
+/* Test empty typedArray */
+var buffer = new ArrayBuffer(0);
+var array = new Uint8Array(buffer);
+array.set([]);
+
+iterator = array.keys ();
+current_item = iterator.next ();
+
+assert (current_item.value === undefined);
+assert (current_item.done === true);
+
+assert ([].keys ().toString () === "[object Array Iterator]");

tests/jerry/es2015/typedarray-prototype-values.js

@@ -0,0 +1,69 @@
+// 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 array = [Uint8Array, Uint16Array, Uint32Array, 
+             Float32Array, Float64Array, 
+             Int8Array, Int16Array, Int32Array];
+
+array.forEach (function(e){
+  try {
+    e.prototype.values.call (undefined);
+    assert (false);
+  }
+  catch (e) {
+    assert (e instanceof TypeError)
+  }
+});
+
+var buffer = new ArrayBuffer(8);
+var array = new Uint8Array(buffer);
+array.set([1, 2, 3, 4, 5, 6, 7, 8]);
+
+var iterator = array.values ();
+
+/* The initial value of the @@iterator property is the same function object
+ as the initial value of the Array.prototype.values property. */
+var symbol_iterator = array[Symbol.iterator] ();
+
+var current_item = iterator.next ();
+var symbol_current_item = symbol_iterator.next ();
+
+for (var i = 0; i < array.length; i++) {
+  assert (current_item.value === array[i]);
+  assert (current_item.done === false);
+
+  assert (current_item.value === symbol_current_item.value);
+  assert (current_item.done === symbol_current_item.done);
+
+  current_item = iterator.next ();
+  symbol_current_item = symbol_iterator.next ();
+}
+
+assert (current_item.value === undefined);
+assert (current_item.done === true);
+assert (current_item.value === symbol_current_item.value);
+assert (current_item.done === symbol_current_item.done);
+
+/* Test empty typedArray */
+var buffer = new ArrayBuffer(0);
+var array = new Uint8Array(buffer);
+array.set([]);
+
+iterator = array.values ();
+current_item = iterator.next ();
+
+assert (current_item.value === undefined);
+assert (current_item.done === true);
+
+assert ([].values ().toString () === "[object Array Iterator]");