diff --git a/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.c b/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.c index 8aee29f3f4..3b8c082585 100644 --- a/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.c +++ b/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,91 @@ 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_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_ARRAY_ITERATOR_PROTOTYPE); + + return ecma_op_create_iterator_object (this_arg, + prototype_obj_p, + ECMA_PSEUDO_ARRAY_ITERATOR, + type); +} /* ecma_builtin_typedarray_iterators_helper */ + +/** + * The %TypedArray%.prototype object's 'keys' routine + * + * 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' and @@iterator routines + * + * 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 + * + * 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 * diff --git a/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.inc.h b/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.inc.h index ea3f25ba04..ef0360daeb 100644 --- a/jerry-core/ecma/builtin-objects/typedarray/ecma-builtin-typedarray-prototype.inc.h +++ b/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" diff --git a/jerry-core/lit/lit-magic-strings.inc.h b/jerry-core/lit/lit-magic-strings.inc.h index 199fb07fa1..e4f48812dc 100644 --- a/jerry-core/lit/lit-magic-strings.inc.h +++ b/jerry-core/lit/lit-magic-strings.inc.h @@ -329,7 +329,8 @@ LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_JSON_UL, "toJSON") #endif #if ENABLED (JERRY_BUILTIN_ARRAY) && ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) \ || ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) && ENABLED (JERRY_ES2015_BUILTIN_MAP) \ -|| ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) && ENABLED (JERRY_ES2015_BUILTIN_SET) +|| ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) && ENABLED (JERRY_ES2015_BUILTIN_SET) \ +|| ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) && ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_VALUES, "values") #endif LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_BOOLEAN_UL, "Boolean") @@ -352,7 +353,8 @@ LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_DEFAULT, "default") #endif #if ENABLED (JERRY_BUILTIN_ARRAY) && ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) \ || ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) && ENABLED (JERRY_ES2015_BUILTIN_MAP) \ -|| ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) && ENABLED (JERRY_ES2015_BUILTIN_SET) +|| ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) && ENABLED (JERRY_ES2015_BUILTIN_SET) \ +|| ENABLED (JERRY_ES2015_BUILTIN_ITERATOR) && ENABLED (JERRY_ES2015_BUILTIN_TYPEDARRAY) LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ENTRIES, "entries") #endif #if ENABLED (JERRY_BUILTIN_ARRAY) \ diff --git a/tests/jerry/es2015/typedarray-prototype-entires.js b/tests/jerry/es2015/typedarray-prototype-entires.js new file mode 100644 index 0000000000..b420ab4cb0 --- /dev/null +++ b/tests/jerry/es2015/typedarray-prototype-entires.js @@ -0,0 +1,71 @@ +// 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_typedarrays = [ + new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Uint16Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Uint32Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Float32Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Float64Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Int8Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Int16Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Int32Array([1, 2, 3, 4, 5, 6, 7, 8]) +]; + +normal_typedarrays.forEach (function(e){ + try { + e.prototype.entries.call (undefined); + assert (false); + } + catch (e) { + assert (e instanceof TypeError) + } +}); + +normal_typedarrays.forEach(function(e){ + var iterator = e.entries (); + var current_item = iterator.next (); + + for (var i = 0; i < e.length; i++) { + assert (current_item.value[0] === i); + assert (current_item.value[1] === e[i]); + assert (current_item.done === false); + + current_item = iterator.next (); + } + + assert (current_item.value === undefined); + assert (current_item.done === true); +}); + +var empty_typedarrays = [ + new Uint8Array([]), + new Uint16Array([]), + new Uint32Array([]), + new Float32Array([]), + new Float64Array([]), + new Int8Array([]), + new Int16Array([]), + new Int32Array([]) +]; + +empty_typedarrays.forEach(function (e){ + iterator = e.entries (); + current_item = iterator.next (); + + assert (current_item.value === undefined); + assert (current_item.done === true); +}); + +assert ([].entries ().toString () === "[object Array Iterator]"); diff --git a/tests/jerry/es2015/typedarray-prototype-keys.js b/tests/jerry/es2015/typedarray-prototype-keys.js new file mode 100644 index 0000000000..228478a74c --- /dev/null +++ b/tests/jerry/es2015/typedarray-prototype-keys.js @@ -0,0 +1,70 @@ +// 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_typedarrays = [ + new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Uint16Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Uint32Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Float32Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Float64Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Int8Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Int16Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Int32Array([1, 2, 3, 4, 5, 6, 7, 8]) +]; + +normal_typedarrays.forEach (function(e){ + try { + e.prototype.keys.call (undefined); + assert (false); + } + catch (e) { + assert (e instanceof TypeError) + } +}); + +normal_typedarrays.forEach(function (e){ + var iterator = e.keys (); + var current_item = iterator.next (); + + for (var i = 0; i < e.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); +}); + +var empty_typedarrays = [ + new Uint8Array([]), + new Uint16Array([]), + new Uint32Array([]), + new Float32Array([]), + new Float64Array([]), + new Int8Array([]), + new Int16Array([]), + new Int32Array([]) +]; + +empty_typedarrays.forEach(function (e){ + iterator = e.keys (); + current_item = iterator.next (); + + assert (current_item.value === undefined); + assert (current_item.done === true); +}); + +assert ([].keys ().toString () === "[object Array Iterator]"); diff --git a/tests/jerry/es2015/typedarray-prototype-values.js b/tests/jerry/es2015/typedarray-prototype-values.js new file mode 100644 index 0000000000..89747e84b9 --- /dev/null +++ b/tests/jerry/es2015/typedarray-prototype-values.js @@ -0,0 +1,79 @@ +// 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_typedarrays = [ + new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Uint16Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Uint32Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Float32Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Float64Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Int8Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Int16Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Int32Array([1, 2, 3, 4, 5, 6, 7, 8]) +]; + +normal_typedarrays.forEach (function(e){ + try { + e.prototype.values.call (undefined); + assert (false); + } + catch (e) { + assert (e instanceof TypeError) + } +}); + +normal_typedarrays.forEach(function (e){ + var iterator = e.values (); + var symbol_iterator = e[Symbol.iterator] (); + + var current_item = iterator.next (); + var symbol_current_item = symbol_iterator.next (); + + for (var i = 0; i < e.length; i++) { + assert (current_item.value === e[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) +}); + +var empty_typedarrays = [ + new Uint8Array([]), + new Uint16Array([]), + new Uint32Array([]), + new Float32Array([]), + new Float64Array([]), + new Int8Array([]), + new Int16Array([]), + new Int32Array([]) +]; + +empty_typedarrays.forEach(function (e){ + iterator = e.values (); + current_item = iterator.next (); + + assert (current_item.value === undefined); + assert (current_item.done === true); +}); + +assert ([].values ().toString () === "[object Array Iterator]");