From f638c381a36e9f7731dd5aa4d05cecd222bdebb8 Mon Sep 17 00:00:00 2001 From: Ruben Ayrapetyan Date: Thu, 14 Aug 2014 21:19:56 +0400 Subject: [PATCH] Introducing ecma-values collection. Implementing ecma-strings collection through ecma-values collection. --- .../ecma-helpers-strings-collection.c | 126 --------------- src/libecmaobjects/ecma-helpers-value.c | 4 +- .../ecma-helpers-values-collection.c | 153 ++++++++++++++++++ src/libecmaobjects/ecma-helpers.c | 6 +- src/libecmaobjects/ecma-helpers.h | 9 +- 5 files changed, 163 insertions(+), 135 deletions(-) delete mode 100644 src/libecmaobjects/ecma-helpers-strings-collection.c create mode 100644 src/libecmaobjects/ecma-helpers-values-collection.c diff --git a/src/libecmaobjects/ecma-helpers-strings-collection.c b/src/libecmaobjects/ecma-helpers-strings-collection.c deleted file mode 100644 index f68b076e9..000000000 --- a/src/libecmaobjects/ecma-helpers-strings-collection.c +++ /dev/null @@ -1,126 +0,0 @@ -/* Copyright 2014 Samsung Electronics Co., Ltd. - * - * 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. - */ - -/** \addtogroup ecma ---TODO--- - * @{ - * - * \addtogroup ecmahelpers Helpers for operations with ECMA data types - * @{ - */ - -#include "ecma-alloc.h" -#include "ecma-globals.h" -#include "ecma-helpers.h" -#include "globals.h" - -/** - * Allocate a collection of ecma-strings. - * - * @return pointer to the collection's header - */ -ecma_collection_header_t* -ecma_new_strings_collection (ecma_string_t* string_ptrs_buffer[], /**< pointers to ecma-strings */ - ecma_length_t strings_number) /**< number of ecma-strings */ -{ - JERRY_ASSERT (string_ptrs_buffer != NULL); - JERRY_ASSERT (strings_number > 0); - - ecma_collection_header_t* header_p = ecma_alloc_collection_header (); - - header_p->unit_number = strings_number; - - uint16_t* next_chunk_cp_p = &header_p->next_chunk_cp; - uint16_t* cur_strcp_buf_iter_p = (uint16_t*) header_p->data; - uint16_t* cur_strcp_buf_end_p = cur_strcp_buf_iter_p + sizeof (header_p->data) / sizeof (uint16_t); - - for (ecma_length_t string_index = 0; - string_index < strings_number; - string_index++) - { - if (unlikely (cur_strcp_buf_iter_p == cur_strcp_buf_end_p)) - { - ecma_collection_chunk_t *chunk_p = ecma_alloc_collection_chunk (); - ECMA_SET_POINTER (*next_chunk_cp_p, chunk_p); - next_chunk_cp_p = &chunk_p->next_chunk_cp; - - cur_strcp_buf_iter_p = (uint16_t*) chunk_p->data; - cur_strcp_buf_end_p = cur_strcp_buf_iter_p + sizeof (chunk_p->data) / sizeof (uint16_t); - } - - JERRY_ASSERT (cur_strcp_buf_iter_p + 1 <= cur_strcp_buf_end_p); - - ecma_ref_ecma_string (string_ptrs_buffer[string_index]); - ECMA_SET_POINTER (*cur_strcp_buf_iter_p, string_ptrs_buffer[string_index]); - cur_strcp_buf_iter_p++; - } - - return header_p; -} /* ecma_new_strings_collection */ - -/** - * Free the collection of ecma-strings. - */ -void -ecma_free_strings_collection (ecma_collection_header_t* header_p) /**< collection's header */ -{ - JERRY_ASSERT (header_p != NULL); - - uint16_t* cur_strcp_buf_iter_p = (uint16_t*) header_p->data; - uint16_t* cur_strcp_buf_end_p = cur_strcp_buf_iter_p + sizeof (header_p->data) / sizeof (uint16_t); - - ecma_length_t string_index = 0; - while (cur_strcp_buf_iter_p != cur_strcp_buf_end_p - && string_index < header_p->unit_number) - { - JERRY_ASSERT (cur_strcp_buf_iter_p < cur_strcp_buf_end_p); - - ecma_free_string (ECMA_GET_POINTER (*cur_strcp_buf_iter_p)); - - cur_strcp_buf_iter_p++; - string_index++; - } - - ecma_collection_chunk_t *chunk_p = ECMA_GET_POINTER (header_p->next_chunk_cp); - - while (chunk_p != NULL) - { - JERRY_ASSERT (string_index < header_p->unit_number); - - cur_strcp_buf_iter_p = (uint16_t*) chunk_p->data; - cur_strcp_buf_end_p = cur_strcp_buf_iter_p + sizeof (chunk_p->data) / sizeof (uint16_t); - - while (cur_strcp_buf_iter_p != cur_strcp_buf_end_p - && string_index < header_p->unit_number) - { - JERRY_ASSERT (cur_strcp_buf_iter_p < cur_strcp_buf_end_p); - - ecma_free_string (ECMA_GET_POINTER (*cur_strcp_buf_iter_p)); - - cur_strcp_buf_iter_p++; - string_index++; - } - - ecma_collection_chunk_t *next_chunk_p = ECMA_GET_POINTER (chunk_p->next_chunk_cp); - ecma_dealloc_collection_chunk (chunk_p); - chunk_p = next_chunk_p; - } - - ecma_dealloc_collection_header (header_p); -} /* ecma_free_strings_collection */ - -/** - * @} - * @} - */ diff --git a/src/libecmaobjects/ecma-helpers-value.c b/src/libecmaobjects/ecma-helpers-value.c index d954f0792..bf527e800 100644 --- a/src/libecmaobjects/ecma-helpers-value.c +++ b/src/libecmaobjects/ecma-helpers-value.c @@ -179,7 +179,7 @@ ecma_make_object_value (ecma_object_t* object_p) /**< object to reference in val ecma_value_t ecma_copy_value (const ecma_value_t value, /**< ecma-value */ bool do_ref_if_object) /**< if the value is object value, - increment reference counter of object */ + increment reference counter of the object */ { ecma_value_t value_copy; @@ -251,7 +251,7 @@ ecma_copy_value (const ecma_value_t value, /**< ecma-value */ void ecma_free_value (ecma_value_t value, /**< value description */ bool do_deref_if_object) /**< if the value is object value, - decrement reference counter of object */ + decrement reference counter of the object */ { switch ((ecma_type_t) value.value_type) { diff --git a/src/libecmaobjects/ecma-helpers-values-collection.c b/src/libecmaobjects/ecma-helpers-values-collection.c new file mode 100644 index 000000000..af40a435b --- /dev/null +++ b/src/libecmaobjects/ecma-helpers-values-collection.c @@ -0,0 +1,153 @@ +/* Copyright 2014 Samsung Electronics Co., Ltd. + * + * 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. + */ + +/** \addtogroup ecma ---TODO--- + * @{ + * + * \addtogroup ecmahelpers Helpers for operations with ECMA data types + * @{ + */ + +#include "ecma-alloc.h" +#include "ecma-globals.h" +#include "ecma-helpers.h" +#include "globals.h" + +/** + * Allocate a collection of ecma-values. + * + * @return pointer to the collection's header + */ +ecma_collection_header_t* +ecma_new_values_collection (ecma_value_t values_buffer[], /**< ecma-values */ + ecma_length_t values_number, /**< number of ecma-values */ + bool do_ref_if_object) /**< if the value is object value, + increase reference counter of the object */ +{ + JERRY_ASSERT (values_buffer != NULL); + JERRY_ASSERT (values_number > 0); + + ecma_collection_header_t* header_p = ecma_alloc_collection_header (); + + header_p->unit_number = values_number; + + uint16_t* next_chunk_cp_p = &header_p->next_chunk_cp; + ecma_value_t* cur_value_buf_iter_p = (ecma_value_t*) header_p->data; + ecma_value_t* cur_value_buf_end_p = cur_value_buf_iter_p + sizeof (header_p->data) / sizeof (ecma_value_t); + + for (ecma_length_t value_index = 0; + value_index < values_number; + value_index++) + { + if (unlikely (cur_value_buf_iter_p == cur_value_buf_end_p)) + { + ecma_collection_chunk_t *chunk_p = ecma_alloc_collection_chunk (); + ECMA_SET_POINTER (*next_chunk_cp_p, chunk_p); + next_chunk_cp_p = &chunk_p->next_chunk_cp; + + cur_value_buf_iter_p = (ecma_value_t*) chunk_p->data; + cur_value_buf_end_p = cur_value_buf_iter_p + sizeof (chunk_p->data) / sizeof (ecma_value_t); + } + + JERRY_ASSERT (cur_value_buf_iter_p + 1 <= cur_value_buf_end_p); + + *cur_value_buf_iter_p = ecma_copy_value (values_buffer[value_index], do_ref_if_object); + cur_value_buf_iter_p++; + } + + return header_p; +} /* ecma_new_values_collection */ + +/** + * Free the collection of ecma-values. + */ +void +ecma_free_values_collection (ecma_collection_header_t* header_p, /**< collection's header */ + bool do_deref_if_object) /**< if the value is object value, + decrement reference counter of the object */ +{ + JERRY_ASSERT (header_p != NULL); + + ecma_value_t* cur_value_buf_iter_p = (ecma_value_t*) header_p->data; + ecma_value_t* cur_value_buf_end_p = cur_value_buf_iter_p + sizeof (header_p->data) / sizeof (ecma_value_t); + + ecma_length_t string_index = 0; + while (cur_value_buf_iter_p != cur_value_buf_end_p + && string_index < header_p->unit_number) + { + JERRY_ASSERT (cur_value_buf_iter_p < cur_value_buf_end_p); + + ecma_free_value (*cur_value_buf_iter_p, do_deref_if_object); + + cur_value_buf_iter_p++; + string_index++; + } + + ecma_collection_chunk_t *chunk_p = ECMA_GET_POINTER (header_p->next_chunk_cp); + + while (chunk_p != NULL) + { + JERRY_ASSERT (string_index < header_p->unit_number); + + cur_value_buf_iter_p = (ecma_value_t*) chunk_p->data; + cur_value_buf_end_p = cur_value_buf_iter_p + sizeof (chunk_p->data) / sizeof (ecma_value_t); + + while (cur_value_buf_iter_p != cur_value_buf_end_p + && string_index < header_p->unit_number) + { + JERRY_ASSERT (cur_value_buf_iter_p < cur_value_buf_end_p); + + ecma_free_value (*cur_value_buf_iter_p, do_deref_if_object); + + cur_value_buf_iter_p++; + string_index++; + } + + ecma_collection_chunk_t *next_chunk_p = ECMA_GET_POINTER (chunk_p->next_chunk_cp); + ecma_dealloc_collection_chunk (chunk_p); + chunk_p = next_chunk_p; + } + + ecma_dealloc_collection_header (header_p); +} /* ecma_free_values_collection */ + +/** + * Allocate a collection of ecma-strings. + * + * @return pointer to the collection's header + */ +ecma_collection_header_t* +ecma_new_strings_collection (ecma_string_t* string_ptrs_buffer[], /**< pointers to ecma-strings */ + ecma_length_t strings_number) /**< number of ecma-strings */ +{ + JERRY_ASSERT (string_ptrs_buffer != NULL); + JERRY_ASSERT (strings_number > 0); + + ecma_value_t values_buffer[strings_number]; + + for (ecma_length_t string_index = 0; + string_index < strings_number; + string_index++) + { + values_buffer[string_index] = ecma_make_string_value (string_ptrs_buffer[string_index]); + } + + return ecma_new_values_collection (values_buffer, strings_number, false); +} /* ecma_new_strings_collection */ + +/** + * @} + * @} + */ diff --git a/src/libecmaobjects/ecma-helpers.c b/src/libecmaobjects/ecma-helpers.c index b63f87462..722ed1253 100644 --- a/src/libecmaobjects/ecma-helpers.c +++ b/src/libecmaobjects/ecma-helpers.c @@ -396,10 +396,8 @@ ecma_free_internal_property (ecma_property_t *property_p) /**< the property */ case ECMA_INTERNAL_PROPERTY_NUMBER_INDEXED_ARRAY_VALUES: /* a collection */ case ECMA_INTERNAL_PROPERTY_STRING_INDEXED_ARRAY_VALUES: /* a collection */ { - TODO (/* Free collection's elements */); - JERRY_UNIMPLEMENTED(); + ecma_free_values_collection (ECMA_GET_POINTER(property_value), true); - ecma_free_collection (ECMA_GET_POINTER(property_value)); break; } @@ -407,7 +405,7 @@ ecma_free_internal_property (ecma_property_t *property_p) /**< the property */ { if (property_value != ECMA_NULL_POINTER) { - ecma_free_strings_collection (ECMA_GET_POINTER(property_value)); + ecma_free_values_collection (ECMA_GET_POINTER(property_value), false); } break; } diff --git a/src/libecmaobjects/ecma-helpers.h b/src/libecmaobjects/ecma-helpers.h index a46411419..c79ec9ec8 100644 --- a/src/libecmaobjects/ecma-helpers.h +++ b/src/libecmaobjects/ecma-helpers.h @@ -98,11 +98,14 @@ extern bool ecma_compare_zt_string_to_ecma_string (const ecma_char_t *string_p, extern bool ecma_compare_ecma_string_to_ecma_string (const ecma_string_t *string1_p, const ecma_string_t *string2_p); -/* ecma-helpers-strings-collection.c */ +/* ecma-helpers-values-collection.c */ + +extern ecma_collection_header_t *ecma_new_values_collection (ecma_value_t values_buffer[], + ecma_length_t values_number, + bool do_ref_if_object); +extern void ecma_free_values_collection (ecma_collection_header_t* header_p, bool do_deref_if_object); extern ecma_collection_header_t *ecma_new_strings_collection (ecma_string_t* string_ptrs_buffer[], ecma_length_t strings_number); -extern void ecma_free_strings_collection (ecma_collection_header_t* header_p); - /* ecma-helpers.c */ extern ecma_object_t* ecma_create_object (ecma_object_t *prototype_object_p, bool is_extensible,