lottie: integrate JerryScript engine for expressions

introduced the JerryScript engine to interpret Lottie
expressions, enhancing the capability to support runtime
programmable animation logic within Lottie expressions
spec. This feature, based on js scripting, represents
the most complicated addition to the Lottie spec so far.

ThorVG probably could includes an option to toggle
this feature at build time, allowing for customizable user
configurations according to specific requirements.

removed unused features for the optimal size:
- DEBUGGER
- MEM_STATS
- SNAPSHOT
- BUILTIN_JSON
- BUILTIN_PROXY
- BUILTIN_REFLECT
- BUILTIN_ATOMICS
- PROMISE_CALLBACK
- MODULE_SYSTEM
- SYSTEM_PORT

This is an experimental version.
Please manually enable the 'lottie-expressions' in meson.build
when you wish to use it.

See: https://jerryscript.net/

meson.build

@@ -56,6 +56,11 @@ endif
 
 if all_loaders or get_option('loaders').contains('lottie') == true
     config_h.set10('THORVG_LOTTIE_LOADER_SUPPORT', true)
+    #Experimental feature, enable it manually
+    lottie_expressions = false
+    if lottie_expressions
+        config_h.set10('THORVG_LOTTIE_EXPRESSIONS_SUPPORT', false)
+    endif
 endif
 
 if all_loaders or get_option('loaders').contains('ttf') == true

src/loaders/lottie/jerryscript/jerry-core/api/meson.build

@@ -0,0 +1,8 @@
+source_file = [
+    'jerryscript.cpp'
+]
+
+subloader_dep += [declare_dependency(
+    include_directories : include_directories('.'),
+    sources : source_file
+)]

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-alloc.cpp

@@ -0,0 +1,232 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+
+#include "jmem.h"
+#include "jrt.h"
+
+JERRY_STATIC_ASSERT ((sizeof (ecma_property_value_t) == sizeof (ecma_value_t)),
+                     size_of_ecma_property_value_t_must_be_equal_to_size_of_ecma_value_t);
+JERRY_STATIC_ASSERT (((sizeof (ecma_property_value_t) - 1) & sizeof (ecma_property_value_t)) == 0,
+                     size_of_ecma_property_value_t_must_be_power_of_2);
+
+JERRY_STATIC_ASSERT ((sizeof (ecma_extended_object_t) - sizeof (ecma_object_t) <= sizeof (uint64_t)),
+                     size_of_ecma_extended_object_part_must_be_less_than_or_equal_to_8_bytes);
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmaalloc Routines for allocation/freeing memory for ECMA data types
+ * @{
+ */
+
+/**
+ * Implementation of routines for allocation/freeing memory for ECMA data types.
+ *
+ * All allocation routines from this module have the same structure:
+ *  1. Try to allocate memory.
+ *  2. If allocation was successful, return pointer to the allocated block.
+ *  3. Run garbage collection.
+ *  4. Try to allocate memory.
+ *  5. If allocation was successful, return pointer to the allocated block;
+ *     else - shutdown engine.
+ */
+
+/**
+ * Allocate memory for ecma-number
+ *
+ * @return pointer to allocated memory
+ */
+ecma_number_t *
+ecma_alloc_number (void)
+{
+  return (ecma_number_t *) jmem_pools_alloc (sizeof (ecma_number_t));
+} /* ecma_alloc_number */
+
+/**
+ * Dealloc memory from an ecma-number
+ *
+ * @return void
+ */
+void
+ecma_dealloc_number (ecma_number_t *number_p) /**< number to be freed */
+{
+  jmem_pools_free ((uint8_t *) number_p, sizeof (ecma_number_t));
+} /* ecma_dealloc_number */
+
+/**
+ * Allocate memory for ecma-object
+ *
+ * @return pointer to allocated memory
+ */
+ecma_object_t *
+ecma_alloc_object (void)
+{
+  return (ecma_object_t *) jmem_pools_alloc (sizeof (ecma_object_t));
+} /* ecma_alloc_object */
+
+/**
+ * Dealloc memory from an ecma-object
+ *
+ * @return void
+ */
+void
+ecma_dealloc_object (ecma_object_t *object_p) /**< object to be freed */
+{
+  jmem_pools_free (object_p, sizeof (ecma_object_t));
+} /* ecma_dealloc_object */
+
+/**
+ * Allocate memory for extended object
+ *
+ * @return pointer to allocated memory
+ */
+ecma_extended_object_t *
+ecma_alloc_extended_object (size_t size) /**< size of object */
+{
+  return (ecma_extended_object_t *) jmem_heap_alloc_block (size);
+} /* ecma_alloc_extended_object */
+
+/**
+ * Dealloc memory of an extended object
+ *
+ * @return void
+ */
+void
+ecma_dealloc_extended_object (ecma_object_t *object_p, /**< extended object */
+                              size_t size) /**< size of object */
+{
+  jmem_heap_free_block (object_p, size);
+} /* ecma_dealloc_extended_object */
+
+/**
+ * Allocate memory for ecma-string descriptor
+ *
+ * @return pointer to allocated memory
+ */
+ecma_string_t *
+ecma_alloc_string (void)
+{
+  return (ecma_string_t *) jmem_pools_alloc (sizeof (ecma_string_t));
+} /* ecma_alloc_string */
+
+/**
+ * Dealloc memory from ecma-string descriptor
+ *
+ * @return void
+ */
+void
+ecma_dealloc_string (ecma_string_t *string_p) /**< string to be freed */
+{
+  jmem_pools_free (string_p, sizeof (ecma_string_t));
+} /* ecma_dealloc_string */
+
+/**
+ * Allocate memory for extended ecma-string descriptor
+ *
+ * @return pointer to allocated memory
+ */
+ecma_extended_string_t *
+ecma_alloc_extended_string (void)
+{
+  return (ecma_extended_string_t *) jmem_heap_alloc_block (sizeof (ecma_extended_string_t));
+} /* ecma_alloc_extended_string */
+
+/**
+ * Dealloc memory from extended ecma-string descriptor
+ *
+ * @return void
+ */
+void
+ecma_dealloc_extended_string (ecma_extended_string_t *ext_string_p) /**< extended string to be freed */
+{
+  jmem_heap_free_block (ext_string_p, sizeof (ecma_extended_string_t));
+} /* ecma_dealloc_extended_string */
+
+/**
+ * Allocate memory for external ecma-string descriptor
+ *
+ * @return pointer to allocated memory
+ */
+ecma_external_string_t *
+ecma_alloc_external_string (void)
+{
+  return (ecma_external_string_t *) jmem_heap_alloc_block (sizeof (ecma_external_string_t));
+} /* ecma_alloc_external_string */
+
+/**
+ * Dealloc memory from external ecma-string descriptor
+ *
+ * @return void
+ */
+void
+ecma_dealloc_external_string (ecma_external_string_t *ext_string_p) /**< external string to be freed */
+{
+  jmem_heap_free_block (ext_string_p, sizeof (ecma_external_string_t));
+} /* ecma_dealloc_external_string */
+
+/**
+ * Allocate memory for an string with character data
+ *
+ * @return pointer to allocated memory
+ */
+ecma_string_t *
+ecma_alloc_string_buffer (size_t size) /**< size of string */
+{
+  return (ecma_string_t *) jmem_heap_alloc_block (size);
+} /* ecma_alloc_string_buffer */
+
+/**
+ * Dealloc memory of a string with character data
+ *
+ * @return void
+ */
+void
+ecma_dealloc_string_buffer (ecma_string_t *string_p, /**< string with data */
+                            size_t size) /**< size of string */
+{
+  jmem_heap_free_block (string_p, size);
+} /* ecma_dealloc_string_buffer */
+
+/**
+ * Allocate memory for ecma-property pair
+ *
+ * @return pointer to allocated memory
+ */
+ecma_property_pair_t *
+ecma_alloc_property_pair (void)
+{
+  return (ecma_property_pair_t *) jmem_heap_alloc_block (sizeof (ecma_property_pair_t));
+} /* ecma_alloc_property_pair */
+
+/**
+ * Dealloc memory of an ecma-property
+ *
+ * @return void
+ */
+void
+ecma_dealloc_property_pair (ecma_property_pair_t *property_pair_p) /**< property pair to be freed */
+{
+  jmem_heap_free_block (property_pair_p, sizeof (ecma_property_pair_t));
+} /* ecma_dealloc_property_pair */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-alloc.h

@@ -0,0 +1,129 @@
+/* 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.
+ */
+
+#ifndef ECMA_ALLOC_H
+#define ECMA_ALLOC_H
+
+#include "ecma-globals.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmaalloc Routines for allocation/freeing memory for ECMA data types
+ * @{
+ */
+
+/**
+ * Allocate memory for ecma-object
+ *
+ * @return pointer to allocated memory
+ */
+ecma_object_t *ecma_alloc_object (void);
+
+/**
+ * Dealloc memory from an ecma-object
+ */
+void ecma_dealloc_object (ecma_object_t *object_p);
+
+/**
+ * Allocate memory for extended object
+ *
+ * @return pointer to allocated memory
+ */
+ecma_extended_object_t *ecma_alloc_extended_object (size_t size);
+
+/**
+ * Dealloc memory of an extended object
+ */
+void ecma_dealloc_extended_object (ecma_object_t *object_p, size_t size);
+
+/**
+ * Allocate memory for ecma-number
+ *
+ * @return pointer to allocated memory
+ */
+ecma_number_t *ecma_alloc_number (void);
+
+/**
+ * Dealloc memory from an ecma-number
+ */
+void ecma_dealloc_number (ecma_number_t *number_p);
+
+/**
+ * Allocate memory for ecma-string descriptor
+ *
+ * @return pointer to allocated memory
+ */
+ecma_string_t *ecma_alloc_string (void);
+
+/**
+ * Dealloc memory from ecma-string descriptor
+ */
+void ecma_dealloc_string (ecma_string_t *string_p);
+
+/**
+ * Allocate memory for extended ecma-string descriptor
+ *
+ * @return pointer to allocated memory
+ */
+ecma_extended_string_t *ecma_alloc_extended_string (void);
+
+/**
+ * Dealloc memory from extended ecma-string descriptor
+ */
+void ecma_dealloc_extended_string (ecma_extended_string_t *string_p);
+
+/**
+ * Allocate memory for external ecma-string descriptor
+ *
+ * @return pointer to allocated memory
+ */
+ecma_external_string_t *ecma_alloc_external_string (void);
+
+/**
+ * Dealloc memory from external ecma-string descriptor
+ */
+void ecma_dealloc_external_string (ecma_external_string_t *string_p);
+
+/**
+ * Allocate memory for string with character data
+ *
+ * @return pointer to allocated memory
+ */
+ecma_string_t *ecma_alloc_string_buffer (size_t size);
+
+/**
+ * Dealloc memory of a string with character data
+ */
+void ecma_dealloc_string_buffer (ecma_string_t *string_p, size_t size);
+
+/**
+ * Allocate memory for ecma-property pair
+ *
+ * @return pointer to allocated memory
+ */
+ecma_property_pair_t *ecma_alloc_property_pair (void);
+
+/**
+ * Dealloc memory from an ecma-property pair
+ */
+void ecma_dealloc_property_pair (ecma_property_pair_t *property_pair_p);
+
+/**
+ * @}
+ * @}
+ */
+
+#endif /* !ECMA_ALLOC_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-error-messages.inc.h

@@ -0,0 +1,743 @@
+/* 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.
+ */
+
+/* This file is automatically generated by the gen-strings.py script
+ * from ecma-error-messages.ini. Do not edit! */
+
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_GROUP, "Invalid group")
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_ESCAPE, "Invalid escape")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_BUILTIN_ATOMICS || JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_LENGTH, "Invalid length")
+#endif /* JERRY_BUILTIN_ATOMICS \
+|| JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_OFFSET, "Invalid offset")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+ECMA_ERROR_DEF (ECMA_ERR_OBJECT_EXPECTED, "Object expected")
+#if JERRY_BUILTIN_ANNEXB && JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_ARGUMENT, "Invalid argument")
+#endif /* JERRY_BUILTIN_ANNEXB && JERRY_BUILTIN_REGEXP */
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_ENCODING, "Invalid encoding")
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_NOTHING_TO_REPEAT, "Nothing to repeat")
+#endif /* JERRY_BUILTIN_REGEXP */
+ECMA_ERROR_DEF (ECMA_ERR_EXPECTED_AN_OBJECT, "Expected an object")
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_CAPABILITY, "Invalid capability")
+#if JERRY_BUILTIN_STRING
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_CODE_POINT, "Invalid code point")
+#endif /* JERRY_BUILTIN_STRING */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_QUANTIFIER, "Invalid quantifier")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_NO_SOURCE_ARGUMENT, "No source argument")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_UNTERMINATED_GROUP, "Unterminated group")
+#endif /* JERRY_BUILTIN_REGEXP */
+ECMA_ERROR_DEF (ECMA_ERR_EXPECTED_A_FUNCTION, "Expected a function")
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_UTF8_STRING, "Invalid UTF8 string")
+#if JERRY_BUILTIN_STRING
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_COUNT_VALUE, "Invalid count value")
+#endif /* JERRY_BUILTIN_STRING */
+#if !(JERRY_BUILTIN_REALMS)
+ECMA_ERROR_DEF (ECMA_ERR_REALMS_ARE_DISABLED, "Realms are disabled")
+#endif /* !(JERRY_BUILTIN_REALMS) */
+ECMA_ERROR_DEF (ECMA_ERR_UNDEFINED_REFERENCE, "Undefined reference")
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_ARRAY_LENGTH, "Invalid Array length")
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_REGEXP_FLAGS, "Invalid RegExp flags")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_STACK_LIMIT_EXCEEDED, "Stack limit exceeded")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_BUILTIN_WEAKREF
+ECMA_ERROR_DEF (ECMA_ERR_TARGET_IS_NOT_OBJECT, "Target is not Object")
+#endif /* JERRY_BUILTIN_WEAKREF */
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_BIGINT_VALUE_EXCPECTED, "BigInt value expected")
+#endif /* JERRY_BUILTIN_BIGINT */
+ECMA_ERROR_DEF (ECMA_ERR_BINDING_CANNOT_SET, "Binding cannot be set")
+#if JERRY_BUILTIN_STRING
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_STRING_, "Invalid string length")
+#endif /* JERRY_BUILTIN_STRING */
+#if JERRY_BUILTIN_CONTAINER
+ECMA_ERROR_DEF (ECMA_ERR_KEY_MUST_BE_AN_OBJECT, "Key must be an object")
+#endif /* JERRY_BUILTIN_CONTAINER */
+#if JERRY_BUILTIN_ARRAY
+ECMA_ERROR_DEF (ECMA_ERR_MISSING_ARRAY_ELEMENT, "Missing Array element")
+#endif /* JERRY_BUILTIN_ARRAY */
+#if JERRY_BUILTIN_WEAKREF
+ECMA_ERROR_DEF (ECMA_ERR_TARGET_IS_NOT_WEAKREF, "Target is not weakRef")
+#endif /* JERRY_BUILTIN_WEAKREF */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TARGET_NOT_EXTENSIBLE, "Target not extensible")
+#endif /* JERRY_BUILTIN_PROXY */
+#if JERRY_BUILTIN_ANNEXB
+ECMA_ERROR_DEF (ECMA_ERR_GETTER_IS_NOT_CALLABLE, "Getter is not callable")
+#endif /* JERRY_BUILTIN_ANNEXB */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_HANDLER_CANNOT_BE_NULL, "Handler cannot be null")
+#endif /* JERRY_BUILTIN_PROXY */
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_UTF8_CHARACTER, "Invalid UTF8 character")
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_UTF8_CODEPOINT, "Invalid UTF8 codepoint")
+#if JERRY_BUILTIN_CONTAINER
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_CONTAINER_TYPE, "Invalid container type")
+#endif /* JERRY_BUILTIN_CONTAINER */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_RANGE_OF_INDEX, "Invalid range of index")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if !(JERRY_BUILTIN_PROXY)
+ECMA_ERROR_DEF (ECMA_ERR_PROXY_IS_NOT_SUPPORTED, "Proxy is not supported")
+#endif /* !(JERRY_BUILTIN_PROXY) */
+#if !(JERRY_BUILTIN_REALMS)
+ECMA_ERROR_DEF (ECMA_ERR_REALM_IS_NOT_AVAILABLE, "Realm is not available")
+#endif /* !(JERRY_BUILTIN_REALMS) */
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_BIGINT_ZERO_DIVISION, "BigInt division by zero")
+#endif /* JERRY_BUILTIN_BIGINT */
+ECMA_ERROR_DEF (ECMA_ERR_EXPECTED_AN_ARRAYBUFFER, "Expected an ArrayBuffer")
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_CHARACTER_CLASS, "Invalid character class")
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_ESCAPE_SEQUENCE, "Invalid escape sequence")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_SNAPSHOT_EXEC
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_SNAPSHOT_FORMAT, "Invalid snapshot format")
+#endif /* JERRY_SNAPSHOT_EXEC */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_LONE_QUANTIFIER_BRACKET, "Lone quantifier bracket")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_OBJECT_CANNOT_BE_FROZEN, "Object cannot be frozen")
+ECMA_ERROR_DEF (ECMA_ERR_OBJECT_CANNOT_BE_SEALED, "Object cannot be sealed")
+#endif /* JERRY_BUILTIN_PROXY */
+#if !(JERRY_BUILTIN_REGEXP)
+ECMA_ERROR_DEF (ECMA_ERR_REGEXP_IS_NOT_SUPPORTED, "RegExp is not supported")
+#endif /* !(JERRY_BUILTIN_REGEXP) */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_UNMATCHED_CLOSE_BRACKET, "Unmatched close bracket")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_NOT_MODULE, "Argument is not a module")
+#endif /* JERRY_MODULE_SYSTEM */
+ECMA_ERROR_DEF (ECMA_ERR_SET_PROTOTYPE, "Cannot set [[Prototype]]")
+#if JERRY_BUILTIN_ARRAY
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_NEW_ARRAY_LENGTH, "Invalid new Array length")
+#endif /* JERRY_BUILTIN_ARRAY */
+ECMA_ERROR_DEF (ECMA_ERR_ITERATOR_IS_NOT_CALLABLE, "Iterator is not callable")
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_MODULE_IS_IN_ERROR_STATE, "Module is in error state")
+#endif /* JERRY_MODULE_SYSTEM */
+ECMA_ERROR_DEF (ECMA_ERR_REJECT_MUST_BE_UNDEFINED, "Reject must be undefined")
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_REQUEST_IS_NOT_AVAILABLE, "Request is not available")
+#endif /* JERRY_MODULE_SYSTEM */
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_IS_NOT_AN_OBJECT, "Argument is not an object")
+#if JERRY_BUILTIN_ATOMICS
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_NOT_SUPPORTED, "Argument is not supported")
+#endif /* JERRY_BUILTIN_ATOMICS */
+#if JERRY_BUILTIN_STRING
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_CODE_POINT_ERROR, "Error: Invalid code point")
+#endif /* JERRY_BUILTIN_STRING */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_TYPEDARRAY_LENGTH, "Invalid TypedArray length")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_HEXADECIMAL_VALUE, "Invalid hexadecimal value")
+ECMA_ERROR_DEF (ECMA_ERR_ITERATOR_IS_NOT_AN_OBJECT, "Iterator is not an object")
+ECMA_ERROR_DEF (ECMA_ERR_RESOLVE_MUST_BE_UNDEFINED, "Resolve must be undefined")
+#if JERRY_SNAPSHOT_SAVE
+ECMA_ERROR_DEF (ECMA_ERR_SNAPSHOT_BUFFER_SMALL, "Snapshot buffer too small")
+#endif /* JERRY_SNAPSHOT_SAVE */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_UNEXPECTED_END_OF_PATTERN, "Unexpected end of pattern")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_SNAPSHOT_SAVE
+ECMA_ERROR_DEF (ECMA_ERR_SNAPSHOT_UNSUPPORTED_COMPILED_CODE, "Unsupported compiled code")
+#endif /* JERRY_SNAPSHOT_SAVE */
+#if !(JERRY_BUILTIN_BIGINT)
+ECMA_ERROR_DEF (ECMA_ERR_BIGINT_NOT_SUPPORTED, "BigInt support is disabled")
+#endif /* !(JERRY_BUILTIN_BIGINT) */
+#if JERRY_BUILTIN_DATAVIEW
+ECMA_ERROR_DEF (ECMA_ERR_EXPECTED_A_DATAVIEW_OBJECT, "Expected a DataView object")
+#endif /* JERRY_BUILTIN_DATAVIEW */
+ECMA_ERROR_DEF (ECMA_ERR_EXPECTED_A_FUNCTION_OBJECT, "Expected a function object")
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_ARRAYBUFFER_LENGTH, "Invalid ArrayBuffer length")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if !(JERRY_MODULE_SYSTEM)
+ECMA_ERROR_DEF (ECMA_ERR_MODULE_NOT_SUPPORTED, "Module support is disabled")
+#endif /* !(JERRY_MODULE_SYSTEM) */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_OBJECT_IS_NOT_A_TYPEDARRAY, "Object is not a TypedArray")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+ECMA_ERROR_DEF (ECMA_ERR_RECEIVER_MUST_BE_AN_OBJECT, "Receiver must be an object")
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_BIGINT_SERIALIZED, "BigInt cannot be serialized")
+#endif /* JERRY_BUILTIN_BIGINT */
+#if JERRY_BUILTIN_CONTAINER
+ECMA_ERROR_DEF (ECMA_ERR_CONTAINER_IS_NOT_AN_OBJECT, "Container is not an object.")
+#endif /* JERRY_BUILTIN_CONTAINER */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_HEX_ESCAPE_SEQUENCE, "Invalid hex escape sequence")
+#endif /* JERRY_BUILTIN_REGEXP */
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_SPECIES_CONSTRUCTOR, "Invalid species constructor")
+ECMA_ERROR_DEF (ECMA_ERR_PROXY_TRAP_RETURNED_FALSISH, "Proxy trap returned falsish")
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_MIN_GREATER_THAN_MAX, "Quantifier error: min > max")
+#endif /* JERRY_BUILTIN_REGEXP */
+ECMA_ERROR_DEF (ECMA_ERR_SYMBOL_IS_NOT_A_CONSTRUCTOR, "Symbol is not a constructor")
+#if JERRY_BUILTIN_REFLECT
+ECMA_ERROR_DEF (ECMA_ERR_TARGET_IS_NOT_A_CONSTRUCTOR, "Target is not a constructor")
+#endif /* JERRY_BUILTIN_REFLECT */
+ECMA_ERROR_DEF (ECMA_ERR_ACCESSOR_WRITABLE, "Accessors cannot be writable")
+#if !(JERRY_BUILTIN_DATAVIEW)
+ECMA_ERROR_DEF (ECMA_ERR_DATA_VIEW_NOT_SUPPORTED, "DataView support is disabled")
+#endif /* !(JERRY_BUILTIN_DATAVIEW) */
+#if JERRY_BUILTIN_DATE
+ECMA_ERROR_DEF (ECMA_ERR_DATE_MUST_BE_A_FINITE_NUMBER, "Date must be a finite number")
+#endif /* JERRY_BUILTIN_DATE */
+ECMA_ERROR_DEF (ECMA_ERR_LOCAL_VARIABLE_IS_REDECLARED, "Local variable is redeclared")
+ECMA_ERROR_DEF (ECMA_ERR_UNSUPPORTED_BINARY_OPERATION, "Unsupported binary operation")
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_UNTERMINATED_CHARACTER_CLASS, "Unterminated character class")
+#endif /* JERRY_BUILTIN_REGEXP */
+ECMA_ERROR_DEF (ECMA_ERR_ARRAYBUFFER_IS_DETACHED, "ArrayBuffer has been detached")
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_NOT_AN_OBJECT, "Constructor must be an object")
+#if !(JERRY_BUILTIN_CONTAINER)
+ECMA_ERROR_DEF (ECMA_ERR_CONTAINER_NOT_SUPPORTED, "Container support is disabled")
+#endif /* !(JERRY_BUILTIN_CONTAINER) */
+#if JERRY_BUILTIN_REALMS
+ECMA_ERROR_DEF (ECMA_ERR_FIRST_ARGUMENT_IS_NOT_A_REALM, "First argument is not a realm")
+#endif /* JERRY_BUILTIN_REALMS */
+#if JERRY_BUILTIN_BIGINT && JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_INCOMPATIBLE_TYPEDARRAY_TYPES, "Incompatible TypedArray types")
+#endif /* JERRY_BUILTIN_BIGINT && JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_INCORRECT_TYPE_FOR_TYPEDARRAY, "Incorrect type for TypedArray")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_OR_OUT_OF_RANGE_INDEX, "Invalid or out-of-range index")
+#if JERRY_SNAPSHOT_SAVE
+ECMA_ERROR_DEF (ECMA_ERR_MAXIMUM_SNAPSHOT_SIZE, "Maximum snapshot size reached")
+#endif /* JERRY_SNAPSHOT_SAVE */
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_MODULE_CANNOT_BE_INSTANTIATED, "Module cannot be instantiated")
+#endif /* JERRY_MODULE_SYSTEM */
+ECMA_ERROR_DEF (ECMA_ERR_SPECIES_MUST_BE_A_CONSTRUCTOR, "Species must be a constructor")
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_IS_NOT_A_PROXY, "Argument is not a Proxy object")
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_NOT_ARRAY_BUFFER, "Argument is not an ArrayBuffer")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_CONTAINER
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_MAP_REQUIRES_NEW, "Constructor Map requires 'new'")
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_SET_REQUIRES_NEW, "Constructor Set requires 'new'")
+#endif /* JERRY_BUILTIN_CONTAINER */
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_MODULE_MUST_BE_IN_LINKED_STATE, "Module must be in linked state")
+ECMA_ERROR_DEF (ECMA_ERR_UNKNOWN_EXPORT, "Native module export not found")
+#endif /* JERRY_MODULE_SYSTEM */
+ECMA_ERROR_DEF (ECMA_ERR_PASSED_ARGUMENT_IS_NOT_A_REALM, "Passed argument is not a realm")
+ECMA_ERROR_DEF (ECMA_ERR_PRIVATE_METHOD_IS_NOT_WRITABLE, "Private method is not writable")
+#if JERRY_BUILTIN_BIGINT || JERRY_BUILTIN_NUMBER
+ECMA_ERROR_DEF (ECMA_ERR_RADIX_IS_OUT_OF_RANGE, "Radix must be between 2 and 36")
+#endif /* JERRY_BUILTIN_BIGINT \
+|| JERRY_BUILTIN_NUMBER */
+#if !(JERRY_SNAPSHOT_EXEC)
+ECMA_ERROR_DEF (ECMA_ERR_SNAPSHOT_EXEC_DISABLED, "Snapshot execution is disabled")
+#endif /* !(JERRY_SNAPSHOT_EXEC) */
+#if !(JERRY_BUILTIN_TYPEDARRAY)
+ECMA_ERROR_DEF (ECMA_ERR_TYPED_ARRAY_NOT_SUPPORTED, "TypedArray support is disabled")
+#endif /* !(JERRY_BUILTIN_TYPEDARRAY) */
+ECMA_ERROR_DEF (ECMA_ERR_UNICODE_SURROGATE_PAIR_MISSING, "Unicode surrogate pair missing")
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_CONTROL_ESCAPE_SEQUENCE, "Invalid control escape sequence")
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_UNICODE_ESCAPE_SEQUENCE, "Invalid unicode escape sequence")
+#endif /* JERRY_BUILTIN_REGEXP */
+ECMA_ERROR_DEF (ECMA_ERR_ITERATOR_NEXT_IS_NOT_CALLABLE, "Iterator 'next' is not callable")
+ECMA_ERROR_DEF (ECMA_ERR_ITERATOR_VALUE_IS_NOT_AN_OBJECT, "Iterator value is not an object")
+ECMA_ERROR_DEF (ECMA_ERR_RESOLVE_METHOD_MUST_BE_CALLABLE, "Resolve method must be callable")
+#if !(JERRY_SNAPSHOT_SAVE)
+ECMA_ERROR_DEF (ECMA_ERR_SNAPSHOT_SAVE_DISABLED, "Snapshot generation is disabled")
+#endif /* !(JERRY_SNAPSHOT_SAVE) */
+#if !(JERRY_PARSER)
+ECMA_ERROR_DEF (ECMA_ERR_PARSER_NOT_SUPPORTED, "Source code parsing is disabled")
+#endif /* !(JERRY_PARSER) */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_MUST_RETURN_WITH_AN_OBJECT, "Trap must return with an object")
+#endif /* JERRY_BUILTIN_PROXY */
+#if JERRY_BUILTIN_CONTAINER
+ECMA_ERROR_DEF (ECMA_ERR_UNSUPPORTED_CONTAINER_OPERATION, "Unsupported container operation")
+#endif /* JERRY_BUILTIN_CONTAINER */
+ECMA_ERROR_DEF (ECMA_ERR_METHOD_RETURN_IS_NOT_CALLABLE, "method 'return' is not callable")
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_PROMISE, "Argument 'this' is not a Promise")
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_OBJECT, "Argument 'this' is not an object")
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_SYMBOL, "Argument 'this' must be a Symbol")
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_CALLBACK_RESULT_NOT_MODULE, "Callback result must be a module")
+#endif /* JERRY_MODULE_SYSTEM */
+ECMA_ERROR_DEF (ECMA_ERR_CLASS_CONSTRUCTOR_REQUIRES_NEW, "Class constructor requires 'new'")
+#if JERRY_BUILTIN_ARRAY
+ECMA_ERROR_DEF (ECMA_ERR_COMPARE_FUNC_NOT_CALLABLE, "Compare function is not callable")
+#endif /* JERRY_BUILTIN_ARRAY */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_PROXY_REQUIRES_NEW, "Constructor Proxy requires 'new'")
+#endif /* JERRY_BUILTIN_PROXY */
+ECMA_ERROR_DEF (ECMA_ERR_EXPECTED_A_CONFIGURABLE_PROPERTY, "Expected a configurable property")
+ECMA_ERROR_DEF (ECMA_ERR_FIRST_PARAMETER_MUST_BE_CALLABLE, "First parameter must be callable")
+#if JERRY_BUILTIN_CONTAINER
+ECMA_ERROR_DEF (ECMA_ERR_FUNCTION_ADD_ORSET_IS_NOT_CALLABLE, "Function add/set is not callable")
+#endif /* JERRY_BUILTIN_CONTAINER */
+ECMA_ERROR_DEF (ECMA_ERR_ITERATOR_RESULT_IS_NOT_AN_OBJECT, "Iterator result is not an object")
+#if (JERRY_STACK_LIMIT != 0)
+ECMA_ERROR_DEF (ECMA_ERR_MAXIMUM_CALL_STACK_SIZE_EXCEEDED, "Maximum call stack size exceeded")
+#endif /* (JERRY_STACK_LIMIT != 0) */
+ECMA_ERROR_DEF (ECMA_ERR_MAXIMUM_STRING_LENGTH_IS_REACHED, "Maximum string length is reached")
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_MODULE_MUST_BE_IN_UNLINKED_STATE, "Module must be in unlinked state")
+#endif /* JERRY_MODULE_SYSTEM */
+#if JERRY_SNAPSHOT_EXEC
+ECMA_ERROR_DEF (ECMA_ERR_STATIC_SNAPSHOTS_ARE_NOT_ENABLED, "Static snapshots are not enabled")
+#endif /* JERRY_SNAPSHOT_EXEC */
+#if JERRY_BUILTIN_WEAKREF
+ECMA_ERROR_DEF (ECMA_ERR_WEAKREF_TARGET_MUST_BE_AN_OBJECT, "WeakRef target must be an object")
+#endif /* JERRY_BUILTIN_WEAKREF */
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_FUNCTION, "Argument 'this' is not a function")
+#if JERRY_BUILTIN_ATOMICS
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_NOT_SHARED_ARRAY_BUFFER, "Argument is not SharedArrayBuffer")
+#endif /* JERRY_BUILTIN_ATOMICS */
+#if JERRY_BUILTIN_ARRAY || JERRY_BUILTIN_CONTAINER || JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_CALLBACK_IS_NOT_CALLABLE, "Callback function is not callable")
+#endif /* JERRY_BUILTIN_ARRAY \
+|| JERRY_BUILTIN_CONTAINER    \
+|| JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_INITIAL_VALUE_CANNOT_BE_UNDEFINED, "Initial value cannot be undefined")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_SHAREDARRAYBUFFER
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_SHARED_ARRAYBUFFER_LENGTH, "Invalid Shared ArrayBuffer length")
+#endif /* JERRY_BUILTIN_SHAREDARRAYBUFFER */
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_TYPE_FOR_CONSTRUCTOR_CALL, "Invalid type for constructor call")
+ECMA_ERROR_DEF (ECMA_ERR_ITERATOR_THROW_IS_NOT_AVAILABLE, "Iterator 'throw' is not available")
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_NAMESPACE_OBJECT_IS_NOT_AVAILABLE, "Namespace object is not available")
+#endif /* JERRY_MODULE_SYSTEM */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_PROXY_TARGET_IS_NOT_A_CONSTRUCTOR, "Proxy target is not a constructor")
+#endif /* JERRY_BUILTIN_PROXY */
+#if JERRY_BUILTIN_REALMS
+ECMA_ERROR_DEF (ECMA_ERR_SECOND_ARGUMENT_MUST_BE_AN_OBJECT, "Second argument must be an object")
+#endif /* JERRY_BUILTIN_REALMS */
+#if JERRY_BUILTIN_DATAVIEW
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_BUFFER_NOT_OBJECT, "Argument 'buffer' is not an object")
+#endif /* JERRY_BUILTIN_DATAVIEW */
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_ITERATOR, "Argument 'this' is not an iterator")
+ECMA_ERROR_DEF (ECMA_ERR_VALUE_MSG, "Argument cannot be marked as error")
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_PROMISE_REQUIRES_NEW, "Constructor Promise requires 'new'")
+#if JERRY_BUILTIN_CONTAINER
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_WEAKMAP_REQUIRES_NEW, "Constructor WeakMap requires 'new'")
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_WEAKSET_REQUIRES_NEW, "Constructor WeakSet requires 'new'")
+#endif /* JERRY_BUILTIN_CONTAINER */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_MAXIMUM_TYPEDARRAY_SIZE_IS_REACHED, "Maximum TypedArray size is reached")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+ECMA_ERROR_DEF (ECMA_ERR_THE_GIVEN_ARGUMENT_IS_NOT_A_SYMBOL, "The given argument is not a Symbol")
+ECMA_ERROR_DEF (ECMA_ERR_PARAMETER_REJECT_MUST_BE_CALLABLE, "'reject' parameter must be callable")
+#if JERRY_BUILTIN_ATOMICS || JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_TYPED_ARRAY, "Argument 'this' is not a TypedArray")
+#endif /* JERRY_BUILTIN_ATOMICS \
+|| JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_SNAPSHOT_SAVE
+ECMA_ERROR_DEF (ECMA_ERR_CANNOT_ALLOCATE_MEMORY_LITERALS, "Cannot allocate memory for literals")
+#endif /* JERRY_SNAPSHOT_SAVE */
+ECMA_ERROR_DEF (ECMA_ERR_INVOKE_NULLABLE_SUPER_METHOD, "Cannot invoke nullable super method")
+#if JERRY_BUILTIN_DATAVIEW
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_DATAVIEW_REQUIRES_NEW, "Constructor DataView requires 'new'")
+#endif /* JERRY_BUILTIN_DATAVIEW */
+#if JERRY_BUILTIN_WEAKREF
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_WEAKREF_REQUIRES_NEW, "Constructor WeakRef requires 'new'.")
+#endif /* JERRY_BUILTIN_WEAKREF */
+ECMA_ERROR_DEF (ECMA_ERR_SUPER_BINDING_MUST_BE_A_CONSTRUCTOR, "Super binding must be a constructor")
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_VALUE_CANNOT_BE_CONVERTED_TO_BIGINT, "Value cannot be converted to BigInt")
+#endif /* JERRY_BUILTIN_BIGINT */
+ECMA_ERROR_DEF (ECMA_ERR_PARAMETER_RESOLVE_MUST_BE_CALLABLE, "'resolve' parameter must be callable")
+#if JERRY_BUILTIN_DATE
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_DATE_OBJECT, "Argument 'this' is not a Date object")
+#endif /* JERRY_BUILTIN_DATE */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_CONSTRUCTOR, "Argument 'this' is not a constructor")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_BIGINT_FUNCTION_NOT_CONSTRUCTOR, "BigInt function is not a constructor")
+#endif /* JERRY_BUILTIN_BIGINT */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTED_OBJECT_IS_NOT_TYPEDARRAY, "Constructed object is not TypedArray")
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_INT8_ARRAY_REQUIRES_NEW, "Constructor Int8Array requires 'new'")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_CONTAINER
+ECMA_ERROR_DEF (ECMA_ERR_CONTAINER_IS_NOT_A_CONTAINER_OBJECT, "Container is not a container object.")
+#endif /* JERRY_BUILTIN_CONTAINER */
+#if JERRY_BUILTIN_DATE
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_ARGUMENT_TYPE_IN_TOPRIMITIVE, "Invalid argument type in toPrimitive")
+#endif /* JERRY_BUILTIN_DATE */
+#if JERRY_ERROR_MESSAGES
+ECMA_ERROR_DEF (ECMA_ERR_METHODS_INVOKE_WITH_NEW, "Methods cannot be invoked with 'new'")
+#endif /* JERRY_ERROR_MESSAGES */
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_MODULE_EXPORTS_MUST_BE_STRING_VALUES, "Module exports must be string values")
+#endif /* JERRY_MODULE_SYSTEM */
+ECMA_ERROR_DEF (ECMA_ERR_PROTOTYPE_IS_NEITHER_OBJECT_NOR_NULL, "Prototype is neither object nor null")
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_THE_MAPFN_ARGUMENT_IS_NOT_CALLABLE, "The 'mapfn' argument is not callable")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_THE_TWO_DESCRIPTORS_ARE_INCOMPATIBLE, "The two descriptors are incompatible")
+#endif /* JERRY_BUILTIN_PROXY */
+ECMA_ERROR_DEF (ECMA_ERR_WRONG_ARGS_MSG, "This type of argument is not allowed")
+#if JERRY_BUILTIN_CONTAINER
+ECMA_ERROR_DEF (ECMA_ERR_CONTAINER_NEEDED, "Value is not a Container or Iterator")
+#endif /* JERRY_BUILTIN_CONTAINER */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_REG_EXP, "Argument 'this' is not a valid RegExp")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_ARRAY_BUFFER_DETACHED, "ArrayBuffer has already been detached")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+ECMA_ERROR_DEF (ECMA_ERR_BULTIN_ROUTINES_HAVE_NO_CONSTRUCTOR, "Built-in routines have no constructor")
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_INT16_ARRAY_REQUIRES_NEW, "Constructor Int16Array requires 'new'")
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_INT32_ARRAY_REQUIRES_NEW, "Constructor Int32Array requires 'new'")
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_UINT8_ARRAY_REQUIRES_NEW, "Constructor Uint8Array requires 'new'")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_SNAPSHOT_EXEC
+ECMA_ERROR_DEF (ECMA_ERR_FUNCTION_INDEX_IS_HIGHER_THAN_MAXIMUM, "Function index is higher than maximum")
+#endif /* JERRY_SNAPSHOT_EXEC */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_RANGE_OUT_OF_ORDER_IN_CHARACTER_CLASS, "Range out of order in character class")
+#endif /* JERRY_BUILTIN_REGEXP */
+ECMA_ERROR_DEF (ECMA_ERR_RESULT_OF_DEFAULTVALUE_IS_INVALID, "Result of [[DefaultValue]] is invalid")
+ECMA_ERROR_DEF (ECMA_ERR_RIGHT_VALUE_OF_IN_MUST_BE_AN_OBJECT, "Right value of 'in' must be an object")
+#if !(JERRY_BUILTIN_SHAREDARRAYBUFFER)
+ECMA_ERROR_DEF (ECMA_ERR_SHARED_ARRAYBUFFER_NOT_SUPPORTED, "SharedArrayBuffer support is disabled")
+#endif /* !(JERRY_BUILTIN_SHAREDARRAYBUFFER) */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_RETURNED_NEITHER_OBJECT_NOR_NULL, "Trap returned neither object nor null")
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_WITH_DUPLICATED_ENTRIES, "Trap returned with duplicated entries")
+#endif /* JERRY_BUILTIN_PROXY */
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_UNARY_PLUS_IS_NOT_ALLOWED_FOR_BIGINTS, "Unary plus is not allowed for BigInts")
+#endif /* JERRY_BUILTIN_BIGINT */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_IS_NOT_AN_REGEXP, "Argument 'this' is not a RegExp object")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_ALLOCATE_ARRAY_BUFFER, "Cannot allocate memory for ArrayBuffer")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+ECMA_ERROR_DEF (ECMA_ERR_CONSTANT_BINDINGS_CANNOT_BE_REASSIGNED, "Constant bindings cannot be reassigned")
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_ARRAYBUFFER_REQUIRES_NEW, "Constructor ArrayBuffer requires 'new'")
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_UINT16_ARRAY_REQUIRES_NEW, "Constructor Uint16Array requires 'new'")
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_UINT32_ARRAY_REQUIRES_NEW, "Constructor Uint32Array requires 'new'")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+ECMA_ERROR_DEF (ECMA_ERR_GENERATOR_IS_CURRENTLY_UNDER_EXECUTION, "Generator is currently under execution")
+ECMA_ERROR_DEF (ECMA_ERR_ITERATOR_RETURN_RESULT_IS_NOT_OBJECT, "Iterator 'return' result is not object")
+ECMA_ERROR_DEF (ECMA_ERR_SEARCH_STRING_CANNOT_BE_OF_TYPE_REGEXP, "Search string can't be of type: RegExp")
+ECMA_ERROR_DEF (ECMA_ERR_VALUE_RECEIVED_BY_YIELD_IS_NOT_OBJECT, "Value received by yield* is not object")
+#if JERRY_BUILTIN_BOOLEAN
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_BOOLEAN_OBJECT, "Argument 'this' is not a Boolean object")
+#endif /* JERRY_BUILTIN_BOOLEAN */
+ECMA_ERROR_DEF (ECMA_ERR_CANNOT_DECLARE_SAME_PRIVATE_FIELD_TWICE, "Cannot declare same private field twice")
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_FLOAT32_ARRAY_REQUIRES_NEW, "Constructor Float32Array requires 'new'")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_TYPEDARRAY && JERRY_NUMBER_TYPE_FLOAT64
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_FLOAT64_ARRAY_REQUIRES_NEW, "Constructor Float64Array requires 'new'")
+#endif /* JERRY_BUILTIN_TYPEDARRAY && JERRY_NUMBER_TYPE_FLOAT64 */
+ECMA_ERROR_DEF (ECMA_ERR_FUNCTION_PROTOTYPE_NOT_A_CONSTRUCTOR, "Function.prototype is not a constructor")
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_IMPORTED_BINDING_SHADOWS_LOCAL_VARIABLE, "Imported binding shadows local variable")
+#endif /* JERRY_MODULE_SYSTEM */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_PROTOTYPE_FROM_REVOKED_PROXY_IS_INVALID, "Prototype from revoked Proxy is invalid")
+#endif /* JERRY_BUILTIN_PROXY */
+#if JERRY_BUILTIN_REGEXP && JERRY_BUILTIN_STRING
+ECMA_ERROR_DEF (ECMA_ERR_REGEXP_ARGUMENT_SHOULD_HAVE_GLOBAL_FLAG, "RegExp argument should have global flag")
+#endif /* JERRY_BUILTIN_REGEXP && JERRY_BUILTIN_STRING */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_IS_NEITHER_AN_OBJECT_NOR_UNDEFINED, "Trap is neither an object nor undefined")
+#endif /* JERRY_BUILTIN_PROXY */
+ECMA_ERROR_DEF (ECMA_ERR_PROMISE_RESOLVE_ITSELF, "A promise cannot be resolved with itself")
+#if JERRY_BUILTIN_BIGINT && JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_BIGINT64_ARRAY_REQUIRES_NEW, "Constructor BigInt64Array requires 'new'")
+#endif /* JERRY_BUILTIN_BIGINT && JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_MODULE_EXPORTS_MUST_BE_VALID_IDENTIFIERS, "Module exports must be valid identifiers")
+#endif /* JERRY_MODULE_SYSTEM */
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_GENERATOR_OBJECT, "Argument 'this' is not a generator object")
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_CANNOT_CONVERT_TO_OBJECT, "Argument cannot be converted to an object")
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_ALLOCATE_BIGINT_VALUE, "Cannot allocate memory for a BigInt value")
+ECMA_ERROR_DEF (ECMA_ERR_CONVERT_BIGINT_TO_NUMBER, "Cannot convert a BigInt value to a number")
+#endif /* JERRY_BUILTIN_BIGINT */
+ECMA_ERROR_DEF (ECMA_ERR_CONVERT_SYMBOL_TO_NUMBER, "Cannot convert a Symbol value to a number")
+ECMA_ERROR_DEF (ECMA_ERR_CONVERT_SYMBOL_TO_STRING, "Cannot convert a Symbol value to a string")
+#if JERRY_BUILTIN_BIGINT && JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_BIG_UINT64_ARRAY_REQUIRES_NEW, "Constructor BigUInt64Array requires 'new'")
+#endif /* JERRY_BUILTIN_BIGINT && JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_NUMBER
+ECMA_ERROR_DEF (ECMA_ERR_FRACTION_DIGITS_OUT_OF_RANGE, "Fraction digits must be between 0 and 100")
+#endif /* JERRY_BUILTIN_NUMBER */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_RETURN_VALUE_IS_NOT_AN_ARRAYBUFFER_OBJECT, "Return value is not an ArrayBuffer object")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+ECMA_ERROR_DEF (ECMA_ERR_SUPER_CONSTRUCTOR_MAY_ONLY_BE_CALLED_ONCE, "Super constructor may only be called once")
+ECMA_ERROR_DEF (ECMA_ERR_BINDING_NOT_EXIST_OR_UNINITIALIZED, "Binding does not exist or is uninitialised")
+#if JERRY_BUILTIN_ARRAY
+ECMA_ERROR_DEF (ECMA_ERR_CANNOT_CONVERT_TO_OBJECT, "Cannot convert undefined or null to object")
+#endif /* JERRY_BUILTIN_ARRAY */
+#if JERRY_BUILTIN_NUMBER
+ECMA_ERROR_DEF (ECMA_ERR_PRECISION_DIGITS_MUST_BE_BETWEEN_IN_RANGE, "Precision digits must be between 1 and 100")
+#endif /* JERRY_BUILTIN_NUMBER */
+ECMA_ERROR_DEF (ECMA_ERR_PRIVATE_FIELD_WAS_DEFINED_WITHOUT_A_GETTER, "Private field was defined without a getter")
+ECMA_ERROR_DEF (ECMA_ERR_PRIVATE_FIELD_WAS_DEFINED_WITHOUT_A_SETTER, "Private field was defined without a setter")
+ECMA_ERROR_DEF (ECMA_ERR_PROPERTY_NAME_IS_NEITHER_SYMBOL_NOR_STRING, "Property name is neither Symbol nor string")
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_STRING_CANNOT_BE_CONVERTED_TO_BIGINT_VALUE, "String cannot be converted to BigInt value")
+#endif /* JERRY_BUILTIN_BIGINT */
+#if JERRY_BUILTIN_CONTAINER
+ECMA_ERROR_DEF (ECMA_ERR_INCORRECT_TYPE_CALL, "Operator called on incorrect container type")
+#endif /* JERRY_BUILTIN_CONTAINER */
+#if JERRY_BUILTIN_ARRAY
+ECMA_ERROR_DEF (ECMA_ERR_REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE, "Reduce of empty Array with no initial value")
+#endif /* JERRY_BUILTIN_ARRAY */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_REG_EXP_OBJECT, "Argument 'this' is not a valid RegExp object")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_ARRAY_BUFFER_OBJECT, "Argument 'this' is not an ArrayBuffer object")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_ERROR_MESSAGES
+ECMA_ERROR_DEF (ECMA_ERR_ARROW_FUNCTIONS_INVOKE_WITH_NEW, "Arrow functions cannot be invoked with 'new'")
+ECMA_ERROR_DEF (ECMA_ERR_ASYNC_FUNCTIONS_INVOKE_WITH_NEW, "Async functions cannot be invoked with 'new'")
+#endif /* JERRY_ERROR_MESSAGES */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_SET_EXTENSIBLE_PROPERTY, "Cannot set [[Extensible]] property of object")
+#endif /* JERRY_BUILTIN_PROXY */
+#if JERRY_BUILTIN_SHAREDARRAYBUFFER
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_SHAREDARRAYBUFFER_REQUIRES_NEW, "Constructor SharedArrayBuffer requires 'new'")
+#endif /* JERRY_BUILTIN_SHAREDARRAYBUFFER */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_CONSTRUCTOR_UINT8_CLAMPED_ARRAY_REQUIRES_NEW, "Constructor Uint8ClampedArray requires 'new'")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_NEGATIVE_EXPONENT_IS_NOT_ALLOWED_FOR_BIGINTS, "Negative exponent is not allowed for BigInts")
+#endif /* JERRY_BUILTIN_BIGINT */
+ECMA_ERROR_DEF (ECMA_ERR_PROMISE_ALL_REMAINING_ELEMENTS_LIMIT_REACHED, "Promise.all remaining elements limit reached")
+ECMA_ERROR_DEF (ECMA_ERR_VALUE_RECEIVED_BY_FOR_ASYNC_OF_IS_NOT_OBJECT, "Value received by for-async-of is not object")
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_INFINITY_OR_NAN_CANNOT_BE_CONVERTED_TO_BIGINT, "Infinity or NaN cannot be converted to BigInt")
+#endif /* JERRY_BUILTIN_BIGINT */
+ECMA_ERROR_DEF (ECMA_ERR_OPERATOR_DELETE_RETURNED_FALSE_IN_STRICT_MODE, "Operator delete returned false in strict mode")
+ECMA_ERROR_DEF (ECMA_ERR_PROPERTY_PROTOTYPE_IS_NOT_AN_OBJECT, "Property 'prototype' is not an object or null")
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_PROXY_HANDLER_IS_NULL_FOR_ISARRAY_OPERATION, "Proxy handler is null for 'isArray' operation")
+#endif /* JERRY_BUILTIN_PROXY */
+#if JERRY_SNAPSHOT_SAVE
+ECMA_ERROR_DEF (ECMA_ERR_REGULAR_EXPRESSION_NOT_SUPPORTED, "Regular expression literals are not supported")
+#endif /* JERRY_SNAPSHOT_SAVE */
+ECMA_ERROR_DEF (ECMA_ERR_RIGHT_VALUE_OF_INSTANCEOF_MUST_BE_AN_OBJECT, "Right value of 'instanceof' must be an object")
+#if JERRY_SNAPSHOT_EXEC
+ECMA_ERROR_DEF (ECMA_ERR_STATIC_SNAPSHOTS_CANNOT_BE_COPIED_INTO_MEMORY, "Static snapshots cannot be copied into memory")
+#endif /* JERRY_SNAPSHOT_EXEC */
+#if JERRY_SNAPSHOT_SAVE
+ECMA_ERROR_DEF (ECMA_ERR_TAGGED_TEMPLATE_LITERALS, "Unsupported feature: tagged template literals")
+ECMA_ERROR_DEF (ECMA_ERR_SNAPSHOT_FLAG_NOT_SUPPORTED, "Unsupported generate snapshot flags specified")
+#endif /* JERRY_SNAPSHOT_SAVE */
+#if JERRY_SNAPSHOT_EXEC
+ECMA_ERROR_DEF (ECMA_ERR_UNSUPPORTED_SNAPSHOT_EXEC_FLAGS_ARE_SPECIFIED, "Unsupported snapshot exec flags are specified")
+#endif /* JERRY_SNAPSHOT_EXEC */
+ECMA_ERROR_DEF (ECMA_ERR_VALUE_FOR_CLASS_HERITAGE_IS_NOT_A_CONSTRUCTOR, "Value for class heritage is not a constructor")
+ECMA_ERROR_DEF (ECMA_ERR_TOO_MANY_ARGUMENTS_DECLARED_FOR_FUNCTION_APPLY,
+                "Too many arguments declared for Function.apply")
+#if JERRY_ERROR_MESSAGES
+ECMA_ERROR_DEF (ECMA_ERR_ACCESSOR_FUNCTIONS_INVOKE_WITH_NEW, "Accessor functions cannot be invoked with 'new'")
+#endif /* JERRY_ERROR_MESSAGES */
+#if JERRY_MODULE_SYSTEM
+ECMA_ERROR_DEF (ECMA_ERR_LINK_TO_MODULE_IN_ERROR_STATE, "Cannot link to a module which is in error state")
+#endif /* JERRY_MODULE_SYSTEM */
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_ONLY_INTEGER_NUMBERS_CAN_BE_CONVERTED_TO_BIGINT,
+                "Only integer numbers can be converted to BigInt")
+#endif /* JERRY_BUILTIN_BIGINT */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_TYPEDARRAY_INTRINSTIC_DIRECTLY_CALLED, "TypedArray intrinstic cannot be directly called")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_UNSIGNED_RIGHT_SHIFT_IS_NOT_ALLOWED_FOR_BIGINTS,
+                "Unsigned right shift is not allowed for BigInts")
+#endif /* JERRY_BUILTIN_BIGINT */
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_ASYNC_GENERATOR, "Argument 'this' is not an async generator object")
+ECMA_ERROR_DEF (ECMA_ERR_CLASS_EXTENDS_NOT_CONSTRUCTOR, "Class extends value is not a constructor or null")
+#if JERRY_ERROR_MESSAGES
+ECMA_ERROR_DEF (ECMA_ERR_GENERATOR_FUNCTIONS_INVOKE_WITH_NEW, "Generator functions cannot be invoked with 'new'")
+#endif /* JERRY_ERROR_MESSAGES */
+#if JERRY_BUILTIN_REGEXP
+ECMA_ERROR_DEF (ECMA_ERR_RETURN_VALUE_OF_EXEC_MUST_BE_AN_OBJECT_OR_NULL,
+                "Return value of 'exec' must be an object or null")
+#endif /* JERRY_BUILTIN_REGEXP */
+#if JERRY_BUILTIN_DATAVIEW
+ECMA_ERROR_DEF (ECMA_ERR_START_OFFSET_IS_OUTSIDE_THE_BOUNDS_OF_THE_BUFFER,
+                "Start offset is outside the bounds of the buffer")
+#endif /* JERRY_BUILTIN_DATAVIEW */
+#if JERRY_BUILTIN_SHAREDARRAYBUFFER
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_SHARED_ARRAY_BUFFER, "Argument 'this' is not a SharedArrayBuffer object")
+#endif /* JERRY_BUILTIN_SHAREDARRAYBUFFER */
+ECMA_ERROR_DEF (ECMA_ERR_CLASS_CONSTRUCTOR_NEW, "Class constructor cannot be invoked without 'new'")
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_INCORRECT_RETURN_PROXY_GET_TRAP, "Incorrect value is returned by a Proxy 'get' trap")
+ECMA_ERROR_DEF (ECMA_ERR_INCORRECT_RETURN_PROXY_SET_TRAP, "Incorrect value is returned by a Proxy 'set' trap")
+#endif /* JERRY_BUILTIN_PROXY */
+ECMA_ERROR_DEF (ECMA_ERR_CLASS_IS_NON_CONFIGURABLE, "Prototype property of a class is non-configurable")
+#if JERRY_BUILTIN_ARRAY
+ECMA_ERROR_DEF (ECMA_ERR_PUSHING_TOO_HIGH_ELEMENT, "Pushing element over 2**53-1 length is disallowed")
+#endif /* JERRY_BUILTIN_ARRAY */
+ECMA_ERROR_DEF (ECMA_ERR_THE_REQUESTED_PROPERTY_UPDATE_CANNOT_BE_PERFORMED,
+                "The requested property update cannot be performed")
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_RESULT_NOT_INCLUDE_ALL_CONFIGURABLE_KEYS,
+                "Trap result did not include all configurable keys")
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_TRUISH_TARGET_NOT_EXTENSIBLE, "Trap returned truish for target is not extensible")
+#endif /* JERRY_BUILTIN_PROXY */
+#if JERRY_BUILTIN_NUMBER
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_NUMBER, "Argument 'this' is not a number or a Number object")
+#endif /* JERRY_BUILTIN_NUMBER */
+#if JERRY_BUILTIN_STRING
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_STRING_OBJECT, "Argument 'this' is not a string or a String object")
+#endif /* JERRY_BUILTIN_STRING */
+#if JERRY_BUILTIN_SHAREDARRAYBUFFER
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_THIS_NOT_SHARED_ARRAY_BUFFER_OBJECT,
+                "Argument 'this' is not an SharedArrayBuffer object")
+#endif /* JERRY_BUILTIN_SHAREDARRAYBUFFER */
+#if JERRY_ERROR_MESSAGES
+ECMA_ERROR_DEF (ECMA_ERR_ASYNC_ARROW_FUNCTIONS_INVOKE_WITH_NEW, "Async arrow functions cannot be invoked with 'new'")
+#endif /* JERRY_ERROR_MESSAGES */
+#if JERRY_BUILTIN_ARRAY
+ECMA_ERROR_DEF (ECMA_ERR_UNSHIFT_TOO_HIGH, "Unshift elements over 2**53-1 length is disallowed")
+#endif /* JERRY_BUILTIN_ARRAY */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_RESULT_NOT_INCLUDE_ALL_NON_CONFIGURABLE_KEYS,
+                "Trap result did not include all non-configurable keys")
+#endif /* JERRY_BUILTIN_PROXY */
+#if JERRY_ERROR_MESSAGES
+ECMA_ERROR_DEF (ECMA_ERR_ASYNC_GENERATOR_FUNCTIONS_INVOKE_WITH_NEW,
+                "Async generator functions cannot be invoked with 'new'")
+#endif /* JERRY_ERROR_MESSAGES */
+#if JERRY_BUILTIN_REFLECT
+ECMA_ERROR_DEF (ECMA_ERR_REFLECT_EXPECTS_AN_OBJECT_AS_SECOND_ARGUMENT,
+                "Reflect.construct expects an object as second argument")
+#endif /* JERRY_BUILTIN_REFLECT */
+#if JERRY_ERROR_MESSAGES
+ECMA_ERROR_DEF (ECMA_ERR_SCRIPT_GLOBAL_FUNCTIONS_INVOKE_WITH_NEW,
+                "Script (global) functions cannot be invoked with 'new'")
+#endif /* JERRY_ERROR_MESSAGES */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_CANNOT_CREATE_PROXY, "Cannot create Proxy with a non-object target or handler")
+#endif /* JERRY_BUILTIN_PROXY */
+ECMA_ERROR_DEF (ECMA_ERR_DERIVED_CTOR_RETURN_NOR_OBJECT_OR_UNDEFINED,
+                "Derived constructors may only return object or undefined")
+#if JERRY_SNAPSHOT_EXEC
+ECMA_ERROR_DEF (ECMA_ERR_INVALID_SNAPSHOT_VERSION_OR_FEATURES,
+                "Invalid snapshot version or unsupported features present")
+#endif /* JERRY_SNAPSHOT_EXEC */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_TYPEDARRAY_SMALLER_THAN_FILTER_CALL_RESULT,
+                "Constructed TypedArray is smaller than filter call result")
+ECMA_ERROR_DEF (ECMA_ERR_DERIVED_ARRAY_BUFFER_CTOR_BUFFER_TOO_SMALL,
+                "Derived ArrayBuffer constructor created a too small buffer")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_RESULT_NOT_REFLECT_TARGET_EXTENSIBILITY,
+                "Trap result does not reflect extensibility of Proxy target")
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_EXTRA_KEYS_FOR_A_NON_EXTENSIBLE_TARGET,
+                "Trap returned extra keys for a non-extensible Proxy target")
+#endif /* JERRY_BUILTIN_PROXY */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_ARRAY_BUFFER_RETURNED_THIS_FROM_CONSTRUCTOR,
+                "ArrayBuffer subclass returned this from species constructor")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_DATAVIEW
+ECMA_ERROR_DEF (ECMA_ERR_ARGUMENT_BUFFER_NOT_ARRAY_OR_SHARED_BUFFER,
+                "Argument 'buffer' is not an ArrayBuffer or SharedArrayBuffer")
+#endif /* JERRY_BUILTIN_DATAVIEW */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_RESULT_NOT_REFLECT_TARGET_INEXTENSIBILITY,
+                "Trap result does not reflect inextensibility of Proxy target")
+#endif /* JERRY_BUILTIN_PROXY */
+#if JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_TYPEDARRAY_INTRINSTIC_CALLED_BY_NEW_EXPRESSION,
+                "TypedArray intrinstic cannot be called by a 'new' expression")
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_BIGINT && JERRY_BUILTIN_TYPEDARRAY
+ECMA_ERROR_DEF (ECMA_ERR_CONTENTTYPE_RETURNED_TYPEDARRAY_NOT_MATCH_SOURCE,
+                "TypedArray returned by [[ContentType]] does not match source")
+#endif /* JERRY_BUILTIN_BIGINT && JERRY_BUILTIN_TYPEDARRAY */
+#if JERRY_BUILTIN_BIGINT
+ECMA_ERROR_DEF (ECMA_ERR_ALLOCATE_BIGINT_STRING, "Cannot allocate memory for a string representation of a BigInt value")
+#endif /* JERRY_BUILTIN_BIGINT */
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TARGET_NOT_EXTENSIBLE_DIFFERENT_PROTOTYPE_RETURNED,
+                "Target object is non-extensible and trap returned different prototype")
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_TRUISH_ADDING_PROPERTY_NON_EXTENSIBLE_TARGET,
+                "Trap returned truish for adding property to the non-extensible target")
+#endif /* JERRY_BUILTIN_PROXY */
+ECMA_ERROR_DEF (ECMA_ERR_CANNOT_READ_PRIVATE_MEMBER_TO_AN_OBJECT_WHOSE_CLASS_DID_NOT_DECLARE_IT,
+                "Cannot read private member to an object whose class did not declare it")
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_GIVEN_PROPERTY_IS_A_NON_CONFIGURABLE,
+                "Given property is a non-configurable data property on the proxy target")
+#endif /* JERRY_BUILTIN_PROXY */
+ECMA_ERROR_DEF (ECMA_ERR_CANNOT_WRITE_PRIVATE_MEMBER_TO_AN_OBJECT_WHOSE_CLASS_DID_NOT_DECLARE_IT,
+                "Cannot write private member to an object whose class did not declare it")
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_FALSISH_PROPERTY_TARGET_NOT_EXTENSIBLE,
+                "Trap returned falsish for property but the proxy target is not extensible")
+ECMA_ERROR_DEF (ECMA_ERR_PROXY_PROPERTY_NOT_CONFIGURABLE_NOT_HAVE_GETTER,
+                "Property of a Proxy is non-configurable and does not have a getter function")
+ECMA_ERROR_DEF (ECMA_ERR_TARGET_PROPERTY_CONFIGURE_ACCESSOR_WITHOUT_SETTER,
+                "The property of a Proxy target is a non configurable accessor without a setter")
+#endif /* JERRY_BUILTIN_PROXY */
+ECMA_ERROR_DEF (ECMA_ERR_LET_CONST_NOT_INITIALIZED,
+                "Variables declared by let/const must be initialized before reading their value")
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_TRUISH_PROPERTY_NON_CONFIGURABLE,
+                "Trap returned truish for property which is non-configurable in the proxy target")
+ECMA_ERROR_DEF (ECMA_ERR_TARGET_NOT_EXTENSIBLE_NOT_RETURNED_ITS_PROTOTYPE,
+                "Proxy target is non-extensible, but the trap did not return its actual prototype")
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_FALSISH_PROPERTY_NON_CONFIGURABLE,
+                "Trap returned falsish for property which exists in the proxy target as non-configurable")
+#endif /* JERRY_BUILTIN_PROXY */
+ECMA_ERROR_DEF (ECMA_ERR_CALL_SUPER_CONSTRUCTOR_DERIVED_CLASS_BEFORE_THIS,
+                "Must call super constructor in derived class before accessing 'this' or returning from it")
+#if JERRY_BUILTIN_PROXY
+ECMA_ERROR_DEF (ECMA_ERR_TRAP_TRUISH_DEFINING_NON_EXISTENT_PROPERTY,
+                "Trap returned truish for defining non-configurable property which is non-existent in the target")
+ECMA_ERROR_DEF (
+  ECMA_ERR_TRAP_TRUISH_ADD_PROPERTY_INCOMPATIBLE_OTHER_PROP,
+  "Trap returned truish for adding property that is incompatible with the existing property in the target")
+#endif /* JERRY_BUILTIN_PROXY */
+ECMA_ERROR_DEF (ECMA_ERR_CANNOT_ACCESS_CALLER_CALLE_ARGUMENTS,
+                "'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the "
+                "arguments objects for calls to them")

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-error-messages.ini

@@ -0,0 +1,331 @@
+# 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.
+
+[ECMA_ERROR_MESSAGES]
+
+ECMA_ERR_CANNOT_ACCESS_CALLER_CALLE_ARGUMENTS = "'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them"
+ECMA_ERR_PARAMETER_REJECT_MUST_BE_CALLABLE = "'reject' parameter must be callable"
+ECMA_ERR_PARAMETER_RESOLVE_MUST_BE_CALLABLE = "'resolve' parameter must be callable"
+ECMA_ERR_PROMISE_RESOLVE_ITSELF = "A promise cannot be resolved with itself"
+ECMA_ERR_ACCESSOR_WRITABLE = "Accessors cannot be writable"
+ECMA_ERR_ARGUMENT_BUFFER_NOT_ARRAY_OR_SHARED_BUFFER = "Argument 'buffer' is not an ArrayBuffer or SharedArrayBuffer"
+ECMA_ERR_ARGUMENT_BUFFER_NOT_OBJECT = "Argument 'buffer' is not an object"
+ECMA_ERR_ARGUMENT_THIS_NOT_ARRAY_BUFFER_OBJECT = "Argument 'this' is not an ArrayBuffer object"
+ECMA_ERR_ARGUMENT_THIS_NOT_BOOLEAN_OBJECT = "Argument 'this' is not a Boolean object"
+ECMA_ERR_ARGUMENT_THIS_NOT_DATE_OBJECT = "Argument 'this' is not a Date object"
+ECMA_ERR_ARGUMENT_THIS_NOT_PROMISE = "Argument 'this' is not a Promise"
+ECMA_ERR_ARGUMENT_THIS_NOT_SHARED_ARRAY_BUFFER = "Argument 'this' is not a SharedArrayBuffer object"
+ECMA_ERR_ARGUMENT_THIS_NOT_TYPED_ARRAY = "Argument 'this' is not a TypedArray"
+ECMA_ERR_ARGUMENT_THIS_NOT_CONSTRUCTOR = "Argument 'this' is not a constructor"
+ECMA_ERR_ARGUMENT_THIS_NOT_FUNCTION = "Argument 'this' is not a function"
+ECMA_ERR_ARGUMENT_THIS_NOT_GENERATOR_OBJECT = "Argument 'this' is not a generator object"
+ECMA_ERR_ARGUMENT_THIS_NOT_NUMBER = "Argument 'this' is not a number or a Number object"
+ECMA_ERR_ARGUMENT_THIS_NOT_STRING_OBJECT = "Argument 'this' is not a string or a String object"
+ECMA_ERR_ARGUMENT_THIS_NOT_REG_EXP = "Argument 'this' is not a valid RegExp"
+ECMA_ERR_ARGUMENT_THIS_NOT_REG_EXP_OBJECT = "Argument 'this' is not a valid RegExp object"
+ECMA_ERR_ARGUMENT_THIS_NOT_SHARED_ARRAY_BUFFER_OBJECT = "Argument 'this' is not an SharedArrayBuffer object"
+ECMA_ERR_ARGUMENT_THIS_NOT_ASYNC_GENERATOR = "Argument 'this' is not an async generator object"
+ECMA_ERR_ARGUMENT_THIS_NOT_ITERATOR = "Argument 'this' is not an iterator"
+ECMA_ERR_ARGUMENT_THIS_NOT_OBJECT = "Argument 'this' is not an object"
+ECMA_ERR_ARGUMENT_THIS_NOT_SYMBOL = "Argument 'this' must be a Symbol"
+ECMA_ERR_ARGUMENT_CANNOT_CONVERT_TO_OBJECT = "Argument cannot be converted to an object"
+ECMA_ERR_ARGUMENT_NOT_SHARED_ARRAY_BUFFER = "Argument is not SharedArrayBuffer"
+ECMA_ERR_ARGUMENT_NOT_ARRAY_BUFFER = "Argument is not an ArrayBuffer"
+ECMA_ERR_ARGUMENT_NOT_SUPPORTED = "Argument is not supported"
+ECMA_ERR_ARRAY_BUFFER_DETACHED = "ArrayBuffer has already been detached"
+ECMA_ERR_ARRAY_BUFFER_RETURNED_THIS_FROM_CONSTRUCTOR = "ArrayBuffer subclass returned this from species constructor"
+ECMA_ERR_BIGINT_SERIALIZED = "BigInt cannot be serialized"
+ECMA_ERR_BIGINT_ZERO_DIVISION = "BigInt division by zero"
+ECMA_ERR_BIGINT_FUNCTION_NOT_CONSTRUCTOR = "BigInt function is not a constructor"
+ECMA_ERR_BIGINT_VALUE_EXCPECTED = "BigInt value expected"
+ECMA_ERR_BINDING_CANNOT_SET = "Binding cannot be set"
+ECMA_ERR_BINDING_NOT_EXIST_OR_UNINITIALIZED = "Binding does not exist or is uninitialised"
+ECMA_ERR_BULTIN_ROUTINES_HAVE_NO_CONSTRUCTOR = "Built-in routines have no constructor"
+ECMA_ERR_CALLBACK_RESULT_NOT_MODULE = "Callback result must be a module"
+ECMA_ERR_ALLOCATE_ARRAY_BUFFER = "Cannot allocate memory for ArrayBuffer"
+ECMA_ERR_ALLOCATE_BIGINT_VALUE = "Cannot allocate memory for a BigInt value"
+ECMA_ERR_ALLOCATE_BIGINT_STRING = "Cannot allocate memory for a string representation of a BigInt value"
+ECMA_ERR_CONVERT_BIGINT_TO_NUMBER = "Cannot convert a BigInt value to a number"
+ECMA_ERR_CONVERT_SYMBOL_TO_NUMBER = "Cannot convert a Symbol value to a number"
+ECMA_ERR_CONVERT_SYMBOL_TO_STRING = "Cannot convert a Symbol value to a string"
+ECMA_ERR_CANNOT_CREATE_PROXY = "Cannot create Proxy with a non-object target or handler"
+ECMA_ERR_INVOKE_NULLABLE_SUPER_METHOD = "Cannot invoke nullable super method"
+ECMA_ERR_LINK_TO_MODULE_IN_ERROR_STATE = "Cannot link to a module which is in error state"
+ECMA_ERR_SET_EXTENSIBLE_PROPERTY = "Cannot set [[Extensible]] property of object"
+ECMA_ERR_SET_PROTOTYPE = "Cannot set [[Prototype]]"
+ECMA_ERR_CLASS_CONSTRUCTOR_REQUIRES_NEW = "Class constructor requires 'new'"
+ECMA_ERR_CLASS_EXTENDS_NOT_CONSTRUCTOR = "Class extends value is not a constructor or null"
+ECMA_ERR_COMPARE_FUNC_NOT_CALLABLE = "Compare function is not callable"
+ECMA_ERR_CONSTANT_BINDINGS_CANNOT_BE_REASSIGNED = "Constant bindings cannot be reassigned"
+ECMA_ERR_TYPEDARRAY_SMALLER_THAN_FILTER_CALL_RESULT = "Constructed TypedArray is smaller than filter call result"
+ECMA_ERR_CONSTRUCTED_OBJECT_IS_NOT_TYPEDARRAY = "Constructed object is not TypedArray"
+ECMA_ERR_CONSTRUCTOR_ARRAYBUFFER_REQUIRES_NEW = "Constructor ArrayBuffer requires 'new'"
+ECMA_ERR_CONSTRUCTOR_BIGINT64_ARRAY_REQUIRES_NEW = "Constructor BigInt64Array requires 'new'"
+ECMA_ERR_CONSTRUCTOR_BIG_UINT64_ARRAY_REQUIRES_NEW = "Constructor BigUInt64Array requires 'new'"
+ECMA_ERR_CONSTRUCTOR_DATAVIEW_REQUIRES_NEW = "Constructor DataView requires 'new'"
+ECMA_ERR_CONSTRUCTOR_FLOAT32_ARRAY_REQUIRES_NEW = "Constructor Float32Array requires 'new'"
+ECMA_ERR_CONSTRUCTOR_FLOAT64_ARRAY_REQUIRES_NEW = "Constructor Float64Array requires 'new'"
+ECMA_ERR_CONSTRUCTOR_INT16_ARRAY_REQUIRES_NEW = "Constructor Int16Array requires 'new'"
+ECMA_ERR_CONSTRUCTOR_INT32_ARRAY_REQUIRES_NEW = "Constructor Int32Array requires 'new'"
+ECMA_ERR_CONSTRUCTOR_INT8_ARRAY_REQUIRES_NEW = "Constructor Int8Array requires 'new'"
+ECMA_ERR_CONSTRUCTOR_MAP_REQUIRES_NEW = "Constructor Map requires 'new'"
+ECMA_ERR_CONSTRUCTOR_PROMISE_REQUIRES_NEW = "Constructor Promise requires 'new'"
+ECMA_ERR_CONSTRUCTOR_PROXY_REQUIRES_NEW = "Constructor Proxy requires 'new'"
+ECMA_ERR_CONSTRUCTOR_SET_REQUIRES_NEW = "Constructor Set requires 'new'"
+ECMA_ERR_CONSTRUCTOR_SHAREDARRAYBUFFER_REQUIRES_NEW = "Constructor SharedArrayBuffer requires 'new'"
+ECMA_ERR_CONSTRUCTOR_UINT16_ARRAY_REQUIRES_NEW = "Constructor Uint16Array requires 'new'"
+ECMA_ERR_CONSTRUCTOR_UINT32_ARRAY_REQUIRES_NEW = "Constructor Uint32Array requires 'new'"
+ECMA_ERR_CONSTRUCTOR_UINT8_ARRAY_REQUIRES_NEW = "Constructor Uint8Array requires 'new'"
+ECMA_ERR_CONSTRUCTOR_UINT8_CLAMPED_ARRAY_REQUIRES_NEW = "Constructor Uint8ClampedArray requires 'new'"
+ECMA_ERR_CONSTRUCTOR_WEAKMAP_REQUIRES_NEW = "Constructor WeakMap requires 'new'"
+ECMA_ERR_CONSTRUCTOR_WEAKREF_REQUIRES_NEW = "Constructor WeakRef requires 'new'."
+ECMA_ERR_CONSTRUCTOR_WEAKSET_REQUIRES_NEW = "Constructor WeakSet requires 'new'"
+ECMA_ERR_CONSTRUCTOR_NOT_AN_OBJECT = "Constructor must be an object"
+ECMA_ERR_CONTAINER_IS_NOT_A_CONTAINER_OBJECT = "Container is not a container object."
+ECMA_ERR_CONTAINER_IS_NOT_AN_OBJECT = "Container is not an object."
+ECMA_ERR_DATE_MUST_BE_A_FINITE_NUMBER = "Date must be a finite number"
+ECMA_ERR_DERIVED_ARRAY_BUFFER_CTOR_BUFFER_TOO_SMALL = "Derived ArrayBuffer constructor created a too small buffer"
+ECMA_ERR_DERIVED_CTOR_RETURN_NOR_OBJECT_OR_UNDEFINED = "Derived constructors may only return object or undefined"
+ECMA_ERR_INVALID_CODE_POINT_ERROR = "Error: Invalid code point"
+ECMA_ERR_EXPECTED_A_DATAVIEW_OBJECT = "Expected a DataView object"
+ECMA_ERR_EXPECTED_A_CONFIGURABLE_PROPERTY = "Expected a configurable property"
+ECMA_ERR_EXPECTED_A_FUNCTION_OBJECT = "Expected a function object"
+ECMA_ERR_EXPECTED_AN_ARRAYBUFFER = "Expected an ArrayBuffer"
+ECMA_ERR_EXPECTED_AN_OBJECT = "Expected an object"
+ECMA_ERR_FIRST_ARGUMENT_IS_NOT_A_REALM = "First argument is not a realm"
+ECMA_ERR_FIRST_PARAMETER_MUST_BE_CALLABLE = "First parameter must be callable"
+ECMA_ERR_FRACTION_DIGITS_OUT_OF_RANGE = "Fraction digits must be between 0 and 100"
+ECMA_ERR_FUNCTION_ADD_ORSET_IS_NOT_CALLABLE = "Function add/set is not callable"
+ECMA_ERR_FUNCTION_INDEX_IS_HIGHER_THAN_MAXIMUM = "Function index is higher than maximum"
+ECMA_ERR_FUNCTION_PROTOTYPE_NOT_A_CONSTRUCTOR = "Function.prototype is not a constructor"
+ECMA_ERR_GENERATOR_IS_CURRENTLY_UNDER_EXECUTION = "Generator is currently under execution"
+ECMA_ERR_GETTER_IS_NOT_CALLABLE = "Getter is not callable"
+ECMA_ERR_GIVEN_PROPERTY_IS_A_NON_CONFIGURABLE = "Given property is a non-configurable data property on the proxy target"
+ECMA_ERR_HANDLER_CANNOT_BE_NULL = "Handler cannot be null"
+ECMA_ERR_IMPORTED_BINDING_SHADOWS_LOCAL_VARIABLE = "Imported binding shadows local variable"
+ECMA_ERR_INCOMPATIBLE_TYPEDARRAY_TYPES = "Incompatible TypedArray types"
+ECMA_ERR_INCORRECT_TYPE_FOR_TYPEDARRAY = "Incorrect type for TypedArray"
+ECMA_ERR_INCORRECT_RETURN_PROXY_GET_TRAP = "Incorrect value is returned by a Proxy 'get' trap"
+ECMA_ERR_INCORRECT_RETURN_PROXY_SET_TRAP = "Incorrect value is returned by a Proxy 'set' trap"
+ECMA_ERR_INFINITY_OR_NAN_CANNOT_BE_CONVERTED_TO_BIGINT = "Infinity or NaN cannot be converted to BigInt"
+ECMA_ERR_INITIAL_VALUE_CANNOT_BE_UNDEFINED = "Initial value cannot be undefined"
+ECMA_ERR_INVALID_ARRAYBUFFER_LENGTH = "Invalid ArrayBuffer length"
+ECMA_ERR_INVALID_JSON_FORMAT = "Invalid JSON format"
+ECMA_ERR_INVALID_REGEXP_FLAGS = "Invalid RegExp flags"
+ECMA_ERR_INVALID_SHARED_ARRAYBUFFER_LENGTH = "Invalid Shared ArrayBuffer length"
+ECMA_ERR_INVALID_TYPEDARRAY_LENGTH = "Invalid TypedArray length"
+ECMA_ERR_INVALID_UTF8_CHARACTER = "Invalid UTF8 character"
+ECMA_ERR_INVALID_UTF8_CODEPOINT = "Invalid UTF8 codepoint"
+ECMA_ERR_INVALID_UTF8_STRING = "Invalid UTF8 string"
+ECMA_ERR_INVALID_ENCODING = "Invalid encoding"
+ECMA_ERR_INVALID_ARGUMENT = "Invalid argument"
+ECMA_ERR_INVALID_ARGUMENT_TYPE_IN_TOPRIMITIVE = "Invalid argument type in toPrimitive"
+ECMA_ERR_INVALID_CAPABILITY = "Invalid capability"
+ECMA_ERR_INVALID_CHARACTER_CLASS = "Invalid character class"
+ECMA_ERR_INVALID_CODE_POINT = "Invalid code point"
+ECMA_ERR_INVALID_CONTAINER_TYPE = "Invalid container type"
+ECMA_ERR_INVALID_CONTROL_ESCAPE_SEQUENCE = "Invalid control escape sequence"
+ECMA_ERR_INVALID_COUNT_VALUE = "Invalid count value"
+ECMA_ERR_INVALID_ESCAPE = "Invalid escape"
+ECMA_ERR_INVALID_ESCAPE_SEQUENCE = "Invalid escape sequence"
+ECMA_ERR_INVALID_GROUP = "Invalid group"
+ECMA_ERR_INVALID_HEX_ESCAPE_SEQUENCE = "Invalid hex escape sequence"
+ECMA_ERR_INVALID_HEXADECIMAL_VALUE = "Invalid hexadecimal value"
+ECMA_ERR_INVALID_LENGTH = "Invalid length"
+ECMA_ERR_INVALID_NEW_ARRAY_LENGTH = "Invalid new Array length"
+ECMA_ERR_INVALID_OFFSET = "Invalid offset"
+ECMA_ERR_INVALID_OR_OUT_OF_RANGE_INDEX = "Invalid or out-of-range index"
+ECMA_ERR_INVALID_QUANTIFIER = "Invalid quantifier"
+ECMA_ERR_INVALID_RANGE_OF_INDEX = "Invalid range of index"
+ECMA_ERR_INVALID_SCOPE_CHAIN_INDEX_FOR_EVAL = "Invalid scope chain index for eval"
+ECMA_ERR_INVALID_SPECIES_CONSTRUCTOR = "Invalid species constructor"
+ECMA_ERR_INVALID_STRING_ = "Invalid string length"
+ECMA_ERR_INVALID_UNICODE_ESCAPE_SEQUENCE = "Invalid unicode escape sequence"
+ECMA_ERR_ITERATOR_NEXT_IS_NOT_CALLABLE = "Iterator 'next' is not callable"
+ECMA_ERR_ITERATOR_RETURN_RESULT_IS_NOT_OBJECT = "Iterator 'return' result is not object"
+ECMA_ERR_ITERATOR_THROW_IS_NOT_AVAILABLE = "Iterator 'throw' is not available"
+ECMA_ERR_ITERATOR_IS_NOT_AN_OBJECT = "Iterator is not an object"
+ECMA_ERR_ITERATOR_IS_NOT_CALLABLE = "Iterator is not callable"
+ECMA_ERR_ITERATOR_RESULT_IS_NOT_AN_OBJECT = "Iterator result is not an object"
+ECMA_ERR_ITERATOR_VALUE_IS_NOT_AN_OBJECT = "Iterator value is not an object"
+ECMA_ERR_JSON_STRING_PARSE_ERROR = "JSON string parse error"
+ECMA_ERR_JSON_STRINGIFY_ERROR = "JSON stringify error"
+ECMA_ERR_KEY_MUST_BE_AN_OBJECT = "Key must be an object"
+ECMA_ERR_LONE_QUANTIFIER_BRACKET = "Lone quantifier bracket"
+ECMA_ERR_MAXIMUM_TYPEDARRAY_SIZE_IS_REACHED = "Maximum TypedArray size is reached"
+ECMA_ERR_MAXIMUM_STRING_LENGTH_IS_REACHED = "Maximum string length is reached"
+ECMA_ERR_MISSING_ARRAY_ELEMENT = "Missing Array element"
+ECMA_ERR_MODULE_CANNOT_BE_INSTANTIATED = "Module cannot be instantiated"
+ECMA_ERR_MODULE_EXPORTS_MUST_BE_STRING_VALUES = "Module exports must be string values"
+ECMA_ERR_MODULE_EXPORTS_MUST_BE_VALID_IDENTIFIERS = "Module exports must be valid identifiers"
+ECMA_ERR_MODULE_IS_IN_ERROR_STATE = "Module is in error state"
+ECMA_ERR_MODULE_MUST_BE_IN_LINKED_STATE = "Module must be in linked state"
+ECMA_ERR_MODULE_MUST_BE_IN_UNLINKED_STATE = "Module must be in unlinked state"
+ECMA_ERR_CALL_SUPER_CONSTRUCTOR_DERIVED_CLASS_BEFORE_THIS = "Must call super constructor in derived class before accessing 'this' or returning from it"
+ECMA_ERR_NAMESPACE_OBJECT_IS_NOT_AVAILABLE = "Namespace object is not available"
+ECMA_ERR_NEGATIVE_EXPONENT_IS_NOT_ALLOWED_FOR_BIGINTS = "Negative exponent is not allowed for BigInts"
+ECMA_ERR_NO_SOURCE_ARGUMENT = "No source argument"
+ECMA_ERR_NOTHING_TO_REPEAT = "Nothing to repeat"
+ECMA_ERR_OBJECT_CANNOT_BE_FROZEN = "Object cannot be frozen"
+ECMA_ERR_OBJECT_CANNOT_BE_SEALED = "Object cannot be sealed"
+ECMA_ERR_OBJECT_EXPECTED = "Object expected"
+ECMA_ERR_OBJECT_IS_NOT_A_TYPEDARRAY = "Object is not a TypedArray"
+ECMA_ERR_ONLY_INTEGER_NUMBERS_CAN_BE_CONVERTED_TO_BIGINT = "Only integer numbers can be converted to BigInt"
+ECMA_ERR_OPERATOR_DELETE_RETURNED_FALSE_IN_STRICT_MODE = "Operator delete returned false in strict mode"
+ECMA_ERR_PASSED_ARGUMENT_IS_NOT_A_REALM = "Passed argument is not a realm"
+ECMA_ERR_PRECISION_DIGITS_MUST_BE_BETWEEN_IN_RANGE = "Precision digits must be between 1 and 100"
+ECMA_ERR_PROMISE_ALL_REMAINING_ELEMENTS_LIMIT_REACHED = "Promise.all remaining elements limit reached"
+ECMA_ERR_PROPERTY_PROTOTYPE_IS_NOT_AN_OBJECT = "Property 'prototype' is not an object or null"
+ECMA_ERR_PROPERTY_NAME_IS_NEITHER_SYMBOL_NOR_STRING = "Property name is neither Symbol nor string"
+ECMA_ERR_PROXY_PROPERTY_NOT_CONFIGURABLE_NOT_HAVE_GETTER = "Property of a Proxy is non-configurable and does not have a getter function"
+ECMA_ERR_PROTOTYPE_FROM_REVOKED_PROXY_IS_INVALID = "Prototype from revoked Proxy is invalid"
+ECMA_ERR_PROTOTYPE_IS_NEITHER_OBJECT_NOR_NULL = "Prototype is neither object nor null"
+ECMA_ERR_PROXY_HANDLER_IS_NULL_FOR_ISARRAY_OPERATION = "Proxy handler is null for 'isArray' operation"
+ECMA_ERR_PROXY_IS_NOT_SUPPORTED = "Proxy is not supported"
+ECMA_ERR_TARGET_NOT_EXTENSIBLE_NOT_RETURNED_ITS_PROTOTYPE = "Proxy target is non-extensible, but the trap did not return its actual prototype"
+ECMA_ERR_PROXY_TRAP_RETURNED_FALSISH = "Proxy trap returned falsish"
+ECMA_ERR_PUSHING_TOO_HIGH_ELEMENT = "Pushing element over 2**53-1 length is disallowed"
+ECMA_ERR_MIN_GREATER_THAN_MAX = "Quantifier error: min > max"
+ECMA_ERR_RADIX_IS_OUT_OF_RANGE = "Radix must be between 2 and 36"
+ECMA_ERR_RANGE_OUT_OF_ORDER_IN_CHARACTER_CLASS = "Range out of order in character class"
+ECMA_ERR_REALM_IS_NOT_AVAILABLE = "Realm is not available"
+ECMA_ERR_REALMS_ARE_DISABLED = "Realms are disabled"
+ECMA_ERR_REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE = "Reduce of empty Array with no initial value"
+ECMA_ERR_REFLECT_EXPECTS_AN_OBJECT_AS_SECOND_ARGUMENT = "Reflect.construct expects an object as second argument"
+ECMA_ERR_REGEXP_ARGUMENT_SHOULD_HAVE_GLOBAL_FLAG = "RegExp argument should have global flag"
+ECMA_ERR_REGEXP_IS_NOT_SUPPORTED = "RegExp is not supported"
+ECMA_ERR_REJECT_MUST_BE_UNDEFINED = "Reject must be undefined"
+ECMA_ERR_REQUEST_IS_NOT_AVAILABLE = "Request is not available"
+ECMA_ERR_RESOLVE_METHOD_MUST_BE_CALLABLE = "Resolve method must be callable"
+ECMA_ERR_RESOLVE_MUST_BE_UNDEFINED = "Resolve must be undefined"
+ECMA_ERR_RESULT_OF_DEFAULTVALUE_IS_INVALID = "Result of [[DefaultValue]] is invalid"
+ECMA_ERR_RETURN_VALUE_IS_NOT_AN_ARRAYBUFFER_OBJECT = "Return value is not an ArrayBuffer object"
+ECMA_ERR_RETURN_VALUE_OF_EXEC_MUST_BE_AN_OBJECT_OR_NULL = "Return value of 'exec' must be an object or null"
+ECMA_ERR_RIGHT_VALUE_OF_IN_MUST_BE_AN_OBJECT = "Right value of 'in' must be an object"
+ECMA_ERR_RIGHT_VALUE_OF_INSTANCEOF_MUST_BE_AN_OBJECT = "Right value of 'instanceof' must be an object"
+ECMA_ERR_SEARCH_STRING_CANNOT_BE_OF_TYPE_REGEXP = "Search string can't be of type: RegExp"
+ECMA_ERR_SECOND_ARGUMENT_MUST_BE_AN_OBJECT = "Second argument must be an object"
+ECMA_ERR_SPECIES_MUST_BE_A_CONSTRUCTOR = "Species must be a constructor"
+ECMA_ERR_STACK_LIMIT_EXCEEDED = "Stack limit exceeded"
+ECMA_ERR_START_OFFSET_IS_OUTSIDE_THE_BOUNDS_OF_THE_BUFFER = "Start offset is outside the bounds of the buffer"
+ECMA_ERR_STATIC_SNAPSHOTS_ARE_NOT_ENABLED = "Static snapshots are not enabled"
+ECMA_ERR_STATIC_SNAPSHOTS_CANNOT_BE_COPIED_INTO_MEMORY = "Static snapshots cannot be copied into memory"
+ECMA_ERR_STRING_CANNOT_BE_CONVERTED_TO_BIGINT_VALUE = "String cannot be converted to BigInt value"
+ECMA_ERR_SUPER_BINDING_MUST_BE_A_CONSTRUCTOR = "Super binding must be a constructor"
+ECMA_ERR_SUPER_CONSTRUCTOR_MAY_ONLY_BE_CALLED_ONCE = "Super constructor may only be called once"
+ECMA_ERR_SYMBOL_IS_NOT_A_CONSTRUCTOR = "Symbol is not a constructor"
+ECMA_ERR_TARGET_IS_NOT_OBJECT = "Target is not Object"
+ECMA_ERR_TARGET_IS_NOT_WEAKREF = "Target is not weakRef"
+ECMA_ERR_TARGET_NOT_EXTENSIBLE = "Target not extensible"
+ECMA_ERR_TARGET_NOT_EXTENSIBLE_DIFFERENT_PROTOTYPE_RETURNED = "Target object is non-extensible and trap returned different prototype"
+ECMA_ERR_THE_MAPFN_ARGUMENT_IS_NOT_CALLABLE = "The 'mapfn' argument is not callable"
+ECMA_ERR_THE_GIVEN_ARGUMENT_IS_NOT_A_SYMBOL = "The given argument is not a Symbol"
+ECMA_ERR_TARGET_PROPERTY_CONFIGURE_ACCESSOR_WITHOUT_SETTER = "The property of a Proxy target is a non configurable accessor without a setter"
+ECMA_ERR_THE_REQUESTED_PROPERTY_UPDATE_CANNOT_BE_PERFORMED = "The requested property update cannot be performed"
+ECMA_ERR_THE_STRUCTURE_IS_CYCLICAL = "The structure is cyclical"
+ECMA_ERR_THE_TWO_DESCRIPTORS_ARE_INCOMPATIBLE = "The two descriptors are incompatible"
+ECMA_ERR_TOO_MANY_ARGUMENTS_DECLARED_FOR_FUNCTION_APPLY = "Too many arguments declared for Function.apply"
+ECMA_ERR_TRAP_IS_NEITHER_AN_OBJECT_NOR_UNDEFINED = "Trap is neither an object nor undefined"
+ECMA_ERR_TRAP_MUST_RETURN_WITH_AN_OBJECT = "Trap must return with an object"
+ECMA_ERR_TRAP_RESULT_NOT_INCLUDE_ALL_CONFIGURABLE_KEYS = "Trap result did not include all configurable keys"
+ECMA_ERR_TRAP_RESULT_NOT_INCLUDE_ALL_NON_CONFIGURABLE_KEYS = "Trap result did not include all non-configurable keys"
+ECMA_ERR_TRAP_RESULT_NOT_REFLECT_TARGET_EXTENSIBILITY = "Trap result does not reflect extensibility of Proxy target"
+ECMA_ERR_TRAP_RESULT_NOT_REFLECT_TARGET_INEXTENSIBILITY = "Trap result does not reflect inextensibility of Proxy target"
+ECMA_ERR_TRAP_EXTRA_KEYS_FOR_A_NON_EXTENSIBLE_TARGET = "Trap returned extra keys for a non-extensible Proxy target"
+ECMA_ERR_TRAP_FALSISH_PROPERTY_TARGET_NOT_EXTENSIBLE = "Trap returned falsish for property but the proxy target is not extensible"
+ECMA_ERR_TRAP_FALSISH_PROPERTY_NON_CONFIGURABLE = "Trap returned falsish for property which exists in the proxy target as non-configurable"
+ECMA_ERR_TRAP_RETURNED_NEITHER_OBJECT_NOR_NULL = "Trap returned neither object nor null"
+ECMA_ERR_TRAP_TRUISH_ADDING_PROPERTY_NON_EXTENSIBLE_TARGET = "Trap returned truish for adding property to the non-extensible target"
+ECMA_ERR_TRAP_TRUISH_ADD_PROPERTY_INCOMPATIBLE_OTHER_PROP = "Trap returned truish for adding property that is incompatible with the existing property in the target"
+ECMA_ERR_TRAP_TRUISH_DEFINING_NON_EXISTENT_PROPERTY = "Trap returned truish for defining non-configurable property which is non-existent in the target"
+ECMA_ERR_TRAP_TRUISH_PROPERTY_NON_CONFIGURABLE = "Trap returned truish for property which is non-configurable in the proxy target"
+ECMA_ERR_TRAP_TRUISH_TARGET_NOT_EXTENSIBLE = "Trap returned truish for target is not extensible"
+ECMA_ERR_TRAP_WITH_DUPLICATED_ENTRIES = "Trap returned with duplicated entries"
+ECMA_ERR_TYPEDARRAY_INTRINSTIC_CALLED_BY_NEW_EXPRESSION = "TypedArray intrinstic cannot be called by a 'new' expression"
+ECMA_ERR_TYPEDARRAY_INTRINSTIC_DIRECTLY_CALLED = "TypedArray intrinstic cannot be directly called"
+ECMA_ERR_CONTENTTYPE_RETURNED_TYPEDARRAY_NOT_MATCH_SOURCE = "TypedArray returned by [[ContentType]] does not match source"
+ECMA_ERR_UNARY_PLUS_IS_NOT_ALLOWED_FOR_BIGINTS = "Unary plus is not allowed for BigInts"
+ECMA_ERR_UNDEFINED_REFERENCE = "Undefined reference"
+ECMA_ERR_UNEXPECTED_END_OF_PATTERN = "Unexpected end of pattern"
+ECMA_ERR_UNICODE_SURROGATE_PAIR_MISSING = "Unicode surrogate pair missing"
+ECMA_ERR_UNMATCHED_CLOSE_BRACKET = "Unmatched close bracket"
+ECMA_ERR_UNSHIFT_TOO_HIGH = "Unshift elements over 2**53-1 length is disallowed"
+ECMA_ERR_UNSIGNED_RIGHT_SHIFT_IS_NOT_ALLOWED_FOR_BIGINTS = "Unsigned right shift is not allowed for BigInts"
+ECMA_ERR_UNSUPPORTED_BINARY_OPERATION = "Unsupported binary operation"
+ECMA_ERR_UNSUPPORTED_CONTAINER_OPERATION = "Unsupported container operation"
+ECMA_ERR_UNSUPPORTED_SNAPSHOT_EXEC_FLAGS_ARE_SPECIFIED = "Unsupported snapshot exec flags are specified"
+ECMA_ERR_UNTERMINATED_CHARACTER_CLASS = "Unterminated character class"
+ECMA_ERR_UNTERMINATED_GROUP = "Unterminated group"
+ECMA_ERR_VALUE_CANNOT_BE_CONVERTED_TO_BIGINT = "Value cannot be converted to BigInt"
+ECMA_ERR_VALUE_FOR_CLASS_HERITAGE_IS_NOT_A_CONSTRUCTOR = "Value for class heritage is not a constructor"
+ECMA_ERR_VALUE_RECEIVED_BY_FOR_ASYNC_OF_IS_NOT_OBJECT = "Value received by for-async-of is not object"
+ECMA_ERR_VALUE_RECEIVED_BY_YIELD_IS_NOT_OBJECT = "Value received by yield* is not object"
+ECMA_ERR_WEAKREF_TARGET_MUST_BE_AN_OBJECT = "WeakRef target must be an object"
+ECMA_ERR_METHOD_RETURN_IS_NOT_CALLABLE = "method 'return' is not callable"
+ECMA_ERR_VALUE_MSG = "Argument cannot be marked as error"
+ECMA_ERR_WRONG_ARGS_MSG = "This type of argument is not allowed"
+ECMA_ERR_PARSER_NOT_SUPPORTED = "Source code parsing is disabled"
+ECMA_ERR_JSON_NOT_SUPPORTED = "JSON support is disabled"
+ECMA_ERR_TYPED_ARRAY_NOT_SUPPORTED = "TypedArray support is disabled"
+ECMA_ERR_SHARED_ARRAYBUFFER_NOT_SUPPORTED = "SharedArrayBuffer support is disabled"
+ECMA_ERR_DATA_VIEW_NOT_SUPPORTED = "DataView support is disabled"
+ECMA_ERR_BIGINT_NOT_SUPPORTED = "BigInt support is disabled"
+ECMA_ERR_CONTAINER_NOT_SUPPORTED = "Container support is disabled"
+ECMA_ERR_NOT_MODULE = "Argument is not a module"
+ECMA_ERR_UNKNOWN_EXPORT = "Native module export not found"
+ECMA_ERR_MODULE_NOT_SUPPORTED = "Module support is disabled"
+ECMA_ERR_CALLBACK_IS_NOT_CALLABLE = "Callback function is not callable"
+ECMA_ERR_ARRAYBUFFER_IS_DETACHED = "ArrayBuffer has been detached"
+ECMA_ERR_CANNOT_CONVERT_TO_OBJECT = "Cannot convert undefined or null to object"
+ECMA_ERR_CLASS_IS_NON_CONFIGURABLE = "Prototype property of a class is non-configurable"
+ECMA_ERR_ARGUMENT_IS_NOT_AN_OBJECT = "Argument is not an object"
+ECMA_ERR_ARGUMENT_IS_NOT_A_PROXY = "Argument is not a Proxy object"
+ECMA_ERR_TARGET_IS_NOT_A_CONSTRUCTOR = "Target is not a constructor"
+ECMA_ERR_ARGUMENT_IS_NOT_AN_REGEXP = "Argument 'this' is not a RegExp object"
+ECMA_ERR_INVALID_ARRAY_LENGTH = "Invalid Array length"
+ECMA_ERR_LOCAL_VARIABLE_IS_REDECLARED = "Local variable is redeclared"
+ECMA_ERR_EXPECTED_A_FUNCTION = "Expected a function"
+ECMA_ERR_CLASS_CONSTRUCTOR_NEW = "Class constructor cannot be invoked without 'new'"
+ECMA_ERR_LET_CONST_NOT_INITIALIZED = "Variables declared by let/const must be initialized before reading their value"
+ECMA_ERR_MAXIMUM_SNAPSHOT_SIZE = "Maximum snapshot size reached"
+ECMA_ERR_REGULAR_EXPRESSION_NOT_SUPPORTED = "Regular expression literals are not supported"
+ECMA_ERR_SNAPSHOT_BUFFER_SMALL = "Snapshot buffer too small"
+ECMA_ERR_SNAPSHOT_UNSUPPORTED_COMPILED_CODE = "Unsupported compiled code"
+ECMA_ERR_SNAPSHOT_FLAG_NOT_SUPPORTED = "Unsupported generate snapshot flags specified"
+ECMA_ERR_SNAPSHOT_SAVE_DISABLED = "Snapshot generation is disabled"
+ECMA_ERR_SNAPSHOT_EXEC_DISABLED = "Snapshot execution is disabled"
+ECMA_ERR_CANNOT_ALLOCATE_MEMORY_LITERALS = "Cannot allocate memory for literals"
+ECMA_ERR_TAGGED_TEMPLATE_LITERALS = "Unsupported feature: tagged template literals"
+ECMA_ERR_CONTAINER_NEEDED = "Value is not a Container or Iterator"
+ECMA_ERR_INCORRECT_TYPE_CALL =  "Operator called on incorrect container type"
+ECMA_ERR_INVALID_TYPE_FOR_CONSTRUCTOR_CALL = "Invalid type for constructor call"
+ECMA_ERR_SCRIPT_GLOBAL_FUNCTIONS_INVOKE_WITH_NEW = "Script (global) functions cannot be invoked with 'new'"
+ECMA_ERR_GENERATOR_FUNCTIONS_INVOKE_WITH_NEW = "Generator functions cannot be invoked with 'new'"
+ECMA_ERR_ASYNC_FUNCTIONS_INVOKE_WITH_NEW = "Async functions cannot be invoked with 'new'"
+ECMA_ERR_ASYNC_GENERATOR_FUNCTIONS_INVOKE_WITH_NEW = "Async generator functions cannot be invoked with 'new'"
+ECMA_ERR_ACCESSOR_FUNCTIONS_INVOKE_WITH_NEW = "Accessor functions cannot be invoked with 'new'"
+ECMA_ERR_METHODS_INVOKE_WITH_NEW = "Methods cannot be invoked with 'new'"
+ECMA_ERR_ARROW_FUNCTIONS_INVOKE_WITH_NEW = "Arrow functions cannot be invoked with 'new'"
+ECMA_ERR_ASYNC_ARROW_FUNCTIONS_INVOKE_WITH_NEW = "Async arrow functions cannot be invoked with 'new'"
+ECMA_ERR_PROXY_TARGET_IS_NOT_A_CONSTRUCTOR = "Proxy target is not a constructor"
+ECMA_ERR_MAXIMUM_CALL_STACK_SIZE_EXCEEDED = "Maximum call stack size exceeded"
+ECMA_ERR_INVALID_SNAPSHOT_FORMAT = "Invalid snapshot format"
+ECMA_ERR_INVALID_SNAPSHOT_VERSION_OR_FEATURES = "Invalid snapshot version or unsupported features present"
+ECMA_ERR_RECEIVER_MUST_BE_AN_OBJECT = "Receiver must be an object"
+ECMA_ERR_CANNOT_DECLARE_SAME_PRIVATE_FIELD_TWICE = "Cannot declare same private field twice"
+ECMA_ERR_CANNOT_WRITE_PRIVATE_MEMBER_TO_AN_OBJECT_WHOSE_CLASS_DID_NOT_DECLARE_IT = "Cannot write private member to an object whose class did not declare it"
+ECMA_ERR_PRIVATE_METHOD_IS_NOT_WRITABLE = "Private method is not writable"
+ECMA_ERR_PRIVATE_FIELD_WAS_DEFINED_WITHOUT_A_SETTER = "Private field was defined without a setter"
+ECMA_ERR_CANNOT_READ_PRIVATE_MEMBER_TO_AN_OBJECT_WHOSE_CLASS_DID_NOT_DECLARE_IT = "Cannot read private member to an object whose class did not declare it"
+ECMA_ERR_PRIVATE_FIELD_WAS_DEFINED_WITHOUT_A_GETTER = "Private field was defined without a getter"

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-errors.cpp

@@ -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.
+ */
+
+#include "ecma-errors.h"
+
+#if JERRY_ERROR_MESSAGES
+/**
+ * Struct to store ecma error message with its size.
+ */
+typedef struct
+{
+  char *text; /* Text of ecma error message. */
+  uint8_t size; /* Size of ecma error message. */
+} ecma_error_message_t;
+
+/* Error message texts with size. */
+static ecma_error_message_t ecma_error_messages[] JERRY_ATTR_CONST_DATA = {
+  { "", 0 }, /* ECMA_ERR_EMPTY */
+/** @cond doxygen_suppress */
+#define ECMA_ERROR_DEF(id, string) { string, sizeof (string) - 1 },
+#include "ecma-error-messages.inc.h"
+#undef ECMA_ERROR_DEF
+  /** @endcond */
+};
+#endif /* JERRY_ERROR_MESSAGES */
+
+/**
+ * Get specified ecma error as zero-terminated string
+ *
+ * @return pointer to zero-terminated ecma error
+ */
+const char *
+ecma_get_error_msg (ecma_error_msg_t id) /**< ecma error id */
+{
+  JERRY_ASSERT (id != ECMA_IS_VALID_CONSTRUCTOR);
+
+#if JERRY_ERROR_MESSAGES
+  return ecma_error_messages[id].text;
+#else /* !JERRY_ERROR_MESSAGES */
+  return NULL;
+#endif /* JERRY_ERROR_MESSAGES */
+} /* ecma_get_error_msg */
+
+/**
+ * Get size of specified ecma error
+ *
+ * @return size in bytes
+ */
+lit_utf8_size_t
+ecma_get_error_size (ecma_error_msg_t id) /**< ecma error id */
+{
+  JERRY_ASSERT (id != ECMA_IS_VALID_CONSTRUCTOR);
+
+#if JERRY_ERROR_MESSAGES
+  return ecma_error_messages[id].size;
+#else /* !JERRY_ERROR_MESSAGES */
+  return 0;
+#endif /* JERRY_ERROR_MESSAGES */
+} /* ecma_get_error_size */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-errors.h

@@ -0,0 +1,39 @@
+/* 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.
+ */
+
+#ifndef ECMA_ERRORS_H
+#define ECMA_ERRORS_H
+
+#include "lit-globals.h"
+
+typedef enum
+{
+  ECMA_ERR_EMPTY,
+/** @cond doxygen_suppress */
+#if JERRY_ERROR_MESSAGES
+#define ECMA_ERROR_DEF(id, ascii_zt_string) id,
+#else /* !JERRY_ERROR_MESSAGES */
+#define ECMA_ERROR_DEF(id, ascii_zt_string) id = ECMA_ERR_EMPTY,
+#endif /* JERRY_ERROR_MESSAGES */
+#include "ecma-error-messages.inc.h"
+#undef ECMA_ERROR_DEF
+  /** @endcond */
+  ECMA_IS_VALID_CONSTRUCTOR /* used as return value when checking constructor */
+} ecma_error_msg_t;
+
+const char* ecma_get_error_msg (ecma_error_msg_t id);
+lit_utf8_size_t ecma_get_error_size (ecma_error_msg_t id);
+
+#endif /* !ECMA_ERRORS_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-extended-info.cpp

@@ -0,0 +1,144 @@
+/* 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.
+ */
+
+#include "ecma-extended-info.h"
+
+#include "ecma-helpers.h"
+
+#include "byte-code.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmaextendedinfo Extended info
+ * @{
+ */
+
+/**
+ * Decodes an uint32_t number, and updates the buffer position.
+ *
+ * @return the decoded value
+ */
+uint32_t
+ecma_extended_info_decode_vlq (uint8_t **buffer_p) /**< [in/out] target buffer */
+{
+  uint8_t *source_p = *buffer_p;
+  uint32_t value = 0;
+
+  do
+  {
+    source_p--;
+    value = (value << ECMA_EXTENDED_INFO_VLQ_SHIFT) | (*source_p & ECMA_EXTENDED_INFO_VLQ_MASK);
+  } while (*source_p & ECMA_EXTENDED_INFO_VLQ_CONTINUE);
+
+  *buffer_p = source_p;
+  return value;
+} /* ecma_extended_info_decode_vlq */
+
+/**
+ * Encodes an uint32_t number into a buffer.
+ */
+void
+ecma_extended_info_encode_vlq (uint8_t **buffer_p, /**< target buffer */
+                               uint32_t value) /**< encoded value */
+{
+  uint8_t *destination_p = *buffer_p - 1;
+
+  if (value <= ECMA_EXTENDED_INFO_VLQ_MASK)
+  {
+    *destination_p = (uint8_t) value;
+    *buffer_p = destination_p;
+    return;
+  }
+
+  uint32_t length = 0;
+  uint32_t current_value = value >> ECMA_EXTENDED_INFO_VLQ_SHIFT;
+
+  do
+  {
+    current_value >>= ECMA_EXTENDED_INFO_VLQ_SHIFT;
+    length++;
+  } while (current_value > 0);
+
+  destination_p -= length;
+  *buffer_p = destination_p;
+
+  do
+  {
+    *destination_p++ = (uint8_t) (value | ECMA_EXTENDED_INFO_VLQ_CONTINUE);
+    value >>= ECMA_EXTENDED_INFO_VLQ_SHIFT;
+  } while (value > 0);
+
+  **buffer_p &= ECMA_EXTENDED_INFO_VLQ_MASK;
+} /* ecma_extended_info_encode_vlq */
+
+/**
+ * Gets the encoded length of a number.
+ *
+ * @return encoded length
+ */
+uint32_t
+ecma_extended_info_get_encoded_length (uint32_t value) /**< encoded value */
+{
+  uint32_t length = 0;
+
+  do
+  {
+    value >>= ECMA_EXTENDED_INFO_VLQ_SHIFT;
+    length++;
+  } while (value > 0);
+
+  return length;
+} /* ecma_extended_info_get_encoded_length */
+
+/**
+ * Get the extended info from a byte code
+ *
+ * @return pointer to the extended info
+ */
+uint8_t *
+ecma_compiled_code_resolve_extended_info (const ecma_compiled_code_t *bytecode_header_p) /**< compiled code */
+{
+  JERRY_ASSERT (bytecode_header_p != NULL);
+  JERRY_ASSERT (bytecode_header_p->status_flags & CBC_CODE_FLAGS_HAS_EXTENDED_INFO);
+
+  ecma_value_t *base_p = ecma_compiled_code_resolve_arguments_start (bytecode_header_p);
+
+  if (CBC_FUNCTION_GET_TYPE (bytecode_header_p->status_flags) != CBC_FUNCTION_CONSTRUCTOR)
+  {
+    base_p--;
+  }
+
+  if (bytecode_header_p->status_flags & CBC_CODE_FLAGS_HAS_TAGGED_LITERALS)
+  {
+    base_p--;
+  }
+
+#if JERRY_LINE_INFO
+  if (bytecode_header_p->status_flags & CBC_CODE_FLAGS_HAS_LINE_INFO)
+  {
+    base_p--;
+  }
+#endif /* JERRY_LINE_INFO */
+
+  JERRY_ASSERT (((uint8_t *) base_p)[-1] != 0);
+
+  return ((uint8_t *) base_p) - 1;
+} /* ecma_compiled_code_resolve_extended_info */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-extended-info.h

@@ -0,0 +1,54 @@
+/* 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.
+ */
+
+#ifndef ECMA_EXTENDED_INFO_H
+#define ECMA_EXTENDED_INFO_H
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmaextendedinfo Extended info
+ * @{
+ */
+
+#include "ecma-globals.h"
+
+/**
+ * Vlq encoding: flag which is set for all bytes except the last one.
+ */
+#define ECMA_EXTENDED_INFO_VLQ_CONTINUE 0x80
+
+/**
+ * Vlq encoding: mask to decode the number fragment.
+ */
+#define ECMA_EXTENDED_INFO_VLQ_MASK 0x7f
+
+/**
+ * Vlq encoding: number of bits stored in a byte.
+ */
+#define ECMA_EXTENDED_INFO_VLQ_SHIFT 7
+
+uint32_t ecma_extended_info_decode_vlq (uint8_t **buffer_p);
+void ecma_extended_info_encode_vlq (uint8_t **buffer_p, uint32_t value);
+uint32_t ecma_extended_info_get_encoded_length (uint32_t value);
+
+uint8_t *ecma_compiled_code_resolve_extended_info (const ecma_compiled_code_t *bytecode_header_p);
+
+/**
+ * @}
+ * @}
+ */
+
+#endif /* !ECMA_EXTENDED_INFO_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-gc.h

@@ -0,0 +1,54 @@
+/* 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.
+ */
+
+#ifndef ECMA_GC_H
+#define ECMA_GC_H
+
+#include "ecma-globals.h"
+
+#include "jmem.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmagc Garbage collector
+ * @{
+ */
+
+/**
+ * Free option flags
+ */
+typedef enum
+{
+  ECMA_GC_FREE_NO_OPTIONS = 0, /**< no options */
+  ECMA_GC_FREE_SECOND_PROPERTY = (1 << 0), /**< free second property of a property pair */
+  ECMA_GC_FREE_REFERENCES = (1 << 1), /**< free references */
+} ecma_gc_free_options_t;
+
+void ecma_init_gc_info (ecma_object_t *object_p);
+void ecma_ref_object (ecma_object_t *object_p);
+void ecma_ref_object_inline (ecma_object_t *object_p);
+void ecma_deref_object (ecma_object_t *object_p);
+void ecma_gc_free_property (ecma_object_t *object_p, ecma_property_pair_t *prop_pair_p, uint32_t options);
+void ecma_gc_free_properties (ecma_object_t *object_p, uint32_t options);
+void ecma_gc_run (void);
+void ecma_free_unused_memory (jmem_pressure_t pressure);
+
+/**
+ * @}
+ * @}
+ */
+
+#endif /* !ECMA_GC_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-helpers-collection.cpp

@@ -0,0 +1,446 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-conversion.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+
+#include "jrt.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmahelpers Helpers for operations with ECMA data types
+ * @{
+ */
+
+/**
+ * Allocate a collection of ecma values.
+ *
+ * @return pointer to the collection
+ */
+ecma_collection_t *
+ecma_new_collection (void)
+{
+  ecma_collection_t *collection_p;
+  collection_p = (ecma_collection_t *) jmem_heap_alloc_block (sizeof (ecma_collection_t));
+
+  collection_p->item_count = 0;
+  collection_p->capacity = ECMA_COLLECTION_INITIAL_CAPACITY;
+  const uint32_t size = ECMA_COLLECTION_ALLOCATED_SIZE (ECMA_COLLECTION_INITIAL_CAPACITY);
+  collection_p->buffer_p = (ecma_value_t *) jmem_heap_alloc_block (size);
+
+  return collection_p;
+} /* ecma_new_collection */
+
+/**
+ * Deallocate a collection of ecma values without freeing it's values
+ *
+ * @return void
+ */
+void
+ecma_collection_destroy (ecma_collection_t *collection_p) /**< value collection */
+{
+  JERRY_ASSERT (collection_p != NULL);
+
+  jmem_heap_free_block (collection_p->buffer_p, ECMA_COLLECTION_ALLOCATED_SIZE (collection_p->capacity));
+  jmem_heap_free_block (collection_p, sizeof (ecma_collection_t));
+} /* ecma_collection_destroy */
+
+/**
+ * Free the object collection elements and deallocate the collection
+ */
+void
+ecma_collection_free_objects (ecma_collection_t *collection_p) /**< value collection */
+{
+  JERRY_ASSERT (collection_p != NULL);
+
+  ecma_value_t *buffer_p = collection_p->buffer_p;
+
+  for (uint32_t i = 0; i < collection_p->item_count; i++)
+  {
+    if (ecma_is_value_object (buffer_p[i]))
+    {
+      ecma_deref_object (ecma_get_object_from_value (buffer_p[i]));
+    }
+  }
+
+  ecma_collection_destroy (collection_p);
+} /* ecma_collection_free_objects */
+
+/**
+ * Free the template literal objects and deallocate the collection
+ */
+void
+ecma_collection_free_template_literal (ecma_collection_t *collection_p) /**< value collection */
+{
+  for (uint32_t i = 0; i < collection_p->item_count; i++)
+  {
+    ecma_object_t *object_p = ecma_get_object_from_value (collection_p->buffer_p[i]);
+
+    JERRY_ASSERT (ecma_get_object_type (object_p) == ECMA_OBJECT_TYPE_ARRAY);
+
+    ecma_extended_object_t *array_object_p = (ecma_extended_object_t *) object_p;
+
+    JERRY_ASSERT (array_object_p->u.array.length_prop_and_hole_count & ECMA_ARRAY_TEMPLATE_LITERAL);
+    array_object_p->u.array.length_prop_and_hole_count &= (uint32_t) ~ECMA_ARRAY_TEMPLATE_LITERAL;
+
+    ecma_property_value_t *property_value_p;
+
+    property_value_p = ecma_get_named_data_property (object_p, ecma_get_magic_string (LIT_MAGIC_STRING_RAW));
+    ecma_object_t *raw_object_p = ecma_get_object_from_value (property_value_p->value);
+
+    JERRY_ASSERT (ecma_get_object_type (raw_object_p) == ECMA_OBJECT_TYPE_ARRAY);
+
+    array_object_p = (ecma_extended_object_t *) raw_object_p;
+
+    JERRY_ASSERT (array_object_p->u.array.length_prop_and_hole_count & ECMA_ARRAY_TEMPLATE_LITERAL);
+    array_object_p->u.array.length_prop_and_hole_count &= (uint32_t) ~ECMA_ARRAY_TEMPLATE_LITERAL;
+
+    ecma_deref_object (raw_object_p);
+    ecma_deref_object (object_p);
+  }
+
+  ecma_collection_destroy (collection_p);
+} /* ecma_collection_free_template_literal */
+
+/**
+ * Free the non-object collection elements and deallocate the collection
+ */
+void
+ecma_collection_free_if_not_object (ecma_collection_t *collection_p) /**< value collection */
+{
+  JERRY_ASSERT (collection_p != NULL);
+
+  ecma_value_t *buffer_p = collection_p->buffer_p;
+
+  for (uint32_t i = 0; i < collection_p->item_count; i++)
+  {
+    ecma_free_value_if_not_object (buffer_p[i]);
+  }
+
+  ecma_collection_destroy (collection_p);
+} /* ecma_collection_free_if_not_object */
+
+/**
+ * Free the collection elements and deallocate the collection
+ */
+void
+ecma_collection_free (ecma_collection_t *collection_p) /**< value collection */
+{
+  JERRY_ASSERT (collection_p != NULL);
+
+  ecma_value_t *buffer_p = collection_p->buffer_p;
+
+  for (uint32_t i = 0; i < collection_p->item_count; i++)
+  {
+    ecma_free_value (buffer_p[i]);
+  }
+
+  ecma_collection_destroy (collection_p);
+} /* ecma_collection_free */
+
+/**
+ * Append new value to ecma values collection
+ *
+ * Note: The reference count of the values are not increased
+ */
+void
+ecma_collection_push_back (ecma_collection_t *collection_p, /**< value collection */
+                           ecma_value_t value) /**< ecma value to append */
+{
+  JERRY_ASSERT (collection_p != NULL);
+
+  ecma_value_t *buffer_p = collection_p->buffer_p;
+
+  if (JERRY_LIKELY (collection_p->item_count < collection_p->capacity))
+  {
+    buffer_p[collection_p->item_count++] = value;
+    return;
+  }
+
+  const uint32_t new_capacity = collection_p->capacity + ECMA_COLLECTION_GROW_FACTOR;
+  const uint32_t old_size = ECMA_COLLECTION_ALLOCATED_SIZE (collection_p->capacity);
+  const uint32_t new_size = ECMA_COLLECTION_ALLOCATED_SIZE (new_capacity);
+
+  buffer_p = (ecma_value_t *) jmem_heap_realloc_block (buffer_p, old_size, new_size);
+  buffer_p[collection_p->item_count++] = value;
+  collection_p->capacity = new_capacity;
+
+  collection_p->buffer_p = buffer_p;
+} /* ecma_collection_push_back */
+
+/**
+ * Reserve space for the given amount of ecma_values in the collection
+ */
+void
+ecma_collection_reserve (ecma_collection_t *collection_p, /**< value collection */
+                         uint32_t count) /**< number of ecma values to reserve */
+{
+  JERRY_ASSERT (collection_p != NULL);
+  JERRY_ASSERT (UINT32_MAX - count > collection_p->capacity);
+
+  const uint32_t new_capacity = collection_p->capacity + count;
+  const uint32_t old_size = ECMA_COLLECTION_ALLOCATED_SIZE (collection_p->capacity);
+  const uint32_t new_size = ECMA_COLLECTION_ALLOCATED_SIZE (new_capacity);
+
+  ecma_value_t *buffer_p = collection_p->buffer_p;
+  buffer_p = (ecma_value_t *) jmem_heap_realloc_block (buffer_p, old_size, new_size);
+
+  collection_p->capacity = new_capacity;
+  collection_p->buffer_p = buffer_p;
+} /* ecma_collection_reserve */
+
+/**
+ * Append a list of values to the end of the collection
+ */
+void
+ecma_collection_append (ecma_collection_t *collection_p, /**< value collection */
+                        const ecma_value_t *buffer_p, /**< values to append */
+                        uint32_t count) /**< number of ecma values to append */
+{
+  JERRY_ASSERT (collection_p != NULL);
+  JERRY_ASSERT (collection_p->capacity >= collection_p->item_count);
+
+  uint32_t free_count = collection_p->capacity - collection_p->item_count;
+
+  if (free_count < count)
+  {
+    ecma_collection_reserve (collection_p, count - free_count);
+  }
+
+  memcpy (collection_p->buffer_p + collection_p->item_count, buffer_p, count * sizeof (ecma_value_t));
+  collection_p->item_count += count;
+} /* ecma_collection_append */
+
+/**
+ * Helper function to check if a given collection have duplicated properties or not
+ *
+ * @return true - if there are duplicated properties in the collection
+ *         false - otherwise
+ */
+bool
+ecma_collection_check_duplicated_entries (ecma_collection_t *collection_p) /**< prop name collection */
+{
+  if (collection_p->item_count == 0)
+  {
+    return false;
+  }
+
+  ecma_value_t *buffer_p = collection_p->buffer_p;
+
+  for (uint32_t i = 0; i < collection_p->item_count - 1; i++)
+  {
+    ecma_string_t *current_name_p = ecma_get_prop_name_from_value (buffer_p[i]);
+
+    for (uint32_t j = i + 1; j < collection_p->item_count; j++)
+    {
+      if (ecma_compare_ecma_strings (current_name_p, ecma_get_prop_name_from_value (buffer_p[j])))
+      {
+        return true;
+      }
+    }
+  }
+
+  return false;
+} /* ecma_collection_check_duplicated_entries */
+
+/**
+ * Check the string value existance in the collection.
+ *
+ * Used by:
+ *         - ecma_builtin_json_stringify step 4.b.ii.5
+ *         - ecma_op_object_enumerate
+ *
+ * @return true, if the string is already in the collection.
+ */
+bool
+ecma_collection_has_string_value (ecma_collection_t *collection_p, /**< collection */
+                                  ecma_string_t *string_p) /**< string */
+{
+  ecma_value_t *buffer_p = collection_p->buffer_p;
+
+  for (uint32_t i = 0; i < collection_p->item_count; i++)
+  {
+    ecma_string_t *current_p = ecma_get_string_from_value (buffer_p[i]);
+
+    if (ecma_compare_ecma_strings (current_p, string_p))
+    {
+      return true;
+    }
+  }
+
+  return false;
+} /* ecma_collection_has_string_value */
+
+/**
+ * Initial capacity of an ecma-collection
+ */
+#define ECMA_COMPACT_COLLECTION_GROWTH 8
+
+/**
+ * Set the size of the compact collection
+ */
+#define ECMA_COMPACT_COLLECTION_SET_SIZE(compact_collection_p, item_count, unused_items) \
+  ((compact_collection_p)[0] = (((item_count) << ECMA_COMPACT_COLLECTION_SIZE_SHIFT) | (unused_items)))
+
+/**
+ * Set the size of the compact collection
+ */
+#define ECMA_COMPACT_COLLECTION_GET_UNUSED_ITEM_COUNT(compact_collection_p) \
+  ((compact_collection_p)[0] & ((1 << ECMA_COMPACT_COLLECTION_SIZE_SHIFT) - 1))
+
+/**
+ * Allocate a compact collection of ecma values
+ *
+ * @return pointer to the compact collection
+ */
+ecma_value_t *
+ecma_new_compact_collection (void)
+{
+  size_t size = (ECMA_COMPACT_COLLECTION_GROWTH / 2) * sizeof (ecma_value_t);
+  ecma_value_t *compact_collection_p = (ecma_value_t *) jmem_heap_alloc_block (size);
+
+  ECMA_COMPACT_COLLECTION_SET_SIZE (compact_collection_p,
+                                    ECMA_COMPACT_COLLECTION_GROWTH / 2,
+                                    (ECMA_COMPACT_COLLECTION_GROWTH / 2) - 1);
+  return compact_collection_p;
+} /* ecma_new_compact_collection */
+
+/**
+ * Append a value to the compact collection
+ *
+ * @return updated pointer to the compact collection
+ */
+ecma_value_t *
+ecma_compact_collection_push_back (ecma_value_t *compact_collection_p, /**< compact collection */
+                                   ecma_value_t value) /**< ecma value to append */
+{
+  ecma_value_t size = ECMA_COMPACT_COLLECTION_GET_SIZE (compact_collection_p);
+  ecma_value_t unused_items = ECMA_COMPACT_COLLECTION_GET_UNUSED_ITEM_COUNT (compact_collection_p);
+
+  if (unused_items > 0)
+  {
+    compact_collection_p[size - unused_items] = value;
+    (*compact_collection_p)--;
+    return compact_collection_p;
+  }
+
+  if (size == ECMA_COMPACT_COLLECTION_GROWTH / 2)
+  {
+    size_t old_size = (ECMA_COMPACT_COLLECTION_GROWTH / 2) * sizeof (ecma_value_t);
+    size_t new_size = ECMA_COMPACT_COLLECTION_GROWTH * sizeof (ecma_value_t);
+    compact_collection_p = (ecma_value_t *) jmem_heap_realloc_block (compact_collection_p, old_size, new_size);
+
+    compact_collection_p[ECMA_COMPACT_COLLECTION_GROWTH / 2] = value;
+
+    ECMA_COMPACT_COLLECTION_SET_SIZE (compact_collection_p,
+                                      ECMA_COMPACT_COLLECTION_GROWTH,
+                                      (ECMA_COMPACT_COLLECTION_GROWTH / 2) - 1);
+    return compact_collection_p;
+  }
+
+  size_t old_size = size * sizeof (ecma_value_t);
+  size_t new_size = old_size + (ECMA_COMPACT_COLLECTION_GROWTH * sizeof (ecma_value_t));
+
+  compact_collection_p = (ecma_value_t *) jmem_heap_realloc_block (compact_collection_p, old_size, new_size);
+  compact_collection_p[size] = value;
+
+  ECMA_COMPACT_COLLECTION_SET_SIZE (compact_collection_p,
+                                    size + ECMA_COMPACT_COLLECTION_GROWTH,
+                                    ECMA_COMPACT_COLLECTION_GROWTH - 1);
+  return compact_collection_p;
+} /* ecma_compact_collection_push_back */
+
+/**
+ * Discard the unused elements of a compact collection
+ *
+ * Note:
+ *     further items should not be added after this call
+ *
+ * @return updated pointer to the compact collection
+ */
+ecma_value_t *
+ecma_compact_collection_shrink (ecma_value_t *compact_collection_p) /**< compact collection */
+{
+  ecma_value_t unused_items = ECMA_COMPACT_COLLECTION_GET_UNUSED_ITEM_COUNT (compact_collection_p);
+
+  if (unused_items == 0)
+  {
+    return compact_collection_p;
+  }
+
+  ecma_value_t size = ECMA_COMPACT_COLLECTION_GET_SIZE (compact_collection_p);
+
+  size_t old_size = size * sizeof (ecma_value_t);
+  size_t new_size = (size - unused_items) * sizeof (ecma_value_t);
+
+  compact_collection_p = (ecma_value_t *) jmem_heap_realloc_block (compact_collection_p, old_size, new_size);
+
+  ECMA_COMPACT_COLLECTION_SET_SIZE (compact_collection_p, size - unused_items, 0);
+  return compact_collection_p;
+} /* ecma_compact_collection_shrink */
+
+/**
+ * Free a compact collection
+ */
+void
+ecma_compact_collection_free (ecma_value_t *compact_collection_p) /**< compact collection */
+{
+  ecma_value_t size = ECMA_COMPACT_COLLECTION_GET_SIZE (compact_collection_p);
+  ecma_value_t unused_items = ECMA_COMPACT_COLLECTION_GET_UNUSED_ITEM_COUNT (compact_collection_p);
+
+  ecma_value_t *end_p = compact_collection_p + size - unused_items;
+  ecma_value_t *current_p = compact_collection_p + 1;
+
+  while (current_p < end_p)
+  {
+    ecma_free_value (*current_p++);
+  }
+
+  jmem_heap_free_block (compact_collection_p, size * sizeof (ecma_value_t));
+} /* ecma_compact_collection_free */
+
+/**
+ * Get the end of a compact collection
+ *
+ * @return pointer to the compact collection end
+ */
+ecma_value_t *
+ecma_compact_collection_end (ecma_value_t *compact_collection_p) /**< compact collection */
+{
+  ecma_value_t size = ECMA_COMPACT_COLLECTION_GET_SIZE (compact_collection_p);
+  ecma_value_t unused_items = ECMA_COMPACT_COLLECTION_GET_UNUSED_ITEM_COUNT (compact_collection_p);
+
+  return compact_collection_p + size - unused_items;
+} /* ecma_compact_collection_end */
+
+/**
+ * Destroy a compact collection
+ */
+void
+ecma_compact_collection_destroy (ecma_value_t *compact_collection_p) /**< compact collection */
+{
+  ecma_value_t size = ECMA_COMPACT_COLLECTION_GET_SIZE (compact_collection_p);
+
+  jmem_heap_free_block (compact_collection_p, size * sizeof (ecma_value_t));
+} /* ecma_compact_collection_destroy */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-helpers-conversion.cpp

@@ -0,0 +1,943 @@
+/* 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.
+ */
+
+#include <math.h>
+
+#include "ecma-globals.h"
+#include "ecma-helpers-number.h"
+#include "ecma-helpers.h"
+
+#include "jrt-libc-includes.h"
+#include "lit-char-helpers.h"
+#include "lit-magic-strings.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmahelpers Helpers for operations with ECMA data types
+ * @{
+ */
+
+#if JERRY_NUMBER_TYPE_FLOAT64
+
+/**
+ * \addtogroup ecmahelpersbigintegers Helpers for operations intermediate 128-bit integers
+ * @{
+ */
+
+/**
+ * 128-bit integer type
+ */
+typedef struct
+{
+  uint64_t hi; /**< high 64 bits */
+  uint64_t lo; /**< low 64 bits */
+} ecma_uint128_t;
+
+/**
+ * Round high part of 128-bit integer to uint64_t
+ *
+ * @return rounded high to uint64_t
+ */
+static uint64_t
+ecma_round_high_to_uint64 (ecma_uint128_t *num_p)
+{
+  uint64_t masked_lo = num_p->lo & ~(1ULL << 63u);
+  uint64_t masked_hi = num_p->hi & 0x1;
+
+  if ((num_p->lo >> 63u != 0) && (masked_lo > 0 || masked_hi != 0))
+  {
+    return (num_p->hi + 1);
+  }
+
+  return num_p->hi;
+} /* ecma_round_high_to_uint64 */
+
+/**
+ * Left shift 128-bit integer by max 63 bits.
+ */
+static void
+ecma_uint128_shift_left (ecma_uint128_t *num_p, int32_t shift)
+{
+  num_p->hi = (num_p->hi << shift) | (num_p->lo >> (64 - shift));
+  num_p->lo <<= shift;
+} /* ecma_uint128_shift_left */
+
+/**
+ * Right shift 128-bit integer by max 63 bits.
+ */
+static void
+ecma_uint128_shift_right (ecma_uint128_t *num_p, int32_t shift)
+{
+  num_p->lo = (num_p->lo >> shift) | (num_p->hi << (64 - shift));
+  num_p->hi >>= shift;
+} /* ecma_uint128_shift_right */
+
+/**
+ * Add two 128-bit integer values and assign the result to the left one.
+ */
+static void
+ecma_uint128_add (ecma_uint128_t *left_p, ecma_uint128_t *right_p)
+{
+  left_p->hi += right_p->hi;
+  left_p->lo += right_p->lo;
+
+  if (left_p->lo < right_p->lo)
+  {
+    left_p->hi++;
+  }
+} /* ecma_uint128_add */
+
+/**
+ * Multiply 128-bit integer by 10
+ */
+static void
+ecma_uint128_mul10 (ecma_uint128_t *num_p)
+{
+  ecma_uint128_shift_left (num_p, 1u);
+
+  ecma_uint128_t tmp = { num_p->hi, num_p->lo };
+  ecma_uint128_shift_left (&tmp, 2u);
+
+  ecma_uint128_add (num_p, &tmp);
+} /* ecma_uint128_mul10 */
+
+/**
+ * Divide 128-bit integer by 10
+ *
+ * N = N3 *2^96  + N2 *2^64  + N1 *2^32  + N0 *2^0     // 128-bit dividend
+ * T = T3 *2^-32 + T2 *2^-64 + T1 *2^-96 + T0 *2^-128  // 128-bit divisor reciprocal, 1/10 * 2^-128
+ *
+ * N * T    = N3*T3 *2^64 + N2*T3 *2^32 + N1*T3 *2^0 + N0*T3 *2^-32
+ *          +               N3*T2 *2^32 + N2*T2 *2^0 + N1*T2 *2^-32 + N0*T2 *2^-64
+ *          +                             N3*T1 *2^0 + N2*T1 *2^-32 + N1*T1 *2^-64 + N0*T1 *2^-96
+ *          +                                          N3*T0 *2^-32 + N2*T0 *2^-64 + N1*T0 *2^-96 + N0*T0 *2^-128
+ *
+ *  Q3=carry  Q2=^+carry    Q1=^+carry    Q0=^+carry   fraction=^...
+ *
+ * Q = Q3 *2^96  + Q2 *2^64  + Q1 *2^32  + Q0 *2^0     // 128-bit quotient
+ */
+static void
+ecma_uint128_div10 (ecma_uint128_t *num_p)
+{
+  /* estimation of reciprocal of 10, 128 bits right of the binary point (T1 == T2) */
+  const uint64_t tenth_l = 0x9999999aul;
+  const uint64_t tenth_m = 0x99999999ul;
+  const uint64_t tenth_h = 0x19999999ul;
+
+  const uint64_t l0 = ((uint32_t) num_p->lo) * tenth_l;
+  const uint64_t l1 = (num_p->lo >> 32u) * tenth_l;
+  const uint64_t l2 = ((uint32_t) num_p->hi) * tenth_l;
+  const uint64_t l3 = (num_p->hi >> 32u) * tenth_l;
+  const uint64_t m0 = ((uint32_t) num_p->lo) * tenth_m;
+  const uint64_t m1 = (num_p->lo >> 32u) * tenth_m;
+  const uint64_t m2 = ((uint32_t) num_p->hi) * tenth_m;
+  const uint64_t m3 = (num_p->hi >> 32u) * tenth_m;
+  const uint64_t h0 = ((uint32_t) num_p->lo) * tenth_h;
+  const uint64_t h1 = (num_p->lo >> 32u) * tenth_h;
+  const uint64_t h2 = ((uint32_t) num_p->hi) * tenth_h;
+  const uint64_t h3 = (num_p->hi >> 32u) * tenth_h;
+
+  uint64_t q0 = l0 >> 32u;
+  q0 += (uint32_t) l1;
+  q0 += (uint32_t) m0;
+
+  q0 >>= 32u;
+  q0 += l1 >> 32u;
+  q0 += m0 >> 32u;
+  q0 += (uint32_t) l2;
+  q0 += (uint32_t) m1;
+  q0 += (uint32_t) m0;
+
+  q0 >>= 32u;
+  q0 += l2 >> 32u;
+  q0 += m1 >> 32u;
+  q0 += m0 >> 32u;
+  q0 += (uint32_t) l3;
+  q0 += (uint32_t) m2;
+  q0 += (uint32_t) m1;
+  q0 += (uint32_t) h0;
+
+  q0 >>= 32u;
+  q0 += l3 >> 32u;
+  q0 += m2 >> 32u;
+  q0 += m1 >> 32u;
+  q0 += h0 >> 32u;
+  q0 += (uint32_t) m3;
+  q0 += (uint32_t) m2;
+  q0 += (uint32_t) h1;
+
+  uint64_t q1 = q0 >> 32u;
+  q1 += m3 >> 32u;
+  q1 += m2 >> 32u;
+  q1 += h1 >> 32u;
+  q1 += (uint32_t) m3;
+  q1 += (uint32_t) h2;
+
+  uint64_t q32 = q1 >> 32u;
+  q32 += m3 >> 32u;
+  q32 += h2 >> 32u;
+  q32 += h3;
+
+  num_p->lo = (q1 << 32u) | ((uint32_t) q0);
+  num_p->hi = q32;
+} /* ecma_uint128_div10 */
+
+/**
+ * Count leading zeros in a 64-bit integer. The behaviour is undefined for 0.
+ *
+ * @return number of leading zeros.
+ */
+inline static int JERRY_ATTR_CONST
+ecma_uint64_clz (uint64_t n) /**< integer to count leading zeros in */
+{
+#if defined(__GNUC__) || defined(__clang__)
+  return __builtin_clzll (n);
+#else /* !defined (__GNUC__) && !defined (__clang__) */
+  JERRY_ASSERT (n != 0);
+
+  int cnt = 0;
+  uint64_t one = 0x8000000000000000ull;
+
+  while ((n & one) == 0)
+  {
+    cnt++;
+    one >>= 1;
+  }
+
+  return cnt;
+#endif /* !defined (__GNUC__) && !defined (__clang__) */
+} /* ecma_uint64_clz */
+
+/**
+ * Count leading zeros in the top 4 bits of a 64-bit integer.
+ *
+ * @return number of leading zeros in top 4 bits.
+ */
+inline static int JERRY_ATTR_CONST
+ecma_uint64_clz_top4 (uint64_t n) /**< integer to count leading zeros in */
+{
+  static const uint8_t ecma_uint4_clz[] = { 4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 };
+  return ecma_uint4_clz[n >> 60];
+} /* ecma_uint64_clz */
+
+/**
+ * Shift required to clear 4 bits of a 64-bit integer.
+ *
+ * @return 0-4
+ */
+inline static int JERRY_ATTR_CONST
+ecma_uint64_normalize_shift (uint64_t n) /**< integer to count leading zeros in */
+{
+  static const uint8_t ecma_uint4_shift[] = { 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4 };
+
+  return ecma_uint4_shift[n >> 60];
+} /* ecma_uint64_normalize_shift */
+
+/**
+ * @}
+ */
+
+/**
+ * Number.MAX_VALUE exponent part when using 64 bit float representation.
+ */
+#define NUMBER_MAX_DECIMAL_EXPONENT 308
+/**
+ * Number.MIN_VALUE exponent part when using 64 bit float representation.
+ */
+#define NUMBER_MIN_DECIMAL_EXPONENT -324
+
+#elif !JERRY_NUMBER_TYPE_FLOAT64
+
+/**
+ * Number.MAX_VALUE exponent part when using 32 bit float representation.
+ */
+#define NUMBER_MAX_DECIMAL_EXPONENT 38
+/**
+ * Number.MIN_VALUE exponent part when using 32 bit float representation.
+ */
+#define NUMBER_MIN_DECIMAL_EXPONENT -45
+
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Value of epsilon
+ */
+#define EPSILON 0.0000001
+
+/**
+ * ECMA-defined conversion from string to number for different radixes (2, 8, 16).
+ *
+ * See also:
+ *          ECMA-262 v5 9.3.1
+ *          ECMA-262 v6 7.1.3.1
+ *
+ * @return NaN - if the conversion fails
+ *         converted number - otherwise
+ */
+ecma_number_t
+ecma_utf8_string_to_number_by_radix (const lit_utf8_byte_t *str_p, /**< utf-8 string */
+                                     const lit_utf8_size_t string_size, /**< end of utf-8 string  */
+                                     uint32_t radix, /**< radix */
+                                     uint32_t options) /**< option flags */
+{
+  JERRY_ASSERT (radix == 2 || radix == 8 || radix == 16);
+  JERRY_ASSERT (*str_p == LIT_CHAR_0);
+
+  const lit_utf8_byte_t *end_p = str_p + string_size;
+
+  /* Skip leading zero */
+  str_p++;
+
+  if (radix != 8 || LEXER_TO_ASCII_LOWERCASE (*str_p) == LIT_CHAR_LOWERCASE_O)
+  {
+    /* Skip radix specifier */
+    str_p++;
+  }
+
+  ecma_number_t num = ECMA_NUMBER_ZERO;
+
+  while (str_p < end_p)
+  {
+    lit_utf8_byte_t digit = *str_p++;
+
+    if (digit == LIT_CHAR_UNDERSCORE && (options & ECMA_CONVERSION_ALLOW_UNDERSCORE))
+    {
+      continue;
+    }
+
+    if (!lit_char_is_hex_digit (digit))
+    {
+      return ecma_number_make_nan ();
+    }
+
+    uint32_t value = lit_char_hex_to_int (digit);
+
+    if (value >= radix)
+    {
+      return ecma_number_make_nan ();
+    }
+
+    num = num * radix + value;
+  }
+
+  return num;
+} /* ecma_utf8_string_to_number_by_radix */
+
+/**
+ * ECMA-defined conversion of string to Number.
+ *
+ * See also:
+ *          ECMA-262 v5, 9.3.1
+ *
+ * @return NaN - if the conversion fails
+ *         converted number - otherwise
+ */
+ecma_number_t
+ecma_utf8_string_to_number (const lit_utf8_byte_t *str_p, /**< utf-8 string */
+                            lit_utf8_size_t str_size, /**< string size */
+                            uint32_t options) /**< allowing underscore option bit */
+{
+  ecma_string_trim_helper (&str_p, &str_size);
+  const lit_utf8_byte_t *end_p = str_p + str_size;
+
+  if (str_size == 0)
+  {
+    return ECMA_NUMBER_ZERO;
+  }
+
+  bool sign = false;
+
+  if (str_p + 2 < end_p && str_p[0] == LIT_CHAR_0)
+  {
+    uint8_t radix = lit_char_to_radix (str_p[1]);
+
+    if (radix != 10)
+    {
+      return ecma_utf8_string_to_number_by_radix (str_p, str_size, radix, options);
+    }
+  }
+
+  if (*str_p == LIT_CHAR_PLUS)
+  {
+    str_p++;
+  }
+  else if (*str_p == LIT_CHAR_MINUS)
+  {
+    sign = true;
+    str_p++;
+  }
+
+  /* Check if string is equal to "Infinity". */
+  const lit_utf8_byte_t *infinity_str_p = lit_get_magic_string_utf8 (LIT_MAGIC_STRING_INFINITY_UL);
+  const lit_utf8_size_t infinity_length = lit_get_magic_string_size (LIT_MAGIC_STRING_INFINITY_UL);
+
+  if ((lit_utf8_size_t) (end_p - str_p) == infinity_length && memcmp (infinity_str_p, str_p, infinity_length) == 0)
+  {
+    return ecma_number_make_infinity (sign);
+  }
+
+  uint64_t significand = 0;
+  uint32_t digit_count = 0;
+  int32_t decimal_exponent = 0;
+  bool has_significand = false;
+
+  /* Parsing integer part */
+  while (str_p < end_p)
+  {
+    if (*str_p == LIT_CHAR_UNDERSCORE && (options & ECMA_CONVERSION_ALLOW_UNDERSCORE))
+    {
+      str_p++;
+      continue;
+    }
+
+    if (!lit_char_is_decimal_digit (*str_p))
+    {
+      break;
+    }
+
+    has_significand = true;
+    uint32_t digit_value = (uint32_t) (*str_p++ - LIT_CHAR_0);
+
+    if (digit_count == 0 && digit_value == 0)
+    {
+      /* Leading zeros are omitted. */
+      continue;
+    }
+
+    if (digit_count >= ECMA_NUMBER_MAX_DIGITS)
+    {
+      decimal_exponent++;
+      continue;
+    }
+
+    significand = significand * 10 + digit_value;
+    digit_count++;
+  }
+
+  /* Parse fraction part */
+  if (str_p < end_p && *str_p == LIT_CHAR_DOT)
+  {
+    str_p++;
+
+    while (str_p < end_p)
+    {
+      if (*str_p == LIT_CHAR_UNDERSCORE && (options & ECMA_CONVERSION_ALLOW_UNDERSCORE))
+      {
+        str_p++;
+        continue;
+      }
+
+      if (!lit_char_is_decimal_digit (*str_p))
+      {
+        break;
+      }
+
+      has_significand = true;
+      uint32_t digit_value = (uint32_t) (*str_p++ - LIT_CHAR_0);
+
+      if (digit_count == 0 && digit_value == 0)
+      {
+        /* Leading zeros are omitted. */
+        decimal_exponent--;
+        continue;
+      }
+
+      if (digit_count < ECMA_NUMBER_MAX_DIGITS)
+      {
+        significand = significand * 10 + digit_value;
+        digit_count++;
+        decimal_exponent--;
+      }
+    }
+  }
+
+  /* Parsing exponent */
+  if (str_p < end_p && LEXER_TO_ASCII_LOWERCASE (*str_p) == LIT_CHAR_LOWERCASE_E)
+  {
+    str_p++;
+
+    int32_t exponent = 0;
+    int32_t exponent_sign = 1;
+
+    if (str_p >= end_p)
+    {
+      return ecma_number_make_nan ();
+    }
+
+    if (*str_p == LIT_CHAR_PLUS)
+    {
+      str_p++;
+    }
+    else if (*str_p == LIT_CHAR_MINUS)
+    {
+      exponent_sign = -1;
+      str_p++;
+    }
+
+    if (str_p >= end_p || !lit_char_is_decimal_digit (*str_p))
+    {
+      return ecma_number_make_nan ();
+    }
+
+    while (str_p < end_p)
+    {
+      if (*str_p == LIT_CHAR_UNDERSCORE && (options & ECMA_CONVERSION_ALLOW_UNDERSCORE))
+      {
+        str_p++;
+        continue;
+      }
+
+      if (!lit_char_is_decimal_digit (*str_p))
+      {
+        break;
+      }
+
+      int32_t digit_value = (*str_p++ - LIT_CHAR_0);
+      exponent = exponent * 10 + digit_value;
+
+      if (exponent_sign * exponent > NUMBER_MAX_DECIMAL_EXPONENT)
+      {
+        return ecma_number_make_infinity (sign);
+      }
+
+      if (exponent_sign * exponent < NUMBER_MIN_DECIMAL_EXPONENT)
+      {
+        return sign ? -ECMA_NUMBER_ZERO : ECMA_NUMBER_ZERO;
+      }
+    }
+
+    decimal_exponent += exponent_sign * exponent;
+  }
+
+  if (!has_significand || str_p < end_p)
+  {
+    return ecma_number_make_nan ();
+  }
+
+  if (significand == 0)
+  {
+    return sign ? -ECMA_NUMBER_ZERO : ECMA_NUMBER_ZERO;
+  }
+
+#if JERRY_NUMBER_TYPE_FLOAT64
+  /*
+   * 128-bit mantissa storage
+   *
+   * Normalized: |4 bits zero|124-bit mantissa with highest bit set to 1|
+   */
+  ecma_uint128_t significand_uint128 = { significand, 0 };
+
+  /* Normalizing mantissa */
+  int shift = 4 - ecma_uint64_clz (significand_uint128.hi);
+
+  if (shift < 0)
+  {
+    ecma_uint128_shift_left (&significand_uint128, -shift);
+  }
+  else
+  {
+    ecma_uint128_shift_right (&significand_uint128, shift);
+  }
+
+  int32_t binary_exponent = ECMA_NUMBER_FRACTION_WIDTH + shift;
+
+  while (decimal_exponent > 0)
+  {
+    JERRY_ASSERT (ecma_uint64_clz (significand_uint128.hi) == 4);
+
+    ecma_uint128_mul10 (&significand_uint128);
+    decimal_exponent--;
+
+    /* Re-normalizing mantissa */
+    shift = ecma_uint64_normalize_shift (significand_uint128.hi);
+    JERRY_ASSERT (shift >= 0 && shift <= 4);
+
+    ecma_uint128_shift_right (&significand_uint128, shift);
+    binary_exponent += shift;
+  }
+
+  while (decimal_exponent < 0)
+  {
+    /* Denormalizing mantissa, moving highest 1 to bit 127 */
+    JERRY_ASSERT (ecma_uint64_clz (significand_uint128.hi) <= 4);
+    shift = ecma_uint64_clz_top4 (significand_uint128.hi);
+    JERRY_ASSERT (shift >= 0 && shift <= 4);
+
+    ecma_uint128_shift_left (&significand_uint128, shift);
+    binary_exponent -= shift;
+
+    ecma_uint128_div10 (&significand_uint128);
+    decimal_exponent++;
+  }
+
+  /*
+   * Preparing mantissa for conversion to 52-bit representation, converting it to:
+   *
+   * |11 zero bits|1|116 mantissa bits|
+   */
+  JERRY_ASSERT (ecma_uint64_clz (significand_uint128.hi) <= 4);
+  shift = 11 - ecma_uint64_clz_top4 (significand_uint128.hi);
+  ecma_uint128_shift_right (&significand_uint128, shift);
+  binary_exponent += shift;
+
+  JERRY_ASSERT (ecma_uint64_clz (significand_uint128.hi) == 11);
+
+  binary_exponent += ECMA_NUMBER_EXPONENT_BIAS;
+
+  /* Handle denormal numbers */
+  if (binary_exponent < 1)
+  {
+    ecma_uint128_shift_right (&significand_uint128, -binary_exponent + 1);
+    binary_exponent = 0;
+  }
+
+  significand = ecma_round_high_to_uint64 (&significand_uint128);
+
+  if (significand >= 1ull << (ECMA_NUMBER_FRACTION_WIDTH + 1))
+  {
+    /* Rounding carried over to the most significant bit, re-normalize.
+     * No need to shift mantissa right, as the low 52 bits will be 0 regardless. */
+    binary_exponent++;
+  }
+
+  if (binary_exponent >= ((1 << ECMA_NUMBER_BIASED_EXP_WIDTH) - 1))
+  {
+    return ecma_number_make_infinity (sign);
+  }
+
+  /* Mask low 52 bits. */
+  significand &= ((1ull << ECMA_NUMBER_FRACTION_WIDTH) - 1);
+
+  JERRY_ASSERT (binary_exponent < (1 << ECMA_NUMBER_BIASED_EXP_WIDTH) - 1);
+  JERRY_ASSERT (significand < (1ull << ECMA_NUMBER_FRACTION_WIDTH));
+
+  return ecma_number_create (sign, (uint32_t) binary_exponent, significand);
+#elif !JERRY_NUMBER_TYPE_FLOAT64
+  /* Less precise conversion */
+  ecma_number_t num = (ecma_number_t) (uint32_t) fraction_uint64;
+
+  ecma_number_t m = e_sign ? (ecma_number_t) 0.1 : (ecma_number_t) 10.0;
+
+  while (e)
+  {
+    if (e % 2)
+    {
+      num *= m;
+    }
+
+    m *= m;
+    e /= 2;
+  }
+
+  return num;
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+} /* ecma_utf8_string_to_number */
+
+/**
+ * ECMA-defined conversion of UInt32 to String (zero-terminated).
+ *
+ * See also:
+ *          ECMA-262 v5, 9.8.1
+ *
+ * @return number of bytes copied to buffer
+ */
+lit_utf8_size_t
+ecma_uint32_to_utf8_string (uint32_t value, /**< value to convert */
+                            lit_utf8_byte_t *out_buffer_p, /**< buffer for string */
+                            lit_utf8_size_t buffer_size) /**< size of buffer */
+{
+  lit_utf8_byte_t *buf_p = out_buffer_p + buffer_size;
+
+  do
+  {
+    JERRY_ASSERT (buf_p >= out_buffer_p);
+
+    buf_p--;
+    *buf_p = (lit_utf8_byte_t) ((value % 10) + LIT_CHAR_0);
+    value /= 10;
+  } while (value != 0);
+
+  JERRY_ASSERT (buf_p >= out_buffer_p);
+
+  lit_utf8_size_t bytes_copied = (lit_utf8_size_t) (out_buffer_p + buffer_size - buf_p);
+
+  if (JERRY_LIKELY (buf_p != out_buffer_p))
+  {
+    memmove (out_buffer_p, buf_p, bytes_copied);
+  }
+
+  return bytes_copied;
+} /* ecma_uint32_to_utf8_string */
+
+/**
+ * ECMA-defined conversion of Number value to UInt32 value
+ *
+ * See also:
+ *          ECMA-262 v5, 9.6
+ *
+ * @return 32-bit unsigned integer - result of conversion.
+ */
+uint32_t
+ecma_number_to_uint32 (ecma_number_t num) /**< ecma-number */
+{
+  if (JERRY_UNLIKELY (ecma_number_is_zero (num) || !ecma_number_is_finite (num)))
+  {
+    return 0;
+  }
+
+  const bool sign = ecma_number_is_negative (num);
+  const ecma_number_t abs_num = sign ? -num : num;
+
+  /* 2 ^ 32 */
+  const uint64_t uint64_2_pow_32 = (1ull << 32);
+
+  const ecma_number_t num_2_pow_32 = (float) uint64_2_pow_32;
+
+  ecma_number_t num_in_uint32_range;
+
+  if (abs_num >= num_2_pow_32)
+  {
+    num_in_uint32_range = ecma_number_remainder (abs_num, num_2_pow_32);
+  }
+  else
+  {
+    num_in_uint32_range = abs_num;
+  }
+
+  /* Check that the floating point value can be represented with uint32_t. */
+  JERRY_ASSERT (num_in_uint32_range < uint64_2_pow_32);
+  uint32_t uint32_num = (uint32_t) num_in_uint32_range;
+
+  const uint32_t ret = sign ? (uint32_t)(-(int32_t)uint32_num) : uint32_num;
+
+#ifndef JERRY_NDEBUG
+  if (sign && uint32_num != 0)
+  {
+    JERRY_ASSERT (ret == uint64_2_pow_32 - uint32_num);
+  }
+  else
+  {
+    JERRY_ASSERT (ret == uint32_num);
+  }
+#endif /* !JERRY_NDEBUG */
+
+  return ret;
+} /* ecma_number_to_uint32 */
+
+/**
+ * ECMA-defined conversion of Number value to Int32 value
+ *
+ * See also:
+ *          ECMA-262 v5, 9.5
+ *
+ * @return 32-bit signed integer - result of conversion.
+ */
+int32_t
+ecma_number_to_int32 (ecma_number_t num) /**< ecma-number */
+{
+  uint32_t uint32_num = ecma_number_to_uint32 (num);
+
+  /* 2 ^ 32 */
+  const int64_t int64_2_pow_32 = (1ll << 32);
+
+  /* 2 ^ 31 */
+  const uint32_t uint32_2_pow_31 = (1ull << 31);
+
+  int32_t ret;
+
+  if (uint32_num >= uint32_2_pow_31)
+  {
+    ret = (int32_t) (uint32_num - int64_2_pow_32);
+  }
+  else
+  {
+    ret = (int32_t) uint32_num;
+  }
+
+#ifndef JERRY_NDEBUG
+  int64_t int64_num = uint32_num;
+
+  JERRY_ASSERT (int64_num >= 0);
+
+  if (int64_num >= uint32_2_pow_31)
+  {
+    JERRY_ASSERT (ret == int64_num - int64_2_pow_32);
+  }
+  else
+  {
+    JERRY_ASSERT (ret == int64_num);
+  }
+#endif /* !JERRY_NDEBUG */
+
+  return ret;
+} /* ecma_number_to_int32 */
+
+/**
+ * Perform conversion of ecma-number to decimal representation with decimal exponent.
+ *
+ * Note:
+ *      The calculated values correspond to s, n, k parameters in ECMA-262 v5, 9.8.1, item 5:
+ *         - parameter out_digits_p corresponds to s, the digits of the number;
+ *         - parameter out_decimal_exp_p corresponds to n, the decimal exponent;
+ *         - return value corresponds to k, the number of digits.
+ *
+ * @return the number of digits
+ */
+lit_utf8_size_t
+ecma_number_to_decimal (ecma_number_t num, /**< ecma-number */
+                        lit_utf8_byte_t *out_digits_p, /**< [out] buffer to fill with digits */
+                        int32_t *out_decimal_exp_p) /**< [out] decimal exponent */
+{
+  JERRY_ASSERT (!ecma_number_is_nan (num));
+  JERRY_ASSERT (!ecma_number_is_zero (num));
+  JERRY_ASSERT (!ecma_number_is_infinity (num));
+  JERRY_ASSERT (!ecma_number_is_negative (num));
+
+  return ecma_errol0_dtoa ((double) num, out_digits_p, out_decimal_exp_p);
+} /* ecma_number_to_decimal */
+
+/**
+ * Convert ecma-number to zero-terminated string
+ *
+ * See also:
+ *          ECMA-262 v5, 9.8.1
+ *
+ *
+ * @return size of utf-8 string
+ */
+lit_utf8_size_t
+ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */
+                            lit_utf8_byte_t *buffer_p, /**< buffer for utf-8 string */
+                            lit_utf8_size_t buffer_size) /**< size of buffer */
+{
+  lit_utf8_byte_t *dst_p;
+
+  if (ecma_number_is_nan (num))
+  {
+    /* 1. */
+    dst_p = lit_copy_magic_string_to_buffer (LIT_MAGIC_STRING_NAN, buffer_p, buffer_size);
+    return (lit_utf8_size_t) (dst_p - buffer_p);
+  }
+
+  if (ecma_number_is_zero (num))
+  {
+    /* 2. */
+    *buffer_p = LIT_CHAR_0;
+    JERRY_ASSERT (1 <= buffer_size);
+    return 1;
+  }
+
+  dst_p = buffer_p;
+
+  if (ecma_number_is_negative (num))
+  {
+    /* 3. */
+    *dst_p++ = LIT_CHAR_MINUS;
+    num = -num;
+  }
+
+  if (ecma_number_is_infinity (num))
+  {
+    /* 4. */
+    dst_p = lit_copy_magic_string_to_buffer (LIT_MAGIC_STRING_INFINITY_UL,
+                                             dst_p,
+                                             (lit_utf8_size_t) (buffer_p + buffer_size - dst_p));
+    JERRY_ASSERT (dst_p <= buffer_p + buffer_size);
+    return (lit_utf8_size_t) (dst_p - buffer_p);
+  }
+
+  /* 5. */
+  uint32_t num_uint32 = ecma_number_to_uint32 (num);
+
+  if (((ecma_number_t) num_uint32) == num)
+  {
+    dst_p += ecma_uint32_to_utf8_string (num_uint32, dst_p, (lit_utf8_size_t) (buffer_p + buffer_size - dst_p));
+    JERRY_ASSERT (dst_p <= buffer_p + buffer_size);
+    return (lit_utf8_size_t) (dst_p - buffer_p);
+  }
+
+  /* decimal exponent */
+  int32_t n;
+  /* number of digits in mantissa */
+  int32_t k;
+
+  k = (int32_t) ecma_number_to_decimal (num, dst_p, &n);
+
+  if (k <= n && n <= 21)
+  {
+    /* 6. */
+    dst_p += k;
+
+    memset (dst_p, LIT_CHAR_0, (size_t) (n - k));
+    dst_p += n - k;
+
+    JERRY_ASSERT (dst_p <= buffer_p + buffer_size);
+    return (lit_utf8_size_t) (dst_p - buffer_p);
+  }
+
+  if (0 < n && n <= 21)
+  {
+    /* 7. */
+    memmove (dst_p + n + 1, dst_p + n, (size_t) (k - n));
+    *(dst_p + n) = LIT_CHAR_DOT;
+    dst_p += k + 1;
+
+    JERRY_ASSERT (dst_p <= buffer_p + buffer_size);
+    return (lit_utf8_size_t) (dst_p - buffer_p);
+  }
+
+  if (-6 < n && n <= 0)
+  {
+    /* 8. */
+    memmove (dst_p + 2 - n, dst_p, (size_t) k);
+    memset (dst_p + 2, LIT_CHAR_0, (size_t) -n);
+    *dst_p = LIT_CHAR_0;
+    *(dst_p + 1) = LIT_CHAR_DOT;
+    dst_p += k - n + 2;
+
+    JERRY_ASSERT (dst_p <= buffer_p + buffer_size);
+    return (lit_utf8_size_t) (dst_p - buffer_p);
+  }
+
+  if (k == 1)
+  {
+    /* 9. */
+    dst_p++;
+  }
+  else
+  {
+    /* 10. */
+    memmove (dst_p + 2, dst_p + 1, (size_t) (k - 1));
+    *(dst_p + 1) = LIT_CHAR_DOT;
+    dst_p += k + 1;
+  }
+
+  /* 9., 10. */
+  *dst_p++ = LIT_CHAR_LOWERCASE_E;
+  *dst_p++ = (n >= 1) ? LIT_CHAR_PLUS : LIT_CHAR_MINUS;
+  uint32_t t = (uint32_t) (n >= 1 ? (n - 1) : -(n - 1));
+
+  dst_p += ecma_uint32_to_utf8_string (t, dst_p, (lit_utf8_size_t) (buffer_p + buffer_size - dst_p));
+
+  JERRY_ASSERT (dst_p <= buffer_p + buffer_size);
+
+  return (lit_utf8_size_t) (dst_p - buffer_p);
+} /* ecma_number_to_utf8_string */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-helpers-errol.cpp

@@ -0,0 +1,245 @@
+/* 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.
+ *
+ * This file is based on work under the following copyright and permission
+ * notice:
+ *
+ *   Copyright (c) 2016 Marc Andrysco
+ *
+ *   Permission is hereby granted, free of charge, to any person obtaining a copy
+ *   of this software and associated documentation files (the "Software"), to deal
+ *   in the Software without restriction, including without limitation the rights
+ *   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *   copies of the Software, and to permit persons to whom the Software is
+ *   furnished to do so, subject to the following conditions:
+ *
+ *   The above copyright notice and this permission notice shall be included in all
+ *   copies or substantial portions of the Software.
+ *
+ *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *   SOFTWARE.
+ */
+
+#include <math.h>
+
+#include "ecma-helpers.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmahelpers Helpers for operations with ECMA data types
+ * @{
+ */
+
+/**
+ * Printing Floating-Point Numbers
+ *
+ * available at http://cseweb.ucsd.edu/~mandrysc/pub/dtoa.pdf
+ */
+
+/**
+ * Floating point format definitions (next float value)
+ */
+#define ECMA_NEXT_FLOAT(value) (nextafter ((value), INFINITY))
+/**
+ * Floating point format definitions (previous float value)
+ */
+#define ECMA_PREV_FLOAT(value) (nextafter ((value), -INFINITY))
+
+/**
+ * Value of epsilon
+ */
+#define ERROL0_EPSILON 0.0000001
+
+/**
+ * High-precision data structure.
+ */
+typedef struct
+{
+  double value; /**< value */
+  double offset; /**< offset */
+} ecma_high_prec_t;
+
+/**
+ * Normalize the number by factoring in the error.
+ *
+ * @return void
+ */
+static inline void
+ecma_normalize_high_prec_data (ecma_high_prec_t *hp_data_p) /**< [in, out] float pair */
+{
+  double val = hp_data_p->value;
+
+  hp_data_p->value += hp_data_p->offset;
+  hp_data_p->offset += val - hp_data_p->value;
+} /* ecma_normalize_high_prec_data */
+
+/**
+ * Multiply the high-precision number by ten.
+ *
+ * @return void
+ */
+static inline void
+ecma_multiply_high_prec_by_10 (ecma_high_prec_t *hp_data_p) /**< [in, out] high-precision number */
+{
+  double value = hp_data_p->value;
+
+  hp_data_p->value *= 10.0;
+  hp_data_p->offset *= 10.0;
+
+  double offset = hp_data_p->value;
+
+  offset -= value * 8.0;
+  offset -= value * 2.0;
+
+  hp_data_p->offset -= offset;
+
+  ecma_normalize_high_prec_data (hp_data_p);
+} /* ecma_multiply_high_prec_by_10 */
+
+/**
+ * Divide the high-precision number by ten.
+ */
+static void
+ecma_divide_high_prec_by_10 (ecma_high_prec_t *hp_data_p) /**< [in, out] high-precision number */
+{
+  double value = hp_data_p->value;
+
+  hp_data_p->value /= 10.0;
+  hp_data_p->offset /= 10.0;
+
+  value -= hp_data_p->value * 8.0;
+  value -= hp_data_p->value * 2.0;
+
+  hp_data_p->offset += value / 10.0;
+
+  ecma_normalize_high_prec_data (hp_data_p);
+} /* ecma_divide_high_prec_by_10 */
+
+/**
+ * Errol0 double to ASCII conversion, guaranteed correct but possibly not optimal.
+ *
+ * @return number of generated digits
+ */
+lit_utf8_size_t
+ecma_errol0_dtoa (double val, /**< ecma number */
+                  lit_utf8_byte_t *buffer_p, /**< buffer to generate digits into */
+                  int32_t *exp_p) /**< [out] exponent */
+{
+  double power_of_10 = 1.0;
+  int32_t exponent = 1;
+
+  /* normalize the midpoint */
+  ecma_high_prec_t mid;
+
+  mid.value = val;
+  mid.offset = 0.0;
+
+  while (((mid.value > 10.0) || ((mid.value == 10.0) && (mid.offset >= 0.0))) && (exponent < 308))
+  {
+    exponent++;
+    ecma_divide_high_prec_by_10 (&mid);
+    power_of_10 /= 10.0;
+  }
+
+  while (((mid.value < 1.0) || ((mid.value == 1.0) && (mid.offset < 0.0))) && (exponent > -307))
+  {
+    exponent--;
+    ecma_multiply_high_prec_by_10 (&mid);
+    power_of_10 *= 10.0;
+  }
+
+  ecma_high_prec_t high_bound, low_bound;
+
+  high_bound.value = mid.value;
+  high_bound.offset = mid.offset;
+
+  if (ECMA_NEXT_FLOAT (val) != INFINITY)
+  {
+    high_bound.offset += (ECMA_NEXT_FLOAT (val) - val) * power_of_10 / (2.0 + ERROL0_EPSILON);
+  }
+
+  low_bound.value = mid.value;
+  low_bound.offset = mid.offset + (ECMA_PREV_FLOAT (val) - val) * power_of_10 / (2.0 + ERROL0_EPSILON);
+
+  ecma_normalize_high_prec_data (&high_bound);
+  ecma_normalize_high_prec_data (&low_bound);
+
+  /* normalized boundaries */
+
+  while (high_bound.value > 10.0 || (high_bound.value == 10.0 && (high_bound.offset >= 0.0)))
+  {
+    exponent++;
+    ecma_divide_high_prec_by_10 (&high_bound);
+    ecma_divide_high_prec_by_10 (&low_bound);
+  }
+
+  while (high_bound.value < 1.0 || (high_bound.value == 1.0 && (high_bound.offset < 0.0)))
+  {
+    exponent--;
+    ecma_multiply_high_prec_by_10 (&high_bound);
+    ecma_multiply_high_prec_by_10 (&low_bound);
+  }
+
+  /* digit generation */
+
+  lit_utf8_byte_t *dst_p = buffer_p;
+
+  while (high_bound.value != 0.0 || high_bound.offset != 0.0)
+  {
+    uint8_t high_digit = (uint8_t) high_bound.value;
+
+    if ((high_bound.value == high_digit) && (high_bound.offset < 0))
+    {
+      high_digit = (uint8_t) (high_digit - 1u);
+    }
+
+    uint8_t low_digit = (uint8_t) low_bound.value;
+
+    if ((low_bound.value == low_digit) && (low_bound.offset < 0))
+    {
+      low_digit = (uint8_t) (low_digit - 1u);
+    }
+
+    if (low_digit != high_digit)
+    {
+      break;
+    }
+
+    *dst_p++ = (lit_utf8_byte_t) ('0' + high_digit);
+
+    high_bound.value -= high_digit;
+    ecma_multiply_high_prec_by_10 (&high_bound);
+
+    low_bound.value -= low_digit;
+    ecma_multiply_high_prec_by_10 (&low_bound);
+  }
+
+  double mdig = (high_bound.value + low_bound.value) / 2.0 + 0.5;
+  *dst_p++ = (lit_utf8_byte_t) ('0' + (uint8_t) mdig);
+
+  *exp_p = exponent;
+
+  return (lit_utf8_size_t) (dst_p - buffer_p);
+} /* ecma_errol0_dtoa */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-helpers-external-pointers.cpp

@@ -0,0 +1,334 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-array-object.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects-general.h"
+#include "ecma-objects.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmahelpers Helpers for operations with ECMA data types
+ * @{
+ */
+
+/**
+ * Create a native pointer property to store the native pointer and its type info.
+ *
+ * @return true - if property was just created with specified value,
+ *         false - otherwise, if property existed before the call, it's value was updated
+ */
+bool
+ecma_create_native_pointer_property (ecma_object_t *obj_p, /**< object to create property in */
+                                     void *native_p, /**< native pointer */
+                                     const jerry_object_native_info_t *native_info_p) /**< native type info */
+{
+  ecma_string_t *name_p = ecma_get_internal_string (LIT_INTERNAL_MAGIC_STRING_NATIVE_POINTER);
+
+  if (native_info_p != NULL && native_info_p->number_of_references > 0)
+  {
+    name_p = ecma_get_internal_string (LIT_INTERNAL_MAGIC_STRING_NATIVE_POINTER_WITH_REFERENCES);
+  }
+
+  if (ecma_op_object_is_fast_array (obj_p))
+  {
+    ecma_fast_array_convert_to_normal (obj_p);
+  }
+
+  ecma_property_t *property_p = ecma_find_named_property (obj_p, name_p);
+
+  bool is_new = (property_p == NULL);
+
+  ecma_native_pointer_t *native_pointer_p;
+
+  if (property_p == NULL)
+  {
+    native_pointer_p = (ecma_native_pointer_t *) jmem_heap_alloc_block (sizeof (ecma_native_pointer_t));
+
+    ecma_property_value_t *value_p;
+    ECMA_CREATE_INTERNAL_PROPERTY (obj_p, name_p, property_p, value_p);
+
+    ECMA_SET_INTERNAL_VALUE_POINTER (value_p->value, native_pointer_p);
+    *property_p |= ECMA_PROPERTY_FLAG_SINGLE_EXTERNAL;
+  }
+  else if (*property_p & ECMA_PROPERTY_FLAG_SINGLE_EXTERNAL)
+  {
+    ecma_property_value_t *value_p = ECMA_PROPERTY_VALUE_PTR (property_p);
+
+    native_pointer_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_native_pointer_t, value_p->value);
+
+    if (native_pointer_p->native_info_p == native_info_p)
+    {
+      native_pointer_p->native_p = native_p;
+      return false;
+    }
+
+    value_p->value = JMEM_CP_NULL;
+    (void) value_p->value; /* Make cppcheck happy. */
+    *property_p &= (ecma_property_t) ~ECMA_PROPERTY_FLAG_SINGLE_EXTERNAL;
+
+    ecma_native_pointer_chain_t *item_p;
+    item_p = (ecma_native_pointer_chain_t *) jmem_heap_alloc_block (sizeof (ecma_native_pointer_chain_t));
+    item_p->data = *native_pointer_p;
+
+    jmem_heap_free_block (native_pointer_p, sizeof (ecma_native_pointer_t));
+
+    item_p->next_p = (ecma_native_pointer_chain_t *) jmem_heap_alloc_block (sizeof (ecma_native_pointer_chain_t));
+    item_p->next_p->next_p = NULL;
+
+    native_pointer_p = &item_p->next_p->data;
+    ECMA_SET_INTERNAL_VALUE_POINTER (value_p->value, item_p);
+  }
+  else
+  {
+    ecma_property_value_t *value_p = ECMA_PROPERTY_VALUE_PTR (property_p);
+
+    if (value_p->value == JMEM_CP_NULL)
+    {
+      native_pointer_p = (ecma_native_pointer_t *) jmem_heap_alloc_block (sizeof (ecma_native_pointer_t));
+      ECMA_SET_INTERNAL_VALUE_POINTER (value_p->value, native_pointer_p);
+
+      *property_p |= ECMA_PROPERTY_FLAG_SINGLE_EXTERNAL;
+    }
+    else
+    {
+      ecma_native_pointer_chain_t *item_p;
+      item_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_native_pointer_chain_t, value_p->value);
+
+      /* There should be at least 2 native pointers in the chain */
+      JERRY_ASSERT (item_p != NULL && item_p->next_p != NULL);
+
+      while (true)
+      {
+        if (item_p->data.native_info_p == native_info_p)
+        {
+          /* The native info already exists -> update the corresponding data */
+          item_p->data.native_p = native_p;
+          return false;
+        }
+
+        if (item_p->next_p == NULL)
+        {
+          /* The native info does not exist -> append a new element to the chain */
+          break;
+        }
+
+        item_p = item_p->next_p;
+      }
+
+      ecma_native_pointer_chain_t *new_item_p;
+
+      new_item_p = (ecma_native_pointer_chain_t *) jmem_heap_alloc_block (sizeof (ecma_native_pointer_chain_t));
+      item_p->next_p = new_item_p;
+      new_item_p->next_p = NULL;
+
+      native_pointer_p = &new_item_p->data;
+    }
+  }
+
+  native_pointer_p->native_p = native_p;
+  native_pointer_p->native_info_p = (jerry_object_native_info_t *) native_info_p;
+
+  return is_new;
+} /* ecma_create_native_pointer_property */
+
+/**
+ * Get value of native package stored in the object's property with specified identifier
+ *
+ * Note:
+ *      property identifier should be one of the following:
+ *        - LIT_INTERNAL_MAGIC_STRING_NATIVE_POINTER
+ *
+ * @return native pointer data if property exists
+ *         NULL otherwise
+ */
+ecma_native_pointer_t *
+ecma_get_native_pointer_value (ecma_object_t *obj_p, /**< object to get property value from */
+                               const jerry_object_native_info_t *native_info_p) /**< native type info */
+{
+  if (ecma_op_object_is_fast_array (obj_p))
+  {
+    /* Fast access mode array can not have native pointer properties */
+    return NULL;
+  }
+
+  ecma_string_t *name_p = ecma_get_internal_string (LIT_INTERNAL_MAGIC_STRING_NATIVE_POINTER);
+
+  if (native_info_p != NULL && native_info_p->number_of_references > 0)
+  {
+    name_p = ecma_get_internal_string (LIT_INTERNAL_MAGIC_STRING_NATIVE_POINTER_WITH_REFERENCES);
+  }
+
+  ecma_property_t *property_p = ecma_find_named_property (obj_p, name_p);
+
+  if (property_p == NULL)
+  {
+    return NULL;
+  }
+
+  ecma_property_value_t *value_p = ECMA_PROPERTY_VALUE_PTR (property_p);
+
+  if (JERRY_LIKELY (*property_p & ECMA_PROPERTY_FLAG_SINGLE_EXTERNAL))
+  {
+    ecma_native_pointer_t *native_pointer_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_native_pointer_t, value_p->value);
+
+    if (native_pointer_p->native_info_p == native_info_p)
+    {
+      return native_pointer_p;
+    }
+
+    return NULL;
+  }
+
+  if (value_p->value == JMEM_CP_NULL)
+  {
+    return NULL;
+  }
+
+  ecma_native_pointer_chain_t *item_p;
+  item_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_native_pointer_chain_t, value_p->value);
+
+  /* There should be at least 2 native pointers in the chain */
+  JERRY_ASSERT (item_p != NULL && item_p->next_p != NULL);
+
+  do
+  {
+    if (item_p->data.native_info_p == native_info_p)
+    {
+      return &item_p->data;
+    }
+
+    item_p = item_p->next_p;
+  } while (item_p != NULL);
+
+  return NULL;
+} /* ecma_get_native_pointer_value */
+
+/**
+ * Delete the previously set native pointer by the native type info from the specified object.
+ *
+ * Note:
+ *      If the specified object has no matching native pointer for the given native type info
+ *      the function has no effect.
+ *
+ * @return true - if the native pointer has been deleted succesfully
+ *         false - otherwise
+ */
+bool
+ecma_delete_native_pointer_property (ecma_object_t *obj_p, /**< object to delete property from */
+                                     const jerry_object_native_info_t *native_info_p) /**< native type info */
+{
+  if (ecma_op_object_is_fast_array (obj_p))
+  {
+    /* Fast access mode array can not have native pointer properties */
+    return false;
+  }
+
+  ecma_string_t *name_p = ecma_get_internal_string (LIT_INTERNAL_MAGIC_STRING_NATIVE_POINTER);
+
+  if (native_info_p != NULL && native_info_p->number_of_references > 0)
+  {
+    name_p = ecma_get_internal_string (LIT_INTERNAL_MAGIC_STRING_NATIVE_POINTER_WITH_REFERENCES);
+  }
+
+  ecma_property_t *property_p = ecma_find_named_property (obj_p, name_p);
+
+  if (property_p == NULL)
+  {
+    return false;
+  }
+
+  ecma_property_value_t *value_p = ECMA_PROPERTY_VALUE_PTR (property_p);
+
+  if (JERRY_LIKELY (*property_p & ECMA_PROPERTY_FLAG_SINGLE_EXTERNAL))
+  {
+    ecma_native_pointer_t *native_pointer_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_native_pointer_t, value_p->value);
+
+    if (native_pointer_p->native_info_p != native_info_p)
+    {
+      return false;
+    }
+
+    value_p->value = JMEM_CP_NULL;
+    *property_p &= (ecma_property_t) ~ECMA_PROPERTY_FLAG_SINGLE_EXTERNAL;
+    jmem_heap_free_block (native_pointer_p, sizeof (ecma_native_pointer_t));
+    return true;
+  }
+
+  if (value_p->value == JMEM_CP_NULL)
+  {
+    return false;
+  }
+
+  ecma_native_pointer_chain_t *first_p;
+  first_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_native_pointer_chain_t, value_p->value);
+
+  /* There should be at least 2 native pointers in the chain */
+  JERRY_ASSERT (first_p != NULL && first_p->next_p != NULL);
+
+  ecma_native_pointer_chain_t *item_p = first_p;
+  ecma_native_pointer_chain_t *prev_p = NULL;
+
+  do
+  {
+    if (item_p->data.native_info_p == native_info_p)
+    {
+      if (prev_p == NULL)
+      {
+        /* The first element is deleted from the chain: change the property value. */
+        first_p = item_p->next_p;
+        ECMA_SET_INTERNAL_VALUE_POINTER (value_p->value, first_p);
+      }
+      else
+      {
+        /* A non-first element is deleted from the chain: update the previous pointer. */
+        prev_p->next_p = item_p->next_p;
+      }
+
+      jmem_heap_free_block (item_p, sizeof (ecma_native_pointer_chain_t));
+
+      if (first_p->next_p != NULL)
+      {
+        return true;
+      }
+
+      /* Only one item remained. The ECMA_PROPERTY_FLAG_SINGLE_EXTERNAL flag is
+       * set early to avoid using the chain if the allocation below triggers a GC. */
+      *property_p |= ECMA_PROPERTY_FLAG_SINGLE_EXTERNAL;
+
+      ecma_native_pointer_t *native_pointer_p;
+      native_pointer_p = (ecma_native_pointer_t *) jmem_heap_alloc_block (sizeof (ecma_native_pointer_t));
+      *native_pointer_p = first_p->data;
+
+      ECMA_SET_INTERNAL_VALUE_POINTER (value_p->value, native_pointer_p);
+
+      jmem_heap_free_block (first_p, sizeof (ecma_native_pointer_chain_t));
+      return true;
+    }
+
+    prev_p = item_p;
+    item_p = item_p->next_p;
+  } while (item_p != NULL);
+
+  return false;
+} /* ecma_delete_native_pointer_property */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-helpers-number.cpp

@@ -0,0 +1,677 @@
+/* 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.
+ */
+
+#include "ecma-helpers-number.h"
+
+#include <math.h>
+
+#include "ecma-conversion.h"
+
+#include "lit-char-helpers.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmahelpers Helpers for operations with ECMA data types
+ * @{
+ */
+
+JERRY_STATIC_ASSERT ((sizeof (ecma_value_t) == sizeof (ecma_integer_value_t)),
+                     size_of_ecma_value_t_must_be_equal_to_the_size_of_ecma_integer_value_t);
+
+JERRY_STATIC_ASSERT ((((int)ECMA_DIRECT_SHIFT) == (((int)ECMA_VALUE_SHIFT) + 1)), currently_directly_encoded_values_has_one_extra_flag);
+
+JERRY_STATIC_ASSERT ((((1 << (ECMA_DIRECT_SHIFT - 1)) | ECMA_TYPE_DIRECT) == ECMA_DIRECT_TYPE_SIMPLE_VALUE),
+                     currently_directly_encoded_values_start_after_direct_type_simple_value);
+
+JERRY_STATIC_ASSERT ((sizeof (ecma_number_t) == sizeof (ecma_binary_num_t)),
+                     size_of_ecma_number_t_must_be_equal_to_binary_representation);
+
+/**
+ * Convert an ecma-number to it's binary representation.
+ *
+ * @return binary representation
+ */
+ecma_binary_num_t JERRY_ATTR_CONST
+ecma_number_to_binary (ecma_number_t number) /**< ecma number */
+{
+  ecma_number_accessor_t f;
+  f.as_number = number;
+
+  return f.as_binary;
+} /* ecma_number_to_binary */
+
+/**
+ * Convert a binary representation to the corresponding ecma-number.
+ *
+ * @return ecma-number
+ */
+ecma_number_t JERRY_ATTR_CONST
+ecma_number_from_binary (ecma_binary_num_t binary) /**< binary representation */
+{
+  ecma_number_accessor_t f;
+  f.as_binary = binary;
+
+  return f.as_number;
+} /* ecma_number_from_binary */
+
+/**
+ * Check signedness of the binary number.
+ *
+ * @return true  - if sign bit is set
+ *         false - otherwise
+ */
+bool JERRY_ATTR_CONST
+ecma_number_sign (ecma_binary_num_t binary) /**< binary representation */
+{
+  return (binary & ECMA_NUMBER_SIGN_BIT) != 0;
+} /* ecma_number_sign */
+
+/**
+ * Get biased exponent field of the binary number.
+ *
+ * @return unsigned integer value of the biased exponent field
+ */
+uint32_t JERRY_ATTR_CONST
+ecma_number_biased_exp (ecma_binary_num_t binary) /**< binary representation */
+{
+  return (uint32_t) ((binary & ~ECMA_NUMBER_SIGN_BIT) >> ECMA_NUMBER_FRACTION_WIDTH);
+} /* ecma_number_biased_exp */
+
+/**
+ * Get fraction field of the binary number.
+ *
+ * @return unsigned integer value of the fraction field
+ */
+uint64_t JERRY_ATTR_CONST
+ecma_number_fraction (ecma_binary_num_t binary) /**< binary representation */
+{
+  return binary & ((1ull << ECMA_NUMBER_FRACTION_WIDTH) - 1);
+} /* ecma_number_fraction */
+
+/**
+ * Packing sign, fraction and biased exponent to ecma-number
+ *
+ * @return ecma-number with specified sign, biased_exponent and fraction
+ */
+ecma_number_t
+ecma_number_create (bool sign, /**< sign */
+                    uint32_t biased_exp, /**< biased exponent */
+                    uint64_t fraction) /**< fraction */
+{
+  JERRY_ASSERT ((biased_exp & ~((1u << ECMA_NUMBER_BIASED_EXP_WIDTH) - 1)) == 0);
+  JERRY_ASSERT ((fraction & ~((1ull << ECMA_NUMBER_FRACTION_WIDTH) - 1)) == 0);
+
+  ecma_binary_num_t binary = biased_exp;
+  binary <<= ECMA_NUMBER_FRACTION_WIDTH;
+
+  binary |= fraction;
+
+  if (sign)
+  {
+    binary |= ECMA_NUMBER_SIGN_BIT;
+  }
+
+  return ecma_number_from_binary (binary);
+} /* ecma_number_create */
+
+/**
+ * Check if ecma-number is NaN
+ *
+ * @return true - if biased exponent is filled with 1 bits and
+                  fraction is filled with anything but not all zero bits,
+ *         false - otherwise
+ */
+bool
+ecma_number_is_nan (ecma_number_t num) /**< ecma-number */
+{
+  bool is_nan = (num != num);
+
+#ifndef JERRY_NDEBUG
+  /* IEEE-754 2008, 3.4, a */
+  ecma_binary_num_t binary = ecma_number_to_binary (num);
+  bool is_nan_exponent = (ecma_number_biased_exp (binary) == (1 << ECMA_NUMBER_BIASED_EXP_WIDTH) - 1);
+  bool is_nan_fraction = (ecma_number_fraction (binary) > 0);
+
+  bool is_nan_ieee754 = is_nan_exponent && is_nan_fraction;
+  JERRY_ASSERT (is_nan == is_nan_ieee754);
+#endif /* !JERRY_NDEBUG */
+
+  return is_nan;
+} /* ecma_number_is_nan */
+
+/**
+ * Make a NaN.
+ *
+ * @return NaN value
+ */
+ecma_number_t JERRY_ATTR_CONST
+ecma_number_make_nan (void)
+{
+  ecma_number_accessor_t f;
+  f.as_binary = ECMA_NUMBER_BINARY_QNAN;
+
+  return f.as_number;
+} /* ecma_number_make_nan */
+
+/**
+ * Make an Infinity.
+ *
+ * @return if !sign - +Infinity value,
+ *         else - -Infinity value.
+ */
+ecma_number_t JERRY_ATTR_CONST
+ecma_number_make_infinity (bool sign) /**< sign of the value */
+{
+  ecma_number_accessor_t f;
+  f.as_binary = ECMA_NUMBER_BINARY_INF;
+
+  if (sign)
+  {
+    f.as_binary |= ECMA_NUMBER_SIGN_BIT;
+  }
+
+  return f.as_number;
+} /* ecma_number_make_infinity */
+
+/**
+ * Check if ecma-number is negative
+ *
+ * @return true - if sign bit of ecma-number is set
+ *         false - otherwise
+ */
+bool JERRY_ATTR_CONST
+ecma_number_is_negative (ecma_number_t num) /**< ecma-number */
+{
+  JERRY_ASSERT (!ecma_number_is_nan (num));
+
+  return (ecma_number_to_binary (num) & ECMA_NUMBER_SIGN_BIT) != 0;
+} /* ecma_number_is_negative */
+
+/**
+ * Check if ecma-number is zero
+ *
+ * @return true - if fraction is zero and biased exponent is zero,
+ *         false - otherwise
+ */
+bool JERRY_ATTR_CONST
+ecma_number_is_zero (ecma_number_t num) /**< ecma-number */
+{
+  bool is_zero = (num == ECMA_NUMBER_ZERO);
+
+#ifndef JERRY_NDEBUG
+  bool is_zero_ieee754 = ((ecma_number_to_binary (num) & ~ECMA_NUMBER_SIGN_BIT) == 0);
+  JERRY_ASSERT (is_zero == is_zero_ieee754);
+#endif /* !JERRY_NDEBUG */
+
+  return is_zero;
+} /* ecma_number_is_zero */
+
+/**
+ * Check if number is infinity
+ *
+ * @return true - if biased exponent is filled with 1 bits and
+ *                fraction is filled with zero bits,
+ *         false - otherwise
+ */
+bool JERRY_ATTR_CONST
+ecma_number_is_infinity (ecma_number_t num) /**< ecma-number */
+{
+  return (ecma_number_to_binary (num) & ~ECMA_NUMBER_SIGN_BIT) == ECMA_NUMBER_BINARY_INF;
+} /* ecma_number_is_infinity */
+
+/**
+ * Check if number is finite
+ *
+ * @return true  - if number is finite
+ *         false - if number is NaN or infinity
+ */
+bool JERRY_ATTR_CONST
+ecma_number_is_finite (ecma_number_t num) /**< ecma-number */
+{
+#if defined(__GNUC__) || defined(__clang__)
+  return __builtin_isfinite (num);
+#elif defined(_WIN32)
+  return isfinite (num);
+#else /* !(defined(__GNUC__) || defined(__clang__) || defined(_WIN32)) */
+  return !ecma_number_is_nan (num) && !ecma_number_is_infinity (num);
+#endif /* defined (__GNUC__) || defined (__clang__) */
+} /* ecma_number_is_finite */
+
+/**
+ * Get previous representable ecma-number
+ *
+ * @return maximum ecma-number that is less compared to passed argument
+ */
+ecma_number_t JERRY_ATTR_CONST
+ecma_number_get_prev (ecma_number_t num) /**< ecma-number */
+{
+#if defined(__GNUC__) || defined(__clang__)
+  return __builtin_nextafter (num, -INFINITY);
+#else /* !defined (__GNUC__) && !defined (__clang__) */
+  JERRY_ASSERT (!ecma_number_is_nan (num));
+  ecma_binary_num_t binary = ecma_number_to_binary (num);
+
+  /* If -Infinity, return self */
+  if (binary == (ECMA_NUMBER_SIGN_BIT | ECMA_NUMBER_BINARY_INF))
+  {
+    return num;
+  }
+
+  /* If +0.0, return -0.0 */
+  if (binary == ECMA_NUMBER_BINARY_ZERO)
+  {
+    return -num;
+  }
+
+  if (ecma_number_sign (binary))
+  {
+    return ecma_number_from_binary (binary + 1);
+  }
+
+  return ecma_number_from_binary (binary - 1);
+#endif /* !defined (__GNUC__) && !defined (__clang__) */
+} /* ecma_number_get_prev */
+
+/**
+ * Get next representable ecma-number
+ *
+ * @return minimum ecma-number that is greater compared to passed argument
+ */
+ecma_number_t JERRY_ATTR_CONST
+ecma_number_get_next (ecma_number_t num) /**< ecma-number */
+{
+#if defined(__GNUC__) || defined(__clang__)
+  return __builtin_nextafter (num, INFINITY);
+#else /* !defined (__GNUC__) && !defined (__clang__) */
+  JERRY_ASSERT (!ecma_number_is_nan (num));
+  ecma_binary_num_t binary = ecma_number_to_binary (num);
+
+  /* If +Infinity, return self */
+  if (binary == ECMA_NUMBER_BINARY_INF)
+  {
+    return num;
+  }
+
+  /* If -0.0, return +0.0 */
+  if (binary == (ECMA_NUMBER_SIGN_BIT | ECMA_NUMBER_BINARY_ZERO))
+  {
+    return -num;
+  }
+
+  if (ecma_number_sign (binary))
+  {
+    return ecma_number_from_binary (binary - 1);
+  }
+
+  return ecma_number_from_binary (binary + 1);
+#endif /* !defined (__GNUC__) && !defined (__clang__) */
+} /* ecma_number_get_next */
+
+/**
+ * Truncate fractional part of the number
+ *
+ * @return integer part of the number
+ */
+ecma_number_t JERRY_ATTR_CONST
+ecma_number_trunc (ecma_number_t num) /**< ecma-number */
+{
+  JERRY_ASSERT (!ecma_number_is_nan (num));
+
+  ecma_binary_num_t binary = ecma_number_to_binary (num);
+  uint32_t exponent = ecma_number_biased_exp (binary);
+
+  if (exponent < ECMA_NUMBER_EXPONENT_BIAS)
+  {
+    return ECMA_NUMBER_ZERO;
+  }
+
+  uint32_t unbiased_exp = exponent - ECMA_NUMBER_EXPONENT_BIAS;
+
+  if (unbiased_exp >= ECMA_NUMBER_FRACTION_WIDTH)
+  {
+    return num;
+  }
+
+  binary &= ~((1ull << (ECMA_NUMBER_FRACTION_WIDTH - unbiased_exp)) - 1);
+  return ecma_number_from_binary (binary);
+} /* ecma_number_trunc */
+
+/**
+ * Calculate remainder of division of two numbers,
+ * as specified in ECMA-262 v5, 11.5.3, item 6.
+ *
+ * Note:
+ *      operands shouldn't contain NaN, Infinity, or zero.
+ *
+ * @return number - calculated remainder.
+ */
+ecma_number_t JERRY_ATTR_CONST
+ecma_number_remainder (ecma_number_t left_num, /**< left operand */
+                       ecma_number_t right_num) /**< right operand */
+{
+  JERRY_ASSERT (ecma_number_is_finite (left_num) && !ecma_number_is_zero (left_num));
+  JERRY_ASSERT (ecma_number_is_finite (right_num) && !ecma_number_is_zero (right_num));
+
+  const ecma_number_t q = ecma_number_trunc (left_num / right_num);
+  ecma_number_t r = left_num - right_num * q;
+
+  if (ecma_number_is_zero (r) && ecma_number_is_negative (left_num))
+  {
+    r = -r;
+  }
+
+  return r;
+} /* ecma_number_remainder */
+
+/**
+ * Compute power operation according to the ES standard.
+ *
+ * @return x ** y
+ */
+ecma_number_t JERRY_ATTR_CONST
+ecma_number_pow (ecma_number_t x, /**< left operand */
+                 ecma_number_t y) /**< right operand */
+{
+  if (ecma_number_is_nan (y) || (ecma_number_is_infinity (y) && (x == ECMA_NUMBER_ONE || x == ECMA_NUMBER_MINUS_ONE)))
+  {
+    /* Handle differences between ES5.1 and ISO C standards for pow. */
+    return ecma_number_make_nan ();
+  }
+
+  if (ecma_number_is_zero (y))
+  {
+    /* Handle differences between ES5.1 and ISO C standards for pow. */
+    return ECMA_NUMBER_ONE;
+  }
+
+  return DOUBLE_TO_ECMA_NUMBER_T (pow (x, y));
+} /* ecma_number_pow */
+
+/**
+ * ECMA-integer number multiplication.
+ *
+ * @return number - result of multiplication.
+ */
+ecma_value_t JERRY_ATTR_CONST
+ecma_integer_multiply (ecma_integer_value_t left_integer, /**< left operand */
+                       ecma_integer_value_t right_integer) /**< right operand */
+{
+#if defined(__GNUC__) || defined(__clang__)
+  /* Check if either integer is power of 2 */
+  if (JERRY_UNLIKELY ((left_integer & (left_integer - 1)) == 0))
+  {
+    /* Right shift right_integer with log2 (left_integer) */
+    return ecma_make_integer_value (
+      (int32_t) ((uint32_t) right_integer << (__builtin_ctz ((unsigned int) left_integer))));
+  }
+
+  if (JERRY_UNLIKELY ((right_integer & (right_integer - 1)) == 0))
+  {
+    /* Right shift left_integer with log2 (right_integer) */
+    return ecma_make_integer_value (
+      (int32_t) ((uint32_t) left_integer << (__builtin_ctz ((unsigned int) right_integer))));
+  }
+#endif /* defined (__GNUC__) || defined (__clang__) */
+
+  return ecma_make_integer_value (left_integer * right_integer);
+} /* ecma_integer_multiply */
+
+/**
+ * The Number object's 'parseInt' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.1.2.2
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_number_parse_int (const lit_utf8_byte_t *str_p, /**< routine's first argument's
+                                                      *   string buffer */
+                       lit_utf8_size_t str_size, /**< routine's first argument's
+                                                  *   string buffer's size */
+                       ecma_value_t radix_value) /**< routine's second argument */
+{
+  /* 2. Remove leading whitespace. */
+  ecma_string_trim_helper (&str_p, &str_size);
+
+  if (str_size == 0)
+  {
+    return ecma_make_nan_value ();
+  }
+
+  const lit_utf8_byte_t *str_end_p = str_p + str_size;
+
+  /* 3. */
+  bool sign = false;
+
+  /* 4. */
+  if (*str_p == LIT_CHAR_MINUS)
+  {
+    sign = true;
+    str_p++;
+  }
+  /* 5. */
+  else if (*str_p == LIT_CHAR_PLUS)
+  {
+    str_p++;
+  }
+
+  /* 6. */
+  ecma_number_t radix_num;
+  radix_value = ecma_op_to_number (radix_value, &radix_num);
+
+  if (ECMA_IS_VALUE_ERROR (radix_value))
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  int32_t radix = ecma_number_to_int32 (radix_num);
+
+  /* 7.*/
+  bool strip_prefix = true;
+
+  /* 8. */
+  if (radix != 0)
+  {
+    /* 8.a */
+    if (radix < 2 || radix > 36)
+    {
+      return ecma_make_nan_value ();
+    }
+    /* 8.b */
+    else if (radix != 16)
+    {
+      strip_prefix = false;
+    }
+  }
+  /* 9. */
+  else
+  {
+    radix = 10;
+  }
+
+  /* 10. */
+  if (strip_prefix && ((str_end_p - str_p) >= 2) && (str_p[0] == LIT_CHAR_0)
+      && (LEXER_TO_ASCII_LOWERCASE (str_p[1]) == LIT_CHAR_LOWERCASE_X))
+  {
+    str_p += 2;
+    radix = 16;
+  }
+
+  ecma_number_t value = ECMA_NUMBER_ZERO;
+  const lit_utf8_byte_t *digit_start_p = str_p;
+
+  /* 11. Check if characters are in [0, Radix - 1]. We also convert them to number values in the process. */
+  while (str_p < str_end_p)
+  {
+    ecma_char_t ch = *str_p;
+
+    int32_t digit = 0;
+
+    if (lit_char_is_decimal_digit (ch))
+    {
+      digit = ch - LIT_CHAR_0;
+    }
+    else if (LEXER_TO_ASCII_LOWERCASE (ch) >= LIT_CHAR_LOWERCASE_A
+             && LEXER_TO_ASCII_LOWERCASE (ch) <= LIT_CHAR_LOWERCASE_Z)
+    {
+      digit = LEXER_TO_ASCII_LOWERCASE (ch) - LIT_CHAR_LOWERCASE_A + 10;
+    }
+    else
+    {
+      /* Not a valid digit char, set to invalid value */
+      digit = radix;
+    }
+
+    if (digit >= radix)
+    {
+      break;
+    }
+
+    value *= radix;
+    value += digit;
+
+    str_p++;
+  }
+
+  /* 12. */
+  if (str_p == digit_start_p)
+  {
+    return ecma_make_nan_value ();
+  }
+
+  /* 15. */
+  if (sign)
+  {
+    value *= ECMA_NUMBER_MINUS_ONE;
+  }
+
+  return ecma_make_number_value (value);
+} /* ecma_number_parse_int */
+
+/**
+ * The Number object's 'parseFloat' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.1.2.2
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_number_parse_float (const lit_utf8_byte_t *str_p, /**< routine's first argument's
+                                                        *   string buffer */
+                         lit_utf8_size_t str_size) /**< routine's first argument's
+                                                    *   string buffer's size */
+{
+  /* 2. Remove leading whitespace. */
+  ecma_string_trim_helper (&str_p, &str_size);
+
+  const lit_utf8_byte_t *str_end_p = str_p + str_size;
+  bool sign = false;
+
+  if (str_size == 0)
+  {
+    return ecma_make_nan_value ();
+  }
+
+  if (*str_p == LIT_CHAR_PLUS)
+  {
+    str_p++;
+  }
+  else if (*str_p == LIT_CHAR_MINUS)
+  {
+    sign = true;
+    str_p++;
+  }
+
+  /* Check if string is equal to "Infinity". */
+  const lit_utf8_byte_t *infinity_str_p = lit_get_magic_string_utf8 (LIT_MAGIC_STRING_INFINITY_UL);
+  const lit_utf8_size_t infinity_length = lit_get_magic_string_size (LIT_MAGIC_STRING_INFINITY_UL);
+
+  /* The input string should be at least the length of "Infinity" to be correctly processed as
+   * the infinity value.
+   */
+  if ((lit_utf8_size_t) (str_end_p - str_p) >= infinity_length && memcmp (infinity_str_p, str_p, infinity_length) == 0)
+  {
+    return ecma_make_number_value (ecma_number_make_infinity (sign));
+  }
+
+  const lit_utf8_byte_t *num_start_p = str_p;
+  const lit_utf8_byte_t *num_end_p = str_p;
+
+  while (str_p < str_end_p && lit_char_is_decimal_digit (*str_p))
+  {
+    str_p++;
+  }
+
+  if (str_p < str_end_p && *str_p == LIT_CHAR_DOT)
+  {
+    str_p++;
+
+    while (str_p < str_end_p && lit_char_is_decimal_digit (*str_p))
+    {
+      str_p++;
+    }
+  }
+
+  num_end_p = str_p;
+
+  if (str_p < str_end_p && LEXER_TO_ASCII_LOWERCASE (*str_p) == LIT_CHAR_LOWERCASE_E)
+  {
+    str_p++;
+
+    if (str_p < str_end_p && (*str_p == LIT_CHAR_PLUS || *str_p == LIT_CHAR_MINUS))
+    {
+      str_p++;
+    }
+
+    if (str_p < str_end_p && lit_char_is_decimal_digit (*str_p))
+    {
+      str_p++;
+
+      while (str_p < str_end_p && lit_char_is_decimal_digit (*str_p))
+      {
+        str_p++;
+      }
+
+      num_end_p = str_p;
+    }
+  }
+
+  lit_utf8_size_t num_size = (lit_utf8_size_t) (num_end_p - num_start_p);
+
+  if (num_size == 0)
+  {
+    return ecma_make_nan_value ();
+  }
+
+  /* 5. */
+  ecma_number_t ret_num = ecma_utf8_string_to_number (num_start_p, num_size, 0);
+
+  if (sign)
+  {
+    ret_num *= ECMA_NUMBER_MINUS_ONE;
+  }
+
+  return ecma_make_number_value (ret_num);
+} /* ecma_number_parse_float */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-helpers-number.h

@@ -0,0 +1,245 @@
+/* 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.
+ */
+
+#ifndef ECMA_HELPERS_NUMBER_H
+#define ECMA_HELPERS_NUMBER_H
+
+#include "ecma-globals.h"
+
+#include "jerry-config.h"
+
+/**
+ * Binary representation of an ecma-number
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+typedef uint64_t ecma_binary_num_t;
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+typedef uint32_t ecma_binary_num_t;
+#endif /* !JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Makes it possible to read/write the binary representation of an ecma_number_t
+ * without strict aliasing rule violation.
+ */
+typedef union
+{
+  ecma_number_t as_number; /**< ecma-number */
+  ecma_binary_num_t as_binary; /**< binary representation */
+} ecma_number_accessor_t;
+
+ecma_binary_num_t ecma_number_to_binary (ecma_number_t number);
+ecma_number_t ecma_number_from_binary (ecma_binary_num_t binary);
+
+bool ecma_number_sign (ecma_binary_num_t binary);
+uint32_t ecma_number_biased_exp (ecma_binary_num_t binary);
+uint64_t ecma_number_fraction (ecma_binary_num_t binary);
+ecma_number_t ecma_number_create (bool sign, uint32_t biased_exp, uint64_t fraction);
+
+/**
+ * Maximum number of significant decimal digits that an ecma-number can store
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_MAX_DIGITS (19)
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_MAX_DIGITS (9)
+#endif /* !JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Width of sign field
+ *
+ * See also:
+ *          IEEE-754 2008, 3.6, Table 3.5
+ */
+#define ECMA_NUMBER_SIGN_WIDTH (1)
+
+/**
+ * Width of biased exponent field
+ *
+ * See also:
+ *          IEEE-754 2008, 3.6, Table 3.5
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_BIASED_EXP_WIDTH (11)
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_BIASED_EXP_WIDTH (8)
+#endif /* !JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Exponent bias
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_EXPONENT_BIAS (1023)
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_EXPONENT_BIAS (127)
+#endif /* !JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Width of fraction field
+ *
+ * See also:
+ *          IEEE-754 2008, 3.6, Table 3.5
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_FRACTION_WIDTH (52)
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_FRACTION_WIDTH (23)
+#endif /* !JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Sign bit in ecma-numbers
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_SIGN_BIT 0x8000000000000000ull
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_SIGN_BIT 0x7f800000u
+#endif /* !JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Binary representation of an IEEE-754 QNaN value.
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_BINARY_QNAN 0x7ff8000000000000ull
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_BINARY_QNAN 0x7fc00000u
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Binary representation of an IEEE-754 Infinity value.
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_BINARY_INF 0x7ff0000000000000ull
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_BINARY_INF 0x7f800000u
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Binary representation of an IEEE-754 zero value.
+ */
+#define ECMA_NUMBER_BINARY_ZERO 0x0ull
+
+/**
+ * Number.MIN_VALUE (i.e., the smallest positive value of ecma-number)
+ *
+ * See also: ECMA_262 v5, 15.7.3.3
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_MIN_VALUE ((ecma_number_t) 5e-324)
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_MIN_VALUE (FLT_MIN)
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Number.MAX_VALUE (i.e., the maximum value of ecma-number)
+ *
+ * See also: ECMA_262 v5, 15.7.3.2
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_MAX_VALUE ((ecma_number_t) 1.7976931348623157e+308)
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_MAX_VALUE (FLT_MAX)
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Number.EPSILON
+ *
+ * See also: ECMA_262 v6, 20.1.2.1
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_EPSILON ((ecma_number_t) 2.2204460492503130808472633361816e-16)
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_EPSILON ((ecma_number_t) 1.1920928955078125e-7)
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Number.MAX_SAFE_INTEGER
+ *
+ * See also: ECMA_262 v6, 20.1.2.6
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_MAX_SAFE_INTEGER ((ecma_number_t) 0x1FFFFFFFFFFFFF)
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_MAX_SAFE_INTEGER ((ecma_number_t) 0xFFFFFF)
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Number.MIN_SAFE_INTEGER
+ *
+ * See also: ECMA_262 v6, 20.1.2.8
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define ECMA_NUMBER_MIN_SAFE_INTEGER ((ecma_number_t) -0x1FFFFFFFFFFFFF)
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define ECMA_NUMBER_MIN_SAFE_INTEGER ((ecma_number_t) -0xFFFFFF)
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Number.MAX_VALUE exponent part
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define NUMBER_MAX_DECIMAL_EXPONENT 308
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define NUMBER_MAX_DECIMAL_EXPONENT 38
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Number.MIN_VALUE exponent part
+ */
+#if JERRY_NUMBER_TYPE_FLOAT64
+#define NUMBER_MIN_DECIMAL_EXPONENT -324
+#else /* !JERRY_NUMBER_TYPE_FLOAT64 */
+#define NUMBER_MIN_DECIMAL_EXPONENT -45
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+
+/**
+ * Euler number
+ */
+#define ECMA_NUMBER_E ((ecma_number_t) 2.7182818284590452354)
+
+/**
+ * Natural logarithm of 10
+ */
+#define ECMA_NUMBER_LN10 ((ecma_number_t) 2.302585092994046)
+
+/**
+ * Natural logarithm of 2
+ */
+#define ECMA_NUMBER_LN2 ((ecma_number_t) 0.6931471805599453)
+
+/**
+ * Logarithm base 2 of the Euler number
+ */
+#define ECMA_NUMBER_LOG2E ((ecma_number_t) 1.4426950408889634)
+
+/**
+ * Logarithm base 10 of the Euler number
+ */
+#define ECMA_NUMBER_LOG10E ((ecma_number_t) 0.4342944819032518)
+
+/**
+ * Pi number
+ */
+#define ECMA_NUMBER_PI ((ecma_number_t) 3.1415926535897932)
+
+/**
+ * Square root of 0.5
+ */
+#define ECMA_NUMBER_SQRT_1_2 ((ecma_number_t) 0.7071067811865476)
+
+/**
+ * Square root of 2
+ */
+#define ECMA_NUMBER_SQRT2 ((ecma_number_t) 1.4142135623730951)
+
+#endif /* !ECMA_HELPERS_NUMBER_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-helpers.h

@@ -0,0 +1,524 @@
+/* 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.
+ */
+
+#ifndef ECMA_HELPERS_H
+#define ECMA_HELPERS_H
+
+#include "ecma-globals.h"
+
+#include "jmem.h"
+#include "lit-strings.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmahelpers Helpers for operations with ECMA data types
+ * @{
+ */
+
+/**
+ * Get value of pointer from specified non-null compressed pointer.
+ */
+#define ECMA_GET_NON_NULL_POINTER(type, field) JMEM_CP_GET_NON_NULL_POINTER (type, field)
+
+/**
+ * Extract value of pointer from specified pointer-tag value
+ */
+#define ECMA_GET_NON_NULL_POINTER_FROM_POINTER_TAG(type, field) \
+  JMEM_CP_GET_NON_NULL_POINTER_FROM_POINTER_TAG (type, field)
+
+/**
+ * Get value of pointer from specified compressed pointer.
+ */
+#define ECMA_GET_POINTER(type, field) JMEM_CP_GET_POINTER (type, field)
+
+/**
+ * Set value of non-null compressed pointer so that it will correspond
+ * to specified non_compressed_pointer.
+ */
+#define ECMA_SET_NON_NULL_POINTER(field, non_compressed_pointer) \
+  JMEM_CP_SET_NON_NULL_POINTER (field, non_compressed_pointer)
+
+/**
+ * Set value of pointer-tag value so that it will correspond
+ * to specified non_compressed_pointer along with tag
+ */
+#define ECMA_SET_NON_NULL_POINTER_TAG(field, non_compressed_pointer, tag) \
+  JMEM_CP_SET_NON_NULL_POINTER_TAG (field, non_compressed_pointer, tag)
+
+/**
+ * Set value of compressed pointer so that it will correspond
+ * to specified non_compressed_pointer.
+ */
+#define ECMA_SET_POINTER(field, non_compressed_pointer) JMEM_CP_SET_POINTER (field, non_compressed_pointer)
+
+/**
+ * Get value of each tag bit from specified pointer-tag value
+ */
+#define ECMA_GET_FIRST_BIT_FROM_POINTER_TAG(field) \
+  JMEM_CP_GET_FIRST_BIT_FROM_POINTER_TAG (field) /**< get first tag bit from jmem_cpointer_tag_t **/
+#define ECMA_GET_SECOND_BIT_FROM_POINTER_TAG(field) \
+  JMEM_CP_GET_SECOND_BIT_FROM_POINTER_TAG (field) /**< get second tag bit from jmem_cpointer_tag_t **/
+#define ECMA_GET_THIRD_BIT_FROM_POINTER_TAG(field) \
+  JMEM_CP_GET_THIRD_BIT_FROM_POINTER_TAG (field) /**< get third tag bit from jmem_cpointer_tag_t **/
+
+/**
+ * Set value of each tag bit to specified pointer-tag value
+ */
+#define ECMA_SET_FIRST_BIT_TO_POINTER_TAG(field) \
+  JMEM_CP_SET_FIRST_BIT_TO_POINTER_TAG (field) /**< set first tag bit to jmem_cpointer_tag_t **/
+#define ECMA_SET_SECOND_BIT_TO_POINTER_TAG(field) \
+  JMEM_CP_SET_SECOND_BIT_TO_POINTER_TAG (field) /**< set second tag bit to jmem_cpointer_tag_t **/
+#define ECMA_SET_THIRD_BIT_TO_POINTER_TAG(field) \
+  JMEM_CP_SET_THIRD_BIT_TO_POINTER_TAG (field) /**< set third tag bit to jmem_cpointer_tag_t **/
+
+/**
+ * Status flags for ecma_string_get_chars function
+ */
+typedef enum
+{
+  ECMA_STRING_FLAG_EMPTY = 0, /**< No options are provided. */
+  ECMA_STRING_FLAG_IS_ASCII = (1 << 0), /**< The string contains only ASCII characters. */
+  ECMA_STRING_FLAG_REHASH_NEEDED = (1 << 1), /**< The hash of the string must be recalculated.
+                                              *   For more details see ecma_append_chars_to_string */
+  ECMA_STRING_FLAG_IS_UINT32 = (1 << 2), /**< The string repesents an UINT32 number */
+  ECMA_STRING_FLAG_MUST_BE_FREED = (1 << 3), /**< The returned buffer must be freed */
+} ecma_string_flag_t;
+
+/**
+ * Underscore is ignored when this option is passed.
+ */
+#define ECMA_CONVERSION_ALLOW_UNDERSCORE 0x1
+
+/**
+ * Convert ecma-string's contents to a cesu-8 string and put it into a buffer.
+ */
+#define ECMA_STRING_TO_UTF8_STRING(ecma_str_ptr, /**< ecma string pointer */       \
+                                   utf8_ptr, /**< [out] output buffer pointer */   \
+                                   utf8_str_size) /**< [out] output buffer size */ \
+  lit_utf8_size_t utf8_str_size;                                                   \
+  uint8_t utf8_ptr##flags = ECMA_STRING_FLAG_EMPTY;                                \
+  const lit_utf8_byte_t *utf8_ptr = ecma_string_get_chars (ecma_str_ptr, &utf8_str_size, NULL, NULL, &utf8_ptr##flags);
+
+/**
+ * Free the cesu-8 string buffer allocated by 'ECMA_STRING_TO_UTF8_STRING'
+ */
+#define ECMA_FINALIZE_UTF8_STRING(utf8_ptr, /**< pointer to character buffer */ \
+                                  utf8_str_size) /**< buffer size */            \
+  if (utf8_ptr##flags & ECMA_STRING_FLAG_MUST_BE_FREED)                         \
+  {                                                                             \
+    JERRY_ASSERT (utf8_ptr != NULL);                                            \
+    jmem_heap_free_block ((void *) utf8_ptr, utf8_str_size);                    \
+  }
+
+#ifdef ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY
+
+/**
+ * Set an internal property value from pointer.
+ */
+#define ECMA_SET_INTERNAL_VALUE_POINTER(field, pointer) ((field) = ((ecma_value_t) pointer))
+
+/**
+ * Set an internal property value from pointer. Pointer can be NULL.
+ */
+#define ECMA_SET_INTERNAL_VALUE_ANY_POINTER(field, pointer) ((field) = ((ecma_value_t) pointer))
+
+/**
+ * Convert an internal property value to pointer.
+ */
+#define ECMA_GET_INTERNAL_VALUE_POINTER(type, field) ((type *) field)
+
+/**
+ * Convert an internal property value to pointer. Result can be NULL.
+ */
+#define ECMA_GET_INTERNAL_VALUE_ANY_POINTER(type, field) ((type *) field)
+
+/**
+ * Checks whether an internal property is NULL.
+ */
+#define ECMA_IS_INTERNAL_VALUE_NULL(field) ((field) == ((ecma_value_t) NULL))
+
+#else /* !ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY */
+
+/**
+ * Set an internal property value from pointer.
+ */
+#define ECMA_SET_INTERNAL_VALUE_POINTER(field, pointer)     ECMA_SET_NON_NULL_POINTER (field, pointer)
+
+/**
+ * Set an internal property value from pointer. Pointer can be NULL.
+ */
+#define ECMA_SET_INTERNAL_VALUE_ANY_POINTER(field, pointer) ECMA_SET_POINTER (field, pointer)
+
+/**
+ * Convert an internal property value to pointer.
+ */
+#define ECMA_GET_INTERNAL_VALUE_POINTER(type, field)        ECMA_GET_NON_NULL_POINTER (type, field)
+
+/**
+ * Convert an internal property value to pointer. Result can be NULL.
+ */
+#define ECMA_GET_INTERNAL_VALUE_ANY_POINTER(type, field)    ECMA_GET_POINTER (type, field)
+
+/**
+ * Checks whether an internal property is NULL.
+ */
+#define ECMA_IS_INTERNAL_VALUE_NULL(field)                  ((field) == ((ecma_value_t) JMEM_CP_NULL))
+
+#endif /* ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY */
+
+/**
+ * Convert boolean to bitfield value.
+ */
+#define ECMA_BOOL_TO_BITFIELD(x) ((x) ? 1 : 0)
+
+/**
+ * Check whether the given type is ECMA_OBJECT_TYPE_PROXY
+ *
+ * @param type object type
+ */
+#define ECMA_OBJECT_TYPE_IS_PROXY(type) (JERRY_UNLIKELY ((type) == ECMA_OBJECT_TYPE_PROXY))
+
+/**
+ * Check whether the given object has [[ProxyHandler]] and [[ProxyTarger]] internal slots
+ *
+ * @param obj_p ecma-object
+ */
+#if JERRY_BUILTIN_PROXY
+#define ECMA_OBJECT_IS_PROXY(obj_p) (ECMA_OBJECT_TYPE_IS_PROXY (ecma_get_object_type ((obj_p))))
+#else /* !JERRY_BUILTIN_PROXY */
+#define ECMA_OBJECT_IS_PROXY(obj_p) (false)
+#endif /* JERRY_BUILTIN_PROXY */
+
+/* ecma-helpers-value.c */
+ecma_type_t JERRY_ATTR_CONST ecma_get_value_type_field (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_direct (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_simple (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_empty (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_undefined (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_null (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_boolean (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_true (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_false (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_found (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_array_hole (ecma_value_t value);
+
+bool JERRY_ATTR_CONST ecma_is_value_integer_number (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_are_values_integer_numbers (ecma_value_t first_value, ecma_value_t second_value);
+bool JERRY_ATTR_CONST ecma_is_value_float_number (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_number (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_string (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_symbol (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_magic_string (ecma_value_t value, lit_magic_string_id_t id);
+bool JERRY_ATTR_CONST ecma_is_value_bigint (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_prop_name (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_direct_string (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_non_direct_string (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_object (ecma_value_t value);
+bool JERRY_ATTR_CONST ecma_is_value_exception (ecma_value_t value);
+ecma_value_t ecma_is_value_array (ecma_value_t arg);
+
+void ecma_check_value_type_is_spec_defined (ecma_value_t value);
+
+ecma_value_t JERRY_ATTR_CONST ecma_make_boolean_value (bool boolean_value);
+ecma_value_t JERRY_ATTR_CONST ecma_make_integer_value (ecma_integer_value_t integer_value);
+ecma_value_t ecma_make_nan_value (void);
+ecma_value_t ecma_make_float_value (ecma_number_t *ecma_num_p);
+ecma_value_t ecma_make_length_value (ecma_length_t length);
+ecma_value_t ecma_make_number_value (ecma_number_t ecma_number);
+ecma_value_t ecma_make_int32_value (int32_t int32_number);
+ecma_value_t ecma_make_uint32_value (uint32_t uint32_number);
+ecma_value_t JERRY_ATTR_PURE ecma_make_string_value (const ecma_string_t *ecma_string_p);
+ecma_value_t JERRY_ATTR_PURE ecma_make_symbol_value (const ecma_string_t *ecma_symbol_p);
+ecma_value_t JERRY_ATTR_PURE ecma_make_prop_name_value (const ecma_string_t *ecma_prop_name_p);
+ecma_value_t JERRY_ATTR_PURE ecma_make_magic_string_value (lit_magic_string_id_t id);
+ecma_value_t JERRY_ATTR_PURE ecma_make_object_value (const ecma_object_t *object_p);
+ecma_value_t JERRY_ATTR_PURE ecma_make_extended_primitive_value (const ecma_extended_primitive_t *primitve_p,
+                                                                 uint32_t type);
+ecma_integer_value_t JERRY_ATTR_CONST ecma_get_integer_from_value (ecma_value_t value);
+ecma_number_t JERRY_ATTR_PURE ecma_get_float_from_value (ecma_value_t value);
+ecma_number_t *ecma_get_pointer_from_float_value (ecma_value_t value);
+ecma_number_t JERRY_ATTR_PURE ecma_get_number_from_value (ecma_value_t value);
+ecma_string_t JERRY_ATTR_PURE *ecma_get_string_from_value (ecma_value_t value);
+ecma_string_t JERRY_ATTR_PURE *ecma_get_symbol_from_value (ecma_value_t value);
+ecma_string_t JERRY_ATTR_PURE *ecma_get_prop_name_from_value (ecma_value_t value);
+ecma_object_t JERRY_ATTR_PURE *ecma_get_object_from_value (ecma_value_t value);
+ecma_extended_primitive_t JERRY_ATTR_PURE *ecma_get_extended_primitive_from_value (ecma_value_t value);
+ecma_value_t JERRY_ATTR_CONST ecma_invert_boolean_value (ecma_value_t value);
+ecma_value_t ecma_copy_value (ecma_value_t value);
+ecma_value_t ecma_fast_copy_value (ecma_value_t value);
+ecma_value_t ecma_copy_value_if_not_object (ecma_value_t value);
+void ecma_ref_if_object (ecma_value_t value);
+void ecma_deref_if_object (ecma_value_t value);
+ecma_value_t ecma_update_float_number (ecma_value_t float_value, ecma_number_t new_number);
+void ecma_value_assign_value (ecma_value_t *value_p, ecma_value_t ecma_value);
+void ecma_value_assign_number (ecma_value_t *value_p, ecma_number_t ecma_number);
+void ecma_free_value (ecma_value_t value);
+void ecma_fast_free_value (ecma_value_t value);
+void ecma_free_value_if_not_object (ecma_value_t value);
+void ecma_free_object (ecma_value_t value);
+void ecma_free_number (ecma_value_t value);
+lit_magic_string_id_t ecma_get_typeof_lit_id (ecma_value_t value);
+
+/* ecma-helpers-string.c */
+ecma_string_t *ecma_new_symbol_from_descriptor_string (ecma_value_t string_desc);
+bool ecma_prop_name_is_symbol (ecma_string_t *string_p);
+ecma_length_t ecma_op_advance_string_index (ecma_string_t *str_p, ecma_length_t index_num, bool is_unicode);
+#if JERRY_BUILTIN_CONTAINER
+ecma_string_t *ecma_new_map_key_string (ecma_value_t value);
+bool ecma_prop_name_is_map_key (ecma_string_t *string_p);
+#endif /* JERRY_BUILTIN_CONTAINER */
+ecma_string_t *ecma_new_ecma_string_from_ascii (const lit_utf8_byte_t *string_p, lit_utf8_size_t string_size);
+ecma_string_t *ecma_new_ecma_string_from_utf8 (const lit_utf8_byte_t *string_p, lit_utf8_size_t string_size);
+ecma_string_t *ecma_new_ecma_string_from_utf8_converted_to_cesu8 (const lit_utf8_byte_t *string_p,
+                                                                  lit_utf8_size_t string_size);
+ecma_string_t *
+ecma_new_ecma_external_string_from_cesu8 (const lit_utf8_byte_t *string_p, lit_utf8_size_t string_size, void *user_p);
+ecma_string_t *ecma_new_ecma_string_from_code_unit (ecma_char_t code_unit);
+ecma_string_t *ecma_new_ecma_string_from_code_units (ecma_char_t first_code_unit, ecma_char_t second_code_unit);
+ecma_string_t *ecma_new_ecma_string_from_length (ecma_length_t index);
+ecma_string_t *ecma_new_ecma_string_from_uint32 (uint32_t uint32_number);
+ecma_string_t *ecma_new_non_direct_string_from_uint32 (uint32_t uint32_number);
+ecma_string_t *ecma_get_ecma_string_from_uint32 (uint32_t uint32_number);
+ecma_string_t *ecma_new_ecma_string_from_number (ecma_number_t num);
+ecma_string_t *ecma_get_magic_string (lit_magic_string_id_t id);
+ecma_string_t *ecma_get_internal_string (lit_magic_string_id_t id);
+ecma_string_t *ecma_append_chars_to_string (ecma_string_t *string1_p,
+                                            const lit_utf8_byte_t *cesu8_string2_p,
+                                            lit_utf8_size_t cesu8_string2_size,
+                                            lit_utf8_size_t cesu8_string2_length);
+ecma_string_t *ecma_concat_ecma_strings (ecma_string_t *string1_p, ecma_string_t *string2_p);
+void ecma_ref_ecma_string (ecma_string_t *string_p);
+void ecma_ref_ecma_string_non_direct (ecma_string_t *string_p);
+void ecma_deref_ecma_string (ecma_string_t *string_p);
+void ecma_deref_ecma_string_non_direct (ecma_string_t *string_p);
+void ecma_destroy_ecma_string (ecma_string_t *string_p);
+ecma_number_t ecma_string_to_number (const ecma_string_t *str_p);
+uint32_t ecma_string_get_array_index (const ecma_string_t *str_p);
+
+lit_utf8_size_t JERRY_ATTR_WARN_UNUSED_RESULT ecma_string_copy_to_buffer (const ecma_string_t *string_desc_p,
+                                                                          lit_utf8_byte_t *buffer_p,
+                                                                          lit_utf8_size_t buffer_size,
+                                                                          jerry_encoding_t encoding);
+void
+ecma_string_to_cesu8_bytes (const ecma_string_t *string_desc_p, lit_utf8_byte_t *buffer_p, lit_utf8_size_t buffer_size);
+const lit_utf8_byte_t *ecma_string_get_chars (const ecma_string_t *string_p,
+                                              lit_utf8_size_t *size_p,
+                                              lit_utf8_size_t *length_p,
+                                              lit_utf8_byte_t *uint32_buff_p,
+                                              uint8_t *flags_p);
+bool ecma_compare_ecma_string_to_magic_id (const ecma_string_t *string_p, lit_magic_string_id_t id);
+bool ecma_string_is_empty (const ecma_string_t *string_p);
+bool ecma_string_is_length (const ecma_string_t *string_p);
+
+jmem_cpointer_t ecma_string_to_property_name (ecma_string_t *prop_name_p, ecma_property_t *name_type_p);
+ecma_string_t *ecma_string_from_property_name (ecma_property_t property, jmem_cpointer_t prop_name_cp);
+lit_string_hash_t ecma_string_get_property_name_hash (ecma_property_t property, jmem_cpointer_t prop_name_cp);
+uint32_t ecma_string_get_property_index (ecma_property_t property, jmem_cpointer_t prop_name_cp);
+bool ecma_string_compare_to_property_name (ecma_property_t property,
+                                           jmem_cpointer_t prop_name_cp,
+                                           const ecma_string_t *string_p);
+
+bool ecma_compare_ecma_strings (const ecma_string_t *string1_p, const ecma_string_t *string2_p);
+bool ecma_compare_ecma_non_direct_strings (const ecma_string_t *string1_p, const ecma_string_t *string2_p);
+bool ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, const ecma_string_t *string2_p);
+lit_utf8_size_t ecma_string_get_length (const ecma_string_t *string_p);
+lit_utf8_size_t ecma_string_get_utf8_length (const ecma_string_t *string_p);
+lit_utf8_size_t ecma_string_get_size (const ecma_string_t *string_p);
+lit_utf8_size_t ecma_string_get_utf8_size (const ecma_string_t *string_p);
+ecma_char_t ecma_string_get_char_at_pos (const ecma_string_t *string_p, lit_utf8_size_t index);
+
+lit_magic_string_id_t ecma_get_string_magic (const ecma_string_t *string_p);
+
+lit_string_hash_t ecma_string_hash (const ecma_string_t *string_p);
+ecma_string_t *ecma_string_substr (const ecma_string_t *string_p, lit_utf8_size_t start_pos, lit_utf8_size_t end_pos);
+const lit_utf8_byte_t *ecma_string_trim_front (const lit_utf8_byte_t *start_p, const lit_utf8_byte_t *end_p);
+const lit_utf8_byte_t *ecma_string_trim_back (const lit_utf8_byte_t *start_p, const lit_utf8_byte_t *end_p);
+void ecma_string_trim_helper (const lit_utf8_byte_t **utf8_str_p, lit_utf8_size_t *utf8_str_size);
+ecma_string_t *ecma_string_trim (const ecma_string_t *string_p);
+ecma_value_t
+ecma_string_pad (ecma_value_t original_string_p, ecma_value_t max_length, ecma_value_t fill_string, bool pad_on_start);
+
+ecma_stringbuilder_t ecma_stringbuilder_create (void);
+ecma_stringbuilder_t ecma_stringbuilder_create_from (ecma_string_t *string_p);
+ecma_stringbuilder_t ecma_stringbuilder_create_raw (const lit_utf8_byte_t *data_p, const lit_utf8_size_t data_size);
+lit_utf8_size_t ecma_stringbuilder_get_size (ecma_stringbuilder_t *builder_p);
+lit_utf8_byte_t *ecma_stringbuilder_get_data (ecma_stringbuilder_t *builder_p);
+void ecma_stringbuilder_revert (ecma_stringbuilder_t *builder_p, const lit_utf8_size_t size);
+void ecma_stringbuilder_append (ecma_stringbuilder_t *builder_p, const ecma_string_t *string_p);
+void ecma_stringbuilder_append_magic (ecma_stringbuilder_t *builder_p, const lit_magic_string_id_t id);
+void ecma_stringbuilder_append_raw (ecma_stringbuilder_t *builder_p,
+                                    const lit_utf8_byte_t *data_p,
+                                    const lit_utf8_size_t data_size);
+void ecma_stringbuilder_append_codepoint (ecma_stringbuilder_t *builder_p, lit_code_point_t cp);
+void ecma_stringbuilder_append_char (ecma_stringbuilder_t *builder_p, const ecma_char_t c);
+void ecma_stringbuilder_append_byte (ecma_stringbuilder_t *builder_p, const lit_utf8_byte_t);
+ecma_string_t *ecma_stringbuilder_finalize (ecma_stringbuilder_t *builder_p);
+void ecma_stringbuilder_destroy (ecma_stringbuilder_t *builder_p);
+
+/* ecma-helpers-number.c */
+ecma_number_t ecma_number_make_nan (void);
+ecma_number_t ecma_number_make_infinity (bool sign);
+bool ecma_number_is_nan (ecma_number_t num);
+bool ecma_number_is_negative (ecma_number_t num);
+bool ecma_number_is_zero (ecma_number_t num);
+bool ecma_number_is_infinity (ecma_number_t num);
+bool ecma_number_is_finite (ecma_number_t num);
+ecma_number_t ecma_number_get_prev (ecma_number_t num);
+ecma_number_t ecma_number_get_next (ecma_number_t num);
+ecma_number_t ecma_number_trunc (ecma_number_t num);
+ecma_number_t ecma_number_remainder (ecma_number_t left_num, ecma_number_t right_num);
+ecma_number_t ecma_number_pow (ecma_number_t x, ecma_number_t y);
+ecma_value_t
+ecma_number_parse_int (const lit_utf8_byte_t *string_buff, lit_utf8_size_t string_buff_size, ecma_value_t radix);
+ecma_value_t ecma_number_parse_float (const lit_utf8_byte_t *string_buff, lit_utf8_size_t string_buff_size);
+ecma_value_t ecma_integer_multiply (ecma_integer_value_t left_integer, ecma_integer_value_t right_integer);
+lit_utf8_size_t ecma_number_to_decimal (ecma_number_t num, lit_utf8_byte_t *out_digits_p, int32_t *out_decimal_exp_p);
+
+/* ecma-helpers-collection.c */
+ecma_collection_t *ecma_new_collection (void);
+void ecma_collection_push_back (ecma_collection_t *collection_p, ecma_value_t value);
+void ecma_collection_reserve (ecma_collection_t *collection_p, uint32_t count);
+void ecma_collection_append (ecma_collection_t *collection_p, const ecma_value_t *buffer_p, uint32_t count);
+void ecma_collection_destroy (ecma_collection_t *collection_p);
+void ecma_collection_free (ecma_collection_t *collection_p);
+void ecma_collection_free_if_not_object (ecma_collection_t *collection_p);
+void ecma_collection_free_objects (ecma_collection_t *collection_p);
+void ecma_collection_free_template_literal (ecma_collection_t *collection_p);
+bool ecma_collection_check_duplicated_entries (ecma_collection_t *collection_p);
+bool ecma_collection_has_string_value (ecma_collection_t *collection_p, ecma_string_t *string_p);
+
+ecma_value_t *ecma_new_compact_collection (void);
+ecma_value_t *ecma_compact_collection_push_back (ecma_value_t *compact_collection_p, ecma_value_t value);
+ecma_value_t *ecma_compact_collection_shrink (ecma_value_t *compact_collection_p);
+void ecma_compact_collection_free (ecma_value_t *compact_collection_p);
+ecma_value_t *ecma_compact_collection_end (ecma_value_t *compact_collection_p);
+void ecma_compact_collection_destroy (ecma_value_t *compact_collection_p);
+
+/* ecma-helpers.c */
+ecma_object_t *ecma_create_object (ecma_object_t *prototype_object_p, size_t ext_object_size, ecma_object_type_t type);
+ecma_object_t *ecma_create_decl_lex_env (ecma_object_t *outer_lexical_environment_p);
+ecma_object_t *ecma_create_object_lex_env (ecma_object_t *outer_lexical_environment_p, ecma_object_t *binding_obj_p);
+ecma_object_t *ecma_create_lex_env_class (ecma_object_t *outer_lexical_environment_p, size_t lexical_env_size);
+bool JERRY_ATTR_PURE ecma_is_lexical_environment (const ecma_object_t *object_p);
+void ecma_op_ordinary_object_set_extensible (ecma_object_t *object_p);
+ecma_object_type_t JERRY_ATTR_PURE ecma_get_object_type (const ecma_object_t *object_p);
+ecma_object_base_type_t JERRY_ATTR_PURE ecma_get_object_base_type (const ecma_object_t *object_p);
+bool JERRY_ATTR_PURE ecma_object_class_is (ecma_object_t *object_p, ecma_object_class_type_t class_id);
+ecma_lexical_environment_type_t JERRY_ATTR_PURE ecma_get_lex_env_type (const ecma_object_t *object_p);
+ecma_object_t JERRY_ATTR_PURE *ecma_get_lex_env_binding_object (const ecma_object_t *object_p);
+ecma_object_t *ecma_clone_decl_lexical_environment (ecma_object_t *lex_env_p, bool copy_values);
+
+ecma_property_value_t *ecma_create_named_data_property (ecma_object_t *object_p,
+                                                        ecma_string_t *name_p,
+                                                        uint8_t prop_attributes,
+                                                        ecma_property_t **out_prop_p);
+ecma_property_value_t *ecma_create_named_accessor_property (ecma_object_t *object_p,
+                                                            ecma_string_t *name_p,
+                                                            ecma_object_t *get_p,
+                                                            ecma_object_t *set_p,
+                                                            uint8_t prop_attributes,
+                                                            ecma_property_t **out_prop_p);
+#if JERRY_MODULE_SYSTEM
+void ecma_create_named_reference_property (ecma_object_t *object_p, ecma_string_t *name_p, ecma_value_t reference);
+#endif /* JERRY_MODULE_SYSTEM */
+ecma_property_t *ecma_find_named_property (ecma_object_t *obj_p, ecma_string_t *name_p);
+ecma_property_value_t *ecma_get_named_data_property (ecma_object_t *obj_p, ecma_string_t *name_p);
+
+void ecma_delete_property (ecma_object_t *object_p, ecma_property_value_t *prop_value_p);
+
+void
+ecma_named_data_property_assign_value (ecma_object_t *obj_p, ecma_property_value_t *prop_value_p, ecma_value_t value);
+
+ecma_getter_setter_pointers_t *ecma_get_named_accessor_property (const ecma_property_value_t *prop_value_p);
+void ecma_set_named_accessor_property_getter (ecma_object_t *object_p,
+                                              ecma_property_value_t *prop_value_p,
+                                              ecma_object_t *getter_p);
+void ecma_set_named_accessor_property_setter (ecma_object_t *object_p,
+                                              ecma_property_value_t *prop_value_p,
+                                              ecma_object_t *setter_p);
+#if JERRY_MODULE_SYSTEM
+ecma_value_t ecma_property_to_reference (ecma_property_t *property_p);
+ecma_property_value_t *ecma_get_property_value_from_named_reference (ecma_property_value_t *reference_p);
+#endif /* JERRY_MODULE_SYSTEM */
+bool ecma_is_property_writable (ecma_property_t property);
+void ecma_set_property_writable_attr (ecma_property_t *property_p, bool is_writable);
+bool ecma_is_property_enumerable (ecma_property_t property);
+void ecma_set_property_enumerable_attr (ecma_property_t *property_p, bool is_enumerable);
+bool ecma_is_property_configurable (ecma_property_t property);
+void ecma_set_property_configurable_attr (ecma_property_t *property_p, bool is_configurable);
+
+#if JERRY_LCACHE
+bool ecma_is_property_lcached (ecma_property_t *property_p);
+void ecma_set_property_lcached (ecma_property_t *property_p, bool is_lcached);
+#endif /* JERRY_LCACHE */
+
+ecma_property_descriptor_t ecma_make_empty_property_descriptor (void);
+void ecma_free_property_descriptor (ecma_property_descriptor_t *prop_desc_p);
+
+void ecma_ref_extended_primitive (ecma_extended_primitive_t *primitve_p);
+void ecma_deref_exception (ecma_extended_primitive_t *exception_p);
+#if JERRY_BUILTIN_BIGINT
+void ecma_deref_bigint (ecma_extended_primitive_t *bigint_p);
+#endif /* JERRY_BUILTIN_BIGINT */
+
+ecma_value_t ecma_create_exception (ecma_value_t value, uint32_t options);
+ecma_value_t ecma_create_exception_from_context (void);
+ecma_value_t ecma_create_exception_from_object (ecma_object_t *object_p);
+void ecma_throw_exception (ecma_value_t value);
+
+void ecma_script_deref (ecma_value_t script_value);
+void ecma_bytecode_ref (ecma_compiled_code_t *bytecode_p);
+void ecma_bytecode_deref (ecma_compiled_code_t *bytecode_p);
+ecma_value_t ecma_script_get_from_value (ecma_value_t value);
+ecma_value_t *ecma_compiled_code_resolve_arguments_start (const ecma_compiled_code_t *bytecode_header_p);
+ecma_value_t *ecma_compiled_code_resolve_function_name (const ecma_compiled_code_t *bytecode_header_p);
+ecma_collection_t *ecma_compiled_code_get_tagged_template_collection (const ecma_compiled_code_t *bytecode_header_p);
+#if JERRY_LINE_INFO
+uint8_t *ecma_compiled_code_get_line_info (const ecma_compiled_code_t *bytecode_header_p);
+#endif /* JERRY_LINE_INFO */
+ecma_value_t ecma_get_source_name (const ecma_compiled_code_t *bytecode_p);
+#if (JERRY_STACK_LIMIT != 0)
+uintptr_t ecma_get_current_stack_usage (void);
+#endif /* (JERRY_STACK_LIMIT != 0) */
+
+/* ecma-helpers-external-pointers.c */
+bool ecma_create_native_pointer_property (ecma_object_t *obj_p,
+                                          void *native_p,
+                                          const jerry_object_native_info_t *native_info_p);
+ecma_native_pointer_t *ecma_get_native_pointer_value (ecma_object_t *obj_p,
+                                                      const jerry_object_native_info_t *native_info_p);
+bool ecma_delete_native_pointer_property (ecma_object_t *obj_p, const jerry_object_native_info_t *native_info_p);
+
+/* ecma-helpers-conversion.c */
+ecma_number_t ecma_utf8_string_to_number (const lit_utf8_byte_t *str_p, lit_utf8_size_t str_size, uint32_t option);
+ecma_number_t ecma_utf8_string_to_number_by_radix (const lit_utf8_byte_t *str_p,
+                                                   lit_utf8_size_t str_size,
+                                                   uint32_t radix,
+                                                   uint32_t option);
+lit_utf8_size_t ecma_uint32_to_utf8_string (uint32_t value, lit_utf8_byte_t *out_buffer_p, lit_utf8_size_t buffer_size);
+uint32_t ecma_number_to_uint32 (ecma_number_t num);
+int32_t ecma_number_to_int32 (ecma_number_t num);
+lit_utf8_size_t ecma_number_to_utf8_string (ecma_number_t num, lit_utf8_byte_t *buffer_p, lit_utf8_size_t buffer_size);
+
+/* ecma-helpers-errol.c */
+lit_utf8_size_t ecma_errol0_dtoa (double val, lit_utf8_byte_t *buffer_p, int32_t *exp_p);
+
+/**
+ * @}
+ * @}
+ */
+
+#endif /* !ECMA_HELPERS_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-init-finalize.cpp

@@ -0,0 +1,106 @@
+/* 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.
+ */
+
+#include "ecma-init-finalize.h"
+
+#include "ecma-builtins.h"
+#include "ecma-gc.h"
+#include "ecma-helpers.h"
+#include "ecma-lex-env.h"
+#include "ecma-literal-storage.h"
+
+#include "jcontext.h"
+#include "jmem.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmainitfinalize Initialization and finalization of ECMA components
+ * @{
+ */
+
+/**
+ * Maximum number of GC loops on cleanup.
+ */
+#define JERRY_GC_LOOP_LIMIT 100
+
+/**
+ * Initialize ECMA components
+ */
+void
+ecma_init (void)
+{
+#if (JERRY_GC_MARK_LIMIT != 0)
+  JERRY_CONTEXT (ecma_gc_mark_recursion_limit) = JERRY_GC_MARK_LIMIT;
+#endif /* (JERRY_GC_MARK_LIMIT != 0) */
+
+  ecma_init_global_environment ();
+
+#if JERRY_PROPERTY_HASHMAP
+  JERRY_CONTEXT (ecma_prop_hashmap_alloc_state) = ECMA_PROP_HASHMAP_ALLOC_ON;
+  JERRY_CONTEXT (status_flags) &= (uint32_t) ~ECMA_STATUS_HIGH_PRESSURE_GC;
+#endif /* JERRY_PROPERTY_HASHMAP */
+
+#if (JERRY_STACK_LIMIT != 0)
+  volatile int sp;
+  JERRY_CONTEXT (stack_base) = (uintptr_t) &sp;
+#endif /* (JERRY_STACK_LIMIT != 0) */
+
+  ecma_job_queue_init ();
+
+  JERRY_CONTEXT (current_new_target_p) = NULL;
+
+#if JERRY_BUILTIN_TYPEDARRAY
+  JERRY_CONTEXT (arraybuffer_compact_allocation_limit) = 256;
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+} /* ecma_init */
+
+/**
+ * Finalize ECMA components
+ */
+void
+ecma_finalize (void)
+{
+  JERRY_ASSERT (JERRY_CONTEXT (current_new_target_p) == NULL);
+
+  ecma_finalize_global_environment ();
+  uint8_t runs = 0;
+
+  do
+  {
+    ecma_gc_run ();
+    if (++runs >= JERRY_GC_LOOP_LIMIT)
+    {
+      jerry_fatal (JERRY_FATAL_UNTERMINATED_GC_LOOPS);
+    }
+  } while (JERRY_CONTEXT (ecma_gc_new_objects) != 0);
+
+  jmem_cpointer_t *global_symbols_cp = JERRY_CONTEXT (global_symbols_cp);
+
+  for (uint32_t i = 0; i < ECMA_BUILTIN_GLOBAL_SYMBOL_COUNT; i++)
+  {
+    if (global_symbols_cp[i] != JMEM_CP_NULL)
+    {
+      ecma_deref_ecma_string (ECMA_GET_NON_NULL_POINTER (ecma_string_t, global_symbols_cp[i]));
+    }
+  }
+
+  ecma_finalize_lit_storage ();
+} /* ecma_finalize */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-init-finalize.h

@@ -0,0 +1,34 @@
+/* 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.
+ */
+
+#ifndef ECMA_INIT_FINALIZE_H
+#define ECMA_INIT_FINALIZE_H
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmainitfinalize Initialization and finalization of ECMA components
+ * @{
+ */
+
+void ecma_init (void);
+void ecma_finalize (void);
+
+/**
+ * @}
+ * @}
+ */
+
+#endif /* !ECMA_INIT_FINALIZE_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-lcache.cpp

@@ -0,0 +1,221 @@
+/* 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.
+ */
+
+#include "ecma-lcache.h"
+
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+
+#include "jcontext.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmalcache Property lookup cache
+ * @{
+ */
+
+#if JERRY_LCACHE
+
+/**
+ * Bitshift index for calculating hash.
+ */
+#if JERRY_CPOINTER_32_BIT
+#define ECMA_LCACHE_HASH_BITSHIFT_INDEX (2 * JMEM_ALIGNMENT_LOG)
+#else /* !JERRY_CPOINTER_32_BIT */
+#define ECMA_LCACHE_HASH_BITSHIFT_INDEX 0
+#endif /* JERRY_CPOINTER_32_BIT */
+
+/**
+ * Mask for hash bits
+ */
+#define ECMA_LCACHE_HASH_MASK ((ECMA_LCACHE_HASH_ROWS_COUNT - 1) << ECMA_LCACHE_HASH_BITSHIFT_INDEX)
+
+/**
+ * Bitshift index for creating property identifier
+ */
+#define ECMA_LCACHE_HASH_ENTRY_ID_SHIFT (8 * sizeof (jmem_cpointer_t))
+
+/**
+ * Create property identifier
+ */
+#define ECMA_LCACHE_CREATE_ID(object_cp, name_cp) \
+  (((ecma_lcache_hash_entry_id_t) (object_cp) << ECMA_LCACHE_HASH_ENTRY_ID_SHIFT) | (name_cp))
+
+/**
+ * Invalidate specified LCache entry
+ */
+static inline void 
+ecma_lcache_invalidate_entry (ecma_lcache_hash_entry_t *entry_p) /**< entry to invalidate */
+{
+  JERRY_ASSERT (entry_p != NULL);
+  JERRY_ASSERT (entry_p->id != 0);
+  JERRY_ASSERT (entry_p->prop_p != NULL);
+
+  entry_p->id = 0;
+  ecma_set_property_lcached (entry_p->prop_p, false);
+} /* ecma_lcache_invalidate_entry */
+
+/**
+ * Compute the row index of object / property name pair
+ *
+ * @return row index
+ */
+static inline size_t 
+ecma_lcache_row_index (jmem_cpointer_t object_cp, /**< compressed pointer to object */
+                       jmem_cpointer_t name_cp) /**< compressed pointer to property name */
+{
+  /* Randomize the property name with the object pointer using a xor operation,
+   * so properties of different objects with the same name can be cached effectively. */
+  return (size_t) (((name_cp ^ object_cp) & ECMA_LCACHE_HASH_MASK) >> ECMA_LCACHE_HASH_BITSHIFT_INDEX);
+} /* ecma_lcache_row_index */
+
+/**
+ * Insert an entry into LCache
+ */
+void
+ecma_lcache_insert (const ecma_object_t *object_p, /**< object */
+                    const jmem_cpointer_t name_cp, /**< property name */
+                    ecma_property_t *prop_p) /**< property */
+{
+  JERRY_ASSERT (object_p != NULL);
+  JERRY_ASSERT (prop_p != NULL && !ecma_is_property_lcached (prop_p));
+  JERRY_ASSERT (ECMA_PROPERTY_IS_NAMED_PROPERTY (*prop_p));
+
+  jmem_cpointer_t object_cp;
+
+  ECMA_SET_NON_NULL_POINTER (object_cp, object_p);
+
+  size_t row_index = ecma_lcache_row_index (object_cp, name_cp);
+  ecma_lcache_hash_entry_t *entry_p = JERRY_CONTEXT (lcache)[row_index];
+  ecma_lcache_hash_entry_t *entry_end_p = entry_p + ECMA_LCACHE_HASH_ROW_LENGTH;
+
+  do
+  {
+    if (entry_p->id == 0)
+    {
+      goto insert;
+    }
+
+    entry_p++;
+  } while (entry_p < entry_end_p);
+
+  /* Invalidate the last entry. */
+  ecma_lcache_invalidate_entry (--entry_p);
+
+  /* Shift other entries towards the end. */
+  for (uint32_t i = 0; i < ECMA_LCACHE_HASH_ROW_LENGTH - 1; i++)
+  {
+    entry_p->id = entry_p[-1].id;
+    entry_p->prop_p = entry_p[-1].prop_p;
+    entry_p--;
+  }
+
+insert:
+  entry_p->prop_p = prop_p;
+  entry_p->id = ECMA_LCACHE_CREATE_ID (object_cp, name_cp);
+
+  ecma_set_property_lcached (entry_p->prop_p, true);
+} /* ecma_lcache_insert */
+
+/**
+ * Lookup property in the LCache
+ *
+ * @return a pointer to an ecma_property_t if the lookup is successful
+ *         NULL otherwise
+ */
+ecma_property_t *
+ecma_lcache_lookup (const ecma_object_t *object_p, /**< object */
+                    const ecma_string_t *prop_name_p) /**< property's name */
+{
+  JERRY_ASSERT (object_p != NULL);
+  JERRY_ASSERT (prop_name_p != NULL);
+
+  jmem_cpointer_t object_cp;
+  ECMA_SET_NON_NULL_POINTER (object_cp, object_p);
+
+  ecma_property_t prop_name_type = ECMA_DIRECT_STRING_PTR;
+  jmem_cpointer_t prop_name_cp;
+
+  if (JERRY_UNLIKELY (ECMA_IS_DIRECT_STRING (prop_name_p)))
+  {
+    prop_name_type = (ecma_property_t) ECMA_GET_DIRECT_STRING_TYPE (prop_name_p);
+    prop_name_cp = (jmem_cpointer_t) ECMA_GET_DIRECT_STRING_VALUE (prop_name_p);
+  }
+  else
+  {
+    ECMA_SET_NON_NULL_POINTER (prop_name_cp, prop_name_p);
+  }
+
+  size_t row_index = ecma_lcache_row_index (object_cp, prop_name_cp);
+
+  ecma_lcache_hash_entry_t *entry_p = JERRY_CONTEXT (lcache)[row_index];
+  ecma_lcache_hash_entry_t *entry_end_p = entry_p + ECMA_LCACHE_HASH_ROW_LENGTH;
+  ecma_lcache_hash_entry_id_t id = ECMA_LCACHE_CREATE_ID (object_cp, prop_name_cp);
+
+  do
+  {
+    if (entry_p->id == id && JERRY_LIKELY (ECMA_PROPERTY_GET_NAME_TYPE (*entry_p->prop_p) == prop_name_type))
+    {
+      JERRY_ASSERT (entry_p->prop_p != NULL && ecma_is_property_lcached (entry_p->prop_p));
+      return entry_p->prop_p;
+    }
+    entry_p++;
+  } while (entry_p < entry_end_p);
+
+  return NULL;
+} /* ecma_lcache_lookup */
+
+/**
+ * Invalidate LCache entries associated with given object and property name / property
+ */
+void
+ecma_lcache_invalidate (const ecma_object_t *object_p, /**< object */
+                        const jmem_cpointer_t name_cp, /**< property name */
+                        ecma_property_t *prop_p) /**< property */
+{
+  JERRY_ASSERT (object_p != NULL);
+  JERRY_ASSERT (prop_p != NULL && ecma_is_property_lcached (prop_p));
+  JERRY_ASSERT (ECMA_PROPERTY_IS_NAMED_PROPERTY (*prop_p));
+
+  jmem_cpointer_t object_cp;
+  ECMA_SET_NON_NULL_POINTER (object_cp, object_p);
+
+  size_t row_index = ecma_lcache_row_index (object_cp, name_cp);
+  ecma_lcache_hash_entry_t *entry_p = JERRY_CONTEXT (lcache)[row_index];
+
+  while (true)
+  {
+    /* The property must be present. */
+    JERRY_ASSERT (entry_p - JERRY_CONTEXT (lcache)[row_index] < ECMA_LCACHE_HASH_ROW_LENGTH);
+
+    if (entry_p->id != 0 && entry_p->prop_p == prop_p)
+    {
+      JERRY_ASSERT (entry_p->id == ECMA_LCACHE_CREATE_ID (object_cp, name_cp));
+
+      ecma_lcache_invalidate_entry (entry_p);
+      return;
+    }
+    entry_p++;
+  }
+} /* ecma_lcache_invalidate */
+
+#endif /* JERRY_LCACHE */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-lcache.h

@@ -0,0 +1,40 @@
+/* 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.
+ */
+
+#ifndef ECMA_LCACHE_H
+#define ECMA_LCACHE_H
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmalcache Property lookup cache
+ * @{
+ */
+
+#include "ecma-globals.h"
+
+#if JERRY_LCACHE
+void ecma_lcache_insert (const ecma_object_t *object_p, const jmem_cpointer_t name_cp, ecma_property_t *prop_p);
+ecma_property_t *ecma_lcache_lookup (const ecma_object_t *object_p, const ecma_string_t *prop_name_p);
+void ecma_lcache_invalidate (const ecma_object_t *object_p, const jmem_cpointer_t name_cp, ecma_property_t *prop_p);
+
+#endif /* JERRY_LCACHE */
+
+/**
+ * @}
+ * @}
+ */
+
+#endif /* !ECMA_LCACHE_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-line-info.cpp

@@ -0,0 +1,271 @@
+/* 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.
+ */
+
+#include "ecma-line-info.h"
+
+#include "ecma-helpers.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmalineinfo Line info
+ * @{
+ */
+
+#if JERRY_LINE_INFO
+
+/* The layout of the structure is defined in js-parser-line-info-create.c */
+
+JERRY_STATIC_ASSERT ((ECMA_LINE_INFO_COLUMN_DEFAULT - 1) == ((ECMA_LINE_INFO_ENCODE_TWO_BYTE >> 1) - 1),
+                     ecma_line_info_column_1_must_be_accessible_with_the_highest_one_byte_negative_value);
+
+/**
+ * Decodes an uint32_t number, and updates the buffer position.
+ * Numbers expected to be larger values.
+ *
+ * @return the decoded value
+ */
+uint32_t
+ecma_line_info_decode_vlq (uint8_t **buffer_p) /**< [in/out] target buffer */
+{
+  uint8_t *source_p = *buffer_p;
+  uint32_t value = 0;
+
+  do
+  {
+    value = (value << ECMA_LINE_INFO_VLQ_SHIFT) | (*source_p & ECMA_LINE_INFO_VLQ_MASK);
+  } while (*source_p++ & ECMA_LINE_INFO_VLQ_CONTINUE);
+
+  *buffer_p = source_p;
+  return value;
+} /* ecma_line_info_decode_vlq */
+
+/**
+ * Decodes an uint32_t number, and updates the buffer position.
+ * Numbers expected to be smaller values.
+ *
+ * @return the decoded value
+ */
+static uint32_t
+ecma_line_info_decode_small (uint8_t **buffer_p) /**< [in/out] target buffer */
+{
+  uint8_t *source_p = *buffer_p;
+  uint32_t type = source_p[0];
+
+  *buffer_p = source_p + 1;
+
+  if (type < ECMA_LINE_INFO_ENCODE_TWO_BYTE_MIN)
+  {
+    return type;
+  }
+
+  if (type == ECMA_LINE_INFO_ENCODE_TWO_BYTE)
+  {
+    *buffer_p = source_p + 2;
+    return ((uint32_t) source_p[1]) + ECMA_LINE_INFO_ENCODE_TWO_BYTE_MIN;
+  }
+
+  JERRY_ASSERT (type == ECMA_LINE_INFO_ENCODE_VLQ);
+  return ecma_line_info_decode_vlq (buffer_p) + ECMA_LINE_INFO_ENCODE_VLQ_MIN;
+} /* ecma_line_info_decode_small */
+
+/**
+ * Updates a value using an encoded difference.
+ *
+ * @return updated value
+ */
+uint32_t
+ecma_line_info_difference_update (uint32_t current_value, /**< current value */
+                                  uint32_t difference_value) /**< encoded difference */
+{
+  if ((difference_value & 0x1) == ECMA_LINE_INFO_INCREASE)
+  {
+    return current_value + (difference_value >> 1) + 1;
+  }
+
+  return current_value - (difference_value >> 1);
+} /* ecma_line_info_difference_update */
+
+/**
+ * Release line info data.
+ */
+void
+ecma_line_info_free (uint8_t *line_info_p) /**< line info buffer */
+{
+  uint8_t *source_p = line_info_p;
+  uint32_t total_length = ecma_line_info_decode_vlq (&source_p);
+
+  jmem_heap_free_block (line_info_p, total_length + (uint32_t) (source_p - line_info_p));
+} /* ecma_line_info_free */
+
+/**
+ * Returns the line/column information for a given byte code offset.
+ */
+void
+ecma_line_info_get (uint8_t *line_info_p, /**< line info buffer */
+                    uint32_t offset, /**< byte code offset */
+                    jerry_frame_location_t *location_p) /**< [out] location */
+{
+  uint32_t line = 1;
+  uint32_t column = ECMA_LINE_INFO_COLUMN_DEFAULT;
+  uint32_t end_offset = 0;
+  uint32_t end_offset_increase;
+  uint32_t value;
+
+  /* Skip total_length. */
+  ecma_line_info_decode_vlq (&line_info_p);
+
+  while (true)
+  {
+    value = ecma_line_info_decode_vlq (&line_info_p);
+    line = ecma_line_info_difference_update (line, value);
+
+    if (*line_info_p == 0)
+    {
+      break;
+    }
+
+    uint8_t *size_p = line_info_p + *line_info_p + (ECMA_LINE_INFO_STREAM_SIZE_MIN + 1);
+
+    uint32_t next_end_offset = end_offset + ecma_line_info_decode_vlq (&size_p);
+
+    if (offset < next_end_offset)
+    {
+      break;
+    }
+
+    end_offset = next_end_offset;
+    line_info_p = size_p;
+  }
+
+  line_info_p++;
+
+  do
+  {
+    end_offset_increase = ecma_line_info_decode_small (&line_info_p);
+
+    if (end_offset_increase & ECMA_LINE_INFO_HAS_LINE)
+    {
+      value = ecma_line_info_decode_small (&line_info_p);
+      line = ecma_line_info_difference_update (line, value);
+      column = ECMA_LINE_INFO_COLUMN_DEFAULT;
+    }
+
+    end_offset_increase >>= 1;
+
+    value = ecma_line_info_decode_small (&line_info_p);
+    column = ecma_line_info_difference_update (column, value);
+
+    end_offset += end_offset_increase;
+  } while (end_offset_increase != 0 && end_offset <= offset);
+
+  location_p->line = line;
+  location_p->column = column;
+} /* ecma_line_info_get */
+
+#if JERRY_PARSER_DUMP_BYTE_CODE
+
+/**
+ * Dumps line info data.
+ */
+void
+ecma_line_info_dump (uint8_t *line_info_p) /**< dumps line info data */
+{
+  bool block_last = false;
+  uint32_t block_line = 1;
+  uint32_t block_byte_code_offset = 0;
+  uint32_t value;
+
+  value = ecma_line_info_decode_vlq (&line_info_p);
+  JERRY_DEBUG_MSG ("\nLine info size: %d bytes\n", (int) value);
+
+  while (true)
+  {
+    value = ecma_line_info_decode_vlq (&line_info_p);
+    block_line = ecma_line_info_difference_update (block_line, value);
+
+    JERRY_DEBUG_MSG ("\nNew block: line: %d", (int) block_line);
+
+    if (*line_info_p == 0)
+    {
+      JERRY_DEBUG_MSG (" StreamLength: [last]\n");
+      block_last = true;
+    }
+    else
+    {
+      uint8_t *size_p = line_info_p + *line_info_p + (ECMA_LINE_INFO_STREAM_SIZE_MIN + 1);
+
+      value = ecma_line_info_decode_vlq (&size_p);
+
+      JERRY_DEBUG_MSG (" StreamLength: %d ByteCodeSize: %d\n",
+                       (int) (*line_info_p + ECMA_LINE_INFO_STREAM_SIZE_MIN),
+                       (int) value);
+    }
+
+    line_info_p++;
+
+    uint32_t stream_line = block_line;
+    uint32_t stream_column = ECMA_LINE_INFO_COLUMN_DEFAULT;
+    uint32_t stream_end_offset = block_byte_code_offset;
+
+    while (true)
+    {
+      uint32_t stream_end_offset_increase = ecma_line_info_decode_small (&line_info_p);
+
+      if (stream_end_offset_increase & ECMA_LINE_INFO_HAS_LINE)
+      {
+        value = ecma_line_info_decode_small (&line_info_p);
+        stream_line = ecma_line_info_difference_update (stream_line, value);
+        stream_column = ECMA_LINE_INFO_COLUMN_DEFAULT;
+      }
+
+      stream_end_offset_increase >>= 1;
+
+      value = ecma_line_info_decode_small (&line_info_p);
+      stream_column = ecma_line_info_difference_update (stream_column, value);
+
+      if (stream_end_offset_increase == 0)
+      {
+        JERRY_DEBUG_MSG ("  ByteCodeEndOffset: [unterminated] Line: %d Column: %d\n",
+                         (int) stream_line,
+                         (int) stream_column);
+        break;
+      }
+
+      stream_end_offset += stream_end_offset_increase;
+
+      JERRY_DEBUG_MSG ("  ByteCodeEndOffset: %d Line: %d Column: %d\n",
+                       (int) stream_end_offset,
+                       (int) stream_line,
+                       (int) stream_column);
+    }
+
+    if (block_last)
+    {
+      break;
+    }
+
+    block_byte_code_offset += ecma_line_info_decode_vlq (&line_info_p);
+  }
+} /* ecma_line_info_dump */
+
+#endif /* JERRY_PARSER_DUMP_BYTE_CODE */
+
+#endif /* JERRY_LINE_INFO */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-line-info.h

@@ -0,0 +1,114 @@
+/* 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.
+ */
+
+#ifndef ECMA_LINE_INFO_H
+#define ECMA_LINE_INFO_H
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmalineinfo Line info
+ * @{
+ */
+
+#ifdef JERRY_LINE_INFO
+
+#include "ecma-globals.h"
+
+/**
+ * Increase the current value of line or column.
+ */
+#define ECMA_LINE_INFO_INCREASE 0x0
+
+/**
+ * Decrease the current value of line or column.
+ */
+#define ECMA_LINE_INFO_DECREASE 0x1
+
+/**
+ * Line update is present.
+ */
+#define ECMA_LINE_INFO_HAS_LINE 0x1
+
+/**
+ * A default value for columns after a line update.
+ */
+#define ECMA_LINE_INFO_COLUMN_DEFAULT 127
+
+/**
+ * Vlq encoding: flag which is set for all bytes except the last one.
+ */
+#define ECMA_LINE_INFO_VLQ_CONTINUE 0x80
+
+/**
+ * Vlq encoding: mask to decode the number fragment.
+ */
+#define ECMA_LINE_INFO_VLQ_MASK 0x7f
+
+/**
+ * Vlq encoding: number of bits stored in a byte.
+ */
+#define ECMA_LINE_INFO_VLQ_SHIFT 7
+
+/**
+ * Small encoding: a value which represents a two byte long number.
+ */
+#define ECMA_LINE_INFO_ENCODE_TWO_BYTE (UINT8_MAX - 1)
+
+/**
+ * Small encoding: minimum value of an encoded two byte long number.
+ */
+#define ECMA_LINE_INFO_ENCODE_TWO_BYTE_MIN (UINT8_MAX - 1)
+
+/**
+ * Small encoding: a value which represents a three byte long number.
+ */
+#define ECMA_LINE_INFO_ENCODE_VLQ UINT8_MAX
+
+/**
+ * Small encoding: minimum value of an encoded three byte long number.
+ */
+#define ECMA_LINE_INFO_ENCODE_VLQ_MIN (ECMA_LINE_INFO_ENCODE_TWO_BYTE_MIN + UINT8_MAX + 1)
+
+/**
+ * Maximum number of line/column entries stored in a stream.
+ */
+#define ECMA_LINE_INFO_STREAM_VALUE_COUNT_MAX 48
+
+/**
+ * Minimum size of a stream (except the last one).
+ */
+#define ECMA_LINE_INFO_STREAM_SIZE_MIN ((2 * ECMA_LINE_INFO_STREAM_VALUE_COUNT_MAX) - 1)
+
+/* Helper functions for parser/js/js-parser-line-info-create.c. */
+uint32_t ecma_line_info_decode_vlq (uint8_t **buffer_p);
+uint32_t ecma_line_info_difference_update (uint32_t current_value, uint32_t difference_value);
+
+/* General functions. */
+void ecma_line_info_free (uint8_t *line_info_p);
+void ecma_line_info_get (uint8_t *line_info_p, uint32_t offset, jerry_frame_location_t *location_p);
+
+#if JERRY_PARSER_DUMP_BYTE_CODE
+void ecma_line_info_dump (uint8_t *line_info_p);
+#endif /* JERRY_PARSER_DUMP_BYTE_CODE */
+
+#endif /* JERRY_LINE_INFO */
+
+/**
+ * @}
+ * @}
+ */
+
+#endif /* !ECMA_LINE_INFO_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-literal-storage.cpp

@@ -0,0 +1,741 @@
+/* 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.
+ */
+
+#include "ecma-literal-storage.h"
+
+#include "ecma-alloc.h"
+#include "ecma-big-uint.h"
+#include "ecma-bigint.h"
+#include "ecma-helpers.h"
+
+#include "jcontext.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmalitstorage Literal storage
+ * @{
+ */
+
+/**
+ * Free symbol list
+ */
+static void
+ecma_free_symbol_list (jmem_cpointer_t symbol_list_cp) /**< symbol list */
+{
+  while (symbol_list_cp != JMEM_CP_NULL)
+  {
+    ecma_lit_storage_item_t *symbol_list_p = JMEM_CP_GET_NON_NULL_POINTER (ecma_lit_storage_item_t, symbol_list_cp);
+
+    for (int i = 0; i < ECMA_LIT_STORAGE_VALUE_COUNT; i++)
+    {
+      if (symbol_list_p->values[i] != JMEM_CP_NULL)
+      {
+        ecma_string_t *string_p = JMEM_CP_GET_NON_NULL_POINTER (ecma_string_t, symbol_list_p->values[i]);
+
+        JERRY_ASSERT (ECMA_STRING_IS_REF_EQUALS_TO_ONE (string_p));
+        ecma_deref_ecma_string (string_p);
+      }
+    }
+
+    jmem_cpointer_t next_item_cp = symbol_list_p->next_cp;
+    jmem_pools_free (symbol_list_p, sizeof (ecma_lit_storage_item_t));
+    symbol_list_cp = next_item_cp;
+  }
+} /* ecma_free_symbol_list */
+
+/**
+ * Free string list
+ */
+static void
+ecma_free_string_list (jmem_cpointer_t string_list_cp) /**< string list */
+{
+  while (string_list_cp != JMEM_CP_NULL)
+  {
+    ecma_lit_storage_item_t *string_list_p = JMEM_CP_GET_NON_NULL_POINTER (ecma_lit_storage_item_t, string_list_cp);
+
+    for (int i = 0; i < ECMA_LIT_STORAGE_VALUE_COUNT; i++)
+    {
+      if (string_list_p->values[i] != JMEM_CP_NULL)
+      {
+        ecma_string_t *string_p = JMEM_CP_GET_NON_NULL_POINTER (ecma_string_t, string_list_p->values[i]);
+
+        JERRY_ASSERT (ECMA_STRING_IS_REF_EQUALS_TO_ONE (string_p));
+        ecma_destroy_ecma_string (string_p);
+      }
+    }
+
+    jmem_cpointer_t next_item_cp = string_list_p->next_cp;
+    jmem_pools_free (string_list_p, sizeof (ecma_lit_storage_item_t));
+    string_list_cp = next_item_cp;
+  }
+} /* ecma_free_string_list */
+
+/**
+ * Free number list
+ */
+static void
+ecma_free_number_list (jmem_cpointer_t number_list_cp) /**< number list */
+{
+  while (number_list_cp != JMEM_CP_NULL)
+  {
+    ecma_lit_storage_item_t *number_list_p = JMEM_CP_GET_NON_NULL_POINTER (ecma_lit_storage_item_t, number_list_cp);
+
+    for (int i = 0; i < ECMA_LIT_STORAGE_VALUE_COUNT; i++)
+    {
+      if (number_list_p->values[i] != JMEM_CP_NULL)
+      {
+        ecma_dealloc_number (JMEM_CP_GET_NON_NULL_POINTER (ecma_number_t, number_list_p->values[i]));
+      }
+    }
+
+    jmem_cpointer_t next_item_cp = number_list_p->next_cp;
+    jmem_pools_free (number_list_p, sizeof (ecma_lit_storage_item_t));
+    number_list_cp = next_item_cp;
+  }
+} /* ecma_free_number_list */
+
+#if JERRY_BUILTIN_BIGINT
+
+/**
+ * Free bigint list
+ */
+static void
+ecma_free_bigint_list (jmem_cpointer_t bigint_list_cp) /**< bigint list */
+{
+  while (bigint_list_cp != JMEM_CP_NULL)
+  {
+    ecma_lit_storage_item_t *bigint_list_p = JMEM_CP_GET_NON_NULL_POINTER (ecma_lit_storage_item_t, bigint_list_cp);
+
+    for (int i = 0; i < ECMA_LIT_STORAGE_VALUE_COUNT; i++)
+    {
+      if (bigint_list_p->values[i] != JMEM_CP_NULL)
+      {
+        ecma_extended_primitive_t *bigint_p =
+          JMEM_CP_GET_NON_NULL_POINTER (ecma_extended_primitive_t, bigint_list_p->values[i]);
+        JERRY_ASSERT (ECMA_EXTENDED_PRIMITIVE_IS_REF_EQUALS_TO_ONE (bigint_p));
+        ecma_deref_bigint (bigint_p);
+      }
+    }
+
+    jmem_cpointer_t next_item_cp = bigint_list_p->next_cp;
+    jmem_pools_free (bigint_list_p, sizeof (ecma_lit_storage_item_t));
+    bigint_list_cp = next_item_cp;
+  }
+} /* ecma_free_bigint_list */
+
+#endif /* JERRY_BUILTIN_BIGINT */
+
+/**
+ * Finalize literal storage
+ */
+void
+ecma_finalize_lit_storage (void)
+{
+  ecma_free_symbol_list (JERRY_CONTEXT (symbol_list_first_cp));
+  ecma_free_string_list (JERRY_CONTEXT (string_list_first_cp));
+  ecma_free_number_list (JERRY_CONTEXT (number_list_first_cp));
+#if JERRY_BUILTIN_BIGINT
+  ecma_free_bigint_list (JERRY_CONTEXT (bigint_list_first_cp));
+#endif /* JERRY_BUILTIN_BIGINT */
+} /* ecma_finalize_lit_storage */
+
+/**
+ * Find or create a literal string.
+ *
+ * @return ecma_string_t compressed pointer
+ */
+ecma_value_t
+ecma_find_or_create_literal_string (const lit_utf8_byte_t *chars_p, /**< string to be searched */
+                                    lit_utf8_size_t size, /**< size of the string */
+                                    bool is_ascii) /**< encode of the string */
+{
+  ecma_string_t *string_p =
+    (is_ascii ? ecma_new_ecma_string_from_ascii (chars_p, size) : ecma_new_ecma_string_from_utf8 (chars_p, size));
+
+  if (ECMA_IS_DIRECT_STRING (string_p))
+  {
+    return ecma_make_string_value (string_p);
+  }
+
+  jmem_cpointer_t string_list_cp = JERRY_CONTEXT (string_list_first_cp);
+  jmem_cpointer_t *empty_cpointer_p = NULL;
+
+  while (string_list_cp != JMEM_CP_NULL)
+  {
+    ecma_lit_storage_item_t *string_list_p = JMEM_CP_GET_NON_NULL_POINTER (ecma_lit_storage_item_t, string_list_cp);
+
+    for (int i = 0; i < ECMA_LIT_STORAGE_VALUE_COUNT; i++)
+    {
+      if (string_list_p->values[i] == JMEM_CP_NULL)
+      {
+        if (empty_cpointer_p == NULL)
+        {
+          empty_cpointer_p = string_list_p->values + i;
+        }
+      }
+      else
+      {
+        ecma_string_t *value_p = JMEM_CP_GET_NON_NULL_POINTER (ecma_string_t, string_list_p->values[i]);
+
+        if (ecma_compare_ecma_strings (string_p, value_p))
+        {
+          /* Return with string if found in the list. */
+          ecma_deref_ecma_string (string_p);
+          return ecma_make_string_value (value_p);
+        }
+      }
+    }
+
+    string_list_cp = string_list_p->next_cp;
+  }
+
+  ECMA_SET_STRING_AS_STATIC (string_p);
+  jmem_cpointer_t result;
+  JMEM_CP_SET_NON_NULL_POINTER (result, string_p);
+
+  if (empty_cpointer_p != NULL)
+  {
+    *empty_cpointer_p = result;
+    return ecma_make_string_value (string_p);
+  }
+
+  ecma_lit_storage_item_t *new_item_p;
+  new_item_p = (ecma_lit_storage_item_t *) jmem_pools_alloc (sizeof (ecma_lit_storage_item_t));
+
+  new_item_p->values[0] = result;
+  for (int i = 1; i < ECMA_LIT_STORAGE_VALUE_COUNT; i++)
+  {
+    new_item_p->values[i] = JMEM_CP_NULL;
+  }
+
+  new_item_p->next_cp = JERRY_CONTEXT (string_list_first_cp);
+  JMEM_CP_SET_NON_NULL_POINTER (JERRY_CONTEXT (string_list_first_cp), new_item_p);
+
+  return ecma_make_string_value (string_p);
+} /* ecma_find_or_create_literal_string */
+
+/**
+ * Find or create a literal number.
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_find_or_create_literal_number (ecma_number_t number_arg) /**< number to be searched */
+{
+  ecma_value_t num = ecma_make_number_value (number_arg);
+
+  if (ecma_is_value_integer_number (num))
+  {
+    return num;
+  }
+
+  JERRY_ASSERT (ecma_is_value_float_number (num));
+
+  jmem_cpointer_t number_list_cp = JERRY_CONTEXT (number_list_first_cp);
+  jmem_cpointer_t *empty_cpointer_p = NULL;
+
+  while (number_list_cp != JMEM_CP_NULL)
+  {
+    ecma_lit_storage_item_t *number_list_p = JMEM_CP_GET_NON_NULL_POINTER (ecma_lit_storage_item_t, number_list_cp);
+
+    for (int i = 0; i < ECMA_LIT_STORAGE_VALUE_COUNT; i++)
+    {
+      if (number_list_p->values[i] == JMEM_CP_NULL)
+      {
+        if (empty_cpointer_p == NULL)
+        {
+          empty_cpointer_p = number_list_p->values + i;
+        }
+      }
+      else
+      {
+        ecma_number_t *number_p = JMEM_CP_GET_NON_NULL_POINTER (ecma_number_t, number_list_p->values[i]);
+
+        if (*number_p == number_arg)
+        {
+          ecma_free_value (num);
+          return ecma_make_float_value (number_p);
+        }
+      }
+    }
+
+    number_list_cp = number_list_p->next_cp;
+  }
+
+  jmem_cpointer_t result;
+  JMEM_CP_SET_NON_NULL_POINTER (result, ecma_get_pointer_from_float_value (num));
+
+  if (empty_cpointer_p != NULL)
+  {
+    *empty_cpointer_p = result;
+    return num;
+  }
+
+  ecma_lit_storage_item_t *new_item_p;
+  new_item_p = (ecma_lit_storage_item_t *) jmem_pools_alloc (sizeof (ecma_lit_storage_item_t));
+
+  new_item_p->values[0] = result;
+  for (int i = 1; i < ECMA_LIT_STORAGE_VALUE_COUNT; i++)
+  {
+    new_item_p->values[i] = JMEM_CP_NULL;
+  }
+
+  new_item_p->next_cp = JERRY_CONTEXT (number_list_first_cp);
+  JMEM_CP_SET_NON_NULL_POINTER (JERRY_CONTEXT (number_list_first_cp), new_item_p);
+
+  return num;
+} /* ecma_find_or_create_literal_number */
+
+#if JERRY_BUILTIN_BIGINT
+
+/**
+ * Find or create a literal BigInt.
+ *
+ * @return BigInt value
+ */
+ecma_value_t
+ecma_find_or_create_literal_bigint (ecma_value_t bigint) /**< bigint to be searched */
+{
+  JERRY_ASSERT (ecma_is_value_bigint (bigint));
+
+  if (bigint == ECMA_BIGINT_ZERO)
+  {
+    return bigint;
+  }
+
+  jmem_cpointer_t bigint_list_cp = JERRY_CONTEXT (bigint_list_first_cp);
+  jmem_cpointer_t *empty_cpointer_p = NULL;
+
+  while (bigint_list_cp != JMEM_CP_NULL)
+  {
+    ecma_lit_storage_item_t *bigint_list_p = JMEM_CP_GET_NON_NULL_POINTER (ecma_lit_storage_item_t, bigint_list_cp);
+
+    for (int i = 0; i < ECMA_LIT_STORAGE_VALUE_COUNT; i++)
+    {
+      if (bigint_list_p->values[i] == JMEM_CP_NULL)
+      {
+        if (empty_cpointer_p == NULL)
+        {
+          empty_cpointer_p = bigint_list_p->values + i;
+        }
+      }
+      else
+      {
+        ecma_extended_primitive_t *other_bigint_p =
+          JMEM_CP_GET_NON_NULL_POINTER (ecma_extended_primitive_t, bigint_list_p->values[i]);
+        ecma_value_t other_bigint = ecma_make_extended_primitive_value (other_bigint_p, ECMA_TYPE_BIGINT);
+
+        if (ecma_bigint_is_equal_to_bigint (bigint, other_bigint))
+        {
+          ecma_free_value (bigint);
+          return other_bigint;
+        }
+      }
+    }
+
+    bigint_list_cp = bigint_list_p->next_cp;
+  }
+
+  jmem_cpointer_t result;
+  JMEM_CP_SET_NON_NULL_POINTER (result, ecma_get_extended_primitive_from_value (bigint));
+
+  if (empty_cpointer_p != NULL)
+  {
+    *empty_cpointer_p = result;
+    return bigint;
+  }
+
+  ecma_lit_storage_item_t *new_item_p;
+  new_item_p = (ecma_lit_storage_item_t *) jmem_pools_alloc (sizeof (ecma_lit_storage_item_t));
+
+  new_item_p->values[0] = result;
+  for (int i = 1; i < ECMA_LIT_STORAGE_VALUE_COUNT; i++)
+  {
+    new_item_p->values[i] = JMEM_CP_NULL;
+  }
+
+  new_item_p->next_cp = JERRY_CONTEXT (bigint_list_first_cp);
+  JMEM_CP_SET_NON_NULL_POINTER (JERRY_CONTEXT (bigint_list_first_cp), new_item_p);
+
+  return bigint;
+} /* ecma_find_or_create_literal_bigint */
+
+#endif /* JERRY_BUILTIN_BIGINT */
+
+/**
+ * Log2 of snapshot literal alignment.
+ */
+#define JERRY_SNAPSHOT_LITERAL_ALIGNMENT_LOG 1
+
+/**
+ * Snapshot literal alignment.
+ */
+#define JERRY_SNAPSHOT_LITERAL_ALIGNMENT (1u << JERRY_SNAPSHOT_LITERAL_ALIGNMENT_LOG)
+
+/**
+ * Literal offset shift.
+ */
+#define JERRY_SNAPSHOT_LITERAL_SHIFT (ECMA_VALUE_SHIFT + 2)
+
+/**
+ * Literal value is number.
+ */
+#define JERRY_SNAPSHOT_LITERAL_IS_NUMBER (1u << ECMA_VALUE_SHIFT)
+
+#if JERRY_BUILTIN_BIGINT
+/**
+ * Literal value is BigInt.
+ */
+#define JERRY_SNAPSHOT_LITERAL_IS_BIGINT (2u << ECMA_VALUE_SHIFT)
+#endif /* JERRY_BUILTIN_BIGINT */
+
+#if JERRY_SNAPSHOT_SAVE
+
+/**
+ * Append the value at the end of the appropriate list if it is not present there.
+ */
+void
+ecma_save_literals_append_value (ecma_value_t value, /**< value to be appended */
+                                 ecma_collection_t *lit_pool_p) /**< list of known values */
+{
+  /* Unlike direct numbers, direct strings are converted to character literals. */
+  if (!ecma_is_value_string (value)
+#if JERRY_BUILTIN_BIGINT
+      && (!ecma_is_value_bigint (value) || value == ECMA_BIGINT_ZERO)
+#endif /* JERRY_BUILTIN_BIGINT */
+      && !ecma_is_value_float_number (value))
+  {
+    return;
+  }
+
+  ecma_value_t *buffer_p = lit_pool_p->buffer_p;
+
+  for (uint32_t i = 0; i < lit_pool_p->item_count; i++)
+  {
+    /* Strings / numbers are direct strings or stored in the literal storage.
+     * Therefore direct comparison is enough to find the same strings / numbers. */
+    if (buffer_p[i] == value)
+    {
+      return;
+    }
+  }
+
+  ecma_collection_push_back (lit_pool_p, value);
+} /* ecma_save_literals_append_value */
+
+/**
+ * Add names from a byte-code data to a list.
+ */
+void
+ecma_save_literals_add_compiled_code (const ecma_compiled_code_t *compiled_code_p, /**< byte-code data */
+                                      ecma_collection_t *lit_pool_p) /**< list of known values */
+{
+  ecma_value_t *literal_p;
+  uint32_t argument_end;
+  uint32_t register_end;
+  uint32_t const_literal_end;
+  uint32_t literal_end;
+
+  JERRY_ASSERT (CBC_IS_FUNCTION (compiled_code_p->status_flags));
+
+  if (compiled_code_p->status_flags & CBC_CODE_FLAGS_UINT16_ARGUMENTS)
+  {
+    cbc_uint16_arguments_t *args_p = (cbc_uint16_arguments_t *) compiled_code_p;
+    uint8_t *byte_p = (uint8_t *) compiled_code_p;
+
+    literal_p = (ecma_value_t *) (byte_p + sizeof (cbc_uint16_arguments_t));
+    register_end = args_p->register_end;
+    const_literal_end = args_p->const_literal_end - register_end;
+    literal_end = args_p->literal_end - register_end;
+    argument_end = args_p->argument_end;
+  }
+  else
+  {
+    cbc_uint8_arguments_t *args_p = (cbc_uint8_arguments_t *) compiled_code_p;
+    uint8_t *byte_p = (uint8_t *) compiled_code_p;
+
+    literal_p = (ecma_value_t *) (byte_p + sizeof (cbc_uint8_arguments_t));
+    register_end = args_p->register_end;
+    const_literal_end = args_p->const_literal_end - register_end;
+    literal_end = args_p->literal_end - register_end;
+    argument_end = args_p->argument_end;
+  }
+
+  if (compiled_code_p->status_flags & CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED)
+  {
+    for (uint32_t i = 0; i < argument_end; i++)
+    {
+      ecma_save_literals_append_value (literal_p[i], lit_pool_p);
+    }
+  }
+
+  for (uint32_t i = 0; i < const_literal_end; i++)
+  {
+    ecma_save_literals_append_value (literal_p[i], lit_pool_p);
+  }
+
+  for (uint32_t i = const_literal_end; i < literal_end; i++)
+  {
+    ecma_compiled_code_t *bytecode_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_compiled_code_t, literal_p[i]);
+
+    if (CBC_IS_FUNCTION (bytecode_p->status_flags) && bytecode_p != compiled_code_p)
+    {
+      ecma_save_literals_add_compiled_code (bytecode_p, lit_pool_p);
+    }
+  }
+
+  uint8_t *byte_p = ((uint8_t *) compiled_code_p) + (((size_t) compiled_code_p->size) << JMEM_ALIGNMENT_LOG);
+  literal_p = ecma_snapshot_resolve_serializable_values ((ecma_compiled_code_t *) compiled_code_p, byte_p);
+
+  while (literal_p < (ecma_value_t *) byte_p)
+  {
+    ecma_save_literals_append_value (*literal_p, lit_pool_p);
+    literal_p++;
+  }
+} /* ecma_save_literals_add_compiled_code */
+
+/**
+ * Save literals to specified snapshot buffer.
+ *
+ * Note:
+ *      Frees 'lit_pool_p' regardless of success.
+ *
+ * @return true - if save was performed successfully (i.e. buffer size is sufficient),
+ *         false - otherwise
+ */
+bool
+ecma_save_literals_for_snapshot (ecma_collection_t *lit_pool_p, /**< list of known values */
+                                 uint32_t *buffer_p, /**< [out] output snapshot buffer */
+                                 size_t buffer_size, /**< size of the buffer */
+                                 size_t *in_out_buffer_offset_p, /**< [in,out] write position in the buffer */
+                                 lit_mem_to_snapshot_id_map_entry_t **out_map_p, /**< [out] map from literal identifiers
+                                                                                  *   to the literal offsets
+                                                                                  *   in snapshot */
+                                 uint32_t *out_map_len_p) /**< [out] number of literals */
+{
+  if (lit_pool_p->item_count == 0)
+  {
+    *out_map_p = NULL;
+    *out_map_len_p = 0;
+  }
+
+  uint32_t lit_table_size = 0;
+  size_t max_lit_table_size = buffer_size - *in_out_buffer_offset_p;
+
+  if (max_lit_table_size > (UINT32_MAX >> JERRY_SNAPSHOT_LITERAL_SHIFT))
+  {
+    max_lit_table_size = (UINT32_MAX >> JERRY_SNAPSHOT_LITERAL_SHIFT);
+  }
+
+  ecma_value_t *lit_buffer_p = lit_pool_p->buffer_p;
+
+  /* Compute the size of the literal pool. */
+  for (uint32_t i = 0; i < lit_pool_p->item_count; i++)
+  {
+    if (ecma_is_value_float_number (lit_buffer_p[i]))
+    {
+      lit_table_size += (uint32_t) sizeof (ecma_number_t);
+    }
+#if JERRY_BUILTIN_BIGINT
+    else if (ecma_is_value_bigint (lit_buffer_p[i]))
+    {
+      ecma_extended_primitive_t *bigint_p = ecma_get_extended_primitive_from_value (lit_buffer_p[i]);
+
+      lit_table_size += (uint32_t) JERRY_ALIGNUP (sizeof (uint32_t) + ECMA_BIGINT_GET_SIZE (bigint_p),
+                                                  JERRY_SNAPSHOT_LITERAL_ALIGNMENT);
+    }
+#endif /* JERRY_BUILTIN_BIGINT */
+    else
+    {
+      ecma_string_t *string_p = ecma_get_string_from_value (lit_buffer_p[i]);
+
+      lit_table_size += (uint32_t) JERRY_ALIGNUP (sizeof (uint16_t) + ecma_string_get_size (string_p),
+                                                  JERRY_SNAPSHOT_LITERAL_ALIGNMENT);
+    }
+
+    /* Check whether enough space is available and the maximum size is not reached. */
+    if (lit_table_size > max_lit_table_size)
+    {
+      ecma_collection_destroy (lit_pool_p);
+      return false;
+    }
+  }
+
+  lit_mem_to_snapshot_id_map_entry_t *map_p;
+  uint32_t total_count = lit_pool_p->item_count;
+
+  map_p = jmem_heap_alloc_block (total_count * sizeof (lit_mem_to_snapshot_id_map_entry_t));
+
+  /* Set return values (no error is possible from here). */
+  JERRY_ASSERT ((*in_out_buffer_offset_p % sizeof (uint32_t)) == 0);
+
+  uint8_t *destination_p = (uint8_t *) (buffer_p + (*in_out_buffer_offset_p / sizeof (uint32_t)));
+  uint32_t literal_offset = 0;
+
+  *in_out_buffer_offset_p += lit_table_size;
+  *out_map_p = map_p;
+  *out_map_len_p = total_count;
+
+  lit_buffer_p = lit_pool_p->buffer_p;
+
+  /* Generate literal pool data. */
+  for (uint32_t i = 0; i < lit_pool_p->item_count; i++)
+  {
+    map_p->literal_id = lit_buffer_p[i];
+    map_p->literal_offset = (literal_offset << JERRY_SNAPSHOT_LITERAL_SHIFT) | ECMA_TYPE_SNAPSHOT_OFFSET;
+
+    lit_utf8_size_t length;
+
+    if (ecma_is_value_float_number (lit_buffer_p[i]))
+    {
+      map_p->literal_offset |= JERRY_SNAPSHOT_LITERAL_IS_NUMBER;
+
+      ecma_number_t num = ecma_get_float_from_value (lit_buffer_p[i]);
+      memcpy (destination_p, &num, sizeof (ecma_number_t));
+
+      length = JERRY_ALIGNUP (sizeof (ecma_number_t), JERRY_SNAPSHOT_LITERAL_ALIGNMENT);
+    }
+#if JERRY_BUILTIN_BIGINT
+    else if (ecma_is_value_bigint (lit_buffer_p[i]))
+    {
+      map_p->literal_offset |= JERRY_SNAPSHOT_LITERAL_IS_BIGINT;
+
+      ecma_extended_primitive_t *bigint_p = ecma_get_extended_primitive_from_value (lit_buffer_p[i]);
+      uint32_t size = ECMA_BIGINT_GET_SIZE (bigint_p);
+
+      memcpy (destination_p, &bigint_p->u.bigint_sign_and_size, sizeof (uint32_t));
+      memcpy (destination_p + sizeof (uint32_t), ECMA_BIGINT_GET_DIGITS (bigint_p, 0), size);
+
+      length = JERRY_ALIGNUP (sizeof (uint32_t) + size, JERRY_SNAPSHOT_LITERAL_ALIGNMENT);
+    }
+#endif /* JERRY_BUILTIN_BIGINT */
+    else
+    {
+      ecma_string_t *string_p = ecma_get_string_from_value (lit_buffer_p[i]);
+      length = ecma_string_get_size (string_p);
+
+      *(uint16_t *) destination_p = (uint16_t) length;
+
+      ecma_string_to_cesu8_bytes (string_p, destination_p + sizeof (uint16_t), length);
+
+      length = JERRY_ALIGNUP (sizeof (uint16_t) + length, JERRY_SNAPSHOT_LITERAL_ALIGNMENT);
+    }
+
+    JERRY_ASSERT ((length % sizeof (uint16_t)) == 0);
+    destination_p += length;
+    literal_offset += length;
+
+    map_p++;
+  }
+
+  ecma_collection_destroy (lit_pool_p);
+  return true;
+} /* ecma_save_literals_for_snapshot */
+
+#endif /* JERRY_SNAPSHOT_SAVE */
+
+#if JERRY_SNAPSHOT_EXEC || JERRY_SNAPSHOT_SAVE
+
+/**
+ * Get the compressed pointer of a given literal.
+ *
+ * @return literal compressed pointer
+ */
+ecma_value_t
+ecma_snapshot_get_literal (const uint8_t *literal_base_p, /**< literal start */
+                           ecma_value_t literal_value) /**< string / number offset */
+{
+  JERRY_ASSERT ((literal_value & ECMA_VALUE_TYPE_MASK) == ECMA_TYPE_SNAPSHOT_OFFSET);
+
+  const uint8_t *literal_p = literal_base_p + (literal_value >> JERRY_SNAPSHOT_LITERAL_SHIFT);
+
+  if (literal_value & JERRY_SNAPSHOT_LITERAL_IS_NUMBER)
+  {
+    ecma_number_t num;
+    memcpy (&num, literal_p, sizeof (ecma_number_t));
+    return ecma_find_or_create_literal_number (num);
+  }
+
+#if JERRY_BUILTIN_BIGINT
+  if (literal_value & JERRY_SNAPSHOT_LITERAL_IS_BIGINT)
+  {
+    uint32_t bigint_sign_and_size = *(uint32_t *) literal_p;
+    uint32_t size = bigint_sign_and_size & ~(uint32_t) (sizeof (ecma_bigint_digit_t) - 1);
+
+    ecma_extended_primitive_t *bigint_p = ecma_bigint_create (size);
+
+    if (bigint_p == NULL)
+    {
+      jerry_fatal (JERRY_FATAL_OUT_OF_MEMORY);
+    }
+
+    /* Only the sign bit can differ. */
+    JERRY_ASSERT (bigint_p->u.bigint_sign_and_size == (bigint_sign_and_size & ~(uint32_t) ECMA_BIGINT_SIGN));
+
+    bigint_p->u.bigint_sign_and_size = bigint_sign_and_size;
+    memcpy (ECMA_BIGINT_GET_DIGITS (bigint_p, 0), literal_p + sizeof (uint32_t), size);
+    return ecma_find_or_create_literal_bigint (ecma_make_extended_primitive_value (bigint_p, ECMA_TYPE_BIGINT));
+  }
+#endif /* JERRY_BUILTIN_BIGINT */
+
+  uint16_t length = *(const uint16_t *) literal_p;
+
+  return ecma_find_or_create_literal_string (literal_p + sizeof (uint16_t), length, false);
+} /* ecma_snapshot_get_literal */
+
+/**
+ * Compute the start of the serializable ecma-values of the bytecode
+ * Related values:
+ *  - function argument names, if CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED is present
+ *  - function name, if CBC_CODE_FLAGS_CLASS_CONSTRUCTOR is not present and es.next profile is enabled
+ *
+ * @return pointer to the beginning of the serializable ecma-values
+ */
+ecma_value_t *
+ecma_snapshot_resolve_serializable_values (const ecma_compiled_code_t *compiled_code_p, /**< compiled code */
+                                           uint8_t *bytecode_end_p) /**< end of the bytecode */
+{
+  ecma_value_t *base_p = (ecma_value_t *) bytecode_end_p;
+
+  if (compiled_code_p->status_flags & CBC_CODE_FLAGS_MAPPED_ARGUMENTS_NEEDED)
+  {
+    uint32_t argument_end;
+    if (compiled_code_p->status_flags & CBC_CODE_FLAGS_UINT16_ARGUMENTS)
+    {
+      argument_end = ((cbc_uint16_arguments_t *) compiled_code_p)->argument_end;
+    }
+    else
+    {
+      argument_end = ((cbc_uint8_arguments_t *) compiled_code_p)->argument_end;
+    }
+
+    base_p -= argument_end;
+  }
+
+  /* function name */
+  if (CBC_FUNCTION_GET_TYPE (compiled_code_p->status_flags) != CBC_FUNCTION_CONSTRUCTOR)
+  {
+    base_p--;
+  }
+
+  return base_p;
+} /* ecma_snapshot_resolve_serializable_values */
+#endif /* JERRY_SNAPSHOT_EXEC || JERRY_SNAPSHOT_SAVE */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-literal-storage.h

@@ -0,0 +1,72 @@
+/* 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.
+ */
+
+#ifndef ECMA_LIT_STORAGE_H
+#define ECMA_LIT_STORAGE_H
+
+#include "ecma-globals.h"
+
+#include "jmem.h"
+#include "lit-globals.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmalitstorage Literal storage
+ * @{
+ */
+
+#if JERRY_SNAPSHOT_SAVE
+/**
+ * Snapshot literal - offset map
+ */
+typedef struct
+{
+  ecma_value_t literal_id; /**< literal id */
+  ecma_value_t literal_offset; /**< literal offset */
+} lit_mem_to_snapshot_id_map_entry_t;
+#endif /* JERRY_SNAPSHOT_SAVE */
+
+void ecma_finalize_lit_storage (void);
+
+ecma_value_t ecma_find_or_create_literal_string (const lit_utf8_byte_t *chars_p, lit_utf8_size_t size, bool is_ascii);
+ecma_value_t ecma_find_or_create_literal_number (ecma_number_t number_arg);
+#if JERRY_BUILTIN_BIGINT
+ecma_value_t ecma_find_or_create_literal_bigint (ecma_value_t bigint);
+#endif /* JERRY_BUILTIN_BIGINT */
+
+#if JERRY_SNAPSHOT_SAVE
+void ecma_save_literals_append_value (ecma_value_t value, ecma_collection_t *lit_pool_p);
+void ecma_save_literals_add_compiled_code (const ecma_compiled_code_t *compiled_code_p, ecma_collection_t *lit_pool_p);
+bool ecma_save_literals_for_snapshot (ecma_collection_t *lit_pool_p,
+                                      uint32_t *buffer_p,
+                                      size_t buffer_size,
+                                      size_t *in_out_buffer_offset_p,
+                                      lit_mem_to_snapshot_id_map_entry_t **out_map_p,
+                                      uint32_t *out_map_len_p);
+#endif /* JERRY_SNAPSHOT_SAVE */
+
+#if JERRY_SNAPSHOT_EXEC || JERRY_SNAPSHOT_SAVE
+ecma_value_t ecma_snapshot_get_literal (const uint8_t *literal_base_p, ecma_value_t literal_value);
+ecma_value_t *ecma_snapshot_resolve_serializable_values (const ecma_compiled_code_t *compiled_code_p,
+                                                         uint8_t *byte_code_end_p);
+#endif /* JERRY_SNAPSHOT_EXEC || JERRY_SNAPSHOT_SAVE */
+
+/**
+ * @}
+ * @}
+ */
+
+#endif /* !ECMA_LIT_STORAGE_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-module.h

@@ -0,0 +1,132 @@
+/* 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.
+ */
+
+#ifndef ECMA_MODULE_H
+#define ECMA_MODULE_H
+
+#include "ecma-globals.h"
+
+#include "common.h"
+
+#if JERRY_MODULE_SYSTEM
+
+#define ECMA_MODULE_MAX_PATH 255u
+
+/**
+ * Module status flags.
+ */
+typedef enum
+{
+  ECMA_MODULE_IS_NATIVE = (1 << 0), /**< native module */
+  ECMA_MODULE_HAS_NAMESPACE = (1 << 1), /**< namespace object has been initialized */
+} ecma_module_flags_t;
+
+/**
+ * Imported or exported names, such as "a as b"
+ * Note: See https://www.ecma-international.org/ecma-262/6.0/#table-39
+ *       and https://www.ecma-international.org/ecma-262/6.0/#table-41
+ */
+typedef struct ecma_module_names
+{
+  struct ecma_module_names *next_p; /**< next linked list node */
+  ecma_string_t *imex_name_p; /**< Import/export name of the item */
+  ecma_string_t *local_name_p; /**< Local name of the item */
+} ecma_module_names_t;
+
+/**
+ * Module structure storing an instance of a module
+ *
+ * Note:
+ *      The imports_p list follows the order of import-from/export-from statements in the source
+ *      code of a module, even if a given module specifier is only used by export-from statements.
+ */
+typedef struct ecma_module
+{
+  /* Note: state is stored in header.u.class_prop.extra_info */
+  ecma_extended_object_t header; /**< header part */
+  /* TODO(dbatyai): These could be compressed pointers */
+  ecma_object_t *scope_p; /**< lexical lenvironment of the module */
+  ecma_object_t *namespace_object_p; /**< namespace object of the module */
+  struct ecma_module_node *imports_p; /**< import requests of the module */
+  ecma_module_names_t *local_exports_p; /**< local exports of the module */
+  struct ecma_module_node *indirect_exports_p; /**< indirect exports of the module */
+  struct ecma_module_node *star_exports_p; /**< star exports of the module */
+
+  /* Code used for evaluating a module */
+  union
+  {
+    ecma_compiled_code_t *compiled_code_p; /**< compiled code for the module */
+    jerry_native_module_evaluate_cb_t callback; /**< callback for evaluating native modules */
+  } u;
+} ecma_module_t;
+
+/**
+ * Module node to store imports / exports.
+ *
+ * Note:
+ *      Only one module node is created for each module specifier: the names are
+ *      concatenated if the same specifier is used multiple times in the source code.
+ *      However, multiple nodes are created for modules with multiple alias
+ *      (for example ./a.mjs and ././a.mjs can refer to the same module).
+ */
+typedef struct ecma_module_node
+{
+  struct ecma_module_node *next_p; /**< next linked list node */
+  ecma_module_names_t *module_names_p; /**< names of the requested import/export node */
+
+  union
+  {
+    ecma_value_t path_or_module; /**< imports: module specifier (if string) or module reference (if object) */
+    ecma_value_t *module_object_p; /**< non-imports: reference to a path_or_module field in the imports */
+  } u;
+} ecma_module_node_t;
+
+/**
+ *  A list of module records that can be used to identify circular imports during resolution
+ */
+typedef struct ecma_module_resolve_set
+{
+  struct ecma_module_resolve_set *next_p; /**< next in linked list */
+  ecma_module_t *module_p; /**< module */
+  ecma_string_t *name_p; /**< identifier name */
+} ecma_module_resolve_set_t;
+
+/**
+ * A list that is used like a stack to drive the resolution process, instead of recursion.
+ */
+typedef struct ecma_module_resolve_stack
+{
+  struct ecma_module_resolve_stack *next_p; /**< next in linked list */
+  ecma_module_t *module_p; /**< module request */
+  ecma_string_t *export_name_p; /**< export identifier name */
+  bool resolving; /**< flag storing wether the current frame started resolving */
+} ecma_module_resolve_stack_t;
+
+ecma_value_t ecma_module_initialize (ecma_module_t *module_p);
+ecma_module_t *ecma_module_get_resolved_module (ecma_value_t module_val);
+
+ecma_value_t ecma_module_link (ecma_module_t *module_p, jerry_module_resolve_cb_t callback_p, void *user_p);
+ecma_value_t ecma_module_evaluate (ecma_module_t *module_p);
+ecma_value_t ecma_module_import (ecma_value_t specifier, ecma_value_t user_value);
+
+ecma_module_t *ecma_module_create (void);
+void ecma_module_cleanup_context (void);
+
+void ecma_module_release_module_names (ecma_module_names_t *module_name_p);
+void ecma_module_release_module (ecma_module_t *module_p);
+
+#endif /* JERRY_MODULE_SYSTEM */
+
+#endif /* !ECMA_MODULE_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-property-hashmap.cpp

@@ -0,0 +1,532 @@
+/* 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.
+ */
+
+#include "ecma-property-hashmap.h"
+
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+
+#include "jcontext.h"
+#include "jrt-libc-includes.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmapropertyhashmap Property hashmap
+ * @{
+ */
+
+#if JERRY_PROPERTY_HASHMAP
+
+/**
+ * Compute the total size of the property hashmap.
+ */
+#define ECMA_PROPERTY_HASHMAP_GET_TOTAL_SIZE(max_property_count) \
+  (sizeof (ecma_property_hashmap_t) + (max_property_count * sizeof (jmem_cpointer_t)) + (max_property_count >> 3))
+
+/**
+ * Number of items in the stepping table.
+ */
+#define ECMA_PROPERTY_HASHMAP_NUMBER_OF_STEPS 8
+
+/**
+ * Stepping values for searching items in the hashmap.
+ */
+static const uint8_t ecma_property_hashmap_steps[ECMA_PROPERTY_HASHMAP_NUMBER_OF_STEPS] JERRY_ATTR_CONST_DATA = {
+  3, 5, 7, 11, 13, 17, 19, 23
+};
+
+/**
+ * Get the value of a bit in a bitmap.
+ */
+#define ECMA_PROPERTY_HASHMAP_GET_BIT(byte_p, index) ((byte_p)[(index) >> 3] & (1 << ((index) &0x7)))
+
+/**
+ * Clear the value of a bit in a bitmap.
+ */
+#define ECMA_PROPERTY_HASHMAP_CLEAR_BIT(byte_p, index) \
+  ((byte_p)[(index) >> 3] = (uint8_t) ((byte_p)[(index) >> 3] & ~(1 << ((index) &0x7))))
+
+/**
+ * Set the value of a bit in a bitmap.
+ */
+#define ECMA_PROPERTY_HASHMAP_SET_BIT(byte_p, index) \
+  ((byte_p)[(index) >> 3] = (uint8_t) ((byte_p)[(index) >> 3] | (1 << ((index) &0x7))))
+
+/**
+ * Create a new property hashmap for the object.
+ * The object must not have a property hashmap.
+ */
+void
+ecma_property_hashmap_create (ecma_object_t *object_p) /**< object */
+{
+  if (JERRY_CONTEXT (ecma_prop_hashmap_alloc_state) != ECMA_PROP_HASHMAP_ALLOC_ON)
+  {
+    return;
+  }
+
+  jmem_cpointer_t prop_iter_cp = object_p->u1.property_list_cp;
+
+  if (prop_iter_cp == JMEM_CP_NULL)
+  {
+    return;
+  }
+
+  uint32_t named_property_count = 0;
+
+  while (prop_iter_cp != JMEM_CP_NULL)
+  {
+    ecma_property_header_t *prop_iter_p = ECMA_GET_NON_NULL_POINTER (ecma_property_header_t, prop_iter_cp);
+    JERRY_ASSERT (ECMA_PROPERTY_IS_PROPERTY_PAIR (prop_iter_p));
+
+    for (int i = 0; i < ECMA_PROPERTY_PAIR_ITEM_COUNT; i++)
+    {
+      if (prop_iter_p->types[i] != ECMA_PROPERTY_TYPE_DELETED)
+      {
+        JERRY_ASSERT (ECMA_PROPERTY_IS_NAMED_PROPERTY (prop_iter_p->types[i]));
+        named_property_count++;
+      }
+    }
+    prop_iter_cp = prop_iter_p->next_property_cp;
+  }
+
+  if (named_property_count < (ECMA_PROPERTY_HASMAP_MINIMUM_SIZE / 2))
+  {
+    return;
+  }
+
+  /* The max_property_count must be power of 2. */
+  uint32_t max_property_count = ECMA_PROPERTY_HASMAP_MINIMUM_SIZE;
+
+  /* At least 1/3 items must be NULL. */
+  while (max_property_count < (named_property_count + (named_property_count >> 1)))
+  {
+    max_property_count <<= 1;
+  }
+
+  size_t total_size = ECMA_PROPERTY_HASHMAP_GET_TOTAL_SIZE (max_property_count);
+
+  ecma_property_hashmap_t *hashmap_p = (ecma_property_hashmap_t *) jmem_heap_alloc_block_null_on_error (total_size);
+
+  if (hashmap_p == NULL)
+  {
+    return;
+  }
+
+  memset (hashmap_p, 0, total_size);
+
+  hashmap_p->header.types[0] = ECMA_PROPERTY_TYPE_HASHMAP;
+  hashmap_p->header.next_property_cp = object_p->u1.property_list_cp;
+  hashmap_p->max_property_count = max_property_count;
+  hashmap_p->null_count = max_property_count - named_property_count;
+  hashmap_p->unused_count = max_property_count - named_property_count;
+
+  jmem_cpointer_t *pair_list_p = (jmem_cpointer_t *) (hashmap_p + 1);
+  uint8_t *bits_p = (uint8_t *) (pair_list_p + max_property_count);
+  uint32_t mask = max_property_count - 1;
+
+  prop_iter_cp = object_p->u1.property_list_cp;
+  ECMA_SET_NON_NULL_POINTER (object_p->u1.property_list_cp, hashmap_p);
+
+  while (prop_iter_cp != JMEM_CP_NULL)
+  {
+    ecma_property_header_t *prop_iter_p = ECMA_GET_NON_NULL_POINTER (ecma_property_header_t, prop_iter_cp);
+    JERRY_ASSERT (ECMA_PROPERTY_IS_PROPERTY_PAIR (prop_iter_p));
+
+    for (int i = 0; i < ECMA_PROPERTY_PAIR_ITEM_COUNT; i++)
+    {
+      if (prop_iter_p->types[i] == ECMA_PROPERTY_TYPE_DELETED)
+      {
+        continue;
+      }
+
+      JERRY_ASSERT (ECMA_PROPERTY_IS_NAMED_PROPERTY (prop_iter_p->types[i]));
+
+      ecma_property_pair_t *property_pair_p = (ecma_property_pair_t *) prop_iter_p;
+
+      uint32_t entry_index = ecma_string_get_property_name_hash (prop_iter_p->types[i], property_pair_p->names_cp[i]);
+      uint32_t step = ecma_property_hashmap_steps[entry_index & (ECMA_PROPERTY_HASHMAP_NUMBER_OF_STEPS - 1)];
+
+      entry_index &= mask;
+#ifndef JERRY_NDEBUG
+      /* Because max_property_count (power of 2) and step (a prime
+       * number) are relative primes, all entries of the hasmap are
+       * visited exactly once before the start entry index is reached
+       * again. Furthermore because at least one NULL is present in
+       * the hashmap, the while loop must be terminated before the
+       * the starting index is reached again. */
+      uint32_t start_entry_index = entry_index;
+#endif /* !JERRY_NDEBUG */
+
+      while (pair_list_p[entry_index] != ECMA_NULL_POINTER)
+      {
+        entry_index = (entry_index + step) & mask;
+
+#ifndef JERRY_NDEBUG
+        JERRY_ASSERT (entry_index != start_entry_index);
+#endif /* !JERRY_NDEBUG */
+      }
+
+      ECMA_SET_NON_NULL_POINTER (pair_list_p[entry_index], property_pair_p);
+
+      if (i != 0)
+      {
+        ECMA_PROPERTY_HASHMAP_SET_BIT (bits_p, entry_index);
+      }
+    }
+
+    prop_iter_cp = prop_iter_p->next_property_cp;
+  }
+} /* ecma_property_hashmap_create */
+
+/**
+ * Free the hashmap of the object.
+ * The object must have a property hashmap.
+ */
+void
+ecma_property_hashmap_free (ecma_object_t *object_p) /**< object */
+{
+  /* Property hash must be exists and must be the first property. */
+  JERRY_ASSERT (object_p->u1.property_list_cp != JMEM_CP_NULL);
+
+  ecma_property_header_t *property_p =
+    ECMA_GET_NON_NULL_POINTER (ecma_property_header_t, object_p->u1.property_list_cp);
+
+  JERRY_ASSERT (property_p->types[0] == ECMA_PROPERTY_TYPE_HASHMAP);
+
+  ecma_property_hashmap_t *hashmap_p = (ecma_property_hashmap_t *) property_p;
+
+  object_p->u1.property_list_cp = property_p->next_property_cp;
+
+  jmem_heap_free_block (hashmap_p, ECMA_PROPERTY_HASHMAP_GET_TOTAL_SIZE (hashmap_p->max_property_count));
+} /* ecma_property_hashmap_free */
+
+/**
+ * Insert named property into the hashmap.
+ */
+void
+ecma_property_hashmap_insert (ecma_object_t *object_p, /**< object */
+                              ecma_string_t *name_p, /**< name of the property */
+                              ecma_property_pair_t *property_pair_p, /**< property pair */
+                              int property_index) /**< property index in the pair (0 or 1) */
+{
+  JERRY_ASSERT (property_pair_p != NULL);
+
+  ecma_property_hashmap_t *hashmap_p =
+    ECMA_GET_NON_NULL_POINTER (ecma_property_hashmap_t, object_p->u1.property_list_cp);
+
+  JERRY_ASSERT (hashmap_p->header.types[0] == ECMA_PROPERTY_TYPE_HASHMAP);
+
+  /* The NULLs are reduced below 1/8 of the hashmap. */
+  if (hashmap_p->null_count < (hashmap_p->max_property_count >> 3))
+  {
+    ecma_property_hashmap_free (object_p);
+    ecma_property_hashmap_create (object_p);
+    return;
+  }
+
+  JERRY_ASSERT (property_index < ECMA_PROPERTY_PAIR_ITEM_COUNT);
+
+  uint32_t entry_index = ecma_string_hash (name_p);
+  uint32_t step = ecma_property_hashmap_steps[entry_index & (ECMA_PROPERTY_HASHMAP_NUMBER_OF_STEPS - 1)];
+  uint32_t mask = hashmap_p->max_property_count - 1;
+  entry_index &= mask;
+
+#ifndef JERRY_NDEBUG
+  /* See the comment for this variable in ecma_property_hashmap_create. */
+  uint32_t start_entry_index = entry_index;
+#endif /* !JERRY_NDEBUG */
+
+  jmem_cpointer_t *pair_list_p = (jmem_cpointer_t *) (hashmap_p + 1);
+
+  while (pair_list_p[entry_index] != ECMA_NULL_POINTER)
+  {
+    entry_index = (entry_index + step) & mask;
+
+#ifndef JERRY_NDEBUG
+    JERRY_ASSERT (entry_index != start_entry_index);
+#endif /* !JERRY_NDEBUG */
+  }
+
+  ECMA_SET_NON_NULL_POINTER (pair_list_p[entry_index], property_pair_p);
+
+  uint8_t *bits_p = (uint8_t *) (pair_list_p + hashmap_p->max_property_count);
+  bits_p += (entry_index >> 3);
+  mask = (uint32_t) (1 << (entry_index & 0x7));
+
+  if (!(*bits_p & mask))
+  {
+    /* Deleted entries also has ECMA_NULL_POINTER
+     * value, but they are not NULL values. */
+    hashmap_p->null_count--;
+    JERRY_ASSERT (hashmap_p->null_count > 0);
+  }
+
+  hashmap_p->unused_count--;
+  JERRY_ASSERT (hashmap_p->unused_count > 0);
+
+  if (property_index == 0)
+  {
+    *bits_p = (uint8_t) ((*bits_p) & ~mask);
+  }
+  else
+  {
+    *bits_p = (uint8_t) ((*bits_p) | mask);
+  }
+} /* ecma_property_hashmap_insert */
+
+/**
+ * Delete named property from the hashmap.
+ *
+ * @return ECMA_PROPERTY_HASHMAP_DELETE_RECREATE_HASHMAP if hashmap should be recreated
+ *         ECMA_PROPERTY_HASHMAP_DELETE_HAS_HASHMAP otherwise
+ */
+ecma_property_hashmap_delete_status
+ecma_property_hashmap_delete (ecma_object_t *object_p, /**< object */
+                              jmem_cpointer_t name_cp, /**< property name */
+                              ecma_property_t *property_p) /**< property */
+{
+  ecma_property_hashmap_t *hashmap_p =
+    ECMA_GET_NON_NULL_POINTER (ecma_property_hashmap_t, object_p->u1.property_list_cp);
+
+  JERRY_ASSERT (hashmap_p->header.types[0] == ECMA_PROPERTY_TYPE_HASHMAP);
+
+  hashmap_p->unused_count++;
+
+  /* The NULLs are above 3/4 of the hashmap. */
+  if (hashmap_p->unused_count > ((hashmap_p->max_property_count * 3) >> 2))
+  {
+    return ECMA_PROPERTY_HASHMAP_DELETE_RECREATE_HASHMAP;
+  }
+
+  uint32_t entry_index = ecma_string_get_property_name_hash (*property_p, name_cp);
+  uint32_t step = ecma_property_hashmap_steps[entry_index & (ECMA_PROPERTY_HASHMAP_NUMBER_OF_STEPS - 1)];
+  uint32_t mask = hashmap_p->max_property_count - 1;
+  jmem_cpointer_t *pair_list_p = (jmem_cpointer_t *) (hashmap_p + 1);
+  uint8_t *bits_p = (uint8_t *) (pair_list_p + hashmap_p->max_property_count);
+
+  entry_index &= mask;
+
+#ifndef JERRY_NDEBUG
+  /* See the comment for this variable in ecma_property_hashmap_create. */
+  uint32_t start_entry_index = entry_index;
+#endif /* !JERRY_NDEBUG */
+
+  while (true)
+  {
+    if (pair_list_p[entry_index] != ECMA_NULL_POINTER)
+    {
+      size_t offset = 0;
+
+      if (ECMA_PROPERTY_HASHMAP_GET_BIT (bits_p, entry_index))
+      {
+        offset = 1;
+      }
+
+      ecma_property_pair_t *property_pair_p =
+        ECMA_GET_NON_NULL_POINTER (ecma_property_pair_t, pair_list_p[entry_index]);
+
+      if ((property_pair_p->header.types + offset) == property_p)
+      {
+        JERRY_ASSERT (property_pair_p->names_cp[offset] == name_cp);
+
+        pair_list_p[entry_index] = ECMA_NULL_POINTER;
+        ECMA_PROPERTY_HASHMAP_SET_BIT (bits_p, entry_index);
+        return ECMA_PROPERTY_HASHMAP_DELETE_HAS_HASHMAP;
+      }
+    }
+    else
+    {
+      /* Must be a deleted entry. */
+      JERRY_ASSERT (ECMA_PROPERTY_HASHMAP_GET_BIT (bits_p, entry_index));
+    }
+
+    entry_index = (entry_index + step) & mask;
+
+#ifndef JERRY_NDEBUG
+    JERRY_ASSERT (entry_index != start_entry_index);
+#endif /* !JERRY_NDEBUG */
+  }
+} /* ecma_property_hashmap_delete */
+
+/**
+ * Find a named property.
+ *
+ * @return pointer to the property if found or NULL otherwise
+ */
+ecma_property_t *
+ecma_property_hashmap_find (ecma_property_hashmap_t *hashmap_p, /**< hashmap */
+                            ecma_string_t *name_p, /**< property name */
+                            jmem_cpointer_t *property_real_name_cp) /**< [out] property real name */
+{
+#ifndef JERRY_NDEBUG
+  /* A sanity check in debug mode: a named property must be present
+   * in both the property hashmap and in the property chain, or missing
+   * from both data collection. The following code checks the property
+   * chain, and sets the property_found variable. */
+  bool property_found = false;
+
+  jmem_cpointer_t prop_iter_cp = hashmap_p->header.next_property_cp;
+
+  while (prop_iter_cp != JMEM_CP_NULL && !property_found)
+  {
+    ecma_property_header_t *prop_iter_p = ECMA_GET_NON_NULL_POINTER (ecma_property_header_t, prop_iter_cp);
+    JERRY_ASSERT (ECMA_PROPERTY_IS_PROPERTY_PAIR (prop_iter_p));
+
+    ecma_property_pair_t *prop_pair_p = (ecma_property_pair_t *) prop_iter_p;
+
+    for (int i = 0; i < ECMA_PROPERTY_PAIR_ITEM_COUNT; i++)
+    {
+      if (ECMA_PROPERTY_IS_NAMED_PROPERTY (prop_iter_p->types[i]))
+      {
+        if (ecma_string_compare_to_property_name (prop_iter_p->types[i], prop_pair_p->names_cp[i], name_p))
+        {
+          /* Property is found */
+          property_found = true;
+          break;
+        }
+      }
+    }
+
+    prop_iter_cp = prop_iter_p->next_property_cp;
+  }
+#endif /* !JERRY_NDEBUG */
+
+  uint32_t entry_index = ecma_string_hash (name_p);
+  uint32_t step = ecma_property_hashmap_steps[entry_index & (ECMA_PROPERTY_HASHMAP_NUMBER_OF_STEPS - 1)];
+  uint32_t mask = hashmap_p->max_property_count - 1;
+  jmem_cpointer_t *pair_list_p = (jmem_cpointer_t *) (hashmap_p + 1);
+  uint8_t *bits_p = (uint8_t *) (pair_list_p + hashmap_p->max_property_count);
+  entry_index &= mask;
+
+#ifndef JERRY_NDEBUG
+  /* See the comment for this variable in ecma_property_hashmap_create. */
+  uint32_t start_entry_index = entry_index;
+#endif /* !JERRY_NDEBUG */
+
+  if (ECMA_IS_DIRECT_STRING (name_p))
+  {
+    ecma_property_t prop_name_type = (ecma_property_t) ECMA_GET_DIRECT_STRING_TYPE (name_p);
+    jmem_cpointer_t property_name_cp = (jmem_cpointer_t) ECMA_GET_DIRECT_STRING_VALUE (name_p);
+
+    JERRY_ASSERT (prop_name_type > 0);
+
+    while (true)
+    {
+      if (pair_list_p[entry_index] != ECMA_NULL_POINTER)
+      {
+        size_t offset = 0;
+        if (ECMA_PROPERTY_HASHMAP_GET_BIT (bits_p, entry_index))
+        {
+          offset = 1;
+        }
+
+        ecma_property_pair_t *property_pair_p =
+          ECMA_GET_NON_NULL_POINTER (ecma_property_pair_t, pair_list_p[entry_index]);
+
+        ecma_property_t *property_p = property_pair_p->header.types + offset;
+
+        JERRY_ASSERT (ECMA_PROPERTY_IS_NAMED_PROPERTY (*property_p));
+
+        if (property_pair_p->names_cp[offset] == property_name_cp
+            && ECMA_PROPERTY_GET_NAME_TYPE (*property_p) == prop_name_type)
+        {
+#ifndef JERRY_NDEBUG
+          JERRY_ASSERT (property_found);
+#endif /* !JERRY_NDEBUG */
+
+          *property_real_name_cp = property_name_cp;
+          return property_p;
+        }
+      }
+      else
+      {
+        if (!ECMA_PROPERTY_HASHMAP_GET_BIT (bits_p, entry_index))
+        {
+#ifndef JERRY_NDEBUG
+          JERRY_ASSERT (!property_found);
+#endif /* !JERRY_NDEBUG */
+
+          return NULL;
+        }
+        /* Otherwise it is a deleted entry. */
+      }
+
+      entry_index = (entry_index + step) & mask;
+
+#ifndef JERRY_NDEBUG
+      JERRY_ASSERT (entry_index != start_entry_index);
+#endif /* !JERRY_NDEBUG */
+    }
+  }
+
+  while (true)
+  {
+    if (pair_list_p[entry_index] != ECMA_NULL_POINTER)
+    {
+      size_t offset = 0;
+      if (ECMA_PROPERTY_HASHMAP_GET_BIT (bits_p, entry_index))
+      {
+        offset = 1;
+      }
+
+      ecma_property_pair_t *property_pair_p =
+        ECMA_GET_NON_NULL_POINTER (ecma_property_pair_t, pair_list_p[entry_index]);
+
+      ecma_property_t *property_p = property_pair_p->header.types + offset;
+
+      JERRY_ASSERT (ECMA_PROPERTY_IS_NAMED_PROPERTY (*property_p));
+
+      if (ECMA_PROPERTY_GET_NAME_TYPE (*property_p) == ECMA_DIRECT_STRING_PTR)
+      {
+        ecma_string_t *prop_name_p = ECMA_GET_NON_NULL_POINTER (ecma_string_t, property_pair_p->names_cp[offset]);
+
+        if (ecma_compare_ecma_non_direct_strings (prop_name_p, name_p))
+        {
+#ifndef JERRY_NDEBUG
+          JERRY_ASSERT (property_found);
+#endif /* !JERRY_NDEBUG */
+
+          *property_real_name_cp = property_pair_p->names_cp[offset];
+          return property_p;
+        }
+      }
+    }
+    else
+    {
+      if (!ECMA_PROPERTY_HASHMAP_GET_BIT (bits_p, entry_index))
+      {
+#ifndef JERRY_NDEBUG
+        JERRY_ASSERT (!property_found);
+#endif /* !JERRY_NDEBUG */
+
+        return NULL;
+      }
+      /* Otherwise it is a deleted entry. */
+    }
+
+    entry_index = (entry_index + step) & mask;
+
+#ifndef JERRY_NDEBUG
+    JERRY_ASSERT (entry_index != start_entry_index);
+#endif /* !JERRY_NDEBUG */
+  }
+} /* ecma_property_hashmap_find */
+#endif /* JERRY_PROPERTY_HASHMAP */
+
+/**
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/ecma-property-hashmap.h

@@ -0,0 +1,89 @@
+/* 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.
+ */
+
+#ifndef ECMA_PROPERTY_HASHMAP_H
+#define ECMA_PROPERTY_HASHMAP_H
+
+#include "ecma-globals.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmapropertyhashmap Property hashmap
+ * @{
+ */
+
+/**
+ * Recommended minimum number of items in a property cache.
+ */
+#define ECMA_PROPERTY_HASMAP_MINIMUM_SIZE 32
+
+/**
+ * Property hash.
+ */
+typedef struct
+{
+  ecma_property_header_t header; /**< header of the property */
+  uint32_t max_property_count; /**< maximum property count (power of 2) */
+  uint32_t null_count; /**< number of NULLs in the map */
+  uint32_t unused_count; /**< number of unused entries in the map */
+
+  /*
+   * The hash is followed by max_property_count ecma_cpointer_t
+   * compressed pointers and (max_property_count + 7) / 8 bytes
+   * which stores a flag for each compressed pointer.
+   *
+   * If the compressed pointer is equal to ECMA_NULL_POINTER
+   *   - flag is cleared if the entry is NULL
+   *   - flag is set if the entry is deleted
+   *
+   * If the compressed pointer is not equal to ECMA_NULL_POINTER
+   *   - flag is cleared if the first entry of a property pair is referenced
+   *   - flag is set if the second entry of a property pair is referenced
+   */
+} ecma_property_hashmap_t;
+
+#if JERRY_PROPERTY_HASHMAP
+
+/**
+ * Simple ecma values
+ */
+typedef enum
+{
+  ECMA_PROPERTY_HASHMAP_DELETE_NO_HASHMAP, /**< object has no hashmap */
+  ECMA_PROPERTY_HASHMAP_DELETE_HAS_HASHMAP, /**< object has hashmap */
+  ECMA_PROPERTY_HASHMAP_DELETE_RECREATE_HASHMAP, /**< hashmap should be recreated */
+} ecma_property_hashmap_delete_status;
+
+void ecma_property_hashmap_create (ecma_object_t *object_p);
+void ecma_property_hashmap_free (ecma_object_t *object_p);
+void ecma_property_hashmap_insert (ecma_object_t *object_p,
+                                   ecma_string_t *name_p,
+                                   ecma_property_pair_t *property_pair_p,
+                                   int property_index);
+ecma_property_hashmap_delete_status
+ecma_property_hashmap_delete (ecma_object_t *object_p, jmem_cpointer_t name_cp, ecma_property_t *property_p);
+
+ecma_property_t *ecma_property_hashmap_find (ecma_property_hashmap_t *hashmap_p,
+                                             ecma_string_t *name_p,
+                                             jmem_cpointer_t *property_real_name_cp);
+#endif /* JERRY_PROPERTY_HASHMAP */
+
+/**
+ * @}
+ * @}
+ */
+
+#endif /* !ECMA_PROPERTY_HASHMAP_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/base/meson.build

@@ -0,0 +1,39 @@
+source_file = [
+    'ecma-alloc.h',
+    'ecma-error-messages.inc.h',
+    'ecma-errors.h',
+    'ecma-extended-info.h',
+    'ecma-gc.h',
+    'ecma-globals.h',
+    'ecma-helpers-number.h',
+    'ecma-helpers.h',
+    'ecma-init-finalize.h',
+    'ecma-lcache.h',
+    'ecma-line-info.h',
+    'ecma-literal-storage.h',
+    'ecma-module.h',
+    'ecma-property-hashmap.h',
+    'ecma-alloc.cpp',
+    'ecma-errors.cpp',
+    'ecma-extended-info.cpp',
+    'ecma-gc.cpp',
+    'ecma-helpers-collection.cpp',
+    'ecma-helpers-conversion.cpp',
+    'ecma-helpers-errol.cpp',
+    'ecma-helpers-external-pointers.cpp',
+    'ecma-helpers-number.cpp',
+    'ecma-helpers-string.cpp',
+    'ecma-helpers-value.cpp',
+    'ecma-helpers.cpp',
+    'ecma-init-finalize.cpp',
+    'ecma-lcache.cpp',
+    'ecma-line-info.cpp',
+    'ecma-literal-storage.cpp',
+    'ecma-module.cpp',
+    'ecma-property-hashmap.cpp'
+]
+
+subloader_dep += [declare_dependency(
+    include_directories : include_directories('.'),
+    sources : source_file
+)]

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-aggregateerror-prototype.cpp

@@ -0,0 +1,33 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+
+#include "jrt.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-aggregateerror-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  aggregate_error_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-aggregateerror-prototype.inc.h

@@ -0,0 +1,34 @@
+/* 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.
+ */
+
+/*
+ * AggregateError.prototype built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.11.7.8 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_AGGREGATE_ERROR, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* ECMA-262 v5, 15.11.7.9 */
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_AGGREGATE_ERROR_UL, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* ECMA-262 v5, 15.11.7.10 */
+STRING_VALUE (LIT_MAGIC_STRING_MESSAGE, LIT_MAGIC_STRING__EMPTY, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-aggregateerror.cpp

@@ -0,0 +1,109 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-array-object.h"
+#include "ecma-builtin-helpers.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-iterator-object.h"
+#include "ecma-objects.h"
+
+#include "jcontext.h"
+#include "jrt.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-aggregateerror.inc.h"
+#define BUILTIN_UNDERSCORED_ID  aggregate_error
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup aggregateerror ECMA AggregateError object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in AggregateError object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_aggregate_error_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                            uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+  ecma_value_t message_val = ECMA_VALUE_UNDEFINED;
+  ecma_value_t error_val = ECMA_VALUE_UNDEFINED;
+
+  if (arguments_list_len > 0)
+  {
+    error_val = arguments_list_p[0];
+
+    if (arguments_list_len > 1)
+    {
+      message_val = arguments_list_p[1];
+    }
+  }
+
+  return ecma_new_aggregate_error (error_val, message_val);
+} /* ecma_builtin_aggregate_error_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in AggregateError object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_aggregate_error_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                 uint32_t arguments_list_len) /**< number of arguments */
+{
+  ecma_object_t *proto_p = ecma_op_get_prototype_from_constructor (JERRY_CONTEXT (current_new_target_p),
+                                                                   ECMA_BUILTIN_ID_AGGREGATE_ERROR_PROTOTYPE);
+
+  if (proto_p == NULL)
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  ecma_value_t result = ecma_builtin_aggregate_error_dispatch_call (arguments_list_p, arguments_list_len);
+
+  if (!ECMA_IS_VALUE_ERROR (result))
+  {
+    ecma_object_t *object_p = ecma_get_object_from_value (result);
+    ECMA_SET_NON_NULL_POINTER (object_p->u2.prototype_cp, proto_p);
+  }
+
+  ecma_deref_object (proto_p);
+
+  return result;
+} /* ecma_builtin_aggregate_error_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-aggregateerror.inc.h

@@ -0,0 +1,35 @@
+/* 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.
+ */
+
+/*
+ * AggregateError built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 2, ECMA_PROPERTY_FLAG_DEFAULT_LENGTH)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.11.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_AGGREGATE_ERROR_PROTOTYPE, ECMA_PROPERTY_FIXED)
+
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_AGGREGATE_ERROR_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-array-iterator-prototype.cpp

@@ -0,0 +1,224 @@
+/* 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.
+ */
+
+#include "ecma-arraybuffer-object.h"
+#include "ecma-builtin-helpers.h"
+#include "ecma-builtins.h"
+#include "ecma-iterator-object.h"
+#include "ecma-typedarray-object.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_ARRAY_ITERATOR_PROTOTYPE_ROUTINE_START = 0,
+  ECMA_ARRAY_ITERATOR_PROTOTYPE_OBJECT_NEXT,
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-array-iterator-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  array_iterator_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup %arrayiteratorprototype% ECMA %ArrayIteratorPrototype% object built-in
+ * @{
+ */
+
+/**
+ * The %ArrayIteratorPrototype% object's 'next' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 22.1.5.2.1
+ *
+ * Note:
+ *     Returned value must be freed with ecma_free_value.
+ *
+ * @return iterator result object, if success
+ *         error - otherwise
+ */
+static ecma_value_t
+ecma_builtin_array_iterator_prototype_object_next (ecma_value_t this_val) /**< this argument */
+{
+  /* 1 - 2. */
+  if (!ecma_is_value_object (this_val))
+  {
+    return ecma_raise_type_error (ECMA_ERR_ARGUMENT_THIS_NOT_OBJECT);
+  }
+
+  ecma_object_t *obj_p = ecma_get_object_from_value (this_val);
+  ecma_extended_object_t *ext_obj_p = (ecma_extended_object_t *) obj_p;
+
+  /* 3. */
+  if (!ecma_object_class_is (obj_p, ECMA_OBJECT_CLASS_ARRAY_ITERATOR))
+  {
+    return ecma_raise_type_error (ECMA_ERR_ARGUMENT_THIS_NOT_ITERATOR);
+  }
+
+  ecma_value_t iterated_value = ext_obj_p->u.cls.u3.iterated_value;
+
+  /* 4 - 5 */
+  if (ecma_is_value_empty (iterated_value))
+  {
+    return ecma_create_iter_result_object (ECMA_VALUE_UNDEFINED, ECMA_VALUE_TRUE);
+  }
+
+  ecma_object_t *array_object_p = ecma_get_object_from_value (iterated_value);
+
+  /* 8. */
+  ecma_length_t length;
+  if (ecma_object_is_typedarray (array_object_p))
+  {
+    /* a. */
+    ecma_object_t *arraybuffer_p = ecma_typedarray_get_arraybuffer (array_object_p);
+    if (ecma_arraybuffer_is_detached (arraybuffer_p))
+    {
+      return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED);
+    }
+
+    /* b. */
+    length = ecma_typedarray_get_length (array_object_p);
+  }
+  else
+  {
+    ecma_value_t len_value = ecma_op_object_get_length (array_object_p, &length);
+
+    if (ECMA_IS_VALUE_ERROR (len_value))
+    {
+      return len_value;
+    }
+  }
+
+  ecma_length_t index = ext_obj_p->u.cls.u2.iterator_index;
+
+  if (JERRY_UNLIKELY (index == ECMA_ITERATOR_INDEX_LIMIT))
+  {
+    /* After the ECMA_ITERATOR_INDEX_LIMIT limit is reached the [[%Iterator%NextIndex]]
+       property is stored as an internal property */
+    ecma_string_t *prop_name_p = ecma_get_magic_string (LIT_INTERNAL_MAGIC_STRING_ITERATOR_NEXT_INDEX);
+    ecma_value_t index_value = ecma_op_object_get (obj_p, prop_name_p);
+
+    if (!ecma_is_value_undefined (index_value))
+    {
+      index = (ecma_length_t) (ecma_get_number_from_value (index_value) + 1);
+    }
+
+    ecma_value_t put_result = ecma_op_object_put (obj_p, prop_name_p, ecma_make_length_value (index), true);
+
+    JERRY_ASSERT (ecma_is_value_true (put_result));
+
+    ecma_free_value (index_value);
+  }
+  else
+  {
+    /* 11. */
+    ext_obj_p->u.cls.u2.iterator_index++;
+  }
+
+  if (index >= length)
+  {
+    ext_obj_p->u.cls.u3.iterated_value = ECMA_VALUE_EMPTY;
+    return ecma_create_iter_result_object (ECMA_VALUE_UNDEFINED, ECMA_VALUE_TRUE);
+  }
+
+  /* 7. */
+  uint8_t iterator_kind = ext_obj_p->u.cls.u1.iterator_kind;
+
+  if (iterator_kind == ECMA_ITERATOR_KEYS)
+  {
+    /* 12. */
+    return ecma_create_iter_result_object (ecma_make_length_value (index), ECMA_VALUE_FALSE);
+  }
+
+  /* 14. */
+  ecma_value_t get_value = ecma_op_object_get_by_index (array_object_p, index);
+
+  /* 15. */
+  if (ECMA_IS_VALUE_ERROR (get_value))
+  {
+    return get_value;
+  }
+
+  ecma_value_t result;
+
+  /* 16. */
+  if (iterator_kind == ECMA_ITERATOR_VALUES)
+  {
+    result = ecma_create_iter_result_object (get_value, ECMA_VALUE_FALSE);
+  }
+  else
+  {
+    /* 17.a */
+    JERRY_ASSERT (iterator_kind == ECMA_ITERATOR_ENTRIES);
+
+    /* 17.b */
+    ecma_value_t entry_array_value;
+    entry_array_value = ecma_create_array_from_iter_element (get_value, ecma_make_length_value (index));
+
+    result = ecma_create_iter_result_object (entry_array_value, ECMA_VALUE_FALSE);
+    ecma_free_value (entry_array_value);
+  }
+
+  ecma_free_value (get_value);
+
+  return result;
+} /* ecma_builtin_array_iterator_prototype_object_next */
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_array_iterator_prototype_dispatch_routine (uint8_t builtin_routine_id, /**< built-in routine identifier */
+                                                        ecma_value_t this_arg, /**< 'this' argument value */
+                                                        const ecma_value_t arguments_list_p[], /**< list of arguments
+                                                                                                *   passed to routine */
+                                                        uint32_t arguments_number) /**< length of arguments' list */
+{
+  JERRY_UNUSED_2 (arguments_list_p, arguments_number);
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_ARRAY_ITERATOR_PROTOTYPE_OBJECT_NEXT:
+    {
+      return ecma_builtin_array_iterator_prototype_object_next (this_arg);
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+} /* ecma_builtin_array_iterator_prototype_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-array-iterator-prototype.inc.h

@@ -0,0 +1,28 @@
+/* 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.
+ */
+
+/*
+ * %ArrayIteratorPrototype% built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG, LIT_MAGIC_STRING_ARRAY_ITERATOR_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_NEXT, ECMA_ARRAY_ITERATOR_PROTOTYPE_OBJECT_NEXT, 0, 0)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype-unscopables.cpp

@@ -0,0 +1,24 @@
+/* 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.
+ */
+
+#include "ecma-builtin-helpers.h"
+#include "ecma-builtins.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-array-prototype-unscopables.inc.h"
+#define BUILTIN_UNDERSCORED_ID  array_prototype_unscopables
+#include "ecma-builtin-internal-routines-template.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype-unscopables.inc.h

@@ -0,0 +1,44 @@
+/* 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.
+ */
+
+/*
+ * Array.prototype[@@unscopables] built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_AT, ECMA_VALUE_TRUE, ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_COPY_WITHIN, ECMA_VALUE_TRUE, ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_ENTRIES, ECMA_VALUE_TRUE, ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_FILL, ECMA_VALUE_TRUE, ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_FIND, ECMA_VALUE_TRUE, ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_FIND_INDEX, ECMA_VALUE_TRUE, ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_FLAT, ECMA_VALUE_TRUE, ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_FLATMAP, ECMA_VALUE_TRUE, ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_INCLUDES, ECMA_VALUE_TRUE, ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_KEYS, ECMA_VALUE_TRUE, ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+SIMPLE_VALUE (LIT_MAGIC_STRING_VALUES, ECMA_VALUE_TRUE, ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.inc.h

@@ -0,0 +1,85 @@
+/* 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.
+ */
+
+/*
+ * Array.prototype built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_ARRAY
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.4.4.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_ARRAY, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* ECMA-262 v6, 22.1.3.31 */
+OBJECT_VALUE (LIT_GLOBAL_SYMBOL_UNSCOPABLES,
+              ECMA_BUILTIN_ID_ARRAY_PROTOTYPE_UNSCOPABLES,
+              ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Number properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.4.4 */
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 0, ECMA_PROPERTY_FLAG_WRITABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_TO_LOCALE_STRING_UL, ECMA_ARRAY_PROTOTYPE_TO_LOCALE_STRING, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_CONCAT, ECMA_ARRAY_PROTOTYPE_CONCAT, NON_FIXED, 1)
+ROUTINE (LIT_MAGIC_STRING_JOIN, ECMA_ARRAY_PROTOTYPE_JOIN, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_POP, ECMA_ARRAY_PROTOTYPE_POP, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_PUSH, ECMA_ARRAY_PROTOTYPE_PUSH, NON_FIXED, 1)
+ROUTINE (LIT_MAGIC_STRING_REVERSE, ECMA_ARRAY_PROTOTYPE_REVERSE, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_SHIFT, ECMA_ARRAY_PROTOTYPE_SHIFT, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_SLICE, ECMA_ARRAY_PROTOTYPE_SLICE, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_SORT, ECMA_ARRAY_PROTOTYPE_SORT, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_AT, ECMA_ARRAY_PROTOTYPE_AT, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_SPLICE, ECMA_ARRAY_PROTOTYPE_SPLICE, NON_FIXED, 2)
+ROUTINE (LIT_MAGIC_STRING_UNSHIFT, ECMA_ARRAY_PROTOTYPE_UNSHIFT, NON_FIXED, 1)
+ROUTINE (LIT_MAGIC_STRING_INDEX_OF_UL, ECMA_ARRAY_PROTOTYPE_INDEX_OF, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_LAST_INDEX_OF_UL, ECMA_ARRAY_PROTOTYPE_LAST_INDEX_OF, NON_FIXED, 1)
+/* Note these 3 routines must be in this order */
+ROUTINE (LIT_MAGIC_STRING_EVERY, ECMA_ARRAY_PROTOTYPE_EVERY, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_SOME, ECMA_ARRAY_PROTOTYPE_SOME, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_FOR_EACH_UL, ECMA_ARRAY_PROTOTYPE_FOR_EACH, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_MAP, ECMA_ARRAY_PROTOTYPE_MAP, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_FILTER, ECMA_ARRAY_PROTOTYPE_FILTER, 2, 1)
+/* Note these 2 routines must be in this order */
+ROUTINE (LIT_MAGIC_STRING_REDUCE, ECMA_ARRAY_PROTOTYPE_REDUCE, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_REDUCE_RIGHT_UL, ECMA_ARRAY_PROTOTYPE_REDUCE_RIGHT, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_FIND, ECMA_ARRAY_PROTOTYPE_FIND, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_FIND_INDEX, ECMA_ARRAY_PROTOTYPE_FIND_INDEX, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_FILL, ECMA_ARRAY_PROTOTYPE_FILL, 3, 1)
+ROUTINE (LIT_MAGIC_STRING_COPY_WITHIN, ECMA_ARRAY_PROTOTYPE_COPY_WITHIN, NON_FIXED, 2)
+ROUTINE (LIT_MAGIC_STRING_ENTRIES, ECMA_ARRAY_PROTOTYPE_ENTRIES, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_KEYS, ECMA_ARRAY_PROTOTYPE_KEYS, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_INCLUDES, ECMA_ARRAY_PROTOTYPE_INCLUDES, NON_FIXED, 1)
+ROUTINE (LIT_MAGIC_STRING_FLAT, ECMA_ARRAY_PROTOTYPE_FLAT, 1, 0)
+ROUTINE (LIT_MAGIC_STRING_FLATMAP, ECMA_ARRAY_PROTOTYPE_FLATMAP, 2, 1)
+INTRINSIC_PROPERTY (LIT_MAGIC_STRING_TO_STRING_UL, LIT_MAGIC_STRING_TO_STRING_UL, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+INTRINSIC_PROPERTY (LIT_MAGIC_STRING_VALUES,
+                    LIT_INTERNAL_MAGIC_STRING_ARRAY_PROTOTYPE_VALUES,
+                    ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+INTRINSIC_PROPERTY (LIT_GLOBAL_SYMBOL_ITERATOR,
+                    LIT_INTERNAL_MAGIC_STRING_ARRAY_PROTOTYPE_VALUES,
+                    ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+#endif /* JERRY_BUILTIN_ARRAY */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-array.cpp

@@ -0,0 +1,569 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-array-object.h"
+#include "ecma-builtin-helpers.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-iterator-object.h"
+#include "ecma-objects.h"
+
+#include "jcontext.h"
+#include "jrt.h"
+
+#if JERRY_BUILTIN_ARRAY
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_ARRAY_ROUTINE_START = 0,
+  ECMA_ARRAY_ROUTINE_IS_ARRAY,
+  ECMA_ARRAY_ROUTINE_FROM,
+  ECMA_ARRAY_ROUTINE_OF,
+  ECMA_ARRAY_ROUTINE_SPECIES_GET
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-array.inc.h"
+#define BUILTIN_UNDERSCORED_ID  array
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup array ECMA Array object built-in
+ * @{
+ */
+
+/**
+ * The Array object's 'from' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 22.1.2.1
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_array_object_from (ecma_value_t this_arg, /**< 'this' argument */
+                                const ecma_value_t *arguments_list_p, /**< arguments list */
+                                uint32_t arguments_list_len) /**< number of arguments */
+{
+  /* 1. */
+  ecma_value_t constructor = this_arg;
+  ecma_value_t call_this_arg = ECMA_VALUE_UNDEFINED;
+  ecma_value_t items = arguments_list_p[0];
+  ecma_value_t mapfn = (arguments_list_len > 1) ? arguments_list_p[1] : ECMA_VALUE_UNDEFINED;
+  ecma_length_t k = 0;
+  ecma_value_t set_status;
+
+  /* 2. */
+  ecma_object_t *mapfn_obj_p = NULL;
+
+  /* 3. */
+  if (!ecma_is_value_undefined (mapfn))
+  {
+    /* 3.a */
+    if (!ecma_op_is_callable (mapfn))
+    {
+      return ecma_raise_type_error (ECMA_ERR_CALLBACK_IS_NOT_CALLABLE);
+    }
+
+    /* 3.b */
+    if (arguments_list_len > 2)
+    {
+      call_this_arg = arguments_list_p[2];
+    }
+
+    /* 3.c */
+    mapfn_obj_p = ecma_get_object_from_value (mapfn);
+  }
+
+  /* 4. */
+  ecma_value_t using_iterator = ecma_op_get_method_by_symbol_id (items, LIT_GLOBAL_SYMBOL_ITERATOR);
+
+  /* 5. */
+  if (ECMA_IS_VALUE_ERROR (using_iterator))
+  {
+    return using_iterator;
+  }
+
+  ecma_value_t ret_value = ECMA_VALUE_ERROR;
+
+  /* 6. */
+  if (!ecma_is_value_undefined (using_iterator))
+  {
+    ecma_object_t *array_obj_p;
+
+    /* 6.a */
+    if (ecma_is_constructor (constructor))
+    {
+      ecma_object_t *constructor_obj_p = ecma_get_object_from_value (constructor);
+
+      ecma_value_t array = ecma_op_function_construct (constructor_obj_p, constructor_obj_p, NULL, 0);
+
+      if (ecma_is_value_undefined (array) || ecma_is_value_null (array))
+      {
+        ecma_free_value (using_iterator);
+        return ecma_raise_type_error (ECMA_ERR_CANNOT_CONVERT_TO_OBJECT);
+      }
+
+      /* 6.c */
+      if (ECMA_IS_VALUE_ERROR (array))
+      {
+        ecma_free_value (using_iterator);
+        return array;
+      }
+
+      array_obj_p = ecma_get_object_from_value (array);
+    }
+    else
+    {
+      /* 6.b */
+      array_obj_p = ecma_op_new_array_object (0);
+    }
+
+    /* 6.d */
+    ecma_value_t next_method;
+    ecma_value_t iterator = ecma_op_get_iterator (items, using_iterator, &next_method);
+    ecma_free_value (using_iterator);
+
+    /* 6.e */
+    if (ECMA_IS_VALUE_ERROR (iterator))
+    {
+      ecma_deref_object (array_obj_p);
+      return iterator;
+    }
+
+    /* 6.f */
+    uint32_t k = 0;
+
+    /* 6.g */
+    while (true)
+    {
+      /* 6.g.ii */
+      ecma_value_t next = ecma_op_iterator_step (iterator, next_method);
+
+      /* 6.g.iii */
+      if (ECMA_IS_VALUE_ERROR (next))
+      {
+        goto iterator_cleanup;
+      }
+
+      /* 6.g.iii */
+      if (ecma_is_value_false (next))
+      {
+        /* 6.g.iv.1 */
+        ecma_value_t len_value = ecma_make_uint32_value (k);
+        ecma_value_t set_status =
+          ecma_op_object_put (array_obj_p, ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH), len_value, true);
+        ecma_free_value (len_value);
+
+        /* 6.g.iv.2 */
+        if (ECMA_IS_VALUE_ERROR (set_status))
+        {
+          goto iterator_cleanup;
+        }
+
+        ecma_free_value (iterator);
+        ecma_free_value (next_method);
+        /* 6.g.iv.3 */
+        return ecma_make_object_value (array_obj_p);
+      }
+
+      /* 6.g.v */
+      ecma_value_t next_value = ecma_op_iterator_value (next);
+
+      ecma_free_value (next);
+
+      /* 6.g.vi */
+      if (ECMA_IS_VALUE_ERROR (next_value))
+      {
+        goto iterator_cleanup;
+      }
+
+      ecma_value_t mapped_value;
+      /* 6.g.vii */
+      if (mapfn_obj_p != NULL)
+      {
+        /* 6.g.vii.1 */
+        ecma_value_t args_p[2] = { next_value, ecma_make_uint32_value (k) };
+        /* 6.g.vii.3 */
+        mapped_value = ecma_op_function_call (mapfn_obj_p, call_this_arg, args_p, 2);
+        ecma_free_value (args_p[1]);
+        ecma_free_value (next_value);
+
+        /* 6.g.vii.2 */
+        if (ECMA_IS_VALUE_ERROR (mapped_value))
+        {
+          ecma_op_iterator_close (iterator);
+          goto iterator_cleanup;
+        }
+      }
+      else
+      {
+        /* 6.g.viii */
+        mapped_value = next_value;
+      }
+
+      /* 6.g.ix */
+      const uint32_t flags = ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE | JERRY_PROP_SHOULD_THROW;
+      ecma_value_t set_status = ecma_builtin_helper_def_prop_by_index (array_obj_p, k, mapped_value, flags);
+
+      ecma_free_value (mapped_value);
+
+      /* 6.g.x */
+      if (ECMA_IS_VALUE_ERROR (set_status))
+      {
+        ecma_op_iterator_close (iterator);
+        goto iterator_cleanup;
+      }
+
+      /* 6.g.xi */
+      k++;
+    }
+
+iterator_cleanup:
+    ecma_free_value (iterator);
+    ecma_free_value (next_method);
+    ecma_deref_object (array_obj_p);
+
+    return ret_value;
+  }
+
+  /* 8. */
+  ecma_value_t array_like = ecma_op_to_object (items);
+
+  /* 9. */
+  if (ECMA_IS_VALUE_ERROR (array_like))
+  {
+    return array_like;
+  }
+
+  ecma_object_t *array_like_obj_p = ecma_get_object_from_value (array_like);
+
+  /* 10. */
+  ecma_length_t len;
+  ecma_value_t len_value = ecma_op_object_get_length (array_like_obj_p, &len);
+
+  /* 11. */
+  if (ECMA_IS_VALUE_ERROR (len_value))
+  {
+    goto cleanup;
+  }
+
+  /* 12. */
+  ecma_object_t *array_obj_p;
+
+  /* 12.a */
+  if (ecma_is_constructor (constructor))
+  {
+    ecma_object_t *constructor_obj_p = ecma_get_object_from_value (constructor);
+
+    len_value = ecma_make_length_value (len);
+    ecma_value_t array = ecma_op_function_construct (constructor_obj_p, constructor_obj_p, &len_value, 1);
+    ecma_free_value (len_value);
+
+    if (ecma_is_value_undefined (array) || ecma_is_value_null (array))
+    {
+      ecma_raise_type_error (ECMA_ERR_CANNOT_CONVERT_TO_OBJECT);
+      goto cleanup;
+    }
+
+    /* 14. */
+    if (ECMA_IS_VALUE_ERROR (array))
+    {
+      goto cleanup;
+    }
+
+    array_obj_p = ecma_get_object_from_value (array);
+  }
+  else
+  {
+    /* 13.a */
+    array_obj_p = ecma_op_new_array_object_from_length (len);
+
+    if (JERRY_UNLIKELY (array_obj_p == NULL))
+    {
+      goto cleanup;
+    }
+  }
+
+  /* 15. */
+  k = 0;
+
+  /* 16. */
+  while (k < len)
+  {
+    /* 16.b */
+    ecma_value_t k_value = ecma_op_object_get_by_index (array_like_obj_p, k);
+
+    /* 16.c */
+    if (ECMA_IS_VALUE_ERROR (k_value))
+    {
+      goto construct_cleanup;
+    }
+
+    ecma_value_t mapped_value;
+    /* 16.d */
+    if (mapfn_obj_p != NULL)
+    {
+      /* 16.d.i */
+      ecma_value_t args_p[2] = { k_value, ecma_make_length_value (k) };
+      mapped_value = ecma_op_function_call (mapfn_obj_p, call_this_arg, args_p, 2);
+      ecma_free_value (args_p[1]);
+      ecma_free_value (k_value);
+
+      /* 16.d.ii */
+      if (ECMA_IS_VALUE_ERROR (mapped_value))
+      {
+        goto construct_cleanup;
+      }
+    }
+    else
+    {
+      /* 16.e */
+      mapped_value = k_value;
+    }
+
+    /* 16.f */
+    const uint32_t flags = ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE | JERRY_PROP_SHOULD_THROW;
+    ecma_value_t set_status = ecma_builtin_helper_def_prop_by_index (array_obj_p, k, mapped_value, flags);
+
+    ecma_free_value (mapped_value);
+
+    /* 16.g */
+    if (ECMA_IS_VALUE_ERROR (set_status))
+    {
+      goto construct_cleanup;
+    }
+
+    /* 16.h */
+    k++;
+  }
+
+  /* 17. */
+  len_value = ecma_make_length_value (k);
+  set_status = ecma_op_object_put (array_obj_p, ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH), len_value, true);
+  ecma_free_value (len_value);
+
+  /* 18. */
+  if (ECMA_IS_VALUE_ERROR (set_status))
+  {
+    goto construct_cleanup;
+  }
+
+  /* 19. */
+  ecma_deref_object (array_like_obj_p);
+  return ecma_make_object_value (array_obj_p);
+
+construct_cleanup:
+  ecma_deref_object (array_obj_p);
+cleanup:
+  ecma_deref_object (array_like_obj_p);
+  return ret_value;
+} /* ecma_builtin_array_object_from */
+
+/**
+ * The Array object's 'of' routine
+ *
+ * See also:
+ *          ECMA-262 v6, 22.1.2.3
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_array_object_of (ecma_value_t this_arg, /**< 'this' argument */
+                              const ecma_value_t *arguments_list_p, /**< arguments list */
+                              uint32_t arguments_list_len) /**< number of arguments */
+{
+  if (!ecma_is_constructor (this_arg))
+  {
+    return ecma_op_new_array_object_from_buffer (arguments_list_p, arguments_list_len);
+  }
+
+  ecma_value_t len = ecma_make_uint32_value (arguments_list_len);
+
+  ecma_value_t ret_val =
+    ecma_op_function_construct (ecma_get_object_from_value (this_arg), ecma_get_object_from_value (this_arg), &len, 1);
+
+  if (ECMA_IS_VALUE_ERROR (ret_val))
+  {
+    ecma_free_value (len);
+    return ret_val;
+  }
+
+  uint32_t k = 0;
+  ecma_object_t *obj_p = ecma_get_object_from_value (ret_val);
+  const uint32_t prop_status_flags = ECMA_PROPERTY_CONFIGURABLE_ENUMERABLE_WRITABLE | JERRY_PROP_SHOULD_THROW;
+
+  while (k < arguments_list_len)
+  {
+    ecma_value_t define_status =
+      ecma_builtin_helper_def_prop_by_index (obj_p, k, arguments_list_p[k], prop_status_flags);
+
+    if (ECMA_IS_VALUE_ERROR (define_status))
+    {
+      ecma_free_value (len);
+      ecma_deref_object (obj_p);
+      return define_status;
+    }
+
+    k++;
+  }
+
+  ret_val = ecma_op_object_put (obj_p, ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH), len, true);
+
+  ecma_free_value (len);
+
+  if (ECMA_IS_VALUE_ERROR (ret_val))
+  {
+    ecma_deref_object (obj_p);
+    return ret_val;
+  }
+
+  return ecma_make_object_value (obj_p);
+} /* ecma_builtin_array_object_of */
+
+/**
+ * Handle calling [[Call]] of built-in Array object
+ *
+ * @return ECMA_VALUE_ERROR - if the array construction fails
+ *         constructed array object - otherwise
+ */
+ecma_value_t
+ecma_builtin_array_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                  uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len != 1 || !ecma_is_value_number (arguments_list_p[0]))
+  {
+    return ecma_op_new_array_object_from_buffer (arguments_list_p, arguments_list_len);
+  }
+
+  ecma_number_t num = ecma_get_number_from_value (arguments_list_p[0]);
+  uint32_t num_uint32 = ecma_number_to_uint32 (num);
+
+  if (num != ((ecma_number_t) num_uint32))
+  {
+    return ecma_raise_range_error (ECMA_ERR_INVALID_ARRAY_LENGTH);
+  }
+
+  return ecma_make_object_value (ecma_op_new_array_object (num_uint32));
+} /* ecma_builtin_array_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Array object
+ *
+ * @return ECMA_VALUE_ERROR - if the array construction fails
+ *         constructed array object - otherwise
+ */
+ecma_value_t
+ecma_builtin_array_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                       uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  ecma_object_t *proto_p =
+    ecma_op_get_prototype_from_constructor (JERRY_CONTEXT (current_new_target_p), ECMA_BUILTIN_ID_ARRAY_PROTOTYPE);
+
+  if (proto_p == NULL)
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  ecma_value_t result = ecma_builtin_array_dispatch_call (arguments_list_p, arguments_list_len);
+
+  if (ECMA_IS_VALUE_ERROR (result))
+  {
+    ecma_deref_object (proto_p);
+    return result;
+  }
+
+  ecma_object_t *object_p = ecma_get_object_from_value (result);
+  ECMA_SET_NON_NULL_POINTER (object_p->u2.prototype_cp, proto_p);
+  ecma_deref_object (proto_p);
+  return result;
+} /* ecma_builtin_array_dispatch_construct */
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_array_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide routine identifier */
+                                     ecma_value_t this_arg, /**< 'this' argument value */
+                                     const ecma_value_t arguments_list_p[], /**< list of arguments
+                                                                             *   passed to routine */
+                                     uint32_t arguments_number) /**< length of arguments' list */
+{
+  JERRY_UNUSED (arguments_number);
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_ARRAY_ROUTINE_IS_ARRAY:
+    {
+      JERRY_UNUSED (this_arg);
+
+      return ecma_is_value_array (arguments_list_p[0]);
+    }
+    case ECMA_ARRAY_ROUTINE_FROM:
+    {
+      return ecma_builtin_array_object_from (this_arg, arguments_list_p, arguments_number);
+    }
+    case ECMA_ARRAY_ROUTINE_OF:
+    {
+      return ecma_builtin_array_object_of (this_arg, arguments_list_p, arguments_number);
+    }
+    case ECMA_ARRAY_ROUTINE_SPECIES_GET:
+    {
+      return ecma_copy_value (this_arg);
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+} /* ecma_builtin_array_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_ARRAY */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-array.inc.h

@@ -0,0 +1,47 @@
+/* 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.
+ */
+
+/*
+ * Array description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_ARRAY
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.4.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_ARRAY_PROTOTYPE, ECMA_PROPERTY_FIXED)
+
+/* Number properties:
+ *  (property name, object pointer getter) */
+
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 1, ECMA_PROPERTY_FLAG_DEFAULT_LENGTH)
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_ARRAY_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_IS_ARRAY_UL, ECMA_ARRAY_ROUTINE_IS_ARRAY, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_FROM, ECMA_ARRAY_ROUTINE_FROM, NON_FIXED, 1)
+ROUTINE (LIT_MAGIC_STRING_OF, ECMA_ARRAY_ROUTINE_OF, NON_FIXED, 0)
+
+/* ECMA-262 v6, 22.1.2.5 */
+ACCESSOR_READ_ONLY (LIT_GLOBAL_SYMBOL_SPECIES, ECMA_ARRAY_ROUTINE_SPECIES_GET, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#endif /* !(JERRY_BUILTIN_ARRAY) */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-arraybuffer-prototype.cpp

@@ -0,0 +1,116 @@
+/* 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.
+ */
+
+#include "ecma-arraybuffer-object.h"
+#include "ecma-builtin-helpers.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+
+#include "jrt-libc-includes.h"
+#include "jrt.h"
+
+#if JERRY_BUILTIN_TYPEDARRAY
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-arraybuffer-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  arraybuffer_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup arraybufferprototype ECMA ArrayBuffer.prototype object built-in
+ * @{
+ */
+
+/**
+ * The ArrayBuffer.prototype.bytelength accessor
+ *
+ * See also:
+ *          ES2015, 24.1.4.1
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_arraybuffer_prototype_bytelength_getter (ecma_value_t this_arg) /**< this argument */
+{
+  if (ecma_is_value_object (this_arg))
+  {
+    ecma_object_t *object_p = ecma_get_object_from_value (this_arg);
+
+    if (ecma_object_class_is (object_p, ECMA_OBJECT_CLASS_ARRAY_BUFFER))
+    {
+      if (ecma_arraybuffer_is_detached (object_p))
+      {
+        return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED);
+      }
+      uint32_t len = ecma_arraybuffer_get_length (object_p);
+
+      return ecma_make_uint32_value (len);
+    }
+  }
+
+  return ecma_raise_type_error (ECMA_ERR_ARGUMENT_THIS_NOT_ARRAY_BUFFER_OBJECT);
+} /* ecma_builtin_arraybuffer_prototype_bytelength_getter */
+
+/**
+ * The ArrayBuffer.prototype object's 'slice' routine
+ *
+ * See also:
+ *          ECMA-262 v11, 24.1.4.3
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_arraybuffer_prototype_object_slice (ecma_value_t this_arg, /**< this argument */
+                                                 const ecma_value_t *argument_list_p, /**< arguments list */
+                                                 uint32_t arguments_number) /**< number of arguments */
+{
+  if (!ecma_is_value_object (this_arg))
+  {
+    return ecma_raise_type_error (ECMA_ERR_ARGUMENT_THIS_NOT_OBJECT);
+  }
+
+  ecma_object_t *object_p = ecma_get_object_from_value (this_arg);
+
+  /* 2. */
+  if (!ecma_object_class_is (object_p, ECMA_OBJECT_CLASS_ARRAY_BUFFER))
+  {
+    return ecma_raise_type_error (ECMA_ERR_ARGUMENT_THIS_NOT_ARRAY_BUFFER_OBJECT);
+  }
+
+  return ecma_builtin_arraybuffer_slice (this_arg, argument_list_p, arguments_number);
+} /* ecma_builtin_arraybuffer_prototype_object_slice */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_TYPEDARRAY */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-arraybuffer-prototype.inc.h

@@ -0,0 +1,43 @@
+/* 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.
+ */
+
+/*
+ * ArrayBuffer.prototype built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_TYPEDARRAY
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_ARRAYBUFFER, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* Readonly accessor properties */
+ACCESSOR_READ_ONLY (LIT_MAGIC_STRING_BYTE_LENGTH_UL,
+                    ecma_builtin_arraybuffer_prototype_bytelength_getter,
+                    ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 24.1.4.4 */
+STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG, LIT_MAGIC_STRING_ARRAY_BUFFER_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_SLICE, ecma_builtin_arraybuffer_prototype_object_slice, NON_FIXED, 2)
+
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-arraybuffer.cpp

@@ -0,0 +1,114 @@
+/* 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.
+ */
+
+#include "ecma-arraybuffer-object.h"
+#include "ecma-builtins.h"
+#include "ecma-dataview-object.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-typedarray-object.h"
+
+#include "jrt.h"
+
+#if JERRY_BUILTIN_TYPEDARRAY
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-arraybuffer.inc.h"
+#define BUILTIN_UNDERSCORED_ID  arraybuffer
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup arraybuffer ECMA ArrayBuffer object built-in
+ * @{
+ */
+
+/**
+ * The ArrayBuffer object's 'isView' routine
+ *
+ * See also:
+ *         ES2015 24.1.3.1
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_arraybuffer_object_is_view (ecma_value_t this_arg, /**< 'this' argument */
+                                         ecma_value_t arg) /**< argument 1 */
+{
+  JERRY_UNUSED (this_arg);
+
+  return ecma_make_boolean_value (ecma_is_typedarray (arg) || ecma_is_dataview (arg));
+} /* ecma_builtin_arraybuffer_object_is_view */
+
+/**
+ * Handle calling [[Call]] of built-in ArrayBuffer object
+ *
+ * ES2015 24.1.2 ArrayBuffer is not intended to be called as
+ * a function and will throw an exception when called in
+ * that manner.
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_arraybuffer_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                        uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_raise_type_error (ECMA_ERR_CONSTRUCTOR_ARRAYBUFFER_REQUIRES_NEW);
+} /* ecma_builtin_arraybuffer_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in ArrayBuffer object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_arraybuffer_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                             uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_op_create_arraybuffer_object (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_arraybuffer_dispatch_construct */
+
+/**
+ * 24.1.3.3 get ArrayBuffer [ @@species ] accessor
+ *
+ * @return ecma_value
+ *         returned value must be freed with ecma_free_value
+ */
+ecma_value_t
+ecma_builtin_arraybuffer_species_get (ecma_value_t this_value) /**< This Value */
+{
+  return ecma_copy_value (this_value);
+} /* ecma_builtin_arraybuffer_species_get */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_TYPEDARRAY */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-arraybuffer.inc.h

@@ -0,0 +1,47 @@
+/* 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.
+ */
+
+/*
+ * ArrayBuffer built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_TYPEDARRAY
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 1, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_ARRAYBUFFER_PROTOTYPE, ECMA_PROPERTY_FIXED)
+
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_ARRAY_BUFFER_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+
+/* ES2015 24.1.3.1 */
+ROUTINE (LIT_MAGIC_STRING_IS_VIEW_UL, ecma_builtin_arraybuffer_object_is_view, 1, 1)
+
+/* ES2015 24.1.3.3 */
+ACCESSOR_READ_ONLY (LIT_GLOBAL_SYMBOL_SPECIES, ecma_builtin_arraybuffer_species_get, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#endif /* JERRY_BUILTIN_TYPEDARRAY */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-from-sync-iterator-prototype.cpp

@@ -0,0 +1,355 @@
+/* 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.
+ */
+
+#include "jerryscript-types.h"
+
+#include "ecma-builtin-handlers.h"
+#include "ecma-builtins.h"
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-iterator-object.h"
+#include "ecma-objects.h"
+#include "ecma-promise-object.h"
+
+#include "jcontext.h"
+#include "jrt.h"
+#include "lit-magic-strings.h"
+#include "lit-strings.h"
+#include "opcodes.h"
+#include "vm-defines.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_ASYNC_FROM_SYNC_ITERATOR_PROTOTYPE_ROUTINE_START = 0, /**< buitlin routine start id */
+  ECMA_ASYNC_FROM_SYNC_ITERATOR_PROTOTYPE_ROUTINE_NEXT, /**< 'next' routine v11, 25.1.4.2.1  */
+  ECMA_ASYNC_FROM_SYNC_ITERATOR_PROTOTYPE_ROUTINE_RETURN, /**< 'return' routine v11, 25.1.4.2.2  */
+  ECMA_ASYNC_FROM_SYNC_ITERATOR_PROTOTYPE_ROUTINE_THROW /**< 'throw' routine v11, 25.1.4.2.3  */
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-async-from-sync-iterator-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  async_from_sync_iterator_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup asyncfromsynciteratorprototype ECMA %AsyncFromSyncIteratorPrototype% object built-in
+ * @{
+ */
+
+/**
+ * AsyncFromSyncIteratorContinuation operation
+ *
+ * See also:
+ *         ECMAScript v11, 25.1.4.4
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_op_async_from_sync_iterator_prototype_continuation (ecma_value_t result, /**< routine's 'result' argument */
+                                                         ecma_object_t *capability_obj_p) /**< promise capability */
+{
+  /* 1. */
+  ecma_value_t done = ecma_op_iterator_complete (result);
+
+  /* 2. */
+  if (ECMA_IS_VALUE_ERROR (ecma_op_if_abrupt_reject_promise (&done, capability_obj_p)))
+  {
+    return done;
+  }
+
+  uint16_t done_flag = ecma_is_value_false (done) ? 0 : (1 << ECMA_NATIVE_HANDLER_COMMON_FLAGS_SHIFT);
+  ecma_free_value (done);
+
+  /* 3. */
+  ecma_value_t value = ecma_op_iterator_value (result);
+
+  /* 4. */
+  if (ECMA_IS_VALUE_ERROR (ecma_op_if_abrupt_reject_promise (&value, capability_obj_p)))
+  {
+    return value;
+  }
+
+  /* 5. */
+  ecma_value_t builtin_promise = ecma_make_object_value (ecma_builtin_get (ECMA_BUILTIN_ID_PROMISE));
+  ecma_value_t value_wrapper = ecma_promise_reject_or_resolve (builtin_promise, value, true);
+  ecma_free_value (value);
+
+  /* 6. */
+  if (ECMA_IS_VALUE_ERROR (ecma_op_if_abrupt_reject_promise (&value_wrapper, capability_obj_p)))
+  {
+    return value_wrapper;
+  }
+
+  /* 8 - 9. */
+  ecma_object_t *on_fullfilled = ecma_op_create_native_handler (ECMA_NATIVE_HANDLER_ASYNC_FROM_SYNC_ITERATOR_UNWRAP,
+                                                                sizeof (ecma_extended_object_t));
+  ((ecma_extended_object_t *) on_fullfilled)->u.built_in.u2.routine_flags = (uint8_t) done_flag;
+
+  /* 10. */
+  ecma_value_t then_result = ecma_promise_perform_then (value_wrapper,
+                                                        ecma_make_object_value (on_fullfilled),
+                                                        ECMA_VALUE_UNDEFINED,
+                                                        capability_obj_p);
+
+  JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (then_result));
+  ecma_deref_object (on_fullfilled);
+  ecma_free_value (value_wrapper);
+
+  /* 11. */
+  return then_result;
+} /* ecma_op_async_from_sync_iterator_prototype_continuation */
+
+/**
+ * The %AsyncFromSyncIteratorPrototype% object's 'next' routine
+ *
+ * See also:
+ *         ECMAScript v11, 25.1.4.2.1
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_async_from_sync_iterator_prototype_next (ecma_async_from_sync_iterator_object_t *iter_p, /**< iterator
+                                                                                                       *   record*/
+                                                      ecma_object_t *capability_p, /**< promise capability */
+                                                      ecma_value_t value) /**< routine's 'value' argument */
+{
+  /* 5. */
+  ecma_value_t next_result =
+    ecma_op_iterator_next (iter_p->header.u.cls.u3.sync_iterator, iter_p->sync_next_method, value);
+
+  /* 6. */
+  if (ECMA_IS_VALUE_ERROR (ecma_op_if_abrupt_reject_promise (&next_result, capability_p)))
+  {
+    return next_result;
+  }
+
+  /* 7. */
+  ecma_value_t result = ecma_op_async_from_sync_iterator_prototype_continuation (next_result, capability_p);
+  ecma_free_value (next_result);
+
+  return result;
+} /* ecma_builtin_async_from_sync_iterator_prototype_next */
+
+/**
+ * The %AsyncFromSyncIteratorPrototype% object's 'return' and 'throw' routines
+ *
+ * See also:
+ *         ECMAScript v11, 25.1.4.2.2
+ *         ECMAScript v11, 25.1.4.2.3
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_async_from_sync_iterator_prototype_do (ecma_async_from_sync_iterator_object_t *iter_p, /**< iterator
+                                                                                                     *   record*/
+                                                    ecma_object_t *capability_obj_p, /**< promise capability */
+                                                    ecma_value_t value, /**< routine's 'value' argument */
+                                                    lit_magic_string_id_t method_id) /**< method id */
+{
+  /* 5. */
+  ecma_value_t sync_iterator = iter_p->header.u.cls.u3.sync_iterator;
+  ecma_value_t method = ecma_op_get_method_by_magic_id (sync_iterator, method_id);
+
+  /* 6. */
+  if (ECMA_IS_VALUE_ERROR (ecma_op_if_abrupt_reject_promise (&method, capability_obj_p)))
+  {
+    return method;
+  }
+
+  ecma_promise_capabality_t *capability_p = (ecma_promise_capabality_t *) capability_obj_p;
+
+  ecma_value_t call_arg;
+  uint32_t arg_size;
+
+  if (ecma_is_value_empty (value))
+  {
+    arg_size = 0;
+    call_arg = ECMA_VALUE_UNDEFINED;
+  }
+  else
+  {
+    arg_size = 1;
+    call_arg = value;
+  }
+
+  /* 7. */
+  if (ecma_is_value_undefined (method))
+  {
+    ecma_value_t func_obj;
+
+    if (method_id == LIT_MAGIC_STRING_RETURN)
+    {
+      /* 7.a. */
+      call_arg = ecma_create_iter_result_object (call_arg, ECMA_VALUE_TRUE);
+      arg_size = 1;
+      func_obj = capability_p->resolve;
+    }
+    else
+    {
+      func_obj = capability_p->reject;
+    }
+
+    /* 7.b. */
+    ecma_value_t resolve =
+      ecma_op_function_call (ecma_get_object_from_value (func_obj), ECMA_VALUE_UNDEFINED, &call_arg, arg_size);
+    JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (resolve));
+    ecma_free_value (resolve);
+
+    if (method_id == LIT_MAGIC_STRING_RETURN)
+    {
+      ecma_free_value (call_arg);
+    }
+
+    /* 7.c. */
+    return ecma_copy_value (capability_p->header.u.cls.u3.promise);
+  }
+
+  /* 8. */
+  ecma_value_t call_result = ecma_op_function_validated_call (method, sync_iterator, &call_arg, arg_size);
+  ecma_free_value (method);
+
+  /* 9. */
+  if (ECMA_IS_VALUE_ERROR (ecma_op_if_abrupt_reject_promise (&call_result, capability_obj_p)))
+  {
+    return call_result;
+  }
+
+  /* 10. */
+  if (!ecma_is_value_object (call_result))
+  {
+    ecma_free_value (call_result);
+
+#if JERRY_ERROR_MESSAGES
+    const lit_utf8_byte_t *msg_p = (lit_utf8_byte_t *) ecma_get_error_msg (ECMA_ERR_ARGUMENT_IS_NOT_AN_OBJECT);
+    lit_utf8_size_t msg_size = ecma_get_error_size (ECMA_ERR_ARGUMENT_IS_NOT_AN_OBJECT);
+    ecma_string_t *error_msg_p = ecma_new_ecma_string_from_ascii (msg_p, msg_size);
+#else /* !JERRY_ERROR_MESSAGES */
+    ecma_string_t *error_msg_p = ecma_get_magic_string (LIT_MAGIC_STRING__EMPTY);
+#endif /* JERRY_ERROR_MESSAGES */
+
+    ecma_object_t *type_error_obj_p = ecma_new_standard_error (JERRY_ERROR_TYPE, error_msg_p);
+
+#if JERRY_ERROR_MESSAGES
+    ecma_deref_ecma_string (error_msg_p);
+#endif /* JERRY_ERROR_MESSAGES */
+
+    ecma_value_t type_error = ecma_make_object_value (type_error_obj_p);
+
+    /* 10.a. */
+    ecma_value_t reject =
+      ecma_op_function_call (ecma_get_object_from_value (capability_p->reject), ECMA_VALUE_UNDEFINED, &type_error, 1);
+    JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (reject));
+    ecma_deref_object (type_error_obj_p);
+    ecma_free_value (reject);
+
+    /* 10.b. */
+    return ecma_copy_value (capability_p->header.u.cls.u3.promise);
+  }
+
+  ecma_value_t result = ecma_op_async_from_sync_iterator_prototype_continuation (call_result, capability_obj_p);
+  ecma_free_value (call_result);
+
+  return result;
+} /* ecma_builtin_async_from_sync_iterator_prototype_do */
+
+/**
+ * Dispatcher of the %AsyncFromSyncIteratorPrototype% built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_async_from_sync_iterator_prototype_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide
+                                                                                               *   routine
+                                                                                               *   identifier */
+                                                                  ecma_value_t this_arg, /**< 'this' argument value */
+                                                                  const ecma_value_t arguments_list_p[], /**< list of
+                                                                                                          *   arguments
+                                                                                                          *   passed to
+                                                                                                          *   routine */
+                                                                  uint32_t arguments_number) /**< length of
+                                                                                              *   arguments' list */
+{
+  JERRY_UNUSED (arguments_number);
+  JERRY_ASSERT (ecma_is_value_object (this_arg));
+
+  ecma_object_t *this_obj_p = ecma_get_object_from_value (this_arg);
+
+  JERRY_ASSERT (ecma_object_class_is (this_obj_p, ECMA_OBJECT_CLASS_ASYNC_FROM_SYNC_ITERATOR));
+
+  ecma_async_from_sync_iterator_object_t *iter_p = (ecma_async_from_sync_iterator_object_t *) this_obj_p;
+
+  ecma_value_t builtin_promise = ecma_make_object_value (ecma_builtin_get (ECMA_BUILTIN_ID_PROMISE));
+  ecma_object_t *capability_p = ecma_promise_new_capability (builtin_promise, ECMA_VALUE_UNDEFINED);
+  JERRY_ASSERT (capability_p != NULL);
+
+  ecma_value_t result;
+  ecma_value_t arg = (arguments_number == 0 ? ECMA_VALUE_EMPTY : arguments_list_p[0]);
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_ASYNC_FROM_SYNC_ITERATOR_PROTOTYPE_ROUTINE_NEXT:
+    {
+      result = ecma_builtin_async_from_sync_iterator_prototype_next (iter_p, capability_p, arg);
+      break;
+    }
+    case ECMA_ASYNC_FROM_SYNC_ITERATOR_PROTOTYPE_ROUTINE_RETURN:
+    {
+      result = ecma_builtin_async_from_sync_iterator_prototype_do (iter_p, capability_p, arg, LIT_MAGIC_STRING_RETURN);
+      break;
+    }
+    case ECMA_ASYNC_FROM_SYNC_ITERATOR_PROTOTYPE_ROUTINE_THROW:
+    {
+      result = ecma_builtin_async_from_sync_iterator_prototype_do (iter_p, capability_p, arg, LIT_MAGIC_STRING_THROW);
+      break;
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+      break;
+    }
+  }
+
+  ecma_deref_object (capability_p);
+
+  return result;
+} /* ecma_builtin_async_from_sync_iterator_prototype_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-from-sync-iterator-prototype.inc.h

@@ -0,0 +1,28 @@
+/* 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.
+ */
+
+/*
+ * %AsyncFromSyncIteratorPrototype% built-in description (AsyncFunction.prototype)
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_NEXT, ECMA_ASYNC_FROM_SYNC_ITERATOR_PROTOTYPE_ROUTINE_NEXT, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_RETURN, ECMA_ASYNC_FROM_SYNC_ITERATOR_PROTOTYPE_ROUTINE_RETURN, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_THROW, ECMA_ASYNC_FROM_SYNC_ITERATOR_PROTOTYPE_ROUTINE_THROW, 1, 1)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-function-prototype.cpp

@@ -0,0 +1,39 @@
+/* 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.
+ */
+
+#include "ecma-globals.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-async-function-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  async_function_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup asyncfunctionprototype ECMA AsyncFunction.prototype object built-in
+ * @{
+ */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-function-prototype.inc.h

@@ -0,0 +1,28 @@
+/* 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.
+ */
+
+/*
+ * %AsyncFunctionPrototype% built-in description (AsyncFunction.prototype)
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* ECMA-262 v11, 25.7.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_ASYNC_FUNCTION, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v11, 25.7.3.2 */
+STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG, LIT_MAGIC_STRING_ASYNC_FUNCTION_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-function.cpp

@@ -0,0 +1,68 @@
+/* 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.
+ */
+
+#include "ecma-globals.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+#include "ecma-function-object.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-async-function.inc.h"
+#define BUILTIN_UNDERSCORED_ID  async_function
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup asyncfunction ECMA AsyncFunction object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in AsyncFunction object
+ *
+ * @return constructed async function object - if success
+ *         raised error otherwise
+ */
+ecma_value_t
+ecma_builtin_async_function_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                           uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_op_create_dynamic_function (arguments_list_p, arguments_list_len, ECMA_PARSE_ASYNC_FUNCTION);
+} /* ecma_builtin_async_function_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in AsyncFunction object
+ *
+ * @return constructed async function object - if success
+ *        raised error otherwise
+ */
+ecma_value_t
+ecma_builtin_async_function_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                uint32_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_async_function_dispatch_call (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_async_function_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-function.inc.h

@@ -0,0 +1,34 @@
+/* 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.
+ */
+
+/*
+ * %AsyncFunction% built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* ECMA-262 v11, 25.7.2 */
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_ASYNC_FUNCTION_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v11, 25.7.2.1 */
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 1, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v10, 25.7.2.2 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_ASYNC_FUNCTION_PROTOTYPE, ECMA_PROPERTY_FIXED)
+
+/* ECMA-262 v11, 25.7.3.2 */
+STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG, LIT_MAGIC_STRING_ASYNC_FUNCTION_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-generator-function.cpp

@@ -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.
+ */
+
+#include "ecma-globals.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+#include "ecma-function-object.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-async-generator-function.inc.h"
+#define BUILTIN_UNDERSCORED_ID  async_generator_function
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup asyncgeneratorfunction ECMA AsyncGeneratorFunction object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in AsyncGeneratorFunction object
+ *
+ * @return constructed async generator function object - if success
+ *         raised error otherwise
+ */
+ecma_value_t
+ecma_builtin_async_generator_function_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                     uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_op_create_dynamic_function (arguments_list_p,
+                                          arguments_list_len,
+                                          (ecma_parse_opts_t)(((unsigned int) ECMA_PARSE_GENERATOR_FUNCTION) | ((unsigned int) ECMA_PARSE_ASYNC_FUNCTION)));
+} /* ecma_builtin_async_generator_function_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in AsyncGeneratorFunction object
+ *
+ * @return constructed async generator function object - if success
+ *        raised error otherwise
+ */
+ecma_value_t
+ecma_builtin_async_generator_function_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                          uint32_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_async_generator_function_dispatch_call (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_async_generator_function_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-generator-function.inc.h

@@ -0,0 +1,31 @@
+/* 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.
+ */
+
+/*
+ * %AsyncGeneratorFunction% built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* ECMA-262 v10, 25.3.2 */
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_ASYNC_GENERATOR_FUNCTION_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v10, 25.3.2.1 */
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 1, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 25.3.2.2 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_ASYNC_GENERATOR, ECMA_PROPERTY_FIXED)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-generator-prototype.cpp

@@ -0,0 +1,147 @@
+/* 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.
+ */
+
+#include "ecma-async-generator-object.h"
+#include "ecma-builtins.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-iterator-object.h"
+#include "ecma-promise-object.h"
+
+#include "jcontext.h"
+#include "opcodes.h"
+#include "vm-defines.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_START = 0,
+  ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_NEXT,
+  ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_THROW,
+  ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_RETURN
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-async-generator-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  async_generator_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup asyncgeneratorprototype ECMA AsyncGenerator.prototype object built-in
+ * @{
+ */
+
+/**
+ * Convert routine type to operation type.
+ */
+#define ECMA_ASYNC_GENERATOR_ROUTINE_TO_OPERATION(type) \
+  ((ecma_async_generator_operation_type_t) ((type) -ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_NEXT))
+
+JERRY_STATIC_ASSERT ((ECMA_ASYNC_GENERATOR_ROUTINE_TO_OPERATION (ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_NEXT) == ECMA_ASYNC_GENERATOR_DO_NEXT),
+                     convert_ecma_async_generator_routine_next_to_ecma_async_generator_do_next_failed);
+
+JERRY_STATIC_ASSERT ((ECMA_ASYNC_GENERATOR_ROUTINE_TO_OPERATION (ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_THROW) == ECMA_ASYNC_GENERATOR_DO_THROW),
+                     convert_ecma_async_generator_routine_throw_to_ecma_async_generator_do_throw_failed);
+
+JERRY_STATIC_ASSERT ((ECMA_ASYNC_GENERATOR_ROUTINE_TO_OPERATION (ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_RETURN) == ECMA_ASYNC_GENERATOR_DO_RETURN),
+                     convert_ecma_async_generator_routine_return_to_ecma_async_generator_do_return_failed);
+
+/**
+ * Dispatcher of the Generator built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_async_generator_prototype_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide routine
+                                                                                      *   identifier */
+                                                         ecma_value_t this_arg, /**< 'this' argument value */
+                                                         const ecma_value_t arguments_list_p[], /**< list of arguments
+                                                                                                 *   passed to
+                                                                                                 *   routine */
+                                                         uint32_t arguments_number) /**< length of arguments'
+                                                                                     *   list */
+{
+  JERRY_UNUSED (arguments_number);
+
+  vm_executable_object_t *executable_object_p = NULL;
+
+  if (ecma_is_value_object (this_arg))
+  {
+    ecma_object_t *object_p = ecma_get_object_from_value (this_arg);
+
+    if (ecma_object_class_is (object_p, ECMA_OBJECT_CLASS_ASYNC_GENERATOR))
+    {
+      executable_object_p = (vm_executable_object_t *) object_p;
+    }
+  }
+
+  if (executable_object_p == NULL)
+  {
+    const char *msg_p = ecma_get_error_msg (ECMA_ERR_ARGUMENT_THIS_NOT_ASYNC_GENERATOR);
+    lit_utf8_size_t msg_size = ecma_get_error_size (ECMA_ERR_ARGUMENT_THIS_NOT_ASYNC_GENERATOR);
+    ecma_string_t *error_msg_p = ecma_new_ecma_string_from_ascii ((const lit_utf8_byte_t *) msg_p, msg_size);
+
+    ecma_object_t *type_error_obj_p = ecma_new_standard_error (JERRY_ERROR_TYPE, error_msg_p);
+    ecma_deref_ecma_string (error_msg_p);
+
+    ecma_value_t promise = ecma_op_create_promise_object (ECMA_VALUE_EMPTY, ECMA_VALUE_UNDEFINED, NULL);
+    ecma_reject_promise (promise, ecma_make_object_value (type_error_obj_p));
+    ecma_deref_object (type_error_obj_p);
+
+    return promise;
+  }
+
+  if (executable_object_p->extended_object.u.cls.u2.executable_obj_flags & ECMA_EXECUTABLE_OBJECT_COMPLETED)
+  {
+    ecma_value_t promise = ecma_make_object_value (ecma_builtin_get (ECMA_BUILTIN_ID_PROMISE));
+
+    if (JERRY_UNLIKELY (builtin_routine_id == ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_THROW))
+    {
+      return ecma_promise_reject_or_resolve (promise, arguments_list_p[0], false);
+    }
+
+    ecma_value_t iter_result = ecma_create_iter_result_object (ECMA_VALUE_UNDEFINED, ECMA_VALUE_TRUE);
+    ecma_value_t result = ecma_promise_reject_or_resolve (promise, iter_result, true);
+    ecma_free_value (iter_result);
+    return result;
+  }
+
+  return ecma_async_generator_enqueue (executable_object_p,
+                                       ECMA_ASYNC_GENERATOR_ROUTINE_TO_OPERATION (builtin_routine_id),
+                                       arguments_list_p[0]);
+} /* ecma_builtin_async_generator_prototype_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-generator-prototype.inc.h

@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+/*
+ * AsyncGenerator.prototype built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v6, 25.3.1.5 */
+STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG, LIT_MAGIC_STRING_ASYNC_GENERATOR_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 25.2.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_ASYNC_GENERATOR, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_NEXT, ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_NEXT, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_RETURN, ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_RETURN, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_THROW, ECMA_ASYNC_GENERATOR_PROTOTYPE_ROUTINE_THROW, 1, 1)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-generator.cpp

@@ -0,0 +1,39 @@
+/* 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.
+ */
+
+#include "ecma-globals.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-async-generator.inc.h"
+#define BUILTIN_UNDERSCORED_ID  async_generator
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup asyncgenerator ECMA AsyncGenerator object built-in
+ * @{
+ */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-generator.inc.h

@@ -0,0 +1,33 @@
+/* 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.
+ */
+
+/*
+ * %AsyncGenerator% built-in description (AsyncGeneratorFunction.prototype)
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* ECMA-262 v6, 25.3.2.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_ASYNC_GENERATOR_FUNCTION, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 25.3.2.3.2 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_ASYNC_GENERATOR_PROTOTYPE, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 25.3.2.3.3 */
+STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG,
+              LIT_MAGIC_STRING_ASYNC_GENERATOR_FUNCTION_UL,
+              ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-iterator-prototype.cpp

@@ -0,0 +1,103 @@
+/* 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.
+ */
+
+#include "ecma-builtin-helpers.h"
+#include "ecma-builtins.h"
+#include "ecma-iterator-object.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_BUILTIN_ASYNC_ITERATOR_PROTOTYPE_ROUTINE_START = 0,
+  ECMA_BUILTIN_ASYNC_ITERATOR_PROTOTYPE_OBJECT_ASYNC_ITERATOR,
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-async-iterator-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  async_iterator_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup %asynciteratorprototype% ECMA %AsyncIteratorPrototype% object built-in
+ * @{
+ */
+
+/**
+ * The %AsyncIteratorPrototype% object's '@@asyncIterator' routine
+ *
+ * See also:
+ *          ECMA-262 v10, 25.1.3.1
+ *
+ * Note:
+ *     Returned value must be freed with ecma_free_value.
+ *
+ * @return the given this value
+ */
+static ecma_value_t
+ecma_builtin_async_iterator_prototype_object_async_iterator (ecma_value_t this_val) /**< this argument */
+{
+  /* 1. */
+  return ecma_copy_value (this_val);
+} /* ecma_builtin_async_iterator_prototype_object_async_iterator */
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_async_iterator_prototype_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide
+                                                                                     *   routine identifier */
+                                                        ecma_value_t this_arg, /**< 'this' argument value */
+                                                        const ecma_value_t arguments_list_p[], /**<
+                                                                                                * list of arguments
+                                                                                                * passed to routine */
+                                                        uint32_t arguments_number) /**< length of arguments' list */
+{
+  JERRY_UNUSED_2 (arguments_list_p, arguments_number);
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_BUILTIN_ASYNC_ITERATOR_PROTOTYPE_OBJECT_ASYNC_ITERATOR:
+    {
+      return ecma_builtin_async_iterator_prototype_object_async_iterator (this_arg);
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+} /* ecma_builtin_async_iterator_prototype_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-async-iterator-prototype.inc.h

@@ -0,0 +1,26 @@
+/* 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.
+ */
+
+/*
+ * %AsyncIteratorPrototype% built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_GLOBAL_SYMBOL_ASYNC_ITERATOR, ECMA_BUILTIN_ASYNC_ITERATOR_PROTOTYPE_OBJECT_ASYNC_ITERATOR, 0, 0)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-atomics.cpp

@@ -0,0 +1,260 @@
+/* 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.
+ */
+
+#include "ecma-atomics-object.h"
+#include "ecma-builtins.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+
+#include "jrt.h"
+
+#if JERRY_BUILTIN_ATOMICS
+
+#define ECMA_BUILTINS_INTERNAL
+
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_ATOMICS_ROUTINE_START = 0, /**< Special value, should be ignored */
+  ECMA_ATOMICS_ROUTINE_ADD, /**< Atomics add routine */
+  ECMA_ATOMICS_ROUTINE_AND, /**< Atomics and routine */
+  ECMA_ATOMICS_ROUTINE_COMPAREEXCHANGE, /**< Atomics compare exchange routine */
+  ECMA_ATOMICS_ROUTINE_EXCHANGE, /**< Atomics exchange routine */
+  ECMA_ATOMICS_ROUTINE_ISLOCKFREE, /**< Atomics is lock free routine */
+  ECMA_ATOMICS_ROUTINE_LOAD, /**< Atomics load routine */
+  ECMA_ATOMICS_ROUTINE_OR, /**< Atomics or routine */
+  ECMA_ATOMICS_ROUTINE_STORE, /**< Atomics store routine */
+  ECMA_ATOMICS_ROUTINE_SUB, /**< Atomics sub routine */
+  ECMA_ATOMICS_ROUTINE_WAIT, /**< Atomics wait routine */
+  ECMA_ATOMICS_ROUTINE_NOTIFY, /**< Atomics notify routine */
+  ECMA_ATOMICS_ROUTINE_XOR, /**< Atomics xor routine */
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-atomics.inc.h"
+#define BUILTIN_UNDERSCORED_ID  atomics
+
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup atomics ECMA Atomics object built-in
+ * @{
+ */
+
+/**
+ * The Atomics object's 'compareExchange' routine
+ *
+ * See also: ES11 24.4.4
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_atomics_compare_exchange (ecma_value_t typedarray, /**< typedArray argument */
+                                       ecma_value_t index, /**< index argument */
+                                       ecma_value_t expected_value, /**< expectedValue argument */
+                                       ecma_value_t replacement_value) /**< replacementValue argument*/
+{
+  JERRY_UNUSED (typedarray);
+  JERRY_UNUSED (index);
+  JERRY_UNUSED (expected_value);
+  JERRY_UNUSED (replacement_value);
+
+  return ecma_make_uint32_value (0);
+} /* ecma_builtin_atomics_compare_exchange */
+
+/**
+ * The Atomics object's 'isLockFree' routine
+ *
+ * See also: ES11 24.4.6
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_atomics_is_lock_free (ecma_value_t size) /**< size argument */
+{
+  JERRY_UNUSED (size);
+
+  return ECMA_VALUE_FALSE;
+} /* ecma_builtin_atomics_is_lock_free */
+
+/**
+ * The Atomics object's 'store' routine
+ *
+ * See also: ES11 24.4.9
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_atomics_store (ecma_value_t typedarray, /**< typedArray argument */
+                            ecma_value_t index, /**< index argument */
+                            ecma_value_t value) /**< value argument */
+{
+  JERRY_UNUSED (typedarray);
+  JERRY_UNUSED (index);
+  JERRY_UNUSED (value);
+
+  return ecma_make_uint32_value (0);
+} /* ecma_builtin_atomics_store */
+
+/**
+ * The Atomics object's 'wait' routine
+ *
+ * See also: ES11 24.4.11
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_atomics_wait (ecma_value_t typedarray, /**< typedArray argument */
+                           ecma_value_t index, /**< index argument */
+                           ecma_value_t value, /**< value argument */
+                           ecma_value_t timeout) /**< timeout argument */
+{
+  JERRY_UNUSED (typedarray);
+  JERRY_UNUSED (index);
+  JERRY_UNUSED (value);
+  JERRY_UNUSED (timeout);
+
+  return ecma_make_uint32_value (0);
+} /* ecma_builtin_atomics_wait */
+
+/**
+ * The Atomics object's 'notify' routine
+ *
+ * See also: ES11 24.4.12
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_atomics_notify (ecma_value_t typedarray, /**< typedArray argument */
+                             ecma_value_t index, /**< index argument */
+                             ecma_value_t count) /**< count argument */
+{
+  JERRY_UNUSED (typedarray);
+  JERRY_UNUSED (index);
+  JERRY_UNUSED (count);
+
+  return ecma_make_uint32_value (0);
+} /* ecma_builtin_atomics_notify */
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_atomics_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide routine identifier */
+                                       ecma_value_t this_arg, /**< 'this' argument value */
+                                       const ecma_value_t arguments_list_p[], /**< list of arguments
+                                                                               *   passed to routine */
+                                       uint32_t arguments_number) /**< length of arguments' list */
+{
+  JERRY_UNUSED (this_arg);
+  ecma_value_t arg1 = arguments_list_p[0];
+  ecma_value_t arg2 = arguments_list_p[1];
+  ecma_value_t arg3 = arguments_list_p[2];
+  ecma_value_t arg4 = (arguments_number > 3) ? arguments_list_p[3] : ECMA_VALUE_UNDEFINED;
+
+  ecma_atomics_op_t type;
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_ATOMICS_ROUTINE_ADD:
+    {
+      type = ECMA_ATOMICS_ADD;
+      break;
+    }
+    case ECMA_ATOMICS_ROUTINE_AND:
+    {
+      type = ECMA_ATOMICS_AND;
+      break;
+    }
+    case ECMA_ATOMICS_ROUTINE_COMPAREEXCHANGE:
+    {
+      return ecma_builtin_atomics_compare_exchange (arg1, arg2, arg3, arg4);
+    }
+    case ECMA_ATOMICS_ROUTINE_EXCHANGE:
+    {
+      type = ECMA_ATOMICS_EXCHANGE;
+      break;
+    }
+    case ECMA_ATOMICS_ROUTINE_ISLOCKFREE:
+    {
+      return ecma_builtin_atomics_is_lock_free (arg1);
+    }
+    case ECMA_ATOMICS_ROUTINE_LOAD:
+    {
+      return ecma_atomic_load (arg1, arg2);
+    }
+    case ECMA_ATOMICS_ROUTINE_OR:
+    {
+      type = ECMA_ATOMICS_OR;
+      break;
+    }
+    case ECMA_ATOMICS_ROUTINE_STORE:
+    {
+      return ecma_builtin_atomics_store (arg1, arg2, arg3);
+    }
+    case ECMA_ATOMICS_ROUTINE_SUB:
+    {
+      type = ECMA_ATOMICS_SUBTRACT;
+      break;
+    }
+    case ECMA_ATOMICS_ROUTINE_WAIT:
+    {
+      return ecma_builtin_atomics_wait (arg1, arg2, arg3, arg4);
+    }
+    case ECMA_ATOMICS_ROUTINE_NOTIFY:
+    {
+      return ecma_builtin_atomics_notify (arg1, arg2, arg3);
+    }
+    case ECMA_ATOMICS_ROUTINE_XOR:
+    {
+      type = ECMA_ATOMICS_XOR;
+      break;
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+  return ecma_atomic_read_modify_write (arg1, arg2, arg3, type);
+} /* ecma_builtin_atomics_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_ATOMICS */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-atomics.inc.h

@@ -0,0 +1,44 @@
+/* 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.
+ */
+
+/*
+ * Atomics built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_ATOMICS
+
+/* ECMA-262 v11, 24.4.14 */
+STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG, LIT_MAGIC_STRING_ATOMICS_U, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_ADD, ECMA_ATOMICS_ROUTINE_ADD, 3, 3)
+ROUTINE (LIT_MAGIC_STRING_ATOMICS_AND, ECMA_ATOMICS_ROUTINE_AND, 3, 3)
+ROUTINE (LIT_MAGIC_STRING_ATOMICS_COMPAREEXCHANGE, ECMA_ATOMICS_ROUTINE_COMPAREEXCHANGE, 4, 4)
+ROUTINE (LIT_MAGIC_STRING_ATOMICS_EXCHANGE, ECMA_ATOMICS_ROUTINE_EXCHANGE, 3, 3)
+ROUTINE (LIT_MAGIC_STRING_ATOMICS_ISLOCKFREE, ECMA_ATOMICS_ROUTINE_ISLOCKFREE, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_ATOMICS_LOAD, ECMA_ATOMICS_ROUTINE_LOAD, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_ATOMICS_OR, ECMA_ATOMICS_ROUTINE_OR, 3, 3)
+ROUTINE (LIT_MAGIC_STRING_ATOMICS_STORE, ECMA_ATOMICS_ROUTINE_STORE, 3, 3)
+ROUTINE (LIT_MAGIC_STRING_ATOMICS_SUB, ECMA_ATOMICS_ROUTINE_SUB, 3, 3)
+ROUTINE (LIT_MAGIC_STRING_ATOMICS_WAIT, ECMA_ATOMICS_ROUTINE_WAIT, 4, 4)
+ROUTINE (LIT_MAGIC_STRING_ATOMICS_NOTIFY, ECMA_ATOMICS_ROUTINE_NOTIFY, 3, 3)
+ROUTINE (LIT_MAGIC_STRING_ATOMICS_XOR, ECMA_ATOMICS_ROUTINE_XOR, 3, 3)
+
+#endif /* JERRY_BUILTIN_ATOMICS */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-bigint-prototype.cpp

@@ -0,0 +1,186 @@
+/* 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.
+ */
+
+#include "ecma-bigint.h"
+#include "ecma-exceptions.h"
+
+#if JERRY_BUILTIN_BIGINT
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_BIGINT_PROTOTYPE_ROUTINE_START = 0,
+  ECMA_BIGINT_PROTOTYPE_VALUE_OF,
+  ECMA_BIGINT_PROTOTYPE_TO_STRING,
+  ECMA_BIGINT_PROTOTYPE_TO_LOCALE_STRING,
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-bigint-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  bigint_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup bigint ECMA BigInt object built-in
+ * @{
+ */
+
+/**
+ * The BigInt.prototype object's 'valueOf' routine
+ *
+ * See also:
+ *          ECMA-262 v11, 20.2.3.4
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_bigint_prototype_object_value_of (ecma_value_t this_arg) /**< this argument */
+{
+  if (ecma_is_value_bigint (this_arg))
+  {
+    return ecma_copy_value (this_arg);
+  }
+
+  if (ecma_is_value_object (this_arg))
+  {
+    ecma_object_t *object_p = ecma_get_object_from_value (this_arg);
+
+    if (ecma_object_class_is (object_p, ECMA_OBJECT_CLASS_BIGINT))
+    {
+      ecma_extended_object_t *ext_object_p = (ecma_extended_object_t *) object_p;
+
+      JERRY_ASSERT (ecma_is_value_bigint (ext_object_p->u.cls.u3.value));
+
+      return ecma_copy_value (ext_object_p->u.cls.u3.value);
+    }
+  }
+
+  return ecma_raise_type_error (ECMA_ERR_BIGINT_VALUE_EXCPECTED);
+} /* ecma_builtin_bigint_prototype_object_value_of */
+
+/**
+ * The BigInt.prototype object's 'toString' routine
+ *
+ * See also:
+ *          ECMA-262 v11, 20.2.3.3
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_bigint_prototype_object_to_string (ecma_value_t this_arg, /**< this argument */
+                                                const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                uint32_t arguments_list_len) /**< number of arguments */
+{
+  uint32_t radix = 10;
+
+  if (arguments_list_len > 0 && !ecma_is_value_undefined (arguments_list_p[0]))
+  {
+    ecma_number_t arg_num;
+
+    if (ECMA_IS_VALUE_ERROR (ecma_op_to_integer (arguments_list_p[0], &arg_num)))
+    {
+      return ECMA_VALUE_ERROR;
+    }
+
+    if (arg_num < 2 || arg_num > 36)
+    {
+      return ecma_raise_range_error (ECMA_ERR_RADIX_IS_OUT_OF_RANGE);
+    }
+
+    radix = (uint32_t) arg_num;
+  }
+
+  ecma_string_t *string_p = ecma_bigint_to_string (this_arg, radix);
+
+  if (string_p == NULL)
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  return ecma_make_string_value (string_p);
+} /* ecma_builtin_bigint_prototype_object_to_string */
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_bigint_prototype_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide routine
+                                                                             *   identifier */
+                                                ecma_value_t this_arg, /**< 'this' argument value */
+                                                const ecma_value_t arguments_list_p[], /**< list of arguments
+                                                                                        *   passed to routine */
+                                                uint32_t arguments_number) /**< length of arguments' list */
+{
+  ecma_value_t this_value = ecma_builtin_bigint_prototype_object_value_of (this_arg);
+  ecma_value_t ret_val;
+
+  if (ECMA_IS_VALUE_ERROR (this_value))
+  {
+    return this_value;
+  }
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_BIGINT_PROTOTYPE_VALUE_OF:
+    {
+      ret_val = this_value;
+      break;
+    }
+    case ECMA_BIGINT_PROTOTYPE_TO_STRING:
+    {
+      ret_val = ecma_builtin_bigint_prototype_object_to_string (this_value, arguments_list_p, arguments_number);
+      ecma_free_value (this_value);
+      break;
+    }
+    case ECMA_BIGINT_PROTOTYPE_TO_LOCALE_STRING:
+    {
+      ret_val = ecma_builtin_bigint_prototype_object_to_string (this_value, 0, 0);
+      ecma_free_value (this_value);
+      break;
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+  return ret_val;
+} /* ecma_builtin_bigint_prototype_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_BIGINT */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-bigint-prototype.inc.h

@@ -0,0 +1,41 @@
+/* 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.
+ */
+
+/*
+ * BigInt.prototype built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_BIGINT
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v11, 20.2.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_BIGINT, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* ECMA-262 v11, 20.2.3.5 */
+STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG, LIT_MAGIC_STRING_BIGINT_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_TO_STRING_UL, ECMA_BIGINT_PROTOTYPE_TO_STRING, NON_FIXED, 0)
+ROUTINE (LIT_MAGIC_STRING_VALUE_OF_UL, ECMA_BIGINT_PROTOTYPE_VALUE_OF, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_TO_LOCALE_STRING_UL, ECMA_BIGINT_PROTOTYPE_TO_LOCALE_STRING, 0, 0)
+
+#endif /* JERRY_BUILTIN_BIGINT */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-bigint.cpp

@@ -0,0 +1,80 @@
+/* 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.
+ */
+
+#include "ecma-bigint.h"
+#include "ecma-builtins.h"
+#include "ecma-exceptions.h"
+
+#if JERRY_BUILTIN_BIGINT
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-bigint.inc.h"
+#define BUILTIN_UNDERSCORED_ID  bigint
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup bigint ECMA BigInt object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in BigInt object
+ *
+ * See also:
+ *          ECMA-262 v11, 20.2.1.1
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_bigint_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                   uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  ecma_value_t value = (arguments_list_len == 0) ? ECMA_VALUE_UNDEFINED : arguments_list_p[0];
+  return ecma_bigint_to_bigint (value, true);
+} /* ecma_builtin_bigint_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in BigInt object
+ *
+ * See also:
+ *          ECMA-262 v11, 20.2.1
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_bigint_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                        uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_raise_type_error (ECMA_ERR_BIGINT_FUNCTION_NOT_CONSTRUCTOR);
+} /* ecma_builtin_bigint_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_BIGINT */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-bigint.inc.h

@@ -0,0 +1,41 @@
+/* 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.
+ */
+
+/*
+ * BigInt built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_BIGINT
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+/* ECMA-262 v11, 20.2.1 */
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 1, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v11, 20.2.1 */
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_BIGINT_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v11, 20.2.2.3 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_BIGINT_PROTOTYPE, ECMA_PROPERTY_FIXED)
+
+#endif /* JERRY_BUILTIN_BIGINT */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-boolean-prototype.cpp

@@ -0,0 +1,140 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+
+#include "jrt.h"
+
+#if JERRY_BUILTIN_BOOLEAN
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_BOOLEAN_PROTOTYPE_ROUTINE_START = 0,
+  ECMA_BOOLEAN_PROTOTYPE_ROUTINE_TO_STRING,
+  ECMA_BOOLEAN_PROTOTYPE_ROUTINE_VALUE_OF
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-boolean-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  boolean_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup booleanprototype ECMA Boolean.prototype object built-in
+ * @{
+ */
+
+/**
+ * The Boolean.prototype object's 'valueOf' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.6.4.3
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_boolean_prototype_object_value_of (ecma_value_t this_arg) /**< this argument */
+{
+  if (ecma_is_value_boolean (this_arg))
+  {
+    return this_arg;
+  }
+  else if (ecma_is_value_object (this_arg))
+  {
+    ecma_object_t *object_p = ecma_get_object_from_value (this_arg);
+
+    if (ecma_object_class_is (object_p, ECMA_OBJECT_CLASS_BOOLEAN))
+    {
+      ecma_extended_object_t *ext_object_p = (ecma_extended_object_t *) object_p;
+
+      JERRY_ASSERT (ecma_is_value_boolean (ext_object_p->u.cls.u3.value));
+
+      return ext_object_p->u.cls.u3.value;
+    }
+  }
+
+  return ecma_raise_type_error (ECMA_ERR_ARGUMENT_THIS_NOT_BOOLEAN_OBJECT);
+} /* ecma_builtin_boolean_prototype_object_value_of */
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_boolean_prototype_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide routine
+                                                                              *   identifier */
+                                                 ecma_value_t this_arg, /**< 'this' argument value */
+                                                 const ecma_value_t arguments_list_p[], /**< list of arguments
+                                                                                         *   passed to routine */
+                                                 uint32_t arguments_number) /**< length of arguments' list */
+{
+  JERRY_UNUSED_2 (arguments_number, arguments_list_p);
+
+  ecma_value_t value_of_ret = ecma_builtin_boolean_prototype_object_value_of (this_arg);
+  if (builtin_routine_id == ECMA_BOOLEAN_PROTOTYPE_ROUTINE_VALUE_OF)
+  {
+    return value_of_ret;
+  }
+
+  JERRY_ASSERT (builtin_routine_id == ECMA_BOOLEAN_PROTOTYPE_ROUTINE_TO_STRING);
+
+  if (ECMA_IS_VALUE_ERROR (value_of_ret))
+  {
+    return value_of_ret;
+  }
+
+  if (ecma_is_value_true (value_of_ret))
+  {
+    return ecma_make_magic_string_value (LIT_MAGIC_STRING_TRUE);
+  }
+
+  JERRY_ASSERT (ecma_is_value_false (value_of_ret));
+
+  return ecma_make_magic_string_value (LIT_MAGIC_STRING_FALSE);
+} /* ecma_builtin_boolean_prototype_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_BOOLEAN */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-boolean-prototype.inc.h

@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+/*
+ * Boolean.prototype description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_BOOLEAN
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.6.4.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_BOOLEAN, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_TO_STRING_UL, ECMA_BOOLEAN_PROTOTYPE_ROUTINE_TO_STRING, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_VALUE_OF_UL, ECMA_BOOLEAN_PROTOTYPE_ROUTINE_VALUE_OF, 0, 0)
+
+#endif /* JERRY_BUILTIN_BOOLEAN */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-boolean.cpp

@@ -0,0 +1,99 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-boolean-object.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+
+#include "jrt.h"
+
+#if JERRY_BUILTIN_BOOLEAN
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-boolean.inc.h"
+#define BUILTIN_UNDERSCORED_ID  boolean
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup boolean ECMA Boolean object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in Boolean object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_boolean_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                    uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  ecma_value_t arg_value;
+
+  if (arguments_list_len == 0)
+  {
+    arg_value = ECMA_VALUE_UNDEFINED;
+  }
+  else
+  {
+    arg_value = arguments_list_p[0];
+  }
+
+  return ecma_make_boolean_value (ecma_op_to_boolean (arg_value));
+} /* ecma_builtin_boolean_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Boolean object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_boolean_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                         uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len == 0)
+  {
+    return ecma_op_create_boolean_object (ECMA_VALUE_FALSE);
+  }
+  else
+  {
+    return ecma_op_create_boolean_object (arguments_list_p[0]);
+  }
+} /* ecma_builtin_boolean_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_BOOLEAN */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-boolean.inc.h

@@ -0,0 +1,38 @@
+/* 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.
+ */
+
+/*
+ * Boolean description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_BOOLEAN
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.6.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_BOOLEAN_PROTOTYPE, ECMA_PROPERTY_FIXED)
+
+/* Number properties:
+ *  (property name, object pointer getter) */
+
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 1, ECMA_PROPERTY_FLAG_DEFAULT_LENGTH)
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_BOOLEAN_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#endif /* JERRY_BUILTIN_BOOLEAN */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-dataview-prototype.cpp

@@ -0,0 +1,238 @@
+/* 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.
+ */
+
+#include "ecma-arraybuffer-object.h"
+#include "ecma-dataview-object.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+
+#if JERRY_BUILTIN_DATAVIEW
+
+#if !JERRY_BUILTIN_TYPEDARRAY
+#error "DataView builtin requires ES2015 TypedArray builtin"
+#endif /* !JERRY_BUILTIN_TYPEDARRAY */
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_DATAVIEW_PROTOTYPE_ROUTINE_START = 0,
+  ECMA_DATAVIEW_PROTOTYPE_BUFFER_GETTER,
+  ECMA_DATAVIEW_PROTOTYPE_BYTE_LENGTH_GETTER,
+  ECMA_DATAVIEW_PROTOTYPE_BYTE_OFFSET_GETTER,
+  ECMA_DATAVIEW_PROTOTYPE_GET_INT8,
+  ECMA_DATAVIEW_PROTOTYPE_GET_UINT8,
+  ECMA_DATAVIEW_PROTOTYPE_GET_UINT8_CLAMPED, /* unused value */
+  ECMA_DATAVIEW_PROTOTYPE_GET_INT16,
+  ECMA_DATAVIEW_PROTOTYPE_GET_UINT16,
+  ECMA_DATAVIEW_PROTOTYPE_GET_INT32,
+  ECMA_DATAVIEW_PROTOTYPE_GET_UINT32,
+  ECMA_DATAVIEW_PROTOTYPE_GET_FLOAT32,
+#if JERRY_NUMBER_TYPE_FLOAT64
+  ECMA_DATAVIEW_PROTOTYPE_GET_FLOAT64,
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+#if JERRY_BUILTIN_BIGINT
+  ECMA_DATAVIEW_PROTOTYPE_GET_BIGINT64,
+  ECMA_DATAVIEW_PROTOTYPE_GET_BIGUINT64,
+#endif /* JERRY_BUILTIN_BIGINT */
+  ECMA_DATAVIEW_PROTOTYPE_SET_INT8,
+  ECMA_DATAVIEW_PROTOTYPE_SET_UINT8,
+  ECMA_DATAVIEW_PROTOTYPE_SET_UINT8_CLAMPED, /* unused value */
+  ECMA_DATAVIEW_PROTOTYPE_SET_INT16,
+  ECMA_DATAVIEW_PROTOTYPE_SET_UINT16,
+  ECMA_DATAVIEW_PROTOTYPE_SET_INT32,
+  ECMA_DATAVIEW_PROTOTYPE_SET_UINT32,
+  ECMA_DATAVIEW_PROTOTYPE_SET_FLOAT32,
+#if JERRY_NUMBER_TYPE_FLOAT64
+  ECMA_DATAVIEW_PROTOTYPE_SET_FLOAT64,
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+#if JERRY_BUILTIN_BIGINT
+  ECMA_DATAVIEW_PROTOTYPE_SET_BIGINT64,
+  ECMA_DATAVIEW_PROTOTYPE_SET_BIGUINT64,
+#endif /* JERRY_BUILTIN_BIGINT */
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-dataview-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  dataview_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup dataviewprototype ECMA DataView.prototype object built-in
+ * @{
+ */
+
+/**
+ * The DataView.prototype object's {buffer, byteOffset, byteLength} getters
+ *
+ * See also:
+ *          ECMA-262 v6, 24.2.4.1
+ *          ECMA-262 v6, 24.2.4.2
+ *          ECMA-262 v6, 24.2.4.3
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_dataview_prototype_object_getters (ecma_value_t this_arg, /**< this argument */
+                                                uint16_t builtin_routine_id) /**< built-in wide routine identifier */
+{
+  ecma_dataview_object_t *obj_p = ecma_op_dataview_get_object (this_arg);
+
+  if (JERRY_UNLIKELY (obj_p == NULL))
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_DATAVIEW_PROTOTYPE_BUFFER_GETTER:
+    {
+      ecma_object_t *buffer_p = obj_p->buffer_p;
+      ecma_ref_object (buffer_p);
+
+      return ecma_make_object_value (buffer_p);
+    }
+    case ECMA_DATAVIEW_PROTOTYPE_BYTE_LENGTH_GETTER:
+    {
+      if (ecma_arraybuffer_is_detached (obj_p->buffer_p))
+      {
+        return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED);
+      }
+      return ecma_make_uint32_value (obj_p->header.u.cls.u3.length);
+    }
+    default:
+    {
+      JERRY_ASSERT (builtin_routine_id == ECMA_DATAVIEW_PROTOTYPE_BYTE_OFFSET_GETTER);
+
+      if (ecma_arraybuffer_is_detached (obj_p->buffer_p))
+      {
+        return ecma_raise_type_error (ECMA_ERR_ARRAYBUFFER_IS_DETACHED);
+      }
+      return ecma_make_uint32_value (obj_p->byte_offset);
+    }
+  }
+} /* ecma_builtin_dataview_prototype_object_getters */
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_dataview_prototype_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide routine identifier */
+                                                  ecma_value_t this_arg, /**< 'this' argument value */
+                                                  const ecma_value_t arguments_list_p[], /**< list of arguments
+                                                                                          *   passed to routine */
+                                                  uint32_t arguments_number) /**< length of arguments' list */
+{
+  JERRY_UNUSED (arguments_number);
+  switch (builtin_routine_id)
+  {
+    case ECMA_DATAVIEW_PROTOTYPE_BUFFER_GETTER:
+    case ECMA_DATAVIEW_PROTOTYPE_BYTE_LENGTH_GETTER:
+    case ECMA_DATAVIEW_PROTOTYPE_BYTE_OFFSET_GETTER:
+    {
+      return ecma_builtin_dataview_prototype_object_getters (this_arg, builtin_routine_id);
+    }
+    case ECMA_DATAVIEW_PROTOTYPE_GET_FLOAT32:
+#if JERRY_NUMBER_TYPE_FLOAT64
+    case ECMA_DATAVIEW_PROTOTYPE_GET_FLOAT64:
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+    case ECMA_DATAVIEW_PROTOTYPE_GET_INT16:
+    case ECMA_DATAVIEW_PROTOTYPE_GET_INT32:
+    case ECMA_DATAVIEW_PROTOTYPE_GET_UINT16:
+    case ECMA_DATAVIEW_PROTOTYPE_GET_UINT32:
+#if JERRY_BUILTIN_BIGINT
+    case ECMA_DATAVIEW_PROTOTYPE_GET_BIGINT64:
+    case ECMA_DATAVIEW_PROTOTYPE_GET_BIGUINT64:
+#endif /* JERRY_BUILTIN_BIGINT */
+    {
+      ecma_typedarray_type_t id = (ecma_typedarray_type_t) (builtin_routine_id - ECMA_DATAVIEW_PROTOTYPE_GET_INT8);
+
+      return ecma_op_dataview_get_set_view_value (this_arg,
+                                                  arguments_list_p[0],
+                                                  arguments_list_p[1],
+                                                  ECMA_VALUE_EMPTY,
+                                                  id);
+    }
+    case ECMA_DATAVIEW_PROTOTYPE_SET_FLOAT32:
+#if JERRY_NUMBER_TYPE_FLOAT64
+    case ECMA_DATAVIEW_PROTOTYPE_SET_FLOAT64:
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+    case ECMA_DATAVIEW_PROTOTYPE_SET_INT16:
+    case ECMA_DATAVIEW_PROTOTYPE_SET_INT32:
+    case ECMA_DATAVIEW_PROTOTYPE_SET_UINT16:
+    case ECMA_DATAVIEW_PROTOTYPE_SET_UINT32:
+#if JERRY_BUILTIN_BIGINT
+    case ECMA_DATAVIEW_PROTOTYPE_SET_BIGINT64:
+    case ECMA_DATAVIEW_PROTOTYPE_SET_BIGUINT64:
+#endif /* JERRY_BUILTIN_BIGINT */
+    {
+      ecma_typedarray_type_t id = (ecma_typedarray_type_t) (builtin_routine_id - ECMA_DATAVIEW_PROTOTYPE_SET_INT8);
+
+      return ecma_op_dataview_get_set_view_value (this_arg,
+                                                  arguments_list_p[0],
+                                                  arguments_list_p[2],
+                                                  arguments_list_p[1],
+                                                  id);
+    }
+    case ECMA_DATAVIEW_PROTOTYPE_GET_INT8:
+    case ECMA_DATAVIEW_PROTOTYPE_GET_UINT8:
+    {
+      ecma_typedarray_type_t id = (ecma_typedarray_type_t) (builtin_routine_id - ECMA_DATAVIEW_PROTOTYPE_GET_INT8);
+
+      return ecma_op_dataview_get_set_view_value (this_arg,
+                                                  arguments_list_p[0],
+                                                  ECMA_VALUE_FALSE,
+                                                  ECMA_VALUE_EMPTY,
+                                                  id);
+    }
+    default:
+    {
+      JERRY_ASSERT (builtin_routine_id == ECMA_DATAVIEW_PROTOTYPE_SET_INT8
+                    || builtin_routine_id == ECMA_DATAVIEW_PROTOTYPE_SET_UINT8);
+      ecma_typedarray_type_t id = (ecma_typedarray_type_t) (builtin_routine_id - ECMA_DATAVIEW_PROTOTYPE_SET_INT8);
+
+      return ecma_op_dataview_get_set_view_value (this_arg,
+                                                  arguments_list_p[0],
+                                                  ECMA_VALUE_FALSE,
+                                                  arguments_list_p[1],
+                                                  id);
+    }
+  }
+} /* ecma_builtin_dataview_prototype_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_DATAVIEW */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-dataview-prototype.inc.h

@@ -0,0 +1,77 @@
+/* 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.
+ */
+
+/*
+ * DataView.prototype built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_DATAVIEW
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v6, 24.2.3 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_DATAVIEW, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* ECMA-262 v6, 23.2.4.21 */
+STRING_VALUE (LIT_GLOBAL_SYMBOL_TO_STRING_TAG, LIT_MAGIC_STRING_DATAVIEW_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_GET_FLOAT_32_UL, ECMA_DATAVIEW_PROTOTYPE_GET_FLOAT32, 2, 1)
+#if JERRY_NUMBER_TYPE_FLOAT64
+ROUTINE (LIT_MAGIC_STRING_GET_FLOAT_64_UL, ECMA_DATAVIEW_PROTOTYPE_GET_FLOAT64, 2, 1)
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+ROUTINE (LIT_MAGIC_STRING_GET_INT8_UL, ECMA_DATAVIEW_PROTOTYPE_GET_INT8, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_GET_INT16_UL, ECMA_DATAVIEW_PROTOTYPE_GET_INT16, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_GET_INT32_UL, ECMA_DATAVIEW_PROTOTYPE_GET_INT32, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_GET_UINT8_UL, ECMA_DATAVIEW_PROTOTYPE_GET_UINT8, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_GET_UINT16_UL, ECMA_DATAVIEW_PROTOTYPE_GET_UINT16, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_GET_UINT32_UL, ECMA_DATAVIEW_PROTOTYPE_GET_UINT32, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_SET_FLOAT_32_UL, ECMA_DATAVIEW_PROTOTYPE_SET_FLOAT32, 2, 2)
+#if JERRY_NUMBER_TYPE_FLOAT64
+ROUTINE (LIT_MAGIC_STRING_SET_FLOAT_64_UL, ECMA_DATAVIEW_PROTOTYPE_SET_FLOAT64, 2, 2)
+#endif /* JERRY_NUMBER_TYPE_FLOAT64 */
+ROUTINE (LIT_MAGIC_STRING_SET_INT8_UL, ECMA_DATAVIEW_PROTOTYPE_SET_INT8, 1, 2)
+ROUTINE (LIT_MAGIC_STRING_SET_INT16_UL, ECMA_DATAVIEW_PROTOTYPE_SET_INT16, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_SET_INT32_UL, ECMA_DATAVIEW_PROTOTYPE_SET_INT32, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_SET_UINT8_UL, ECMA_DATAVIEW_PROTOTYPE_SET_UINT8, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_SET_UINT16_UL, ECMA_DATAVIEW_PROTOTYPE_SET_UINT16, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_SET_UINT32_UL, ECMA_DATAVIEW_PROTOTYPE_SET_UINT32, 2, 2)
+#if JERRY_BUILTIN_BIGINT
+ROUTINE (LIT_MAGIC_STRING_GET_BIGINT64, ECMA_DATAVIEW_PROTOTYPE_GET_BIGINT64, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_GET_BIGUINT64, ECMA_DATAVIEW_PROTOTYPE_GET_BIGUINT64, 2, 1)
+ROUTINE (LIT_MAGIC_STRING_SET_BIGINT64, ECMA_DATAVIEW_PROTOTYPE_SET_BIGINT64, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_SET_BIGUINT64, ECMA_DATAVIEW_PROTOTYPE_SET_BIGUINT64, 2, 2)
+#endif /* JERRY_BUILTIN_BIGINT */
+
+/* ECMA-262 v6, 24.2.4.1 */
+ACCESSOR_READ_ONLY (LIT_MAGIC_STRING_BUFFER, ECMA_DATAVIEW_PROTOTYPE_BUFFER_GETTER, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 24.2.4.2 */
+ACCESSOR_READ_ONLY (LIT_MAGIC_STRING_BYTE_LENGTH_UL,
+                    ECMA_DATAVIEW_PROTOTYPE_BYTE_LENGTH_GETTER,
+                    ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 24.2.4.3 */
+ACCESSOR_READ_ONLY (LIT_MAGIC_STRING_BYTE_OFFSET_UL,
+                    ECMA_DATAVIEW_PROTOTYPE_BYTE_OFFSET_GETTER,
+                    ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#endif /* JERRY_BUILTIN_DATAVIEW */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-dataview.cpp

@@ -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.
+ */
+
+#include "ecma-builtins.h"
+#include "ecma-dataview-object.h"
+#include "ecma-exceptions.h"
+
+#if JERRY_BUILTIN_DATAVIEW
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-dataview.inc.h"
+#define BUILTIN_UNDERSCORED_ID  dataview
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup dataview ECMA DataView object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in DataView object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_dataview_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                     uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_raise_type_error (ECMA_ERR_CONSTRUCTOR_DATAVIEW_REQUIRES_NEW);
+} /* ecma_builtin_dataview_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in DataView object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_dataview_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                          uint32_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_op_dataview_create (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_dataview_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_DATAVIEW */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-dataview.inc.h

@@ -0,0 +1,41 @@
+/* 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.
+ */
+
+/*
+ * DataView built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_DATAVIEW
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+/* ECMA-262 v6, 23.1.2 */
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 1, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 23.1 */
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_DATAVIEW_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v6, 23.1.2.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_DATAVIEW_PROTOTYPE, ECMA_PROPERTY_FIXED)
+
+#endif /* JERRY_BUILTIN_DATAVIEW */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-date-prototype.cpp

@@ -0,0 +1,722 @@
+/* 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.
+ */
+
+#include <math.h>
+
+#include "ecma-alloc.h"
+#include "ecma-builtin-helpers.h"
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects-general.h"
+#include "ecma-objects.h"
+
+#if JERRY_BUILTIN_DATE
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * Checks whether the function uses UTC time zone.
+ */
+#define BUILTIN_DATE_FUNCTION_IS_UTC(builtin_routine_id) \
+  (((builtin_routine_id) -ECMA_DATE_PROTOTYPE_GET_FULL_YEAR) & 0x1)
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_DATE_PROTOTYPE_ROUTINE_START = 0,
+
+  ECMA_DATE_PROTOTYPE_GET_FULL_YEAR, /* ECMA-262 v5 15.9.5.10 */
+  ECMA_DATE_PROTOTYPE_GET_UTC_FULL_YEAR, /* ECMA-262 v5 15.9.5.11 */
+#if JERRY_BUILTIN_ANNEXB
+  ECMA_DATE_PROTOTYPE_GET_YEAR, /* ECMA-262 v5, AnnexB.B.2.4 */
+  ECMA_DATE_PROTOTYPE_GET_UTC_YEAR, /* has no UTC variant */
+#endif /* JERRY_BUILTIN_ANNEXB */
+  ECMA_DATE_PROTOTYPE_GET_MONTH, /* ECMA-262 v5 15.9.5.12 */
+  ECMA_DATE_PROTOTYPE_GET_UTC_MONTH, /* ECMA-262 v5 15.9.5.13 */
+  ECMA_DATE_PROTOTYPE_GET_DATE, /* ECMA-262 v5 15.9.5.14 */
+  ECMA_DATE_PROTOTYPE_GET_UTC_DATE, /* ECMA-262 v5 15.9.5.15 */
+  ECMA_DATE_PROTOTYPE_GET_DAY, /* ECMA-262 v5 15.9.5.16 */
+  ECMA_DATE_PROTOTYPE_GET_UTC_DAY, /* ECMA-262 v5 15.9.5.17 */
+  ECMA_DATE_PROTOTYPE_GET_HOURS, /* ECMA-262 v5 15.9.5.18 */
+  ECMA_DATE_PROTOTYPE_GET_UTC_HOURS, /* ECMA-262 v5 15.9.5.19 */
+  ECMA_DATE_PROTOTYPE_GET_MINUTES, /* ECMA-262 v5 15.9.5.20 */
+  ECMA_DATE_PROTOTYPE_GET_UTC_MINUTES, /* ECMA-262 v5 15.9.5.21 */
+  ECMA_DATE_PROTOTYPE_GET_SECONDS, /* ECMA-262 v5 15.9.5.22 */
+  ECMA_DATE_PROTOTYPE_GET_UTC_SECONDS, /* ECMA-262 v5 15.9.5.23 */
+  ECMA_DATE_PROTOTYPE_GET_MILLISECONDS, /* ECMA-262 v5 15.9.5.24 */
+  ECMA_DATE_PROTOTYPE_GET_UTC_MILLISECONDS, /* ECMA-262 v5 15.9.5.25 */
+  ECMA_DATE_PROTOTYPE_GET_TIMEZONE_OFFSET, /* has no local time zone variant */
+  ECMA_DATE_PROTOTYPE_GET_UTC_TIMEZONE_OFFSET, /* ECMA-262 v5 15.9.5.26 */
+
+  ECMA_DATE_PROTOTYPE_SET_FULL_YEAR, /* ECMA-262 v5, 15.9.5.40 */
+  ECMA_DATE_PROTOTYPE_SET_UTC_FULL_YEAR, /* ECMA-262 v5, 15.9.5.41 */
+#if JERRY_BUILTIN_ANNEXB
+  ECMA_DATE_PROTOTYPE_SET_YEAR, /* ECMA-262 v5, ECMA-262 v5, AnnexB.B.2.5 */
+  ECMA_DATE_PROTOTYPE_SET_UTC_YEAR, /* has no UTC variant */
+#endif /* JERRY_BUILTIN_ANNEXB */
+  ECMA_DATE_PROTOTYPE_SET_MONTH, /* ECMA-262 v5, 15.9.5.38 */
+  ECMA_DATE_PROTOTYPE_SET_UTC_MONTH, /* ECMA-262 v5, 15.9.5.39 */
+  ECMA_DATE_PROTOTYPE_SET_DATE, /* ECMA-262 v5, 15.9.5.36 */
+  ECMA_DATE_PROTOTYPE_SET_UTC_DATE, /* ECMA-262 v5, 15.9.5.37 */
+  ECMA_DATE_PROTOTYPE_SET_HOURS, /* ECMA-262 v5, 15.9.5.34 */
+  ECMA_DATE_PROTOTYPE_SET_UTC_HOURS, /* ECMA-262 v5, 15.9.5.35 */
+  ECMA_DATE_PROTOTYPE_SET_MINUTES, /* ECMA-262 v5, 15.9.5.32 */
+  ECMA_DATE_PROTOTYPE_SET_UTC_MINUTES, /* ECMA-262 v5, 15.9.5.33 */
+  ECMA_DATE_PROTOTYPE_SET_SECONDS, /* ECMA-262 v5, 15.9.5.30 */
+  ECMA_DATE_PROTOTYPE_SET_UTC_SECONDS, /* ECMA-262 v5, 15.9.5.31 */
+  ECMA_DATE_PROTOTYPE_SET_MILLISECONDS, /* ECMA-262 v5, 15.9.5.28 */
+  ECMA_DATE_PROTOTYPE_SET_UTC_MILLISECONDS, /* ECMA-262 v5, 15.9.5.29 */
+
+  ECMA_DATE_PROTOTYPE_TO_STRING, /* ECMA-262 v5, 15.9.5.2 */
+  ECMA_DATE_PROTOTYPE_TO_DATE_STRING, /* ECMA-262 v5, 15.9.5.3 */
+  ECMA_DATE_PROTOTYPE_TO_TIME_STRING, /* ECMA-262 v5, 15.9.5.4 */
+  ECMA_DATE_PROTOTYPE_TO_ISO_STRING, /* ECMA-262 v5, 15.9.5.43 */
+
+  ECMA_DATE_PROTOTYPE_GET_TIME, /* ECMA-262 v5, 15.9.5.9 */
+  ECMA_DATE_PROTOTYPE_SET_TIME, /* ECMA-262 v5, 15.9.5.27 */
+  ECMA_DATE_PROTOTYPE_TO_JSON, /* ECMA-262 v5, 15.9.5.44 */
+
+  ECMA_DATE_PROTOTYPE_TO_PRIMITIVE, /*  ECMA-262 v6 20.3.4.45 */
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-date-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  date_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup dateprototype ECMA Date.prototype object built-in
+ * @{
+ */
+
+/**
+ * The Date.prototype object's 'toJSON' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.9.5.44
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_date_prototype_to_json (ecma_value_t this_arg) /**< this argument */
+{
+  /* 1. */
+  ecma_value_t obj = ecma_op_to_object (this_arg);
+
+  if (ECMA_IS_VALUE_ERROR (obj))
+  {
+    return obj;
+  }
+
+  /* 2. */
+  ecma_value_t tv = ecma_op_to_primitive (obj, ECMA_PREFERRED_TYPE_NUMBER);
+
+  if (ECMA_IS_VALUE_ERROR (tv))
+  {
+    ecma_free_value (obj);
+    return tv;
+  }
+
+  /* 3. */
+  if (ecma_is_value_number (tv))
+  {
+    ecma_number_t num_value = ecma_get_number_from_value (tv);
+
+    ecma_free_value (tv);
+
+    if (ecma_number_is_nan (num_value) || ecma_number_is_infinity (num_value))
+    {
+      ecma_free_value (obj);
+      return ECMA_VALUE_NULL;
+    }
+  }
+  else
+  {
+    ecma_free_value (tv);
+  }
+
+  ecma_object_t *value_obj_p = ecma_get_object_from_value (obj);
+
+  /* 4. */
+  ecma_value_t ret_value = ecma_op_invoke_by_magic_id (obj, LIT_MAGIC_STRING_TO_ISO_STRING_UL, NULL, 0);
+
+  ecma_deref_object (value_obj_p);
+
+  return ret_value;
+} /* ecma_builtin_date_prototype_to_json */
+
+/**
+ * The Date.prototype object's toPrimitive routine
+ *
+ * See also:
+ *          ECMA-262 v6, 20.3.4.45
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_date_prototype_to_primitive (ecma_value_t this_arg, /**< this argument */
+                                          ecma_value_t hint_arg) /**< {"default", "number", "string"} */
+{
+  if (ecma_is_value_object (this_arg) && ecma_is_value_string (hint_arg))
+  {
+    ecma_string_t *hint_str_p = ecma_get_string_from_value (hint_arg);
+
+    ecma_preferred_type_hint_t hint = ECMA_PREFERRED_TYPE_NO;
+
+    if (hint_str_p == ecma_get_magic_string (LIT_MAGIC_STRING_STRING)
+        || hint_str_p == ecma_get_magic_string (LIT_MAGIC_STRING_DEFAULT))
+    {
+      hint = ECMA_PREFERRED_TYPE_STRING;
+    }
+    else if (hint_str_p == ecma_get_magic_string (LIT_MAGIC_STRING_NUMBER))
+    {
+      hint = ECMA_PREFERRED_TYPE_NUMBER;
+    }
+
+    if (hint != ECMA_PREFERRED_TYPE_NO)
+    {
+      return ecma_op_general_object_ordinary_value (ecma_get_object_from_value (this_arg), hint);
+    }
+  }
+
+  return ecma_raise_type_error (ECMA_ERR_INVALID_ARGUMENT_TYPE_IN_TOPRIMITIVE);
+} /* ecma_builtin_date_prototype_to_primitive */
+
+/**
+ * Dispatch get date functions
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_date_prototype_dispatch_get (uint16_t builtin_routine_id, /**< built-in wide routine
+                                                                        *   identifier */
+                                          ecma_number_t date_value) /**< date converted to number */
+{
+  if (ecma_number_is_nan (date_value))
+  {
+    return ecma_make_nan_value ();
+  }
+
+  int32_t result;
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_DATE_PROTOTYPE_GET_FULL_YEAR:
+    case ECMA_DATE_PROTOTYPE_GET_UTC_FULL_YEAR:
+    {
+      result = ecma_date_year_from_time (date_value);
+      break;
+    }
+#if JERRY_BUILTIN_ANNEXB
+    case ECMA_DATE_PROTOTYPE_GET_YEAR:
+    {
+      result = (ecma_date_year_from_time (date_value) - 1900);
+      break;
+    }
+#endif /* JERRY_BUILTIN_ANNEXB */
+    case ECMA_DATE_PROTOTYPE_GET_MONTH:
+    case ECMA_DATE_PROTOTYPE_GET_UTC_MONTH:
+    {
+      result = ecma_date_month_from_time (date_value);
+      break;
+    }
+    case ECMA_DATE_PROTOTYPE_GET_DATE:
+    case ECMA_DATE_PROTOTYPE_GET_UTC_DATE:
+    {
+      result = ecma_date_date_from_time (date_value);
+      break;
+    }
+    case ECMA_DATE_PROTOTYPE_GET_DAY:
+    case ECMA_DATE_PROTOTYPE_GET_UTC_DAY:
+    {
+      result = ecma_date_week_day (date_value);
+      break;
+    }
+    case ECMA_DATE_PROTOTYPE_GET_HOURS:
+    case ECMA_DATE_PROTOTYPE_GET_UTC_HOURS:
+    {
+      result = ecma_date_hour_from_time (date_value);
+      break;
+    }
+    case ECMA_DATE_PROTOTYPE_GET_MINUTES:
+    case ECMA_DATE_PROTOTYPE_GET_UTC_MINUTES:
+    {
+      result = ecma_date_min_from_time (date_value);
+      break;
+    }
+    case ECMA_DATE_PROTOTYPE_GET_SECONDS:
+    case ECMA_DATE_PROTOTYPE_GET_UTC_SECONDS:
+    {
+      result = ecma_date_sec_from_time (date_value);
+      break;
+    }
+    case ECMA_DATE_PROTOTYPE_GET_MILLISECONDS:
+    case ECMA_DATE_PROTOTYPE_GET_UTC_MILLISECONDS:
+    {
+      result = ecma_date_ms_from_time (date_value);
+      break;
+    }
+    default:
+    {
+      JERRY_ASSERT (builtin_routine_id == ECMA_DATE_PROTOTYPE_GET_UTC_TIMEZONE_OFFSET);
+
+      result = -ecma_date_local_time_zone_adjustment (date_value) / ECMA_DATE_MS_PER_MINUTE;
+      break;
+    }
+  }
+
+  return ecma_make_int32_value (result);
+} /* ecma_builtin_date_prototype_dispatch_get */
+
+#if JERRY_BUILTIN_ANNEXB
+
+/**
+ * Returns true, if the built-in id sets a year.
+ */
+#define ECMA_DATE_PROTOTYPE_IS_SET_YEAR_ROUTINE(builtin_routine_id) \
+  ((builtin_routine_id) == ECMA_DATE_PROTOTYPE_SET_FULL_YEAR        \
+   || (builtin_routine_id) == ECMA_DATE_PROTOTYPE_SET_UTC_FULL_YEAR \
+   || (builtin_routine_id) == ECMA_DATE_PROTOTYPE_SET_YEAR)
+
+#else /* !JERRY_BUILTIN_ANNEXB */
+
+/**
+ * Returns true, if the built-in id sets a year.
+ */
+#define ECMA_DATE_PROTOTYPE_IS_SET_YEAR_ROUTINE(builtin_routine_id) \
+  ((builtin_routine_id) == ECMA_DATE_PROTOTYPE_SET_FULL_YEAR        \
+   || (builtin_routine_id) == ECMA_DATE_PROTOTYPE_SET_UTC_FULL_YEAR)
+
+#endif /* JERRY_BUILTIN_ANNEXB */
+
+/**
+ * Dispatch set date functions
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_date_prototype_dispatch_set (uint16_t builtin_routine_id, /**< built-in wide routine
+                                                                        *   identifier */
+                                          ecma_object_t *object_p, /**< date object */
+                                          const ecma_value_t arguments_list[], /**< list of arguments
+                                                                                *   passed to routine */
+                                          uint32_t arguments_number) /**< length of arguments' list */
+{
+  ecma_number_t converted_number[4];
+  uint32_t conversions = 0;
+
+  /* If the first argument is not specified, it is always converted to NaN. */
+  converted_number[0] = ecma_number_make_nan ();
+
+  switch (builtin_routine_id)
+  {
+#if JERRY_BUILTIN_ANNEXB
+    case ECMA_DATE_PROTOTYPE_SET_YEAR:
+#endif /* JERRY_BUILTIN_ANNEXB */
+    case ECMA_DATE_PROTOTYPE_SET_DATE:
+    case ECMA_DATE_PROTOTYPE_SET_UTC_DATE:
+    case ECMA_DATE_PROTOTYPE_SET_UTC_MILLISECONDS:
+    case ECMA_DATE_PROTOTYPE_SET_MILLISECONDS:
+    {
+      conversions = 1;
+      break;
+    }
+    case ECMA_DATE_PROTOTYPE_SET_MONTH:
+    case ECMA_DATE_PROTOTYPE_SET_UTC_MONTH:
+    case ECMA_DATE_PROTOTYPE_SET_UTC_SECONDS:
+    case ECMA_DATE_PROTOTYPE_SET_SECONDS:
+    {
+      conversions = 2;
+      break;
+    }
+    case ECMA_DATE_PROTOTYPE_SET_FULL_YEAR:
+    case ECMA_DATE_PROTOTYPE_SET_UTC_FULL_YEAR:
+    case ECMA_DATE_PROTOTYPE_SET_MINUTES:
+    case ECMA_DATE_PROTOTYPE_SET_UTC_MINUTES:
+    {
+      conversions = 3;
+      break;
+    }
+    default:
+    {
+      JERRY_ASSERT (builtin_routine_id == ECMA_DATE_PROTOTYPE_SET_HOURS
+                    || builtin_routine_id == ECMA_DATE_PROTOTYPE_SET_UTC_HOURS);
+
+      conversions = 4;
+      break;
+    }
+  }
+
+  if (conversions > arguments_number)
+  {
+    conversions = arguments_number;
+  }
+
+  for (uint32_t i = 0; i < conversions; i++)
+  {
+    ecma_value_t value = ecma_op_to_number (arguments_list[i], &converted_number[i]);
+
+    if (ECMA_IS_VALUE_ERROR (value))
+    {
+      return value;
+    }
+  }
+
+  ecma_date_object_t *date_object_p = (ecma_date_object_t *) object_p;
+  ecma_number_t *date_value_p = &date_object_p->date_value;
+  ecma_number_t date_value = *date_value_p;
+
+  if (!BUILTIN_DATE_FUNCTION_IS_UTC (builtin_routine_id))
+  {
+    ecma_number_t local_tza;
+
+    if (date_object_p->header.u.cls.u1.date_flags & ECMA_DATE_TZA_SET)
+    {
+      local_tza = date_object_p->header.u.cls.u3.tza;
+      JERRY_ASSERT (local_tza == ecma_date_local_time_zone_adjustment (date_value));
+    }
+    else
+    {
+      local_tza = ecma_date_local_time_zone_adjustment (date_value);
+    }
+
+    date_value += local_tza;
+  }
+
+  ecma_number_t day_part;
+  ecma_number_t time_part;
+
+  if (builtin_routine_id <= ECMA_DATE_PROTOTYPE_SET_UTC_DATE)
+  {
+    if (ecma_number_is_nan (date_value))
+    {
+      if (!ECMA_DATE_PROTOTYPE_IS_SET_YEAR_ROUTINE (builtin_routine_id))
+      {
+        return ecma_make_number_value (date_value);
+      }
+
+      date_value = ECMA_NUMBER_ZERO;
+    }
+
+    time_part = ecma_date_time_in_day_from_time (date_value);
+
+    ecma_number_t year = ecma_date_year_from_time (date_value);
+    ecma_number_t month = ecma_date_month_from_time (date_value);
+    ecma_number_t day = ecma_date_date_from_time (date_value);
+
+    switch (builtin_routine_id)
+    {
+      case ECMA_DATE_PROTOTYPE_SET_FULL_YEAR:
+      case ECMA_DATE_PROTOTYPE_SET_UTC_FULL_YEAR:
+      {
+        year = converted_number[0];
+        if (conversions >= 2)
+        {
+          month = converted_number[1];
+        }
+        if (conversions >= 3)
+        {
+          day = converted_number[2];
+        }
+        break;
+      }
+#if JERRY_BUILTIN_ANNEXB
+      case ECMA_DATE_PROTOTYPE_SET_YEAR:
+      {
+        if (ecma_number_is_nan (converted_number[0]))
+        {
+          *date_value_p = converted_number[0];
+          date_object_p->header.u.cls.u1.date_flags &= (uint8_t) ~ECMA_DATE_TZA_SET;
+          return ecma_make_number_value (converted_number[0]);
+        }
+
+        year = ecma_number_trunc (converted_number[0]);
+        if (year >= 0 && year <= 99)
+        {
+          year += 1900;
+        }
+        break;
+      }
+#endif /* JERRY_BUILTIN_ANNEXB */
+      case ECMA_DATE_PROTOTYPE_SET_MONTH:
+      case ECMA_DATE_PROTOTYPE_SET_UTC_MONTH:
+      {
+        month = converted_number[0];
+        if (conversions >= 2)
+        {
+          day = converted_number[1];
+        }
+        break;
+      }
+      default:
+      {
+        JERRY_ASSERT (builtin_routine_id == ECMA_DATE_PROTOTYPE_SET_DATE
+                      || builtin_routine_id == ECMA_DATE_PROTOTYPE_SET_UTC_DATE);
+
+        day = converted_number[0];
+        break;
+      }
+    }
+
+    day_part = ecma_date_make_day (year, month, day);
+
+#if JERRY_BUILTIN_ANNEXB
+    if (builtin_routine_id == ECMA_DATE_PROTOTYPE_SET_YEAR)
+    {
+      if (ecma_number_is_nan (converted_number[0]))
+      {
+        day_part = 0;
+        time_part = converted_number[0];
+      }
+    }
+#endif /* JERRY_BUILTIN_ANNEXB */
+  }
+  else
+  {
+    if (ecma_number_is_nan (date_value))
+    {
+      return ecma_make_number_value (date_value);
+    }
+
+    day_part = ecma_date_day_from_time (date_value) * (ecma_number_t) ECMA_DATE_MS_PER_DAY;
+
+    ecma_number_t hour = ecma_date_hour_from_time (date_value);
+    ecma_number_t min = ecma_date_min_from_time (date_value);
+    ecma_number_t sec = ecma_date_sec_from_time (date_value);
+    ecma_number_t ms = ecma_date_ms_from_time (date_value);
+
+    switch (builtin_routine_id)
+    {
+      case ECMA_DATE_PROTOTYPE_SET_HOURS:
+      case ECMA_DATE_PROTOTYPE_SET_UTC_HOURS:
+      {
+        hour = converted_number[0];
+        if (conversions >= 2)
+        {
+          min = converted_number[1];
+        }
+        if (conversions >= 3)
+        {
+          sec = converted_number[2];
+        }
+        if (conversions >= 4)
+        {
+          ms = converted_number[3];
+        }
+        break;
+      }
+      case ECMA_DATE_PROTOTYPE_SET_MINUTES:
+      case ECMA_DATE_PROTOTYPE_SET_UTC_MINUTES:
+      {
+        min = converted_number[0];
+        if (conversions >= 2)
+        {
+          sec = converted_number[1];
+        }
+        if (conversions >= 3)
+        {
+          ms = converted_number[2];
+        }
+        break;
+      }
+      case ECMA_DATE_PROTOTYPE_SET_UTC_SECONDS:
+      case ECMA_DATE_PROTOTYPE_SET_SECONDS:
+      {
+        sec = converted_number[0];
+        if (conversions >= 2)
+        {
+          ms = converted_number[1];
+        }
+        break;
+      }
+      default:
+      {
+        JERRY_ASSERT (builtin_routine_id == ECMA_DATE_PROTOTYPE_SET_UTC_MILLISECONDS
+                      || builtin_routine_id == ECMA_DATE_PROTOTYPE_SET_MILLISECONDS);
+
+        ms = converted_number[0];
+        break;
+      }
+    }
+
+    time_part = ecma_date_make_time (hour, min, sec, ms);
+  }
+
+  bool is_utc = BUILTIN_DATE_FUNCTION_IS_UTC (builtin_routine_id);
+
+  ecma_number_t full_date = ecma_date_make_date (day_part, time_part);
+
+  if (!is_utc)
+  {
+    full_date = ecma_date_utc (full_date);
+  }
+
+  full_date = ecma_date_time_clip (full_date);
+
+  *date_value_p = full_date;
+
+  date_object_p->header.u.cls.u1.date_flags &= (uint8_t) ~ECMA_DATE_TZA_SET;
+
+  return ecma_make_number_value (full_date);
+} /* ecma_builtin_date_prototype_dispatch_set */
+
+#undef ECMA_DATE_PROTOTYPE_IS_SET_YEAR_ROUTINE
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_date_prototype_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide routine
+                                                                           *   identifier */
+                                              ecma_value_t this_arg, /**< 'this' argument value */
+                                              const ecma_value_t arguments_list[], /**< list of arguments
+                                                                                    *   passed to routine */
+                                              uint32_t arguments_number) /**< length of arguments' list */
+{
+  if (JERRY_UNLIKELY (builtin_routine_id == ECMA_DATE_PROTOTYPE_TO_JSON))
+  {
+    return ecma_builtin_date_prototype_to_json (this_arg);
+  }
+
+  if (JERRY_UNLIKELY (builtin_routine_id == ECMA_DATE_PROTOTYPE_TO_PRIMITIVE))
+  {
+    return ecma_builtin_date_prototype_to_primitive (this_arg, arguments_list[0]);
+  }
+
+  if (!ecma_is_value_object (this_arg)
+      || !ecma_object_class_is (ecma_get_object_from_value (this_arg), ECMA_OBJECT_CLASS_DATE))
+  {
+    return ecma_raise_type_error (ECMA_ERR_ARGUMENT_THIS_NOT_DATE_OBJECT);
+  }
+
+  ecma_object_t *this_obj_p = ecma_get_object_from_value (this_arg);
+
+  ecma_date_object_t *date_object_p = (ecma_date_object_t *) this_obj_p;
+  ecma_number_t *date_value_p = &date_object_p->date_value;
+  ecma_number_t date_value = *date_value_p;
+
+  if (builtin_routine_id == ECMA_DATE_PROTOTYPE_GET_TIME)
+  {
+    return ecma_make_number_value (date_value);
+  }
+
+  if (builtin_routine_id == ECMA_DATE_PROTOTYPE_SET_TIME)
+  {
+    ecma_number_t time_num;
+
+    if (ECMA_IS_VALUE_ERROR (ecma_op_to_number (arguments_list[0], &time_num)))
+    {
+      return ECMA_VALUE_ERROR;
+    }
+
+    *date_value_p = ecma_date_time_clip (time_num);
+    date_object_p->header.u.cls.u1.date_flags &= (uint8_t) ~ECMA_DATE_TZA_SET;
+
+    return ecma_make_number_value (*date_value_p);
+  }
+
+  if (builtin_routine_id <= ECMA_DATE_PROTOTYPE_SET_UTC_MILLISECONDS)
+  {
+    if (builtin_routine_id <= ECMA_DATE_PROTOTYPE_GET_UTC_TIMEZONE_OFFSET)
+    {
+      if (!BUILTIN_DATE_FUNCTION_IS_UTC (builtin_routine_id))
+      {
+        ecma_number_t local_tza;
+
+        if (date_object_p->header.u.cls.u1.date_flags & ECMA_DATE_TZA_SET)
+        {
+          local_tza = date_object_p->header.u.cls.u3.tza;
+          JERRY_ASSERT (local_tza == ecma_date_local_time_zone_adjustment (date_value));
+        }
+        else
+        {
+          local_tza = ecma_date_local_time_zone_adjustment (date_value);
+          JERRY_ASSERT (local_tza <= INT32_MAX && local_tza >= INT32_MIN);
+          date_object_p->header.u.cls.u3.tza = (int32_t) local_tza;
+          date_object_p->header.u.cls.u1.date_flags |= ECMA_DATE_TZA_SET;
+        }
+
+        date_value += local_tza;
+      }
+
+      return ecma_builtin_date_prototype_dispatch_get (builtin_routine_id, date_value);
+    }
+
+    return ecma_builtin_date_prototype_dispatch_set (builtin_routine_id, this_obj_p, arguments_list, arguments_number);
+  }
+
+  if (builtin_routine_id == ECMA_DATE_PROTOTYPE_TO_ISO_STRING)
+  {
+    if (ecma_number_is_nan (date_value))
+    {
+      return ecma_raise_range_error (ECMA_ERR_DATE_MUST_BE_A_FINITE_NUMBER);
+    }
+
+    return ecma_date_value_to_iso_string (date_value);
+  }
+
+  if (ecma_number_is_nan (date_value))
+  {
+    return ecma_make_magic_string_value (LIT_MAGIC_STRING_INVALID_DATE_UL);
+  }
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_DATE_PROTOTYPE_TO_STRING:
+    {
+      return ecma_date_value_to_string (date_value);
+    }
+    case ECMA_DATE_PROTOTYPE_TO_DATE_STRING:
+    {
+      return ecma_date_value_to_date_string (date_value);
+    }
+    default:
+    {
+      JERRY_ASSERT (builtin_routine_id == ECMA_DATE_PROTOTYPE_TO_TIME_STRING);
+
+      return ecma_date_value_to_time_string (date_value);
+    }
+  }
+} /* ecma_builtin_date_prototype_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_DATE */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-date-prototype.inc.h

@@ -0,0 +1,83 @@
+/* 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.
+ */
+
+/*
+ * Date.prototype built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_DATE
+
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_DATE, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+ROUTINE (LIT_MAGIC_STRING_TO_STRING_UL, ECMA_DATE_PROTOTYPE_TO_STRING, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_TO_DATE_STRING_UL, ECMA_DATE_PROTOTYPE_TO_DATE_STRING, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_TO_TIME_STRING_UL, ECMA_DATE_PROTOTYPE_TO_TIME_STRING, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_TO_LOCALE_STRING_UL, ECMA_DATE_PROTOTYPE_TO_STRING, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_TO_LOCALE_DATE_STRING_UL, ECMA_DATE_PROTOTYPE_TO_DATE_STRING, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_TO_LOCALE_TIME_STRING_UL, ECMA_DATE_PROTOTYPE_TO_TIME_STRING, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_VALUE_OF_UL, ECMA_DATE_PROTOTYPE_GET_TIME, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_TIME_UL, ECMA_DATE_PROTOTYPE_GET_TIME, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_FULL_YEAR_UL, ECMA_DATE_PROTOTYPE_GET_FULL_YEAR, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_UTC_FULL_YEAR_UL, ECMA_DATE_PROTOTYPE_GET_UTC_FULL_YEAR, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_MONTH_UL, ECMA_DATE_PROTOTYPE_GET_MONTH, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_UTC_MONTH_UL, ECMA_DATE_PROTOTYPE_GET_UTC_MONTH, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_DATE_UL, ECMA_DATE_PROTOTYPE_GET_DATE, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_UTC_DATE_UL, ECMA_DATE_PROTOTYPE_GET_UTC_DATE, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_DAY_UL, ECMA_DATE_PROTOTYPE_GET_DAY, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_UTC_DAY_UL, ECMA_DATE_PROTOTYPE_GET_UTC_DAY, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_HOURS_UL, ECMA_DATE_PROTOTYPE_GET_HOURS, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_UTC_HOURS_UL, ECMA_DATE_PROTOTYPE_GET_UTC_HOURS, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_MINUTES_UL, ECMA_DATE_PROTOTYPE_GET_MINUTES, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_UTC_MINUTES_UL, ECMA_DATE_PROTOTYPE_GET_UTC_MINUTES, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_SECONDS_UL, ECMA_DATE_PROTOTYPE_GET_SECONDS, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_UTC_SECONDS_UL, ECMA_DATE_PROTOTYPE_GET_UTC_SECONDS, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_MILLISECONDS_UL, ECMA_DATE_PROTOTYPE_GET_MILLISECONDS, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_UTC_MILLISECONDS_UL, ECMA_DATE_PROTOTYPE_GET_UTC_MILLISECONDS, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_GET_TIMEZONE_OFFSET_UL, ECMA_DATE_PROTOTYPE_GET_UTC_TIMEZONE_OFFSET, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_SET_TIME_UL, ECMA_DATE_PROTOTYPE_SET_TIME, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_SET_MILLISECONDS_UL, ECMA_DATE_PROTOTYPE_SET_MILLISECONDS, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_SET_UTC_MILLISECONDS_UL, ECMA_DATE_PROTOTYPE_SET_UTC_MILLISECONDS, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_SET_SECONDS_UL, ECMA_DATE_PROTOTYPE_SET_SECONDS, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_SET_UTC_SECONDS_UL, ECMA_DATE_PROTOTYPE_SET_UTC_SECONDS, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_SET_MINUTES_UL, ECMA_DATE_PROTOTYPE_SET_MINUTES, NON_FIXED, 3)
+ROUTINE (LIT_MAGIC_STRING_SET_UTC_MINUTES_UL, ECMA_DATE_PROTOTYPE_SET_UTC_MINUTES, NON_FIXED, 3)
+ROUTINE (LIT_MAGIC_STRING_SET_HOURS_UL, ECMA_DATE_PROTOTYPE_SET_HOURS, NON_FIXED, 4)
+ROUTINE (LIT_MAGIC_STRING_SET_UTC_HOURS_UL, ECMA_DATE_PROTOTYPE_SET_UTC_HOURS, NON_FIXED, 4)
+ROUTINE (LIT_MAGIC_STRING_SET_DATE_UL, ECMA_DATE_PROTOTYPE_SET_DATE, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_SET_UTC_DATE_UL, ECMA_DATE_PROTOTYPE_SET_UTC_DATE, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_SET_MONTH_UL, ECMA_DATE_PROTOTYPE_SET_MONTH, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_SET_UTC_MONTH_UL, ECMA_DATE_PROTOTYPE_SET_UTC_MONTH, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_SET_FULL_YEAR_UL, ECMA_DATE_PROTOTYPE_SET_FULL_YEAR, NON_FIXED, 3)
+ROUTINE (LIT_MAGIC_STRING_SET_UTC_FULL_YEAR_UL, ECMA_DATE_PROTOTYPE_SET_UTC_FULL_YEAR, NON_FIXED, 3)
+ROUTINE (LIT_MAGIC_STRING_TO_ISO_STRING_UL, ECMA_DATE_PROTOTYPE_TO_ISO_STRING, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_TO_JSON_UL, ECMA_DATE_PROTOTYPE_TO_JSON, 1, 1)
+ROUTINE_CONFIGURABLE_ONLY (LIT_GLOBAL_SYMBOL_TO_PRIMITIVE, ECMA_DATE_PROTOTYPE_TO_PRIMITIVE, 1, 1)
+INTRINSIC_PROPERTY (LIT_MAGIC_STRING_TO_UTC_STRING_UL,
+                    LIT_MAGIC_STRING_TO_UTC_STRING_UL,
+                    ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+#if JERRY_BUILTIN_ANNEXB
+INTRINSIC_PROPERTY (LIT_MAGIC_STRING_TO_GMT_STRING_UL,
+                    LIT_MAGIC_STRING_TO_UTC_STRING_UL,
+                    ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+ROUTINE (LIT_MAGIC_STRING_GET_YEAR_UL, ECMA_DATE_PROTOTYPE_GET_YEAR, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_SET_YEAR_UL, ECMA_DATE_PROTOTYPE_SET_YEAR, 1, 1)
+
+#endif /* JERRY_BUILTIN_ANNEXB */
+
+#endif /* JERRY_BUILTIN_DATE */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-date.cpp

@@ -0,0 +1,874 @@
+/* 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.
+ */
+
+#include <math.h>
+
+#include "ecma-alloc.h"
+#include "ecma-builtin-helpers.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+
+#include "jcontext.h"
+#include "lit-char-helpers.h"
+
+#if JERRY_BUILTIN_DATE
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_DATE_ROUTINE_START = 0,
+  ECMA_DATE_ROUTINE_PARSE,
+  ECMA_DATE_ROUTINE_UTC,
+  ECMA_DATE_ROUTINE_NOW,
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-date.inc.h"
+#define BUILTIN_UNDERSCORED_ID  date
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup date ECMA Date object built-in
+ * @{
+ */
+
+/**
+ * Encode minimum/maximum limits
+ *
+ * See: ecma_date_parse_date_chars
+ *
+ * @param min: 8 bits unsigned number
+ * @param max: 24 bits unsigned number
+ */
+#define ECMA_DATE_LIMIT(min, max) (min << 24 | max)
+
+/**
+ * Decode the minimum value from the encoded limit
+ */
+#define ECMA_DATE_LIMIT_MIN(limit) (limit >> 24)
+
+/**
+ * Decode the maximum value from the encoded limit
+ */
+#define ECMA_DATE_LIMIT_MAX(limit) (limit & ((1 << 24) - 1))
+
+/**
+ * Helper function to try to parse a part of a date string
+ *
+ * @return NaN if cannot read from string, ToNumber() otherwise
+ */
+static ecma_number_t
+ecma_date_parse_date_chars (const lit_utf8_byte_t **str_p, /**< pointer to the cesu8 string */
+                            const lit_utf8_byte_t *str_end_p, /**< pointer to the end of the string */
+                            uint32_t num_of_chars, /**< number of characters to read and convert */
+                            uint32_t limit) /**< minimum/maximum valid value */
+{
+  JERRY_ASSERT (num_of_chars > 0 && num_of_chars <= 6);
+
+  if (*str_p + num_of_chars > str_end_p)
+  {
+    return ecma_number_make_nan ();
+  }
+
+  str_end_p = *str_p + num_of_chars;
+
+  uint32_t num = 0;
+
+  while (num_of_chars--)
+  {
+    lit_utf8_byte_t c = **str_p;
+    if (!lit_char_is_decimal_digit (c))
+    {
+      return ecma_number_make_nan ();
+    }
+
+    num = (num * 10) + (uint32_t) ((c - LIT_CHAR_0));
+    (*str_p)++;
+  }
+
+  if (num >= ECMA_DATE_LIMIT_MIN (limit) && num <= ECMA_DATE_LIMIT_MAX (limit))
+  {
+    return (ecma_number_t) num;
+  }
+
+  return ecma_number_make_nan ();
+} /* ecma_date_parse_date_chars */
+
+/**
+ * Helper function to try to parse a special chracter (+,-,T,Z,:,.) in a date string
+ *
+ * @return true if the first character is same as the expected, false otherwise
+ */
+static bool
+ecma_date_parse_special_char (const lit_utf8_byte_t **str_p, /**< pointer to the cesu8 string */
+                              const lit_utf8_byte_t *str_end_p, /**< pointer to the end of the string */
+                              ecma_char_t expected_char) /**< expected character */
+{
+  if ((*str_p < str_end_p) && (**str_p == expected_char))
+  {
+    (*str_p)++;
+    return true;
+  }
+
+  return false;
+} /* ecma_date_parse_special_char */
+
+static inline bool
+ecma_date_check_two_chars (const lit_utf8_byte_t *str_p, /**< pointer to the cesu8 string */
+                           const lit_utf8_byte_t *str_end_p, /**< pointer to the end of the string */
+                           ecma_char_t expected_char1, /**< first expected character */
+                           ecma_char_t expected_char2) /**< second expected character */
+{
+  return (str_p < str_end_p && (*str_p == expected_char1 || *str_p == expected_char2));
+} /* ecma_date_check_two_chars */
+
+/**
+ * Helper function to try to parse a 4-5-6 digit year with optional negative sign in a date string
+ *
+ * Date.prototype.toString() and Date.prototype.toUTCString() emits year
+ * in this format and Date.parse() should parse this format too.
+ *
+ * @return the parsed year or NaN.
+ */
+static ecma_number_t
+ecma_date_parse_year (const lit_utf8_byte_t **str_p, /**< pointer to the cesu8 string */
+                      const lit_utf8_byte_t *str_end_p) /**< pointer to the end of the string */
+{
+  bool is_year_sign_negative = ecma_date_parse_special_char (str_p, str_end_p, LIT_CHAR_MINUS);
+  const lit_utf8_byte_t *str_start_p = *str_p;
+  int32_t parsed_year = 0;
+
+  while ((str_start_p - *str_p < 6) && (str_start_p < str_end_p) && lit_char_is_decimal_digit (*str_start_p))
+  {
+    parsed_year = 10 * parsed_year + *str_start_p - LIT_CHAR_0;
+    str_start_p++;
+  }
+
+  if (str_start_p - *str_p >= 4)
+  {
+    *str_p = str_start_p;
+    return is_year_sign_negative ? -parsed_year : parsed_year;
+  }
+
+  return ecma_number_make_nan ();
+} /* ecma_date_parse_year */
+
+/**
+ * Helper function to try to parse a day name in a date string
+ * Valid day names: Sun, Mon, Tue, Wed, Thu, Fri, Sat
+ * See also:
+ *          ECMA-262 v9, 20.3.4.41.2 Table 46
+ *
+ * @return true if the string starts with a valid day name, false otherwise
+ */
+static bool
+ecma_date_parse_day_name (const lit_utf8_byte_t **str_p, /**< pointer to the cesu8 string */
+                          const lit_utf8_byte_t *str_end_p) /**< pointer to the end of the string */
+{
+  if (*str_p + 3 < str_end_p)
+  {
+    for (uint32_t i = 0; i < 7; i++)
+    {
+      if (!memcmp (day_names_p[i], *str_p, 3))
+      {
+        (*str_p) += 3;
+        return true;
+      }
+    }
+  }
+  return false;
+} /* ecma_date_parse_day_name */
+
+/**
+ * Helper function to try to parse a month name in a date string
+ * Valid month names: Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec
+ * See also:
+ *          ECMA-262 v9, 20.3.4.41.2 Table 47
+ *
+ * @return number of the month if the string starts with a valid month name, 0 otherwise
+ */
+static uint32_t
+ecma_date_parse_month_name (const lit_utf8_byte_t **str_p, /**< pointer to the cesu8 string */
+                            const lit_utf8_byte_t *str_end_p) /**< pointer to the end of the string */
+{
+  if (*str_p + 3 < str_end_p)
+  {
+    for (uint32_t i = 0; i < 12; i++)
+    {
+      if (!memcmp (month_names_p[i], *str_p, 3))
+      {
+        (*str_p) += 3;
+        return (i + 1);
+      }
+    }
+  }
+  return 0;
+} /* ecma_date_parse_month_name */
+
+/**
+ * Calculate MakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli)) for Date constructor and UTC
+ *
+ * See also:
+ *          ECMA-262 v11, 20.4.3.4
+ *
+ * @return false - if the operation fails
+ *         true - otherwise
+ */
+static bool
+ecma_date_construct_helper (const ecma_value_t *args, /**< arguments passed to the Date constructor */
+                            uint32_t args_len, /**< number of arguments */
+                            ecma_number_t *tv_p) /**< [out] time value */
+{
+  ecma_number_t date_nums[7] = {
+    ECMA_NUMBER_ZERO, /* year */
+    ECMA_NUMBER_ZERO, /* month */
+    ECMA_NUMBER_ONE, /* date */
+    ECMA_NUMBER_ZERO, /* hours */
+    ECMA_NUMBER_ZERO, /* minutes */
+    ECMA_NUMBER_ZERO, /* seconds */
+    ECMA_NUMBER_ZERO /* miliseconds */
+  };
+
+  args_len = JERRY_MIN (args_len, sizeof (date_nums) / sizeof (date_nums[0]));
+
+  /* 1-7. */
+  for (uint32_t i = 0; i < args_len; i++)
+  {
+    ecma_value_t status = ecma_op_to_number (args[i], date_nums + i);
+
+    if (ECMA_IS_VALUE_ERROR (status))
+    {
+      return false;
+    }
+  }
+
+  /* 8. */
+  if (!ecma_number_is_nan (date_nums[0]))
+  {
+    /* 9.a */
+    ecma_number_t yi = ecma_number_trunc (date_nums[0]);
+
+    /* 9.b */
+    if (yi >= 0 && yi <= 99)
+    {
+      date_nums[0] = 1900 + yi;
+    }
+  }
+
+  /* 10. */
+  *tv_p = ecma_date_make_date (ecma_date_make_day (date_nums[0], date_nums[1], date_nums[2]),
+                               ecma_date_make_time (date_nums[3], date_nums[4], date_nums[5], date_nums[6]));
+  return true;
+} /* ecma_date_construct_helper */
+
+/**
+ * Helper function used by ecma_builtin_date_parse
+ *
+ * See also:
+ *          ECMA-262 v5, 15.9.4.2  Date.parse (string)
+ *          ECMA-262 v5, 15.9.1.15 Date Time String Format
+ *
+ * @return the parsed date as ecma_number_t or NaN otherwise
+ */
+static ecma_number_t
+ecma_builtin_date_parse_basic (const lit_utf8_byte_t *date_str_curr_p, /**< date string start */
+                               const lit_utf8_byte_t *date_str_end_p) /**< date string end */
+{
+  /* 1. read year */
+
+  uint32_t year_digits = 4;
+  uint32_t year_limit = 9999;
+
+  bool is_year_sign_negative = false;
+
+  if (ecma_date_check_two_chars (date_str_curr_p, date_str_end_p, LIT_CHAR_MINUS, LIT_CHAR_PLUS))
+  {
+    is_year_sign_negative = (*date_str_curr_p++ == LIT_CHAR_MINUS);
+    year_digits = 6;
+    year_limit = 999999;
+  }
+
+  ecma_number_t year =
+    ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, year_digits, ECMA_DATE_LIMIT (0, year_limit));
+  if (is_year_sign_negative)
+  {
+    year = -year;
+  }
+
+  if (ecma_number_is_nan (year))
+  {
+    return year;
+  }
+
+  ecma_number_t month = ECMA_NUMBER_ONE;
+  ecma_number_t day = ECMA_NUMBER_ONE;
+  ecma_number_t time = ECMA_NUMBER_ZERO;
+
+  /* 2. read month if any */
+  if (ecma_date_check_two_chars (date_str_curr_p, date_str_end_p, LIT_CHAR_MINUS, LIT_CHAR_SLASH))
+  {
+    lit_utf8_byte_t separator = *date_str_curr_p++;
+    month = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (1, 12));
+
+    /* 3. read day if any */
+    if (ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, separator))
+    {
+      day = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (1, 31));
+    }
+  }
+
+  bool is_utc = true;
+  /* 4. read time if any */
+  if (ecma_date_check_two_chars (date_str_curr_p, date_str_end_p, LIT_CHAR_UPPERCASE_T, LIT_CHAR_SP))
+  {
+    date_str_curr_p++;
+
+    ecma_number_t hours = ECMA_NUMBER_ZERO;
+    ecma_number_t minutes = ECMA_NUMBER_ZERO;
+    ecma_number_t seconds = ECMA_NUMBER_ZERO;
+    ecma_number_t milliseconds = ECMA_NUMBER_ZERO;
+
+    /* 'HH:mm' must present */
+    if (date_str_end_p - date_str_curr_p < 5)
+    {
+      return ecma_number_make_nan ();
+    }
+
+    /* 4.1 read hours and minutes */
+    hours = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 24));
+
+    if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_COLON))
+    {
+      return ecma_number_make_nan ();
+    }
+
+    minutes = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 59));
+
+    /* 4.2 read seconds if any */
+    if (ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_COLON))
+    {
+      seconds = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 59));
+
+      /* 4.3 read milliseconds if any */
+      if (ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_DOT))
+      {
+        milliseconds = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 3, ECMA_DATE_LIMIT (0, 999));
+      }
+    }
+
+    if (hours == 24 && (minutes != 0 || seconds != 0 || milliseconds != 0))
+    {
+      return ecma_number_make_nan ();
+    }
+
+    time = ecma_date_make_time (hours, minutes, seconds, milliseconds);
+
+    if (ecma_number_is_nan (time))
+    {
+      return time;
+    }
+
+    /* 4.4 read timezone if any */
+    if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_UPPERCASE_Z))
+    {
+      if ((date_str_end_p - date_str_curr_p) == 6
+          && (*date_str_curr_p == LIT_CHAR_MINUS || *date_str_curr_p == LIT_CHAR_PLUS))
+      {
+        bool is_timezone_sign_negative = (*date_str_curr_p++ == LIT_CHAR_MINUS);
+        /* read hours and minutes */
+        hours = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 24));
+
+        if (hours == 24)
+        {
+          hours = ECMA_NUMBER_ZERO;
+        }
+
+        if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_COLON))
+        {
+          return ecma_number_make_nan ();
+        }
+
+        minutes = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 59));
+        ecma_number_t timezone_offset = ecma_date_make_time (hours, minutes, ECMA_NUMBER_ZERO, ECMA_NUMBER_ZERO);
+        time += is_timezone_sign_negative ? timezone_offset : -timezone_offset;
+      }
+      else
+      {
+        is_utc = false;
+      }
+    }
+  }
+
+  if (date_str_curr_p < date_str_end_p)
+  {
+    return ecma_number_make_nan ();
+  }
+
+  ecma_number_t date = ecma_date_make_day (year, month - 1, day);
+  ecma_number_t result_date = ecma_date_make_date (date, time);
+
+  if (!is_utc)
+  {
+    result_date = ecma_date_utc (result_date);
+  }
+
+  return result_date;
+} /* ecma_builtin_date_parse_basic */
+
+/**
+ * Helper function used by ecma_builtin_date_parse
+ *
+ * See also:
+ *          ECMA-262 v5, 15.9.4.2  Date.parse (string)
+ *          ECMA-262 v9, 20.3.4.41 Date.prototype.toString ()
+ *          ECMA-262 v9, 20.3.4.43 Date.prototype.toUTCString ()
+ *
+ * Used by: ecma_builtin_date_parse
+ *
+ * @return the parsed date as ecma_number_t or NaN otherwise
+ */
+static ecma_number_t
+ecma_builtin_date_parse_toString_formats (const lit_utf8_byte_t *date_str_curr_p, const lit_utf8_byte_t *date_str_end_p)
+{
+  const ecma_number_t nan = ecma_number_make_nan ();
+
+  if (!ecma_date_parse_day_name (&date_str_curr_p, date_str_end_p))
+  {
+    return nan;
+  }
+
+  const bool is_toUTCString_format = ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_COMMA);
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_SP))
+  {
+    return nan;
+  }
+
+  ecma_number_t month = 0;
+  ecma_number_t day = 0;
+  if (is_toUTCString_format)
+  {
+    day = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 31));
+
+    if (ecma_number_is_nan (day))
+    {
+      return nan;
+    }
+
+    if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_SP))
+    {
+      return nan;
+    }
+
+    month = ecma_date_parse_month_name (&date_str_curr_p, date_str_end_p);
+
+    if (month == 0)
+    {
+      return ecma_number_make_nan ();
+    }
+  }
+  else
+  {
+    month = ecma_date_parse_month_name (&date_str_curr_p, date_str_end_p);
+
+    if (month == 0)
+    {
+      return nan;
+    }
+
+    if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_SP))
+    {
+      return nan;
+    }
+
+    day = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 31));
+
+    if (ecma_number_is_nan (day))
+    {
+      return nan;
+    }
+  }
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_SP))
+  {
+    return nan;
+  }
+
+  ecma_number_t year = ecma_date_parse_year (&date_str_curr_p, date_str_end_p);
+
+  if (ecma_number_is_nan (year))
+  {
+    return nan;
+  }
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_SP))
+  {
+    return nan;
+  }
+
+  ecma_number_t hours = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 24));
+
+  if (ecma_number_is_nan (hours))
+  {
+    return nan;
+  }
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_COLON))
+  {
+    return nan;
+  }
+
+  ecma_number_t minutes = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 59));
+
+  if (ecma_number_is_nan (minutes))
+  {
+    return nan;
+  }
+
+  if (!ecma_date_parse_special_char (&date_str_curr_p, date_str_end_p, LIT_CHAR_COLON))
+  {
+    return nan;
+  }
+
+  ecma_number_t seconds = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 59));
+
+  if (ecma_number_is_nan (seconds))
+  {
+    return nan;
+  }
+
+  if (hours == 24 && (minutes != 0 || seconds != 0))
+  {
+    return nan;
+  }
+
+  const char gmt_p[] = " GMT";
+  if (date_str_end_p - date_str_curr_p < 4 || memcmp (date_str_curr_p, gmt_p, 4) != 0)
+  {
+    return nan;
+  }
+
+  date_str_curr_p += 4;
+
+  ecma_number_t time = ecma_date_make_time (hours, minutes, seconds, 0);
+
+  if (!is_toUTCString_format)
+  {
+    if (!ecma_date_check_two_chars (date_str_curr_p, date_str_end_p, LIT_CHAR_MINUS, LIT_CHAR_PLUS))
+    {
+      return nan;
+    }
+
+    bool is_timezone_sign_negative = (*date_str_curr_p++ == LIT_CHAR_MINUS);
+
+    hours = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 24));
+
+    if (ecma_number_is_nan (hours))
+    {
+      return nan;
+    }
+
+    if (hours == 24)
+    {
+      hours = ECMA_NUMBER_ZERO;
+    }
+
+    minutes = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 2, ECMA_DATE_LIMIT (0, 59));
+
+    if (ecma_number_is_nan (minutes))
+    {
+      return nan;
+    }
+
+    ecma_number_t timezone_offset = ecma_date_make_time (hours, minutes, ECMA_NUMBER_ZERO, ECMA_NUMBER_ZERO);
+
+    time += is_timezone_sign_negative ? timezone_offset : -timezone_offset;
+  }
+
+  if (date_str_curr_p < date_str_end_p)
+  {
+    return nan;
+  }
+
+  ecma_number_t date = ecma_date_make_day (year, month - 1, day);
+  return ecma_date_make_date (date, time);
+} /* ecma_builtin_date_parse_toString_formats */
+
+/**
+ * The Date object's 'parse' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.9.4.2  Date.parse (string)
+ *          ECMA-262 v5, 15.9.1.15 Date Time String Format
+ *          ECMA-262 v9, 20.3.4.41 Date.prototype.toString ()
+ *          ECMA-262 v9, 20.3.4.43 Date.prototype.toUTCString ()
+ *
+ * @return parsed time
+ */
+static ecma_number_t
+ecma_builtin_date_parse (ecma_string_t *string_p) /**< string */
+{
+  ECMA_STRING_TO_UTF8_STRING (string_p, str_p, str_size);
+  const lit_utf8_byte_t *date_str_curr_p = str_p;
+  const lit_utf8_byte_t *date_str_end_p = str_p + str_size;
+
+  /* try to parse date string as ISO string - ECMA-262 v5, 15.9.1.15 */
+  ecma_number_t tv = ecma_builtin_date_parse_basic (date_str_curr_p, date_str_end_p);
+
+  if (ecma_number_is_nan (tv))
+  {
+    /* try to parse date string in Date.prototype.toString() or toUTCString() format */
+    tv = ecma_builtin_date_parse_toString_formats (date_str_curr_p, date_str_end_p);
+  }
+
+  ECMA_FINALIZE_UTF8_STRING (str_p, str_size);
+
+  return tv;
+} /* ecma_builtin_date_parse */
+
+/**
+ * The Date object's 'UTC' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.9.4.3
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_date_utc (const ecma_value_t args[], /**< arguments list */
+                       uint32_t args_number) /**< number of arguments */
+{
+  if (args_number < 1)
+  {
+    return ecma_make_nan_value ();
+  }
+
+  ecma_number_t tv;
+
+  if (!ecma_date_construct_helper (args, args_number, &tv))
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  return ecma_make_number_value ((ecma_number_t) ecma_date_time_clip (tv));
+} /* ecma_builtin_date_utc */
+
+/**
+ * Helper method to get the current time
+ *
+ * @return ecma_number_t
+ */
+static ecma_number_t
+ecma_builtin_date_now_helper (void)
+{
+  return floor (DOUBLE_TO_ECMA_NUMBER_T (jerry_port_current_time ()));
+} /* ecma_builtin_date_now_helper */
+
+/**
+ * Construct a date object with the given [[DateValue]]
+ *
+ * Note: New target must be a valid object
+ *
+ * @return ECMA_VALUE_ERROR - if the operation fails
+ *         constructed date object - otherwise
+ */
+static ecma_value_t
+ecma_builtin_date_create (ecma_number_t tv)
+{
+  JERRY_ASSERT (JERRY_CONTEXT (current_new_target_p) != NULL);
+
+  ecma_object_t *prototype_obj_p =
+    ecma_op_get_prototype_from_constructor (JERRY_CONTEXT (current_new_target_p), ECMA_BUILTIN_ID_DATE_PROTOTYPE);
+
+  if (JERRY_UNLIKELY (prototype_obj_p == NULL))
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  ecma_object_t *obj_p = ecma_create_object (prototype_obj_p, sizeof (ecma_date_object_t), ECMA_OBJECT_TYPE_CLASS);
+  ecma_deref_object (prototype_obj_p);
+
+  ecma_date_object_t *date_object_p = (ecma_date_object_t *) obj_p;
+  date_object_p->header.u.cls.type = ECMA_OBJECT_CLASS_DATE;
+  date_object_p->header.u.cls.u1.date_flags = ECMA_DATE_TZA_NONE;
+  date_object_p->header.u.cls.u3.tza = 0;
+  date_object_p->date_value = tv;
+
+  return ecma_make_object_value (obj_p);
+} /* ecma_builtin_date_create */
+
+/**
+ * Handle calling [[Call]] of built-in Date object
+ *
+ * See also:
+ *          ECMA-262 v5, 15.9.2.1
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_date_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                 uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_UNUSED (arguments_list_p);
+  JERRY_UNUSED (arguments_list_len);
+
+  return ecma_date_value_to_string (ecma_builtin_date_now_helper ());
+} /* ecma_builtin_date_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Date object
+ *
+ * See also:
+ *          ECMA-262 v5, 15.9.3.1
+ *          ECMA-262 v11, 20.4.2
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_date_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                      uint32_t arguments_list_len) /**< number of arguments */
+{
+  /* 20.4.2.3 */
+  if (arguments_list_len == 0)
+  {
+    return ecma_builtin_date_create (ecma_builtin_date_now_helper ());
+  }
+
+  ecma_number_t tv;
+  /* 20.4.2.2 */
+  if (arguments_list_len == 1)
+  {
+    ecma_value_t argument = arguments_list_p[0];
+
+    /* 4.a */
+    if (ecma_is_value_object (argument)
+        && ecma_object_class_is (ecma_get_object_from_value (argument), ECMA_OBJECT_CLASS_DATE))
+    {
+      return ecma_builtin_date_create (((ecma_date_object_t *) ecma_get_object_from_value (argument))->date_value);
+    }
+    /* 4.b */
+    ecma_value_t primitive = ecma_op_to_primitive (argument, ECMA_PREFERRED_TYPE_NO);
+
+    if (ECMA_IS_VALUE_ERROR (primitive))
+    {
+      return primitive;
+    }
+
+    if (ecma_is_value_string (primitive))
+    {
+      ecma_string_t *prim_str_p = ecma_get_string_from_value (primitive);
+      tv = ecma_builtin_date_parse (prim_str_p);
+      ecma_deref_ecma_string (prim_str_p);
+    }
+    else
+    {
+      ecma_value_t prim_value = ecma_op_to_number (primitive, &tv);
+      ecma_free_value (primitive);
+
+      if (ECMA_IS_VALUE_ERROR (prim_value))
+      {
+        return prim_value;
+      }
+    }
+  }
+  /* 20.4.2.1 */
+  else if (ecma_date_construct_helper (arguments_list_p, arguments_list_len, &tv))
+  {
+    tv = ecma_date_utc (tv);
+  }
+  else
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  return ecma_builtin_date_create (ecma_date_time_clip (tv));
+} /* ecma_builtin_date_dispatch_construct */
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_date_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide routine  identifier */
+                                    ecma_value_t this_arg, /**< 'this' argument value */
+                                    const ecma_value_t arguments_list_p[], /**< list of arguments passed to routine */
+                                    uint32_t arguments_number) /**< length of arguments' list */
+{
+  JERRY_UNUSED (this_arg);
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_DATE_ROUTINE_NOW:
+    {
+      return ecma_make_number_value (ecma_builtin_date_now_helper ());
+    }
+    case ECMA_DATE_ROUTINE_UTC:
+    {
+      return ecma_builtin_date_utc (arguments_list_p, arguments_number);
+    }
+    case ECMA_DATE_ROUTINE_PARSE:
+    {
+      if (arguments_number < 1)
+      {
+        return ecma_make_nan_value ();
+      }
+
+      ecma_string_t *str_p = ecma_op_to_string (arguments_list_p[0]);
+
+      if (JERRY_UNLIKELY (str_p == NULL))
+      {
+        return ECMA_VALUE_ERROR;
+      }
+
+      ecma_value_t result = ecma_make_number_value (ecma_date_time_clip (ecma_builtin_date_parse (str_p)));
+      ecma_deref_ecma_string (str_p);
+
+      return result;
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+} /* ecma_builtin_date_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_DATE */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-date.inc.h

@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+/*
+ * Date built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_DATE
+
+/* ECMA-262 v5, 15.9.4.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_DATE_PROTOTYPE, ECMA_PROPERTY_FIXED)
+
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 7, ECMA_PROPERTY_FLAG_DEFAULT_LENGTH)
+
+ROUTINE (LIT_MAGIC_STRING_PARSE, ECMA_DATE_ROUTINE_PARSE, 1, 1)
+ROUTINE (LIT_MAGIC_STRING_UTC_U, ECMA_DATE_ROUTINE_UTC, NON_FIXED, 7)
+ROUTINE (LIT_MAGIC_STRING_NOW, ECMA_DATE_ROUTINE_NOW, 0, 0)
+
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_DATE_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#endif /* JERRY_BUILTIN_DATE */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-error-prototype.cpp

@@ -0,0 +1,180 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+
+#include "jrt.h"
+#include "lit-char-helpers.h"
+#include "lit-magic-strings.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_ERROR_PROTOTYPE_ROUTINE_START = 0,
+  ECMA_ERROR_PROTOTYPE_ROUTINE_TO_STRING,
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-error-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  error_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup errorprototype ECMA Error.prototype object built-in
+ * @{
+ */
+
+/**
+ * Helper method to get a property value from an error object
+ *
+ * @return ecma_string_t
+ */
+static ecma_string_t *
+ecma_builtin_error_prototype_object_to_string_helper (ecma_object_t *obj_p, /**< error object */
+                                                      lit_magic_string_id_t property_id, /**< property id */
+                                                      lit_magic_string_id_t default_value) /**< default prop value */
+{
+  ecma_value_t prop_value = ecma_op_object_get_by_magic_id (obj_p, property_id);
+
+  if (ECMA_IS_VALUE_ERROR (prop_value))
+  {
+    return NULL;
+  }
+
+  if (ecma_is_value_undefined (prop_value))
+  {
+    return ecma_get_magic_string (default_value);
+  }
+
+  ecma_string_t *ret_str_p = ecma_op_to_string (prop_value);
+  ecma_free_value (prop_value);
+
+  return ret_str_p;
+} /* ecma_builtin_error_prototype_object_to_string_helper */
+
+/**
+ * The Error.prototype object's 'toString' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.11.4.4
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_error_prototype_object_to_string (ecma_value_t this_arg) /**< this argument */
+{
+  /* 2. */
+  if (!ecma_is_value_object (this_arg))
+  {
+    return ecma_raise_type_error (ECMA_ERR_ARGUMENT_THIS_NOT_OBJECT);
+  }
+
+  ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
+
+  ecma_string_t *name_string_p =
+    ecma_builtin_error_prototype_object_to_string_helper (obj_p, LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_ERROR_UL);
+
+  if (JERRY_UNLIKELY (name_string_p == NULL))
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  ecma_string_t *msg_string_p =
+    ecma_builtin_error_prototype_object_to_string_helper (obj_p, LIT_MAGIC_STRING_MESSAGE, LIT_MAGIC_STRING__EMPTY);
+
+  if (JERRY_UNLIKELY (msg_string_p == NULL))
+  {
+    ecma_deref_ecma_string (name_string_p);
+    return ECMA_VALUE_ERROR;
+  }
+
+  if (ecma_string_is_empty (name_string_p))
+  {
+    return ecma_make_string_value (msg_string_p);
+  }
+
+  if (ecma_string_is_empty (msg_string_p))
+  {
+    return ecma_make_string_value (name_string_p);
+  }
+
+  ecma_stringbuilder_t builder = ecma_stringbuilder_create_from (name_string_p);
+
+  ecma_stringbuilder_append_raw (&builder, (const lit_utf8_byte_t *) ": ", 2);
+  ecma_stringbuilder_append (&builder, msg_string_p);
+
+  ecma_deref_ecma_string (name_string_p);
+  ecma_deref_ecma_string (msg_string_p);
+
+  return ecma_make_string_value (ecma_stringbuilder_finalize (&builder));
+} /* ecma_builtin_error_prototype_object_to_string */
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_error_prototype_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide routine
+                                                                            *   identifier */
+                                               ecma_value_t this_arg, /**< 'this' argument value */
+                                               const ecma_value_t arguments_list_p[], /**< list of arguments passed to
+                                                                                       *  routine */
+                                               uint32_t arguments_number) /**< length of arguments' list */
+{
+  JERRY_UNUSED_2 (arguments_number, arguments_list_p);
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_ERROR_PROTOTYPE_ROUTINE_TO_STRING:
+    {
+      return ecma_builtin_error_prototype_object_to_string (this_arg);
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+} /* ecma_builtin_error_prototype_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-error-prototype.inc.h

@@ -0,0 +1,38 @@
+/* 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.
+ */
+
+/*
+ * Error.prototype built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.11.4.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_ERROR, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* ECMA-262 v5, 15.11.4.2 */
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_ERROR_UL, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* ECMA-262 v5, 15.11.4.3 */
+STRING_VALUE (LIT_MAGIC_STRING_MESSAGE, LIT_MAGIC_STRING__EMPTY, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_TO_STRING_UL, ECMA_ERROR_PROTOTYPE_ROUTINE_TO_STRING, 0, 0)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-error.cpp

@@ -0,0 +1,93 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtin-helpers.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+
+#include "jcontext.h"
+#include "jrt.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-error.inc.h"
+#define BUILTIN_UNDERSCORED_ID  error
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup error ECMA Error object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in Error object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_error_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                  uint32_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_helper_error_dispatch_call (JERRY_ERROR_COMMON, arguments_list_p, arguments_list_len);
+} /* ecma_builtin_error_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Error object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_error_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                       uint32_t arguments_list_len) /**< number of arguments */
+{
+  ecma_object_t *proto_p =
+    ecma_op_get_prototype_from_constructor (JERRY_CONTEXT (current_new_target_p), ECMA_BUILTIN_ID_ERROR_PROTOTYPE);
+
+  if (proto_p == NULL)
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  ecma_value_t result = ecma_builtin_error_dispatch_call (arguments_list_p, arguments_list_len);
+
+  if (!ECMA_IS_VALUE_ERROR (result))
+  {
+    ecma_object_t *object_p = ecma_get_object_from_value (result);
+    ECMA_SET_NON_NULL_POINTER (object_p->u2.prototype_cp, proto_p);
+  }
+
+  ecma_deref_object (proto_p);
+
+  return result;
+} /* ecma_builtin_error_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-error.inc.h

@@ -0,0 +1,35 @@
+/* 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.
+ */
+
+/*
+ * Error built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 1, ECMA_PROPERTY_FLAG_DEFAULT_LENGTH)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.7.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_ERROR_PROTOTYPE, ECMA_PROPERTY_FIXED)
+
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_ERROR_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-evalerror-prototype.cpp

@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+
+#include "jrt.h"
+
+#if JERRY_BUILTIN_ERRORS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-evalerror-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  eval_error_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+#endif /* JERRY_BUILTIN_ERRORS */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-evalerror-prototype.inc.h

@@ -0,0 +1,38 @@
+/* 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.
+ */
+
+/*
+ * EvalError.prototype built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_ERRORS
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.11.7.8 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_EVAL_ERROR, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* ECMA-262 v5, 15.11.7.9 */
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_EVAL_ERROR_UL, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* ECMA-262 v5, 15.11.7.10 */
+STRING_VALUE (LIT_MAGIC_STRING_MESSAGE, LIT_MAGIC_STRING__EMPTY, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+#endif /* JERRY_BUILTIN_ERRORS */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-evalerror.cpp

@@ -0,0 +1,97 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtin-helpers.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+
+#include "jcontext.h"
+#include "jrt.h"
+
+#if JERRY_BUILTIN_ERRORS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-evalerror.inc.h"
+#define BUILTIN_UNDERSCORED_ID  eval_error
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup evalerror ECMA EvalError object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in EvalError object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_eval_error_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                       uint32_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_helper_error_dispatch_call (JERRY_ERROR_EVAL, arguments_list_p, arguments_list_len);
+} /* ecma_builtin_eval_error_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in EvalError object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_eval_error_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                            uint32_t arguments_list_len) /**< number of arguments */
+{
+  ecma_object_t *proto_p =
+    ecma_op_get_prototype_from_constructor (JERRY_CONTEXT (current_new_target_p), ECMA_BUILTIN_ID_EVAL_ERROR_PROTOTYPE);
+
+  if (proto_p == NULL)
+  {
+    return ECMA_VALUE_ERROR;
+  }
+
+  ecma_value_t result = ecma_builtin_eval_error_dispatch_call (arguments_list_p, arguments_list_len);
+
+  if (!ECMA_IS_VALUE_ERROR (result))
+  {
+    ecma_object_t *object_p = ecma_get_object_from_value (result);
+    ECMA_SET_NON_NULL_POINTER (object_p->u2.prototype_cp, proto_p);
+  }
+
+  ecma_deref_object (proto_p);
+
+  return result;
+} /* ecma_builtin_eval_error_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* JERRY_BUILTIN_ERRORS */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-evalerror.inc.h

@@ -0,0 +1,39 @@
+/* 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.
+ */
+
+/*
+ * EvalError built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+#if JERRY_BUILTIN_ERRORS
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 1, ECMA_PROPERTY_FLAG_DEFAULT_LENGTH)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.11.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_EVAL_ERROR_PROTOTYPE, ECMA_PROPERTY_FIXED)
+
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_EVAL_ERROR_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#endif /* JERRY_BUILTIN_ERRORS */
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.cpp

@@ -0,0 +1,550 @@
+/* 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.
+ */
+
+#include "ecma-builtin-function-prototype.h"
+
+#include "ecma-alloc.h"
+#include "ecma-builtin-helpers.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-extended-info.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-proxy-object.h"
+
+#include "jrt.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/**
+ * This object has a custom dispatch function.
+ */
+#define BUILTIN_CUSTOM_DISPATCH
+
+/**
+ * List of built-in routine identifiers.
+ */
+enum
+{
+  ECMA_FUNCTION_PROTOTYPE_ROUTINE_START = 0,
+  ECMA_FUNCTION_PROTOTYPE_TO_STRING,
+  ECMA_FUNCTION_PROTOTYPE_CALL,
+  ECMA_FUNCTION_PROTOTYPE_APPLY,
+  ECMA_FUNCTION_PROTOTYPE_BIND,
+  ECMA_FUNCTION_PROTOTYPE_SYMBOL_HAS_INSTANCE,
+};
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-function-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID  function_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup functionprototype ECMA Function.prototype object built-in
+ * @{
+ */
+
+/**
+ * Maximum number of arguments for an apply function.
+ */
+#define ECMA_FUNCTION_APPLY_ARGUMENT_COUNT_LIMIT 65535
+
+/**
+ * The Function.prototype object's 'toString' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.3.4.2
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_function_prototype_object_to_string (ecma_object_t *func_obj_p) /**< this argument object */
+{
+  if (ecma_get_object_type (func_obj_p) != ECMA_OBJECT_TYPE_FUNCTION)
+  {
+    return ecma_make_magic_string_value (LIT_MAGIC_STRING_FUNCTION_TO_STRING_NATIVE);
+  }
+
+#if JERRY_FUNCTION_TO_STRING
+  const ecma_compiled_code_t *bytecode_p;
+  bytecode_p = ecma_op_function_get_compiled_code ((ecma_extended_object_t *) func_obj_p);
+
+  ecma_value_t script_value = ((cbc_uint8_arguments_t *) bytecode_p)->script_value;
+  cbc_script_t *script_p = ECMA_GET_INTERNAL_VALUE_POINTER (cbc_script_t, script_value);
+
+  if (bytecode_p->status_flags & CBC_CODE_FLAGS_HAS_EXTENDED_INFO)
+  {
+    uint8_t *extended_info_p = ecma_compiled_code_resolve_extended_info (bytecode_p);
+    uint8_t extended_info = *extended_info_p;
+
+    if (extended_info & CBC_EXTENDED_CODE_FLAGS_HAS_SOURCE_CODE_RANGE)
+    {
+      if (extended_info & CBC_EXTENDED_CODE_FLAGS_HAS_ARGUMENT_LENGTH)
+      {
+        ecma_extended_info_decode_vlq (&extended_info_p);
+      }
+
+      uint32_t range_start = ecma_extended_info_decode_vlq (&extended_info_p);
+      uint32_t range_size = ecma_extended_info_decode_vlq (&extended_info_p);
+      ecma_value_t source_code;
+
+      if (!(extended_info & CBC_EXTENDED_CODE_FLAGS_SOURCE_CODE_IN_ARGUMENTS))
+      {
+        source_code = script_p->source_code;
+#if JERRY_SNAPSHOT_EXEC
+        if (ecma_is_value_magic_string (source_code, LIT_MAGIC_STRING__EMPTY))
+        {
+          return ecma_make_magic_string_value (LIT_MAGIC_STRING_FUNCTION_TO_STRING_ECMA);
+        }
+#endif /* JERRY_SNAPSHOT_EXEC */
+      }
+      else
+      {
+#if JERRY_SNAPSHOT_EXEC
+        if (!(script_p->refs_and_type & CBC_SCRIPT_HAS_FUNCTION_ARGUMENTS))
+        {
+          return ecma_make_magic_string_value (LIT_MAGIC_STRING_FUNCTION_TO_STRING_ECMA);
+        }
+#else /* !JERRY_SNAPSHOT_EXEC */
+        JERRY_ASSERT (script_p->refs_and_type & CBC_SCRIPT_HAS_FUNCTION_ARGUMENTS);
+#endif /* JERRY_SNAPSHOT_EXEC */
+
+        source_code = CBC_SCRIPT_GET_FUNCTION_ARGUMENTS (script_p, script_p->refs_and_type);
+      }
+
+      ecma_string_t *result_string_p;
+
+      ECMA_STRING_TO_UTF8_STRING (ecma_get_string_from_value (source_code), source_p, source_size);
+      result_string_p = ecma_new_ecma_string_from_utf8 (source_p + range_start, range_size);
+      ECMA_FINALIZE_UTF8_STRING (source_p, source_size);
+
+      return ecma_make_string_value (result_string_p);
+    }
+  }
+
+#if JERRY_SNAPSHOT_EXEC
+  if (!(script_p->refs_and_type & CBC_SCRIPT_HAS_FUNCTION_ARGUMENTS))
+  {
+    return ecma_make_magic_string_value (LIT_MAGIC_STRING_FUNCTION_TO_STRING_ECMA);
+  }
+#else /* !JERRY_SNAPSHOT_EXEC */
+  JERRY_ASSERT (script_p->refs_and_type & CBC_SCRIPT_HAS_FUNCTION_ARGUMENTS);
+#endif /* JERRY_SNAPSHOT_EXEC */
+
+  lit_magic_string_id_t header_id = LIT_MAGIC_STRING_FUNCTION_TO_STRING_ANON;
+
+  switch (CBC_FUNCTION_GET_TYPE (bytecode_p->status_flags))
+  {
+    case CBC_FUNCTION_GENERATOR:
+    {
+      header_id = LIT_MAGIC_STRING_FUNCTION_TO_STRING_ANON_GENERATOR;
+      break;
+    }
+    case CBC_FUNCTION_ASYNC_GENERATOR:
+    {
+      header_id = LIT_MAGIC_STRING_FUNCTION_TO_STRING_ANON_ASYNC_GENERATOR;
+      break;
+    }
+    case CBC_FUNCTION_ASYNC:
+    {
+      header_id = LIT_MAGIC_STRING_FUNCTION_TO_STRING_ANON_ASYNC;
+      break;
+    }
+  }
+
+  ecma_stringbuilder_t builder = ecma_stringbuilder_create_from (ecma_get_magic_string (header_id));
+  ecma_value_t function_arguments = CBC_SCRIPT_GET_FUNCTION_ARGUMENTS (script_p, script_p->refs_and_type);
+
+  ecma_stringbuilder_append (&builder, ecma_get_string_from_value (function_arguments));
+  ecma_stringbuilder_append_raw (&builder, (const lit_utf8_byte_t *) "\n) {\n", 5);
+  ecma_stringbuilder_append (&builder, ecma_get_string_from_value (script_p->source_code));
+  ecma_stringbuilder_append_raw (&builder, (const lit_utf8_byte_t *) "\n}", 2);
+
+  return ecma_make_string_value (ecma_stringbuilder_finalize (&builder));
+#else /* !JERRY_FUNCTION_TO_STRING */
+  return ecma_make_magic_string_value (LIT_MAGIC_STRING_FUNCTION_TO_STRING_ECMA);
+#endif /* JERRY_FUNCTION_TO_STRING */
+} /* ecma_builtin_function_prototype_object_to_string */
+
+/**
+ * The Function.prototype object's 'apply' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.3.4.3
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_function_prototype_object_apply (ecma_object_t *func_obj_p, /**< this argument object */
+                                              ecma_value_t arg1, /**< first argument */
+                                              ecma_value_t arg2) /**< second argument */
+{
+  /* 2. */
+  if (ecma_is_value_null (arg2) || ecma_is_value_undefined (arg2))
+  {
+    return ecma_op_function_call (func_obj_p, arg1, NULL, 0);
+  }
+
+  /* 3. */
+  if (!ecma_is_value_object (arg2))
+  {
+    return ecma_raise_type_error (ECMA_ERR_ARGUMENT_IS_NOT_AN_OBJECT);
+  }
+
+  ecma_object_t *obj_p = ecma_get_object_from_value (arg2);
+
+  /* 4-5. */
+  ecma_length_t length;
+  ecma_value_t len_value = ecma_op_object_get_length (obj_p, &length);
+
+  if (ECMA_IS_VALUE_ERROR (len_value))
+  {
+    return len_value;
+  }
+
+  if (length >= ECMA_FUNCTION_APPLY_ARGUMENT_COUNT_LIMIT)
+  {
+    return ecma_raise_range_error (ECMA_ERR_TOO_MANY_ARGUMENTS_DECLARED_FOR_FUNCTION_APPLY);
+  }
+
+  /* 6. */
+  ecma_value_t ret_value = ECMA_VALUE_EMPTY;
+  JMEM_DEFINE_LOCAL_ARRAY (arguments_list_p, length, ecma_value_t);
+  ecma_length_t index = 0;
+
+  /* 7. */
+  for (index = 0; index < length; index++)
+  {
+    ecma_value_t get_value = ecma_op_object_get_by_index (obj_p, index);
+
+    if (ECMA_IS_VALUE_ERROR (get_value))
+    {
+      ret_value = get_value;
+      break;
+    }
+
+    arguments_list_p[index] = get_value;
+  }
+
+  if (ecma_is_value_empty (ret_value))
+  {
+    JERRY_ASSERT (index == length);
+    ret_value = ecma_op_function_call (func_obj_p, arg1, arguments_list_p, (uint32_t) length);
+  }
+
+  for (uint32_t remove_index = 0; remove_index < index; remove_index++)
+  {
+    ecma_free_value (arguments_list_p[remove_index]);
+  }
+
+  JMEM_FINALIZE_LOCAL_ARRAY (arguments_list_p);
+
+  return ret_value;
+} /* ecma_builtin_function_prototype_object_apply */
+
+/**
+ * The Function.prototype object's 'call' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.3.4.4
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_function_prototype_object_call (ecma_object_t *func_obj_p, /**< this argument object */
+                                             const ecma_value_t *arguments_list_p, /**< list of arguments */
+                                             uint32_t arguments_number) /**< number of arguments */
+{
+  if (arguments_number == 0)
+  {
+    /* Even a 'this' argument is missing. */
+    return ecma_op_function_call (func_obj_p, ECMA_VALUE_UNDEFINED, NULL, 0);
+  }
+
+  return ecma_op_function_call (func_obj_p,
+                                arguments_list_p[0],
+                                arguments_list_p + 1,
+                                (uint32_t) (arguments_number - 1u));
+} /* ecma_builtin_function_prototype_object_call */
+
+/**
+ * The Function.prototype object's 'bind' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.3.4.5
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+static ecma_value_t
+ecma_builtin_function_prototype_object_bind (ecma_object_t *this_arg_obj_p, /**< this argument object */
+                                             const ecma_value_t *arguments_list_p, /**< list of arguments */
+                                             uint32_t arguments_number) /**< number of arguments */
+{
+  /* 4. 11. 18. */
+  ecma_object_t *prototype_obj_p;
+
+#if JERRY_BUILTIN_PROXY
+  if (ECMA_OBJECT_IS_PROXY (this_arg_obj_p))
+  {
+    ecma_value_t proto = ecma_proxy_object_get_prototype_of (this_arg_obj_p);
+
+    if (ECMA_IS_VALUE_ERROR (proto))
+    {
+      return proto;
+    }
+    prototype_obj_p = ecma_is_value_null (proto) ? NULL : ecma_get_object_from_value (proto);
+  }
+  else
+  {
+#endif /* JERRY_BUILTIN_PROXY */
+    jmem_cpointer_t proto_cp = ecma_op_ordinary_object_get_prototype_of (this_arg_obj_p);
+    if (proto_cp != JMEM_CP_NULL)
+    {
+      prototype_obj_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t, proto_cp);
+      ecma_ref_object (prototype_obj_p);
+    }
+    else
+    {
+      prototype_obj_p = NULL;
+    }
+#if JERRY_BUILTIN_PROXY
+  }
+#endif /* JERRY_BUILTIN_PROXY */
+
+  ecma_object_t *function_p;
+  ecma_bound_function_t *bound_func_p;
+
+  if (arguments_number == 0 || (arguments_number == 1 && !ecma_is_value_integer_number (arguments_list_p[0])))
+  {
+    function_p = ecma_create_object (prototype_obj_p, sizeof (ecma_bound_function_t), ECMA_OBJECT_TYPE_BOUND_FUNCTION);
+
+    /* 8. */
+    bound_func_p = (ecma_bound_function_t *) function_p;
+    ECMA_SET_NON_NULL_POINTER_TAG (bound_func_p->header.u.bound_function.target_function, this_arg_obj_p, 0);
+
+    bound_func_p->header.u.bound_function.args_len_or_this = ECMA_VALUE_UNDEFINED;
+
+    if (arguments_number != 0)
+    {
+      bound_func_p->header.u.bound_function.args_len_or_this = ecma_copy_value_if_not_object (arguments_list_p[0]);
+    }
+  }
+  else
+  {
+    JERRY_ASSERT (arguments_number > 0);
+
+    size_t obj_size = sizeof (ecma_bound_function_t) + (arguments_number * sizeof (ecma_value_t));
+
+    function_p = ecma_create_object (prototype_obj_p, obj_size, ECMA_OBJECT_TYPE_BOUND_FUNCTION);
+
+    /* 8. */
+    bound_func_p = (ecma_bound_function_t *) function_p;
+    ECMA_SET_NON_NULL_POINTER_TAG (bound_func_p->header.u.bound_function.target_function, this_arg_obj_p, 0);
+
+    /* NOTE: This solution provides temporary false data about the object's size
+       but prevents GC from freeing it until it's not fully initialized. */
+    bound_func_p->header.u.bound_function.args_len_or_this = ECMA_VALUE_UNDEFINED;
+    ecma_value_t *args_p = (ecma_value_t *) (bound_func_p + 1);
+
+    for (uint32_t i = 0; i < arguments_number; i++)
+    {
+      *args_p++ = ecma_copy_value_if_not_object (arguments_list_p[i]);
+    }
+
+    ecma_value_t args_len_or_this = ecma_make_integer_value ((ecma_integer_value_t) arguments_number);
+    bound_func_p->header.u.bound_function.args_len_or_this = args_len_or_this;
+  }
+
+  if (prototype_obj_p != NULL)
+  {
+    ecma_deref_object (prototype_obj_p);
+  }
+
+  bound_func_p->target_length = ecma_make_integer_value (0);
+
+  ecma_string_t *len_string = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
+  ecma_property_descriptor_t prop_desc;
+  ecma_value_t status = ecma_op_object_get_own_property_descriptor (this_arg_obj_p, len_string, &prop_desc);
+
+#if JERRY_BUILTIN_PROXY
+  if (ECMA_IS_VALUE_ERROR (status))
+  {
+    ecma_deref_object (function_p);
+    return status;
+  }
+#endif /* JERRY_BUILTIN_PROXY */
+
+  if (ecma_is_value_true (status))
+  {
+    ecma_free_property_descriptor (&prop_desc);
+    ecma_value_t len_value = ecma_op_object_get (this_arg_obj_p, len_string);
+
+    if (ECMA_IS_VALUE_ERROR (len_value))
+    {
+      ecma_deref_object (function_p);
+      return len_value;
+    }
+
+    if (ecma_is_value_number (len_value))
+    {
+      ecma_number_t len_num;
+      ecma_op_to_integer (len_value, &len_num);
+      bound_func_p->target_length = ecma_make_number_value (len_num);
+    }
+    ecma_free_value (len_value);
+  }
+
+  /* 12. */
+  ecma_value_t name_value = ecma_op_object_get_by_magic_id (this_arg_obj_p, LIT_MAGIC_STRING_NAME);
+  if (ECMA_IS_VALUE_ERROR (name_value))
+  {
+    ecma_deref_object (function_p);
+    return name_value;
+  }
+
+  ecma_string_t *name_p;
+
+  if (ecma_is_value_string (name_value))
+  {
+    name_p = ecma_get_string_from_value (name_value);
+  }
+  else
+  {
+    ecma_free_value (name_value);
+    name_p = ecma_get_magic_string (LIT_MAGIC_STRING__EMPTY);
+  }
+
+  ecma_value_t bound_function_name = ecma_op_function_form_name (name_p, (char*)"bound ", 6);
+
+  ecma_deref_ecma_string (name_p);
+
+  ecma_property_value_t *name_prop_value_p;
+  name_prop_value_p = ecma_create_named_data_property (function_p,
+                                                       ecma_get_magic_string (LIT_MAGIC_STRING_NAME),
+                                                       ECMA_PROPERTY_FLAG_CONFIGURABLE,
+                                                       NULL);
+
+  name_prop_value_p->value = bound_function_name;
+
+  /*
+   * [[Class]] property is not stored explicitly for objects of ECMA_OBJECT_TYPE_FUNCTION type.
+   *
+   * See also: ecma_object_get_class_name
+   */
+
+  /* 22. */
+  return ecma_make_object_value (function_p);
+} /* ecma_builtin_function_prototype_object_bind */
+
+/**
+ * Handle calling [[Call]] of built-in Function.prototype object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_function_prototype_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                               uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ECMA_VALUE_UNDEFINED;
+} /* ecma_builtin_function_prototype_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Function.prototype object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_function_prototype_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                    uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_raise_type_error (ECMA_ERR_FUNCTION_PROTOTYPE_NOT_A_CONSTRUCTOR);
+} /* ecma_builtin_function_prototype_dispatch_construct */
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return ecma value
+ *         Returned value must be freed with ecma_free_value.
+ */
+ecma_value_t
+ecma_builtin_function_prototype_dispatch_routine (uint8_t builtin_routine_id, /**< built-in wide routine identifier */
+                                                  ecma_value_t this_arg, /**< 'this' argument value */
+                                                  const ecma_value_t arguments_list_p[], /**< list of arguments
+                                                                                          *   passed to routine */
+                                                  uint32_t arguments_number) /**< length of arguments' list */
+{
+  if (!ecma_op_is_callable (this_arg))
+  {
+    if (JERRY_UNLIKELY (builtin_routine_id == ECMA_FUNCTION_PROTOTYPE_SYMBOL_HAS_INSTANCE))
+    {
+      return ECMA_VALUE_FALSE;
+    }
+
+    return ecma_raise_type_error (ECMA_ERR_ARGUMENT_THIS_NOT_FUNCTION);
+  }
+
+  ecma_object_t *func_obj_p = ecma_get_object_from_value (this_arg);
+
+  switch (builtin_routine_id)
+  {
+    case ECMA_FUNCTION_PROTOTYPE_TO_STRING:
+    {
+      return ecma_builtin_function_prototype_object_to_string (func_obj_p);
+    }
+    case ECMA_FUNCTION_PROTOTYPE_APPLY:
+    {
+      return ecma_builtin_function_prototype_object_apply (func_obj_p, arguments_list_p[0], arguments_list_p[1]);
+    }
+    case ECMA_FUNCTION_PROTOTYPE_CALL:
+    {
+      return ecma_builtin_function_prototype_object_call (func_obj_p, arguments_list_p, arguments_number);
+    }
+    case ECMA_FUNCTION_PROTOTYPE_BIND:
+    {
+      return ecma_builtin_function_prototype_object_bind (func_obj_p, arguments_list_p, arguments_number);
+    }
+    case ECMA_FUNCTION_PROTOTYPE_SYMBOL_HAS_INSTANCE:
+    {
+      return ecma_op_object_has_instance (func_obj_p, arguments_list_p[0]);
+    }
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+} /* ecma_builtin_function_prototype_dispatch_routine */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.h

@@ -0,0 +1,24 @@
+/* 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.
+ */
+
+#ifndef ECMA_BUILTIN_FUNCTION_PROTOTYPE_H
+#define ECMA_BUILTIN_FUNCTION_PROTOTYPE_H
+
+#include "ecma-globals.h"
+
+ecma_value_t
+ecma_builtin_function_prototype_object_apply (ecma_object_t *func_obj_p, ecma_value_t arg1, ecma_value_t arg2);
+
+#endif /* !ECMA_BUILTIN_FUNCTION_PROTOTYPE_H */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.inc.h

@@ -0,0 +1,55 @@
+/* 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.
+ */
+
+/*
+ * Function.prototype built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.3.4.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_CONSTRUCTOR, ECMA_BUILTIN_ID_FUNCTION, ECMA_PROPERTY_CONFIGURABLE_WRITABLE)
+
+/* Number properties:
+ *  (property name, object pointer getter) */
+
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 0, ECMA_PROPERTY_FLAG_DEFAULT_LENGTH)
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING__EMPTY, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (LIT_MAGIC_STRING_TO_STRING_UL, ECMA_FUNCTION_PROTOTYPE_TO_STRING, 0, 0)
+ROUTINE (LIT_MAGIC_STRING_APPLY, ECMA_FUNCTION_PROTOTYPE_APPLY, 2, 2)
+ROUTINE (LIT_MAGIC_STRING_CALL, ECMA_FUNCTION_PROTOTYPE_CALL, NON_FIXED, 1)
+ROUTINE (LIT_MAGIC_STRING_BIND, ECMA_FUNCTION_PROTOTYPE_BIND, NON_FIXED, 1)
+
+/**
+ * ECMA-262 v6.0 19.2.3.6 @@hasInstance
+ *  the property attributes are: { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
+ */
+ROUTINE_WITH_FLAGS (LIT_GLOBAL_SYMBOL_HAS_INSTANCE, ECMA_FUNCTION_PROTOTYPE_SYMBOL_HAS_INSTANCE, 1, 1, 0 /* flags */)
+ACCESSOR_BUILTIN_FUNCTION (LIT_MAGIC_STRING_ARGUMENTS,
+                           ECMA_BUILTIN_ID_TYPE_ERROR_THROWER,
+                           ECMA_BUILTIN_ID_TYPE_ERROR_THROWER,
+                           ECMA_PROPERTY_FLAG_CONFIGURABLE)
+ACCESSOR_BUILTIN_FUNCTION (LIT_MAGIC_STRING_CALLER,
+                           ECMA_BUILTIN_ID_TYPE_ERROR_THROWER,
+                           ECMA_BUILTIN_ID_TYPE_ERROR_THROWER,
+                           ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-function.cpp

@@ -0,0 +1,77 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-conversion.h"
+#include "ecma-eval.h"
+#include "ecma-exceptions.h"
+#include "ecma-function-object.h"
+#include "ecma-gc.h"
+#include "ecma-lex-env.h"
+
+#include "js-parser.h"
+#include "lit-magic-strings.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-function.inc.h"
+#define BUILTIN_UNDERSCORED_ID  function
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup function ECMA Function object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in Function object
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_function_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                     uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_builtin_function_dispatch_construct (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_function_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Function object
+ *
+ * See also:
+ *          ECMA-262 v5, 15.3.
+ *
+ * @return ecma value
+ */
+ecma_value_t
+ecma_builtin_function_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                          uint32_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_op_create_dynamic_function (arguments_list_p, arguments_list_len, ECMA_PARSE_NO_OPTS);
+} /* ecma_builtin_function_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-function.inc.h

@@ -0,0 +1,34 @@
+/* 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.
+ */
+
+/*
+ * Function built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+/* ECMA-262 v5, 15.3.3.1 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE, ECMA_PROPERTY_FIXED)
+
+/* Number properties:
+ *  (property name, object pointer getter) */
+
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 1, ECMA_PROPERTY_FLAG_DEFAULT_LENGTH)
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_FUNCTION_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-generator-function.cpp

@@ -0,0 +1,68 @@
+/* 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.
+ */
+
+#include "ecma-globals.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+#include "ecma-function-object.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-generator-function.inc.h"
+#define BUILTIN_UNDERSCORED_ID  generator_function
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup generatorfunction ECMA GeneratorFunction object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in GeneratorFunction object
+ *
+ * @return constructed generator function object - if success
+ *         raised error otherwise
+ */
+ecma_value_t
+ecma_builtin_generator_function_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                               uint32_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_op_create_dynamic_function (arguments_list_p, arguments_list_len, ECMA_PARSE_GENERATOR_FUNCTION);
+} /* ecma_builtin_generator_function_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in GeneratorFunction object
+ *
+ * @return constructed generator function object - if success
+ *        raised error otherwise
+ */
+ecma_value_t
+ecma_builtin_generator_function_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                    uint32_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_generator_function_dispatch_call (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_generator_function_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

src/loaders/lottie/jerryscript/jerry-core/ecma/builtin-objects/ecma-builtin-generator-function.inc.h

@@ -0,0 +1,31 @@
+/* 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.
+ */
+
+/*
+ * %GeneratorFunction% built-in description
+ */
+
+#include "ecma-builtin-helpers-macro-defines.inc.h"
+
+/* ECMA-262 v6, 25.2.2 */
+STRING_VALUE (LIT_MAGIC_STRING_NAME, LIT_MAGIC_STRING_GENERATOR_FUNCTION_UL, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 25.2.2.1 */
+NUMBER_VALUE (LIT_MAGIC_STRING_LENGTH, 1, ECMA_PROPERTY_FLAG_CONFIGURABLE)
+
+/* ECMA-262 v6, 25.2.2.2 */
+OBJECT_VALUE (LIT_MAGIC_STRING_PROTOTYPE, ECMA_BUILTIN_ID_GENERATOR, ECMA_PROPERTY_FIXED)
+
+#include "ecma-builtin-helpers-macro-undefs.inc.h"