From 9dad7dbfbabe4b789c755497ac345773f5ba3ae3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A1szl=C3=B3=20Lang=C3=B3?= Date: Tue, 29 Mar 2016 09:23:23 +0200 Subject: [PATCH] Introduce ECMA_STRING_TO_UTF8_STRING and ECMA_FINALIZE_UTF8_STRING MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Benefits: * Better readability and maintenance * Better heap consumption on 'date-format-xparb.js' test of SunSpider JerryScript-DCO-1.0-Signed-off-by: László Langó llango.u-szeged@partner.samsung.com --- jerry-core/ecma/base/ecma-helpers-string.c | 63 +++++++++---------- jerry-core/ecma/base/ecma-helpers.h | 30 +++++++++ .../ecma/builtin-objects/ecma-builtin-date.c | 12 ++-- .../builtin-objects/ecma-builtin-global.c | 41 +++++------- .../builtin-objects/ecma-builtin-helpers.c | 30 ++------- .../ecma/builtin-objects/ecma-builtin-json.c | 47 +++++--------- .../ecma-builtin-string-prototype.c | 32 +++------- jerry-core/ecma/operations/ecma-eval.c | 11 +--- .../ecma/operations/ecma-regexp-object.c | 36 +++++------ jerry-core/jerry.c | 11 ++-- jerry-core/parser/regexp/re-compiler.c | 12 ++-- jerry-core/parser/regexp/re-parser.c | 2 +- jerry-core/parser/regexp/re-parser.h | 4 +- 13 files changed, 136 insertions(+), 195 deletions(-) diff --git a/jerry-core/ecma/base/ecma-helpers-string.c b/jerry-core/ecma/base/ecma-helpers-string.c index ef3dfd4e3..89e458892 100644 --- a/jerry-core/ecma/base/ecma-helpers-string.c +++ b/jerry-core/ecma/base/ecma-helpers-string.c @@ -549,25 +549,18 @@ ecma_string_to_number (const ecma_string_t *str_p) /**< ecma-string */ case ECMA_STRING_CONTAINER_MAGIC_STRING: case ECMA_STRING_CONTAINER_MAGIC_STRING_EX: { - const lit_utf8_size_t string_size = ecma_string_get_size (str_p); + ecma_number_t num; - if (string_size == 0) + ECMA_STRING_TO_UTF8_STRING (str_p, str_buffer_p, str_buffer_size); + + if (str_buffer_size == 0) { return ECMA_NUMBER_ZERO; } - ecma_number_t num; + num = ecma_utf8_string_to_number (str_buffer_p, str_buffer_size); - MEM_DEFINE_LOCAL_ARRAY (str_buffer_p, string_size, lit_utf8_byte_t); - - lit_utf8_size_t bytes_copied = ecma_string_to_utf8_string (str_p, - str_buffer_p, - string_size); - JERRY_ASSERT (bytes_copied == string_size); - - num = ecma_utf8_string_to_number (str_buffer_p, string_size); - - MEM_FINALIZE_LOCAL_ARRAY (str_buffer_p); + ECMA_FINALIZE_UTF8_STRING (str_buffer_p, str_buffer_size); return num; } @@ -1345,12 +1338,16 @@ static bool ecma_is_string_magic_longpath (const ecma_string_t *string_p, /**< ecma-string */ lit_magic_string_id_t *out_id_p) /**< [out] magic string's id */ { - lit_utf8_byte_t utf8_string_buffer[LIT_MAGIC_STRING_LENGTH_LIMIT]; + lit_utf8_size_t utf8_str_size; + bool is_ascii; + const lit_utf8_byte_t *utf8_str_p = ecma_string_raw_chars (string_p, &utf8_str_size, &is_ascii); - lit_utf8_size_t copied = ecma_string_to_utf8_string (string_p, utf8_string_buffer, sizeof (utf8_string_buffer)); - JERRY_ASSERT (copied <= sizeof (utf8_string_buffer)); + if (utf8_str_p == NULL || !is_ascii) + { + return false; + } - return lit_is_utf8_string_magic (utf8_string_buffer, (lit_utf8_size_t) copied, out_id_p); + return lit_is_utf8_string_magic (utf8_str_p, utf8_str_size, out_id_p); } /* ecma_is_string_magic_longpath */ /** @@ -1366,12 +1363,16 @@ static bool ecma_is_ex_string_magic_longpath (const ecma_string_t *string_p, /**< ecma-string */ lit_magic_string_ex_id_t *out_id_p) /**< [out] external magic string's id */ { - lit_utf8_byte_t utf8_string_buffer[LIT_MAGIC_STRING_LENGTH_LIMIT]; + lit_utf8_size_t utf8_str_size; + bool is_ascii; + const lit_utf8_byte_t *utf8_str_p = ecma_string_raw_chars (string_p, &utf8_str_size, &is_ascii); - lit_utf8_size_t copied = ecma_string_to_utf8_string (string_p, utf8_string_buffer, sizeof (utf8_string_buffer)); - JERRY_ASSERT (copied <= sizeof (utf8_string_buffer)); + if (utf8_str_p == NULL || !is_ascii) + { + return false; + } - return lit_is_ex_utf8_string_magic (utf8_string_buffer, (lit_utf8_size_t) copied, out_id_p); + return lit_is_ex_utf8_string_magic (utf8_str_p, utf8_str_size, out_id_p); } /* ecma_is_ex_string_magic_longpath */ /** @@ -1556,19 +1557,14 @@ ecma_string_trim (const ecma_string_t *string_p) /**< pointer to an ecma string { ecma_string_t *ret_string_p; - lit_utf8_size_t buffer_size = ecma_string_get_size (string_p); + ECMA_STRING_TO_UTF8_STRING (string_p, utf8_str_p, utf8_str_size); - if (buffer_size > 0) + if (utf8_str_size > 0) { - MEM_DEFINE_LOCAL_ARRAY (utf8_str_p, buffer_size, lit_utf8_byte_t); - - lit_utf8_size_t sz = ecma_string_to_utf8_string (string_p, utf8_str_p, buffer_size); - JERRY_ASSERT (sz == buffer_size); - ecma_char_t ch; lit_utf8_size_t read_size; - lit_utf8_byte_t *nonws_start_p = utf8_str_p + buffer_size; - lit_utf8_byte_t *current_p = utf8_str_p; + const lit_utf8_byte_t *nonws_start_p = utf8_str_p + utf8_str_size; + const lit_utf8_byte_t *current_p = utf8_str_p; /* Trim front. */ while (current_p < nonws_start_p) @@ -1585,7 +1581,7 @@ ecma_string_trim (const ecma_string_t *string_p) /**< pointer to an ecma string current_p += read_size; } - current_p = utf8_str_p + buffer_size; + current_p = utf8_str_p + utf8_str_size; /* Trim back. */ while (current_p > utf8_str_p) @@ -1611,16 +1607,15 @@ ecma_string_trim (const ecma_string_t *string_p) /**< pointer to an ecma string { ret_string_p = ecma_get_magic_string (LIT_MAGIC_STRING__EMPTY); } - - MEM_FINALIZE_LOCAL_ARRAY (utf8_str_p); } else { ret_string_p = ecma_get_magic_string (LIT_MAGIC_STRING__EMPTY); } - return ret_string_p; + ECMA_FINALIZE_UTF8_STRING (utf8_str_p, utf8_str_size); + return ret_string_p; } /* ecma_string_trim */ /** diff --git a/jerry-core/ecma/base/ecma-helpers.h b/jerry-core/ecma/base/ecma-helpers.h index 05439b8cb..ad9b1282f 100644 --- a/jerry-core/ecma/base/ecma-helpers.h +++ b/jerry-core/ecma/base/ecma-helpers.h @@ -52,6 +52,36 @@ */ #define ECMA_SET_POINTER(field, non_compressed_pointer) MEM_CP_SET_POINTER (field, non_compressed_pointer) +/** + * 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; \ + bool utf8_ptr ## must_be_freed; \ + const lit_utf8_byte_t *utf8_ptr = ecma_string_raw_chars (ecma_str_ptr, &utf8_str_size, &utf8_ptr ## must_be_freed); \ + utf8_ptr ## must_be_freed = false; /* it was used as 'is_ascii' in 'ecma_string_raw_chars', so we must reset it */ \ + \ + if (utf8_ptr == NULL) \ + { \ + utf8_ptr = (const lit_utf8_byte_t *) (mem_heap_alloc_block (utf8_str_size)); \ + lit_utf8_size_t sz = ecma_string_to_utf8_string (ecma_str_ptr, (lit_utf8_byte_t *) utf8_ptr, utf8_str_size); \ + JERRY_ASSERT (sz == utf8_str_size); \ + utf8_ptr ## must_be_freed = true; \ + } + +/** + * 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 ## must_be_freed) \ + { \ + JERRY_ASSERT (utf8_ptr != NULL); \ + mem_heap_free_block ((void *) utf8_ptr, utf8_str_size); \ + } + /* ecma-helpers-value.c */ extern ecma_type_t ecma_get_value_type_field (ecma_value_t) __attr_pure___; diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-date.c b/jerry-core/ecma/builtin-objects/ecma-builtin-date.c index fcd943cbe..846ae66c5 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-date.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-date.c @@ -205,14 +205,10 @@ ecma_builtin_date_parse (ecma_value_t this_arg __attr_unused___, /**< this argum ecma_string_t *date_str_p = ecma_get_string_from_value (date_str_value); - lit_utf8_size_t date_str_size = ecma_string_get_size (date_str_p); - MEM_DEFINE_LOCAL_ARRAY (date_start_p, date_str_size, lit_utf8_byte_t); + ECMA_STRING_TO_UTF8_STRING (date_str_p, date_start_p, date_start_size); - lit_utf8_size_t sz = ecma_string_to_utf8_string (date_str_p, date_start_p, date_str_size); - JERRY_ASSERT (sz == date_str_size); - - lit_utf8_byte_t *date_str_curr_p = date_start_p; - const lit_utf8_byte_t *date_str_end_p = date_start_p + date_str_size; + lit_utf8_byte_t *date_str_curr_p = (lit_utf8_byte_t *) date_start_p; + const lit_utf8_byte_t *date_str_end_p = date_start_p + date_start_size; /* 1. read year */ ecma_number_t year = ecma_date_parse_date_chars (&date_str_curr_p, date_str_end_p, 4); @@ -396,7 +392,7 @@ ecma_builtin_date_parse (ecma_value_t this_arg __attr_unused___, /**< this argum ret_value = ecma_make_number_value (date_num_p); - MEM_FINALIZE_LOCAL_ARRAY (date_start_p); + ECMA_FINALIZE_UTF8_STRING (date_start_p, date_start_size); ECMA_FINALIZE (date_str_value); return ret_value; diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-global.c b/jerry-core/ecma/builtin-objects/ecma-builtin-global.c index f42506fe1..2d913d718 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-global.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-global.c @@ -203,23 +203,17 @@ ecma_builtin_global_object_parse_int (ecma_value_t this_arg __attr_unused___, /* ECMA_TRY_CATCH (string_var, ecma_op_to_string (string), ret_value); ecma_string_t *number_str_p = ecma_get_string_from_value (string_var); - lit_utf8_size_t str_size = ecma_string_get_size (number_str_p); + ECMA_STRING_TO_UTF8_STRING (number_str_p, string_buff, string_buff_size); - if (str_size > 0) + if (string_buff_size > 0) { - MEM_DEFINE_LOCAL_ARRAY (string_buff, str_size, lit_utf8_byte_t); - - lit_utf8_size_t bytes_copied = ecma_string_to_utf8_string (number_str_p, - string_buff, - str_size); - JERRY_ASSERT (bytes_copied == str_size); - lit_utf8_byte_t *string_curr_p = string_buff; - lit_utf8_byte_t *string_end_p = string_buff + str_size; + lit_utf8_byte_t *string_curr_p = (lit_utf8_byte_t *) string_buff; + const lit_utf8_byte_t *string_end_p = string_buff + string_buff_size; /* 2. Remove leading whitespace. */ - lit_utf8_byte_t *start_p = string_end_p; - lit_utf8_byte_t *end_p = string_end_p; + lit_utf8_byte_t *start_p = (lit_utf8_byte_t *) string_end_p; + lit_utf8_byte_t *end_p = start_p; while (string_curr_p < string_end_p) { @@ -396,7 +390,6 @@ ecma_builtin_global_object_parse_int (ecma_value_t this_arg __attr_unused___, /* ret_value = ecma_make_number_value (ret_num_p); } - MEM_FINALIZE_LOCAL_ARRAY (string_buff); } else { @@ -405,6 +398,7 @@ ecma_builtin_global_object_parse_int (ecma_value_t this_arg __attr_unused___, /* ret_value = ecma_make_number_value (ret_num_p); } + ECMA_FINALIZE_UTF8_STRING (string_buff, string_buff_size); ECMA_FINALIZE (string_var); return ret_value; } /* ecma_builtin_global_object_parse_int */ @@ -428,22 +422,15 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___, ECMA_TRY_CATCH (string_var, ecma_op_to_string (string), ret_value); ecma_string_t *number_str_p = ecma_get_string_from_value (string_var); - lit_utf8_size_t str_size = ecma_string_get_size (number_str_p); + ECMA_STRING_TO_UTF8_STRING (number_str_p, string_buff, string_buff_size); - if (str_size > 0) + if (string_buff_size > 0) { - MEM_DEFINE_LOCAL_ARRAY (string_buff, str_size, lit_utf8_byte_t); + lit_utf8_byte_t *str_curr_p = (lit_utf8_byte_t *) string_buff; + const lit_utf8_byte_t *str_end_p = string_buff + string_buff_size; - lit_utf8_size_t bytes_copied = ecma_string_to_utf8_string (number_str_p, - string_buff, - str_size); - JERRY_ASSERT (bytes_copied == str_size); - - lit_utf8_byte_t *str_curr_p = string_buff; - lit_utf8_byte_t *str_end_p = string_buff + str_size; - - lit_utf8_byte_t *start_p = str_end_p; - lit_utf8_byte_t *end_p = str_end_p; + lit_utf8_byte_t *start_p = (lit_utf8_byte_t *) str_end_p; + lit_utf8_byte_t *end_p = (lit_utf8_byte_t *) str_end_p; /* 2. Find first non whitespace char and set starting position. */ while (str_curr_p < str_end_p) @@ -626,7 +613,6 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___, *ret_num_p = ecma_number_make_nan (); ret_value = ecma_make_number_value (ret_num_p); } - MEM_FINALIZE_LOCAL_ARRAY (string_buff); } /* String length is zero. */ else @@ -636,6 +622,7 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___, ret_value = ecma_make_number_value (ret_num_p); } + ECMA_FINALIZE_UTF8_STRING (string_buff, string_buff_size); ECMA_FINALIZE (string_var); return ret_value; diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c b/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c index 05d49b78e..8915396f4 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c @@ -565,12 +565,8 @@ ecma_builtin_helper_string_find_index (ecma_string_t *original_str_p, /**< index ecma_length_t *ret_index_p) /**< position found in original string */ { bool match_found = false; - const ecma_length_t original_len = ecma_string_get_length (original_str_p); - const lit_utf8_size_t original_size = ecma_string_get_size (original_str_p); - const ecma_length_t search_len = ecma_string_get_length (search_str_p); - const lit_utf8_size_t search_size = ecma_string_get_size (search_str_p); if (search_len <= original_len) { @@ -582,34 +578,20 @@ ecma_builtin_helper_string_find_index (ecma_string_t *original_str_p, /**< index else { /* create utf8 string from original string and advance to position */ - MEM_DEFINE_LOCAL_ARRAY (original_str_utf8_p, - original_size, - lit_utf8_byte_t); - - lit_utf8_size_t sz = ecma_string_to_utf8_string (original_str_p, - original_str_utf8_p, - original_size); - JERRY_ASSERT (sz == original_size); + ECMA_STRING_TO_UTF8_STRING (original_str_p, original_str_utf8_p, original_str_size); ecma_length_t index = start_pos; - lit_utf8_byte_t *original_str_curr_p = original_str_utf8_p; + lit_utf8_byte_t *original_str_curr_p = (lit_utf8_byte_t *) original_str_utf8_p; for (ecma_length_t idx = 0; idx < index; idx++) { lit_utf8_incr (&original_str_curr_p); } /* create utf8 string from search string */ - MEM_DEFINE_LOCAL_ARRAY (search_str_utf8_p, - search_size, - lit_utf8_byte_t); + ECMA_STRING_TO_UTF8_STRING (search_str_p, search_str_utf8_p, search_str_size); - lit_utf8_size_t sz = ecma_string_to_utf8_string (search_str_p, - search_str_utf8_p, - search_size); - JERRY_ASSERT (sz == search_size); - - lit_utf8_byte_t *search_str_curr_p = search_str_utf8_p; + lit_utf8_byte_t *search_str_curr_p = (lit_utf8_byte_t *) search_str_utf8_p; /* iterate original string and try to match at each position */ bool searching = true; @@ -667,8 +649,8 @@ ecma_builtin_helper_string_find_index (ecma_string_t *original_str_p, /**< index } } - MEM_FINALIZE_LOCAL_ARRAY (search_str_utf8_p); - MEM_FINALIZE_LOCAL_ARRAY (original_str_utf8_p); + ECMA_FINALIZE_UTF8_STRING (search_str_utf8_p, search_str_size); + ECMA_FINALIZE_UTF8_STRING (original_str_utf8_p, original_str_size); } } diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-json.c b/jerry-core/ecma/builtin-objects/ecma-builtin-json.c index 2850fa25b..cfc88bbcc 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-json.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-json.c @@ -76,12 +76,12 @@ typedef struct { ecma_json_token_type_t type; /**< type of the current token */ lit_utf8_byte_t *current_p; /**< current position of the string processed by the parser */ - lit_utf8_byte_t *end_p; /**< end of the string processed by the parser */ + const lit_utf8_byte_t *end_p; /**< end of the string processed by the parser */ union { struct { - lit_utf8_byte_t *start_p; /**< when type is string_token, it contains the start of the string */ + const lit_utf8_byte_t *start_p; /**< when type is string_token, it contains the start of the string */ lit_utf8_size_t size; /**< when type is string_token, it contains the size of the string */ } string; ecma_number_t number; /**< when type is number_token, it contains the value of the number */ @@ -286,11 +286,11 @@ ecma_builtin_json_parse_next_token (ecma_json_token_t *token_p) /**< token argum lit_utf8_byte_t *current_p = token_p->current_p; token_p->type = invalid_token; - /* - * No need for end check since the string is zero terminated. - */ - while (*current_p == LIT_CHAR_SP || *current_p == LIT_CHAR_CR - || *current_p == LIT_CHAR_LF || *current_p == LIT_CHAR_TAB) + while (current_p < token_p->end_p + && (*current_p == LIT_CHAR_SP + || *current_p == LIT_CHAR_CR + || *current_p == LIT_CHAR_LF + || *current_p == LIT_CHAR_TAB)) { current_p++; } @@ -500,7 +500,7 @@ ecma_builtin_json_parse_value (ecma_json_token_t *token_p) /**< token argument * break; } - lit_utf8_byte_t *string_start_p = token_p->u.string.start_p; + const lit_utf8_byte_t *string_start_p = token_p->u.string.start_p; lit_utf8_size_t string_size = token_p->u.string.size; ecma_builtin_json_parse_next_token (token_p); @@ -709,19 +709,12 @@ ecma_builtin_json_parse (ecma_value_t this_arg __attr_unused___, /**< 'this' arg ret_value); ecma_string_t *string_p = ecma_get_string_from_value (string); - ecma_length_t string_size = (uint32_t) ecma_string_get_size (string_p); - lit_utf8_size_t buffer_size = sizeof (lit_utf8_byte_t) * (string_size + 1); - MEM_DEFINE_LOCAL_ARRAY (str_start_p, buffer_size, lit_utf8_byte_t); - - lit_utf8_size_t sz = ecma_string_to_utf8_string (string_p, str_start_p, buffer_size); - JERRY_ASSERT (sz == string_size); - - str_start_p[string_size] = LIT_BYTE_NULL; + ECMA_STRING_TO_UTF8_STRING (string_p, str_start_p, str_start_size); ecma_json_token_t token; - token.current_p = str_start_p; - token.end_p = str_start_p + string_size; + token.current_p = (lit_utf8_byte_t *) str_start_p; + token.end_p = str_start_p + str_start_size; ecma_value_t final_result = ecma_builtin_json_parse_value (&token); @@ -767,7 +760,7 @@ ecma_builtin_json_parse (ecma_value_t this_arg __attr_unused___, /**< 'this' arg } } - MEM_FINALIZE_LOCAL_ARRAY (str_start_p); + ECMA_FINALIZE_UTF8_STRING (str_start_p, str_start_size); ECMA_FINALIZE (string); return ret_value; @@ -1064,18 +1057,10 @@ ecma_builtin_json_quote (ecma_string_t *string_p) /**< string that should be quo ecma_string_t *product_str_p = ecma_copy_or_ref_ecma_string (quote_str_p); ecma_string_t *tmp_str_p; - ecma_length_t string_size = ecma_string_get_size (string_p); + ECMA_STRING_TO_UTF8_STRING (string_p, string_buff, string_buff_size); - MEM_DEFINE_LOCAL_ARRAY (string_buff, string_size, lit_utf8_byte_t); - - lit_utf8_size_t bytes_copied = ecma_string_to_utf8_string (string_p, - string_buff, - string_size); - - JERRY_ASSERT (bytes_copied == string_size); - - lit_utf8_byte_t *str_p = string_buff; - const lit_utf8_byte_t *str_end_p = str_p + string_size; + lit_utf8_byte_t *str_p = (lit_utf8_byte_t *) string_buff; + const lit_utf8_byte_t *str_end_p = string_buff + string_buff_size; while (str_p < str_end_p) { @@ -1196,7 +1181,7 @@ ecma_builtin_json_quote (ecma_string_t *string_p) /**< string that should be quo } } - MEM_FINALIZE_LOCAL_ARRAY (string_buff); + ECMA_FINALIZE_UTF8_STRING (string_buff, string_buff_size); /* 3. */ tmp_str_p = ecma_concat_ecma_strings (product_str_p, quote_str_p); diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.c b/jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.c index 77a84f480..98f426b13 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.c @@ -1198,23 +1198,15 @@ ecma_builtin_string_prototype_object_replace_main (ecma_builtin_replace_search_c ret_value); ecma_string_t *replace_string_p = ecma_get_string_from_value (to_string_replace_val); - lit_utf8_size_t replace_size = ecma_string_get_size (replace_string_p); - MEM_DEFINE_LOCAL_ARRAY (replace_start_p, - replace_size, - lit_utf8_byte_t); - - lit_utf8_size_t sz = ecma_string_to_utf8_string (replace_string_p, - replace_start_p, - replace_size); - JERRY_ASSERT (sz == replace_size); + ECMA_STRING_TO_UTF8_STRING (replace_string_p, replace_start_p, replace_start_size); context_p->replace_string_p = replace_string_p; - context_p->replace_str_curr_p = replace_start_p; + context_p->replace_str_curr_p = (lit_utf8_byte_t *) replace_start_p; ret_value = ecma_builtin_string_prototype_object_replace_loop (context_p); - MEM_FINALIZE_LOCAL_ARRAY (replace_start_p); + ECMA_FINALIZE_UTF8_STRING (replace_start_p, replace_start_size); ECMA_FINALIZE (to_string_replace_val); } @@ -2073,16 +2065,8 @@ ecma_builtin_string_prototype_object_conversion_helper (ecma_value_t this_arg, / /* 3. */ ecma_string_t *input_string_p = ecma_get_string_from_value (to_string_val); - lit_utf8_size_t input_size = ecma_string_get_size (input_string_p); - MEM_DEFINE_LOCAL_ARRAY (input_start_p, - input_size, - lit_utf8_byte_t); - - lit_utf8_size_t sz = ecma_string_to_utf8_string (input_string_p, - input_start_p, - input_size); - JERRY_ASSERT (sz == input_size); + ECMA_STRING_TO_UTF8_STRING (input_string_p, input_start_p, input_start_size); /* * The URI encoding has two major phases: first we compute @@ -2090,8 +2074,8 @@ ecma_builtin_string_prototype_object_conversion_helper (ecma_value_t this_arg, / */ lit_utf8_size_t output_length = 0; - lit_utf8_byte_t *input_str_curr_p = input_start_p; - const lit_utf8_byte_t *input_str_end_p = input_start_p + input_size; + lit_utf8_byte_t *input_str_curr_p = (lit_utf8_byte_t *) input_start_p; + const lit_utf8_byte_t *input_str_end_p = input_start_p + input_start_size; while (input_str_curr_p < input_str_end_p) { @@ -2130,7 +2114,7 @@ ecma_builtin_string_prototype_object_conversion_helper (ecma_value_t this_arg, / lit_utf8_byte_t *output_char_p = output_start_p; /* Encoding the output. */ - input_str_curr_p = input_start_p; + input_str_curr_p = (lit_utf8_byte_t *) input_start_p; while (input_str_curr_p < input_str_end_p) { @@ -2166,7 +2150,7 @@ ecma_builtin_string_prototype_object_conversion_helper (ecma_value_t this_arg, / ret_value = ecma_make_string_value (output_string_p); MEM_FINALIZE_LOCAL_ARRAY (output_start_p); - MEM_FINALIZE_LOCAL_ARRAY (input_start_p); + ECMA_FINALIZE_UTF8_STRING (input_start_p, input_start_size); ECMA_FINALIZE (to_string_val); ECMA_FINALIZE (check_coercible_val); diff --git a/jerry-core/ecma/operations/ecma-eval.c b/jerry-core/ecma/operations/ecma-eval.c index 9ae6744cc..0e7f12c98 100644 --- a/jerry-core/ecma/operations/ecma-eval.c +++ b/jerry-core/ecma/operations/ecma-eval.c @@ -52,21 +52,14 @@ ecma_op_eval (ecma_string_t *code_p, /**< code string */ } else { - MEM_DEFINE_LOCAL_ARRAY (code_utf8_buffer_p, - chars_num, - lit_utf8_byte_t); - - lit_utf8_size_t buffer_size_req = ecma_string_to_utf8_string (code_p, - code_utf8_buffer_p, - chars_num); - JERRY_ASSERT (buffer_size_req == chars_num); + ECMA_STRING_TO_UTF8_STRING (code_p, code_utf8_buffer_p, code_utf8_buffer_size); ret_value = ecma_op_eval_chars_buffer ((jerry_api_char_t *) code_utf8_buffer_p, chars_num, is_direct, is_called_from_strict_mode_code); - MEM_FINALIZE_LOCAL_ARRAY (code_utf8_buffer_p); + ECMA_FINALIZE_UTF8_STRING (code_utf8_buffer_p, code_utf8_buffer_size); } return ret_value; diff --git a/jerry-core/ecma/operations/ecma-regexp-object.c b/jerry-core/ecma/operations/ecma-regexp-object.c index 156d36d70..6e2cab6af 100644 --- a/jerry-core/ecma/operations/ecma-regexp-object.c +++ b/jerry-core/ecma/operations/ecma-regexp-object.c @@ -76,14 +76,10 @@ re_parse_regexp_flags (ecma_string_t *flags_str_p, /**< Input string with flags { ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY); - lit_utf8_size_t flags_str_size = ecma_string_get_size (flags_str_p); - MEM_DEFINE_LOCAL_ARRAY (flags_start_p, flags_str_size, lit_utf8_byte_t); + ECMA_STRING_TO_UTF8_STRING (flags_str_p, flags_start_p, flags_start_size); - lit_utf8_size_t sz = ecma_string_to_utf8_string (flags_str_p, flags_start_p, flags_str_size); - JERRY_ASSERT (sz == flags_str_size); - - lit_utf8_byte_t *flags_str_curr_p = flags_start_p; - const lit_utf8_byte_t *flags_str_end_p = flags_start_p + flags_str_size; + const lit_utf8_byte_t *flags_str_curr_p = flags_start_p; + const lit_utf8_byte_t *flags_str_end_p = flags_start_p + flags_start_size; while (flags_str_curr_p < flags_str_end_p && ecma_is_value_empty (ret_value)) @@ -125,7 +121,7 @@ re_parse_regexp_flags (ecma_string_t *flags_str_p, /**< Input string with flags } } - MEM_FINALIZE_LOCAL_ARRAY (flags_start_p); + ECMA_FINALIZE_UTF8_STRING (flags_start_p, flags_start_size); return ret_value; } /* re_parse_regexp_flags */ @@ -1274,27 +1270,23 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */ return ecma_raise_type_error (ECMA_ERR_MSG ("Incompatible type")); } - ecma_string_t *input_string_p = ecma_get_string_from_value (input_string); - lit_utf8_size_t input_string_size = ecma_string_get_size (input_string_p); - - MEM_DEFINE_LOCAL_ARRAY (input_buffer_p, input_string_size, lit_utf8_byte_t); - re_matcher_ctx_t re_ctx; lit_utf8_byte_t *input_curr_p = NULL; - lit_utf8_size_t sz = ecma_string_to_utf8_string (input_string_p, input_buffer_p, input_string_size); - JERRY_ASSERT (sz == input_string_size); - if (input_string_size == 0u) + ecma_string_t *input_string_p = ecma_get_string_from_value (input_string); + ECMA_STRING_TO_UTF8_STRING (input_string_p, input_buffer_p, input_buffer_size); + + if (input_buffer_size == 0u) { input_curr_p = (lit_utf8_byte_t *) lit_get_magic_string_utf8 (LIT_MAGIC_STRING__EMPTY); } else { - input_curr_p = input_buffer_p; + input_curr_p = (lit_utf8_byte_t *) input_buffer_p; } re_ctx.input_start_p = input_curr_p; - const lit_utf8_byte_t *input_end_p = re_ctx.input_start_p + input_string_size; + const lit_utf8_byte_t *input_end_p = re_ctx.input_start_p + input_buffer_size; re_ctx.input_end_p = input_end_p; /* 1. Read bytecode header and init regexp matcher context. */ @@ -1333,7 +1325,9 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */ bool is_match = false; re_ctx.num_of_iterations_p = num_of_iter_p; int32_t index = 0; - ecma_length_t input_str_len = lit_utf8_string_length (input_buffer_p, input_string_size); + ecma_length_t input_str_len; + + input_str_len = lit_utf8_string_length (input_buffer_p, input_buffer_size); if (input_buffer_p && (re_ctx.flags & RE_FLAG_GLOBAL)) { @@ -1435,7 +1429,7 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */ ecma_value_t result_array = ecma_op_create_array_object (0, 0, false); ecma_object_t *result_array_obj_p = ecma_get_object_from_value (result_array); - ecma_string_t *input_str_p = ecma_new_ecma_string_from_utf8 (input_buffer_p, input_string_size); + ecma_string_t *input_str_p = ecma_new_ecma_string_from_utf8 (input_buffer_p, input_buffer_size); re_set_result_array_properties (result_array_obj_p, input_str_p, re_ctx.num_of_captures / 2, index); ecma_deref_ecma_string (input_str_p); @@ -1492,7 +1486,7 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */ MEM_FINALIZE_LOCAL_ARRAY (num_of_iter_p); MEM_FINALIZE_LOCAL_ARRAY (saved_p); - MEM_FINALIZE_LOCAL_ARRAY (input_buffer_p); + ECMA_FINALIZE_UTF8_STRING (input_buffer_p, input_buffer_size); return ret_value; } /* ecma_regexp_exec_helper */ diff --git a/jerry-core/jerry.c b/jerry-core/jerry.c index d140166a9..943f4811d 100644 --- a/jerry-core/jerry.c +++ b/jerry-core/jerry.c @@ -1886,23 +1886,22 @@ snapshot_add_compiled_code (ecma_compiled_code_t *compiled_code_p) /**< compiled ecma_string_t *pattern_string_p = ECMA_GET_NON_NULL_POINTER (ecma_string_t, pattern_cp); - ecma_length_t pattern_size = ecma_string_get_size (pattern_string_p); + ecma_length_t pattern_size = 0; - MEM_DEFINE_LOCAL_ARRAY (buffer_p, pattern_size, lit_utf8_byte_t); + ECMA_STRING_TO_UTF8_STRING (pattern_string_p, buffer_p, buffer_size); - lit_utf8_size_t sz = ecma_string_to_utf8_string (pattern_string_p, buffer_p, pattern_size); - JERRY_ASSERT (sz == pattern_size); + pattern_size = buffer_size; if (!jrt_write_to_buffer_by_offset (snapshot_buffer_p, snapshot_buffer_size, &snapshot_buffer_write_offset, buffer_p, - pattern_size)) + buffer_size)) { snapshot_error_occured = true; } - MEM_FINALIZE_LOCAL_ARRAY (buffer_p); + ECMA_FINALIZE_UTF8_STRING (buffer_p, buffer_size); snapshot_buffer_write_offset = JERRY_ALIGNUP (snapshot_buffer_write_offset, MEM_ALIGNMENT); diff --git a/jerry-core/parser/regexp/re-compiler.c b/jerry-core/parser/regexp/re-compiler.c index 079efe65e..a8cae435d 100644 --- a/jerry-core/parser/regexp/re-compiler.c +++ b/jerry-core/parser/regexp/re-compiler.c @@ -546,16 +546,12 @@ re_compile_bytecode (const re_compiled_code_t **out_bytecode_p, /**< [out] point re_ctx.bytecode_ctx_p = &bc_ctx; - lit_utf8_size_t pattern_str_size = ecma_string_get_size (pattern_str_p); - MEM_DEFINE_LOCAL_ARRAY (pattern_start_p, pattern_str_size, lit_utf8_byte_t); - - lit_utf8_size_t sz = ecma_string_to_utf8_string (pattern_str_p, pattern_start_p, pattern_str_size); - JERRY_ASSERT (sz == pattern_str_size); + ECMA_STRING_TO_UTF8_STRING (pattern_str_p, pattern_start_p, pattern_start_size); re_parser_ctx_t parser_ctx; parser_ctx.input_start_p = pattern_start_p; - parser_ctx.input_curr_p = pattern_start_p; - parser_ctx.input_end_p = pattern_start_p + pattern_str_size; + parser_ctx.input_curr_p = (lit_utf8_byte_t *) pattern_start_p; + parser_ctx.input_end_p = pattern_start_p + pattern_start_size; parser_ctx.num_of_groups = -1; re_ctx.parser_ctx_p = &parser_ctx; @@ -593,7 +589,7 @@ re_compile_bytecode (const re_compiled_code_t **out_bytecode_p, /**< [out] point ECMA_FINALIZE (empty); - MEM_FINALIZE_LOCAL_ARRAY (pattern_start_p); + ECMA_FINALIZE_UTF8_STRING (pattern_start_p, pattern_start_size); size_t byte_code_size = (size_t) (bc_ctx.block_end_p - bc_ctx.block_start_p); diff --git a/jerry-core/parser/regexp/re-parser.c b/jerry-core/parser/regexp/re-parser.c index b49213227..46d16de9d 100644 --- a/jerry-core/parser/regexp/re-parser.c +++ b/jerry-core/parser/regexp/re-parser.c @@ -259,7 +259,7 @@ re_count_num_of_groups (re_parser_ctx_t *parser_ctx_p) /**< RegExp parser contex { int char_class_in = 0; parser_ctx_p->num_of_groups = 0; - lit_utf8_byte_t *curr_p = parser_ctx_p->input_start_p; + lit_utf8_byte_t *curr_p = (lit_utf8_byte_t *) parser_ctx_p->input_start_p; while (curr_p < parser_ctx_p->input_end_p) { diff --git a/jerry-core/parser/regexp/re-parser.h b/jerry-core/parser/regexp/re-parser.h index d011f1b73..31bb03432 100644 --- a/jerry-core/parser/regexp/re-parser.h +++ b/jerry-core/parser/regexp/re-parser.h @@ -92,9 +92,9 @@ typedef struct */ typedef struct { - lit_utf8_byte_t *input_start_p; /**< start of input pattern */ + const lit_utf8_byte_t *input_start_p; /**< start of input pattern */ lit_utf8_byte_t *input_curr_p; /**< current position in input pattern */ - lit_utf8_byte_t *input_end_p; /**< end of input pattern */ + const lit_utf8_byte_t *input_end_p; /**< end of input pattern */ int num_of_groups; /**< number of groups */ uint32_t num_of_classes; /**< number of character classes */ } re_parser_ctx_t;