diff --git a/jerry-core/api/jerry-snapshot.c b/jerry-core/api/jerry-snapshot.c
index 33760b299f..b0dcba2d6f 100644
--- a/jerry-core/api/jerry-snapshot.c
+++ b/jerry-core/api/jerry-snapshot.c
@@ -191,22 +191,19 @@ snapshot_add_compiled_code (const ecma_compiled_code_t *compiled_code_p, /**< co
lit_utf8_size_t pattern_size = 0;
- ECMA_STRING_TO_UTF8_STRING (pattern_string_p, buffer_p, buffer_size);
+ ECMA_STRING_TO_UTF8_STRING (pattern_string_p, buffer);
- pattern_size = buffer_size;
+ pattern_size = buffer.size;
if (!snapshot_write_to_buffer_by_offset (snapshot_buffer_p,
snapshot_buffer_size,
&globals_p->snapshot_buffer_write_offset,
- buffer_p,
- buffer_size))
+ buffer.ptr,
+ buffer.size))
{
globals_p->snapshot_error = jerry_throw_sz (JERRY_ERROR_RANGE, error_buffer_too_small_p);
- /* cannot return inside ECMA_FINALIZE_UTF8_STRING */
}
- ECMA_FINALIZE_UTF8_STRING (buffer_p, buffer_size);
-
if (!ecma_is_value_empty (globals_p->snapshot_error))
{
return 0;
@@ -1484,15 +1481,13 @@ jerry_append_ecma_string_to_buffer (uint8_t *buffer_p, /**< buffer */
uint8_t *buffer_end_p, /**< the end of the buffer */
ecma_string_t *string_p) /**< ecma-string */
{
- ECMA_STRING_TO_UTF8_STRING (string_p, str_buffer_p, str_buffer_size);
+ ECMA_STRING_TO_UTF8_STRING (string_p, str_buffer);
/* Append the string to the buffer. */
uint8_t *new_buffer_p = jerry_append_chars_to_buffer (buffer_p,
buffer_end_p,
- (const jerry_char_t *) str_buffer_p,
- (jerry_size_t) str_buffer_size);
-
- ECMA_FINALIZE_UTF8_STRING (str_buffer_p, str_buffer_size);
+ (const jerry_char_t *) str_buffer.ptr,
+ (jerry_size_t) str_buffer.size);
return new_buffer_p;
} /* jerry_append_ecma_string_to_buffer */
@@ -1507,11 +1502,13 @@ jerry_append_number_to_buffer (uint8_t *buffer_p, /**< buffer */
uint8_t *buffer_end_p, /**< the end of the buffer */
lit_utf8_size_t number) /**< number */
{
- lit_utf8_byte_t uint32_to_str_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
+ lit_utf8_byte_t uint32_to_str_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];
lit_utf8_size_t utf8_str_size =
- ecma_uint32_to_utf8_string (number, uint32_to_str_buffer, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+ ecma_uint32_to_utf8_string (number,
+ uint32_to_str_buffer,
+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
- JERRY_ASSERT (utf8_str_size <= ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+ JERRY_ASSERT (utf8_str_size < ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
return jerry_append_chars_to_buffer (buffer_p,
buffer_end_p,
@@ -1623,10 +1620,10 @@ jerry_get_literals_from_snapshot (const uint32_t *snapshot_p, /**< input snapsho
for (lit_utf8_size_t i = 0; i < literal_count; i++)
{
lit_buf_p = jerry_append_chars_to_buffer (lit_buf_p, buffer_end_p, JERRY_ZSTR_ARG (" \""));
- ECMA_STRING_TO_UTF8_STRING (literal_array[i], str_buffer_p, str_buffer_size);
- for (lit_utf8_size_t j = 0; j < str_buffer_size; j++)
+ ECMA_STRING_TO_UTF8_STRING (literal_array[i], str_buffer);
+ for (lit_utf8_size_t j = 0; j < str_buffer.size; j++)
{
- uint8_t byte = str_buffer_p[j];
+ uint8_t byte = str_buffer.ptr[j];
if (byte < 32 || byte > 127)
{
lit_buf_p = jerry_append_chars_to_buffer (lit_buf_p, buffer_end_p, JERRY_ZSTR_ARG ("\\x"));
@@ -1645,7 +1642,6 @@ jerry_get_literals_from_snapshot (const uint32_t *snapshot_p, /**< input snapsho
}
}
- ECMA_FINALIZE_UTF8_STRING (str_buffer_p, str_buffer_size);
lit_buf_p = jerry_append_chars_to_buffer (lit_buf_p, buffer_end_p, JERRY_ZSTR_ARG ("\""));
if (i < literal_count - 1)
diff --git a/jerry-core/api/jerryscript.c b/jerry-core/api/jerryscript.c
index d8174b92c0..56663e0eaa 100644
--- a/jerry-core/api/jerryscript.c
+++ b/jerry-core/api/jerryscript.c
@@ -384,14 +384,11 @@ jerry_parse_common (void *source_p, /**< script source */
if ((JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED) && options_p != NULL
&& (options_p->options & JERRY_PARSE_HAS_SOURCE_NAME) && ecma_is_value_string (options_p->source_name))
{
- ECMA_STRING_TO_UTF8_STRING (ecma_get_string_from_value (options_p->source_name),
- source_name_start_p,
- source_name_size);
+ ECMA_STRING_TO_UTF8_STRING (ecma_get_string_from_value (options_p->source_name), source_name_start);
jerry_debugger_send_string (JERRY_DEBUGGER_SOURCE_CODE_NAME,
JERRY_DEBUGGER_NO_SUBTYPE,
- source_name_start_p,
- source_name_size);
- ECMA_FINALIZE_UTF8_STRING (source_name_start_p, source_name_size);
+ source_name_start.ptr,
+ source_name_start.size);
}
#endif /* JERRY_DEBUGGER */
@@ -891,12 +888,12 @@ jerry_native_module (jerry_native_module_evaluate_cb_t callback, /**< evaluation
bool valid_identifier = false;
- ECMA_STRING_TO_UTF8_STRING (name_str_p, name_start_p, name_size);
+ ECMA_STRING_TO_UTF8_STRING (name_str_p, name_start);
- if (name_size > 0)
+ if (name_start.size > 0)
{
- const lit_utf8_byte_t *name_p = name_start_p;
- const lit_utf8_byte_t *name_end_p = name_start_p + name_size;
+ const lit_utf8_byte_t *name_p = name_start.ptr;
+ const lit_utf8_byte_t *name_end_p = name_start.ptr + name_start.size;
lit_code_point_t code_point;
lit_utf8_size_t size = lit_read_code_point_from_cesu8 (name_p, name_end_p, &code_point);
@@ -922,8 +919,6 @@ jerry_native_module (jerry_native_module_evaluate_cb_t callback, /**< evaluation
}
}
- ECMA_FINALIZE_UTF8_STRING (name_start_p, name_size);
-
if (!valid_identifier)
{
ecma_deref_object (scope_p);
@@ -3001,10 +2996,10 @@ jerry_string_iterate (const jerry_value_t value,
}
ecma_string_t *str_p = ecma_get_string_from_value (value);
- ECMA_STRING_TO_UTF8_STRING (str_p, buffer_p, buffer_size);
+ ECMA_STRING_TO_UTF8_STRING (str_p, buffer);
- const lit_utf8_byte_t *current_p = buffer_p;
- const lit_utf8_byte_t *end_p = buffer_p + buffer_size;
+ const lit_utf8_byte_t *current_p = buffer.ptr;
+ const lit_utf8_byte_t *end_p = buffer.ptr + buffer.size;
switch (encoding)
{
@@ -3048,7 +3043,6 @@ jerry_string_iterate (const jerry_value_t value,
break;
}
}
- ECMA_FINALIZE_UTF8_STRING (buffer_p, buffer_size);
} /* jerry_string_iterate */
/**
diff --git a/jerry-core/debugger/debugger.c b/jerry-core/debugger/debugger.c
index 2d77f88328..e35fc2fbbf 100644
--- a/jerry-core/debugger/debugger.c
+++ b/jerry-core/debugger/debugger.c
@@ -335,7 +335,7 @@ jerry_debugger_copy_variables_to_string_message (uint8_t variable_type, /**< typ
const size_t max_byte_count = JERRY_DEBUGGER_SEND_MAX (uint8_t);
const size_t max_message_size = JERRY_DEBUGGER_SEND_SIZE (max_byte_count, uint8_t);
- ECMA_STRING_TO_UTF8_STRING (value_str, str_buff, str_buff_size);
+ ECMA_STRING_TO_UTF8_STRING (value_str, str_buff);
size_t str_size = 0;
size_t str_limit = 255;
@@ -373,7 +373,7 @@ jerry_debugger_copy_variables_to_string_message (uint8_t variable_type, /**< typ
}
else
{
- str_size = (str_buff_size > str_limit) ? str_limit : str_buff_size;
+ str_size = (str_buff.size > str_limit) ? str_limit : str_buff.size;
}
message_string_p->string[*buffer_pos] = (uint8_t) str_size;
@@ -384,7 +384,7 @@ jerry_debugger_copy_variables_to_string_message (uint8_t variable_type, /**< typ
if (result)
{
size_t free_bytes = max_byte_count - *buffer_pos;
- const uint8_t *string_p = str_buff;
+ const uint8_t *string_p = str_buff.ptr;
while (str_size > free_bytes)
{
@@ -409,8 +409,6 @@ jerry_debugger_copy_variables_to_string_message (uint8_t variable_type, /**< typ
}
}
- ECMA_FINALIZE_UTF8_STRING (str_buff, str_buff_size);
-
return result;
} /* jerry_debugger_copy_variables_to_string_message */
@@ -614,9 +612,8 @@ jerry_debugger_send_eval (const lit_utf8_byte_t *eval_string_p, /**< evaluated s
ecma_string_t *string_p = ecma_get_string_from_value (message);
- ECMA_STRING_TO_UTF8_STRING (string_p, buffer_p, buffer_size);
- jerry_debugger_send_string (JERRY_DEBUGGER_EVAL_RESULT, type, buffer_p, buffer_size);
- ECMA_FINALIZE_UTF8_STRING (buffer_p, buffer_size);
+ ECMA_STRING_TO_UTF8_STRING (string_p, buffer);
+ jerry_debugger_send_string (JERRY_DEBUGGER_EVAL_RESULT, type, buffer.ptr, buffer.size);
ecma_free_value (message);
@@ -1525,12 +1522,9 @@ jerry_debugger_send_exception_string (ecma_value_t exception_value)
string_p = ecma_op_to_string (exception_value);
}
- ECMA_STRING_TO_UTF8_STRING (string_p, string_data_p, string_size);
-
- bool result =
- jerry_debugger_send_string (JERRY_DEBUGGER_EXCEPTION_STR, JERRY_DEBUGGER_NO_SUBTYPE, string_data_p, string_size);
+ ECMA_STRING_TO_UTF8_STRING (string_p, str);
- ECMA_FINALIZE_UTF8_STRING (string_data_p, string_size);
+ bool result = jerry_debugger_send_string (JERRY_DEBUGGER_EXCEPTION_STR, JERRY_DEBUGGER_NO_SUBTYPE, str.ptr, str.size);
ecma_deref_ecma_string (string_p);
return result;
diff --git a/jerry-core/ecma/base/ecma-globals.h b/jerry-core/ecma/base/ecma-globals.h
index 75c70e196b..6f0b1791de 100644
--- a/jerry-core/ecma/base/ecma-globals.h
+++ b/jerry-core/ecma/base/ecma-globals.h
@@ -1379,6 +1379,12 @@ typedef float ecma_number_t;
*/
#define ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32 10
+/**
+ * Maximum number of characters in string representation of ecma-uint32 plus one.
+ * That is the '\0' terminator
+ */
+#define ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED (ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32 + 1)
+
/**
* String is not a valid array index.
*/
diff --git a/jerry-core/ecma/base/ecma-helpers-conversion.c b/jerry-core/ecma/base/ecma-helpers-conversion.c
index cae04a1dbd..055e63eaad 100644
--- a/jerry-core/ecma/base/ecma-helpers-conversion.c
+++ b/jerry-core/ecma/base/ecma-helpers-conversion.c
@@ -662,7 +662,8 @@ 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;
+ lit_utf8_byte_t *buf_p_tail = out_buffer_p + buffer_size - 1;
+ lit_utf8_byte_t *buf_p = buf_p_tail;
do
{
@@ -675,12 +676,13 @@ ecma_uint32_to_utf8_string (uint32_t value, /**< value to convert */
JERRY_ASSERT (buf_p >= out_buffer_p);
- lit_utf8_size_t bytes_copied = (lit_utf8_size_t) (out_buffer_p + buffer_size - buf_p);
+ lit_utf8_size_t bytes_copied = (lit_utf8_size_t) (buf_p_tail - buf_p);
if (JERRY_LIKELY (buf_p != out_buffer_p))
{
memmove (out_buffer_p, buf_p, bytes_copied);
}
+ buf_p[bytes_copied] = '\0';
return bytes_copied;
} /* ecma_uint32_to_utf8_string */
@@ -868,7 +870,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */
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);
+ JERRY_ASSERT (dst_p < buffer_p + buffer_size);
return (lit_utf8_size_t) (dst_p - buffer_p);
}
@@ -935,7 +937,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */
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);
+ JERRY_ASSERT (dst_p < buffer_p + buffer_size);
return (lit_utf8_size_t) (dst_p - buffer_p);
} /* ecma_number_to_utf8_string */
diff --git a/jerry-core/ecma/base/ecma-helpers-string.c b/jerry-core/ecma/base/ecma-helpers-string.c
index 2f88abab7a..ddac6c1d4e 100644
--- a/jerry-core/ecma/base/ecma-helpers-string.c
+++ b/jerry-core/ecma/base/ecma-helpers-string.c
@@ -723,29 +723,22 @@ ecma_append_chars_to_string (ecma_string_t *string1_p, /**< base ecma-string */
return ecma_new_ecma_string_from_utf8 (cesu8_string2_p, cesu8_string2_size);
}
- lit_utf8_size_t cesu8_string1_size;
- lit_utf8_size_t cesu8_string1_length;
- uint8_t flags = ECMA_STRING_FLAG_IS_ASCII;
- lit_utf8_byte_t uint32_to_string_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
+ ECMA_STRING_TO_UTF8_STRING_AND_LENGTH (string1_p, cesu8_string1);
- const lit_utf8_byte_t *cesu8_string1_p =
- ecma_string_get_chars (string1_p, &cesu8_string1_size, &cesu8_string1_length, uint32_to_string_buffer, &flags);
-
- JERRY_ASSERT (!(flags & ECMA_STRING_FLAG_MUST_BE_FREED));
JERRY_ASSERT (cesu8_string1_length > 0);
- JERRY_ASSERT (cesu8_string1_length <= cesu8_string1_size);
+ JERRY_ASSERT (cesu8_string1_length <= cesu8_string1.size);
- lit_utf8_size_t new_size = cesu8_string1_size + cesu8_string2_size;
+ lit_utf8_size_t new_size = cesu8_string1.size + cesu8_string2_size;
/* Poor man's carry flag check: it is impossible to allocate this large string. */
- if (new_size < (cesu8_string1_size | cesu8_string2_size))
+ if (new_size < (cesu8_string1.size | cesu8_string2_size))
{
jerry_fatal (JERRY_FATAL_OUT_OF_MEMORY);
}
lit_magic_string_id_t magic_string_id;
magic_string_id =
- lit_is_utf8_string_pair_magic (cesu8_string1_p, cesu8_string1_size, cesu8_string2_p, cesu8_string2_size);
+ lit_is_utf8_string_pair_magic (cesu8_string1.ptr, cesu8_string1.size, cesu8_string2_p, cesu8_string2_size);
if (magic_string_id != LIT_MAGIC_STRING__COUNT)
{
@@ -753,13 +746,14 @@ ecma_append_chars_to_string (ecma_string_t *string1_p, /**< base ecma-string */
return ecma_get_magic_string (magic_string_id);
}
- if ((flags & ECMA_STRING_FLAG_IS_UINT32) && new_size <= ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32)
+ if ((cesu8_string1_flags & ECMA_STRING_FLAG_IS_UINT32)
+ && new_size < ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED)
{
- memcpy (uint32_to_string_buffer + cesu8_string1_size, cesu8_string2_p, cesu8_string2_size);
+ memcpy (cesu8_string1_uint32_buffer + cesu8_string1.size, cesu8_string2_p, cesu8_string2_size);
uint32_t array_index;
- if (ecma_string_to_array_index (uint32_to_string_buffer, new_size, &array_index))
+ if (ecma_string_to_array_index (cesu8_string1_uint32_buffer, new_size, &array_index))
{
ecma_deref_ecma_string (string1_p);
return ecma_new_ecma_string_from_uint32 (array_index);
@@ -770,7 +764,7 @@ ecma_append_chars_to_string (ecma_string_t *string1_p, /**< base ecma-string */
{
lit_magic_string_ex_id_t magic_string_ex_id;
magic_string_ex_id =
- lit_is_ex_utf8_string_pair_magic (cesu8_string1_p, cesu8_string1_size, cesu8_string2_p, cesu8_string2_size);
+ lit_is_ex_utf8_string_pair_magic (cesu8_string1.ptr, cesu8_string1.size, cesu8_string2_p, cesu8_string2_size);
if (magic_string_ex_id < lit_get_magic_string_ex_count ())
{
@@ -785,9 +779,9 @@ ecma_append_chars_to_string (ecma_string_t *string1_p, /**< base ecma-string */
lit_string_hash_t hash_start;
- if (JERRY_UNLIKELY (flags & ECMA_STRING_FLAG_REHASH_NEEDED))
+ if (JERRY_UNLIKELY (cesu8_string1_flags & ECMA_STRING_FLAG_REHASH_NEEDED))
{
- hash_start = lit_utf8_string_calc_hash (cesu8_string1_p, cesu8_string1_size);
+ hash_start = lit_utf8_string_calc_hash (cesu8_string1.ptr, cesu8_string1.size);
}
else
{
@@ -797,8 +791,8 @@ ecma_append_chars_to_string (ecma_string_t *string1_p, /**< base ecma-string */
string_desc_p->u.hash = lit_utf8_string_hash_combine (hash_start, cesu8_string2_p, cesu8_string2_size);
- memcpy (data_p, cesu8_string1_p, cesu8_string1_size);
- memcpy (data_p + cesu8_string1_size, cesu8_string2_p, cesu8_string2_size);
+ memcpy (data_p, cesu8_string1.ptr, cesu8_string1.size);
+ memcpy (data_p + cesu8_string1.size, cesu8_string2_p, cesu8_string2_size);
ecma_deref_ecma_string (string1_p);
return (ecma_string_t *) string_desc_p;
@@ -829,20 +823,11 @@ ecma_concat_ecma_strings (ecma_string_t *string1_p, /**< first ecma-string */
return string1_p;
}
- lit_utf8_size_t cesu8_string2_size;
- lit_utf8_size_t cesu8_string2_length;
- lit_utf8_byte_t uint32_to_string_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
- uint8_t flags = ECMA_STRING_FLAG_IS_ASCII;
-
- const lit_utf8_byte_t *cesu8_string2_p =
- ecma_string_get_chars (string2_p, &cesu8_string2_size, &cesu8_string2_length, uint32_to_string_buffer, &flags);
-
- JERRY_ASSERT (cesu8_string2_p != NULL);
+ ECMA_STRING_TO_UTF8_STRING_AND_LENGTH (string2_p, cesu8_string2);
+ JERRY_ASSERT (cesu8_string2.ptr != NULL);
ecma_string_t *result_p =
- ecma_append_chars_to_string (string1_p, cesu8_string2_p, cesu8_string2_size, cesu8_string2_length);
-
- JERRY_ASSERT (!(flags & ECMA_STRING_FLAG_MUST_BE_FREED));
+ ecma_append_chars_to_string (string1_p, cesu8_string2.ptr, cesu8_string2.size, cesu8_string2_length);
return result_p;
} /* ecma_concat_ecma_strings */
@@ -1077,8 +1062,9 @@ ecma_uint32_to_buffer (uint32_t num, /**< number */
lit_utf8_byte_t *buffer_p /**< destination buffer */,
lit_utf8_size_t buffer_size /**< buffer size */)
{
- lit_utf8_byte_t digits[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
- lit_utf8_size_t digit_count = ecma_uint32_to_utf8_string (num, digits, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+ lit_utf8_byte_t digits[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];
+ lit_utf8_size_t digit_count =
+ ecma_uint32_to_utf8_string (num, digits, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
digit_count = JERRY_MIN (buffer_size, digit_count);
memcpy (buffer_p, digits, digit_count);
@@ -1186,7 +1172,7 @@ ecma_string_to_cesu8_bytes (const ecma_string_t *string_desc_p, /**< ecma-string
*
* @return size in bytes
*/
-static inline lit_utf8_size_t JERRY_ATTR_ALWAYS_INLINE
+extern inline lit_utf8_size_t JERRY_ATTR_ALWAYS_INLINE
ecma_string_get_uint32_size (const uint32_t uint32_number) /**< number in the string-descriptor */
{
uint32_t prev_number = 1;
@@ -1224,13 +1210,11 @@ ecma_string_get_uint32_size (const uint32_t uint32_number) /**< number in the st
* - The ASCII check only happens if the flags parameter gets
* 'ECMA_STRING_FLAG_IS_ASCII' as an input.
*
- * @return start of cesu8 characters
+ * @return the length of the ecma string
*/
-const lit_utf8_byte_t *
+lit_utf8_size_t
ecma_string_get_chars (const ecma_string_t *string_p, /**< ecma-string */
- lit_utf8_size_t *size_p, /**< [out] size of the ecma string */
- lit_utf8_size_t *length_p, /**< [out] optional argument. If the pointer is not NULL the pointed
- * memory area is filled with the length of the ecma string */
+ lit_utf8_string_t *string_out_p, /**< [out] size of the ecma string */
lit_utf8_byte_t *uint32_buff_p, /**< [out] optional argument. If the pointer is not NULL the
* pointed memory area is filled with the string converted
* uint32 string descriptor */
@@ -1286,11 +1270,11 @@ ecma_string_get_chars (const ecma_string_t *string_p, /**< ecma-string */
}
else
{
- result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size);
+ result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size + 1);
*flags_p |= ECMA_STRING_FLAG_MUST_BE_FREED;
}
- length = ecma_uint32_to_utf8_string (uint32_number, (lit_utf8_byte_t *) result_p, size);
+ length = ecma_uint32_to_utf8_string (uint32_number, (lit_utf8_byte_t *) result_p, size + 1);
JERRY_ASSERT (length == size);
*flags_p |= ECMA_STRING_FLAG_IS_UINT32;
@@ -1337,11 +1321,11 @@ ecma_string_get_chars (const ecma_string_t *string_p, /**< ecma-string */
}
else
{
- result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size);
+ result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size + 1);
*flags_p |= ECMA_STRING_FLAG_MUST_BE_FREED;
}
- length = ecma_uint32_to_utf8_string (string_p->u.uint32_number, (lit_utf8_byte_t *) result_p, size);
+ length = ecma_uint32_to_utf8_string (string_p->u.uint32_number, (lit_utf8_byte_t *) result_p, size + 1);
JERRY_ASSERT (length == size);
*flags_p |= ECMA_STRING_FLAG_IS_UINT32 | ECMA_STRING_FLAG_REHASH_NEEDED;
@@ -1366,19 +1350,15 @@ ecma_string_get_chars (const ecma_string_t *string_p, /**< ecma-string */
}
}
}
-
- *size_p = size;
- if (length_p != NULL)
- {
- *length_p = length;
- }
+ string_out_p->ptr = result_p;
+ string_out_p->size = size;
if ((*flags_p & ECMA_STRING_FLAG_IS_ASCII) && length != size)
{
*flags_p = (uint8_t) (*flags_p & (uint8_t) ~ECMA_STRING_FLAG_IS_ASCII);
}
- return result_p;
+ return length;
} /* ecma_string_get_chars */
/**
@@ -1711,8 +1691,8 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
const lit_utf8_byte_t *utf8_string1_p, *utf8_string2_p;
lit_utf8_size_t utf8_string1_size, utf8_string2_size;
- lit_utf8_byte_t uint32_to_string_buffer1[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
- lit_utf8_byte_t uint32_to_string_buffer2[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
+ lit_utf8_byte_t uint32_to_string_buffer1[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];
+ lit_utf8_byte_t uint32_to_string_buffer2[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];
if (ECMA_IS_DIRECT_STRING (string1_p))
{
@@ -1724,7 +1704,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
{
utf8_string1_size = ecma_uint32_to_utf8_string ((uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string1_p),
uint32_to_string_buffer1,
- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
utf8_string1_p = uint32_to_string_buffer1;
}
}
@@ -1740,7 +1720,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
{
utf8_string1_size = ecma_uint32_to_utf8_string (string1_p->u.uint32_number,
uint32_to_string_buffer1,
- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
utf8_string1_p = uint32_to_string_buffer1;
}
}
@@ -1755,7 +1735,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
{
utf8_string2_size = ecma_uint32_to_utf8_string ((uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string2_p),
uint32_to_string_buffer2,
- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
utf8_string2_p = uint32_to_string_buffer2;
}
}
@@ -1771,7 +1751,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
{
utf8_string2_size = ecma_uint32_to_utf8_string (string2_p->u.uint32_number,
uint32_to_string_buffer2,
- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
utf8_string2_p = uint32_to_string_buffer2;
}
}
@@ -2056,7 +2036,7 @@ ecma_string_get_char_at_pos (const ecma_string_t *string_p, /**< ecma-string */
{
JERRY_ASSERT (index < ecma_string_get_length (string_p));
- lit_utf8_byte_t uint32_to_string_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
+ lit_utf8_byte_t uint32_to_string_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];
if (ECMA_IS_DIRECT_STRING (string_p))
{
@@ -2081,7 +2061,9 @@ ecma_string_get_char_at_pos (const ecma_string_t *string_p, /**< ecma-string */
JERRY_ASSERT (ECMA_GET_DIRECT_STRING_TYPE (string_p) == ECMA_DIRECT_STRING_UINT);
uint32_t uint32_number = (uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string_p);
- ecma_uint32_to_utf8_string (uint32_number, uint32_to_string_buffer, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+ ecma_uint32_to_utf8_string (uint32_number,
+ uint32_to_string_buffer,
+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
return (ecma_char_t) uint32_to_string_buffer[index];
}
@@ -2127,7 +2109,7 @@ ecma_string_get_char_at_pos (const ecma_string_t *string_p, /**< ecma-string */
{
ecma_uint32_to_utf8_string (string_p->u.uint32_number,
uint32_to_string_buffer,
- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
return (ecma_char_t) uint32_to_string_buffer[index];
}
@@ -2200,9 +2182,10 @@ ecma_string_substr (const ecma_string_t *string_p, /**< pointer to an ecma strin
ecma_string_t *ecma_string_p = NULL;
end_pos -= start_pos;
- ECMA_STRING_TO_UTF8_STRING (string_p, start_p, buffer_size);
+ ECMA_STRING_TO_UTF8_STRING (string_p, string_start);
+ const lit_utf8_byte_t *start_p = string_start.ptr;
- if (string_length == buffer_size)
+ if (string_length == string_start.size)
{
ecma_string_p = ecma_new_ecma_string_from_utf8 (start_p + start_pos, (lit_utf8_size_t) end_pos);
}
@@ -2222,8 +2205,6 @@ ecma_string_substr (const ecma_string_t *string_p, /**< pointer to an ecma strin
ecma_string_p = ecma_new_ecma_string_from_utf8 (start_p, (lit_utf8_size_t) (end_p - start_p));
}
- ECMA_FINALIZE_UTF8_STRING (start_p, buffer_size);
-
return ecma_string_p;
} /* ecma_string_substr */
@@ -2318,12 +2299,11 @@ ecma_string_trim (const ecma_string_t *string_p) /**< pointer to an ecma string
{
ecma_string_t *ret_string_p;
- lit_utf8_size_t utf8_str_size;
- uint8_t flags = ECMA_STRING_FLAG_IS_ASCII;
- const lit_utf8_byte_t *utf8_str_p = ecma_string_get_chars (string_p, &utf8_str_size, NULL, NULL, &flags);
-
- if (utf8_str_size > 0)
+ ECMA_STRING_TO_UTF8_STRING (string_p, utf8_str);
+ if (utf8_str.size > 0)
{
+ const lit_utf8_byte_t *utf8_str_p = utf8_str.ptr;
+ lit_utf8_size_t utf8_str_size = utf8_str.size;
ecma_string_trim_helper (&utf8_str_p, &utf8_str_size);
ret_string_p = ecma_new_ecma_string_from_utf8 (utf8_str_p, utf8_str_size);
}
@@ -2332,11 +2312,6 @@ 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);
}
- if (flags & ECMA_STRING_FLAG_MUST_BE_FREED)
- {
- jmem_heap_free_block ((void *) utf8_str_p, utf8_str_size);
- }
-
return ret_string_p;
} /* ecma_string_trim */
@@ -2410,8 +2385,8 @@ ecma_string_pad (ecma_value_t original_string_p, /**< Input ecma string */
uint32_t remaining = fill_len - (prepend_count * filler_length);
- ECMA_STRING_TO_UTF8_STRING (filler_p, start_p, utf8_str_size);
- const lit_utf8_byte_t *temp_start_p = start_p;
+ ECMA_STRING_TO_UTF8_STRING (filler_p, start);
+ const lit_utf8_byte_t *temp_start_p = start.ptr;
while (remaining > 0)
{
ecma_char_t ch;
@@ -2420,7 +2395,6 @@ ecma_string_pad (ecma_value_t original_string_p, /**< Input ecma string */
temp_start_p += read_size;
remaining--;
}
- ECMA_FINALIZE_UTF8_STRING (start_p, utf8_str_size);
ecma_deref_ecma_string (filler_p);
/* 11 - 12 */
diff --git a/jerry-core/ecma/base/ecma-helpers.h b/jerry-core/ecma/base/ecma-helpers.h
index 0e98ea243b..b4cbdc2d46 100644
--- a/jerry-core/ecma/base/ecma-helpers.h
+++ b/jerry-core/ecma/base/ecma-helpers.h
@@ -104,24 +104,35 @@ typedef enum
/**
* Convert ecma-string's contents to a cesu-8 string and put it into a buffer.
+ * No allocation needed by providing a uint32 string buffer.
+ * The flags name is `utf8_str##_flags`
+ * The uint32 string buffer name is `utf8_str##_uint32_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);
+#define ECMA_STRING_TO_UTF8_STRING(ecma_str_ptr, /**< ecma string pointer */ \
+ utf8_str) /**< [out] lit_utf8_string_t to get */ \
+ lit_utf8_string_t utf8_str; \
+ uint8_t utf8_str##_flags = ECMA_STRING_FLAG_EMPTY; \
+ lit_utf8_byte_t utf8_str##_uint32_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED]; \
+ (void) ecma_string_get_chars (ecma_str_ptr, &utf8_str, utf8_str##_uint32_buffer, &utf8_str##_flags); \
+ JERRY_ASSERT (!(utf8_str##_flags & ECMA_STRING_FLAG_MUST_BE_FREED));
/**
- * Free the cesu-8 string buffer allocated by 'ECMA_STRING_TO_UTF8_STRING'
+ * Convert ecma-string's contents to a cesu-8 string and put it into a buffer.
+ * No allocation needed by providing a uint32 string buffer
+ * The flags name is `utf8_str##_flags`
+ * The uint32 string buffer name is `utf8_str##_uint32_buffer`
+ * The string length name is `utf8_str##_length`
+ *
*/
-#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); \
- }
+#define ECMA_STRING_TO_UTF8_STRING_AND_LENGTH(ecma_str_ptr, /**< ecma string pointer */ \
+ utf8_str) /**< [out] lit_utf8_string_t to get */ \
+ lit_utf8_string_t utf8_str; \
+ uint8_t utf8_str##_flags = ECMA_STRING_FLAG_IS_ASCII; \
+ lit_utf8_byte_t utf8_str##_uint32_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED]; \
+ lit_utf8_size_t utf8_str##_length = \
+ ecma_string_get_chars (ecma_str_ptr, &utf8_str, utf8_str##_uint32_buffer, &utf8_str##_flags); \
+ JERRY_ASSERT (!(utf8_str##_flags & ECMA_STRING_FLAG_MUST_BE_FREED));
#ifdef ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY
@@ -314,11 +325,10 @@ lit_utf8_size_t JERRY_ATTR_WARN_UNUSED_RESULT ecma_string_copy_to_buffer (const
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);
+lit_utf8_size_t ecma_string_get_chars (const ecma_string_t *string_p,
+ lit_utf8_string_t *string_out_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);
@@ -508,6 +518,7 @@ 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_string_get_uint32_size (const uint32_t uint32_number);
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);
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-date.c b/jerry-core/ecma/builtin-objects/ecma-builtin-date.c
index 201634d93a..4d84a969ba 100644
--- a/jerry-core/ecma/builtin-objects/ecma-builtin-date.c
+++ b/jerry-core/ecma/builtin-objects/ecma-builtin-date.c
@@ -638,9 +638,9 @@ ecma_builtin_date_parse_toString_formats (const lit_utf8_byte_t *date_str_curr_p
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;
+ ECMA_STRING_TO_UTF8_STRING (string_p, str);
+ const lit_utf8_byte_t *date_str_curr_p = str.ptr;
+ const lit_utf8_byte_t *date_str_end_p = str.ptr + 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);
@@ -651,8 +651,6 @@ ecma_builtin_date_parse (ecma_string_t *string_p) /**< string */
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 */
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.c b/jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.c
index e7f0b1f9a4..19fb95527c 100644
--- a/jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.c
+++ b/jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.c
@@ -136,9 +136,8 @@ ecma_builtin_function_prototype_object_to_string (ecma_object_t *func_obj_p) /**
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);
+ ECMA_STRING_TO_UTF8_STRING (ecma_get_string_from_value (source_code), source);
+ result_string_p = ecma_new_ecma_string_from_utf8 (source.ptr + range_start, range_size);
return ecma_make_string_value (result_string_p);
}
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-global.c b/jerry-core/ecma/builtin-objects/ecma-builtin-global.c
index d9ccc8ff68..428324e22d 100644
--- a/jerry-core/ecma/builtin-objects/ecma-builtin-global.c
+++ b/jerry-core/ecma/builtin-objects/ecma-builtin-global.c
@@ -626,19 +626,18 @@ ecma_builtin_global_dispatch_routine (uint8_t builtin_routine_id, /**< built-in
if (builtin_routine_id <= ECMA_GLOBAL_PARSE_FLOAT)
{
- ECMA_STRING_TO_UTF8_STRING (str_p, string_buff, string_buff_size);
+ ECMA_STRING_TO_UTF8_STRING (str_p, string_buff);
if (builtin_routine_id == ECMA_GLOBAL_PARSE_INT)
{
- ret_value = ecma_number_parse_int (string_buff, string_buff_size, arguments_list_p[1]);
+ ret_value = ecma_number_parse_int (string_buff.ptr, string_buff.size, arguments_list_p[1]);
}
else
{
JERRY_ASSERT (builtin_routine_id == ECMA_GLOBAL_PARSE_FLOAT);
- ret_value = ecma_number_parse_float (string_buff, string_buff_size);
+ ret_value = ecma_number_parse_float (string_buff.ptr, string_buff.size);
}
- ECMA_FINALIZE_UTF8_STRING (string_buff, string_buff_size);
ecma_deref_ecma_string (str_p);
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 e298fad4ac..4d7692f6e3 100644
--- a/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c
+++ b/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c
@@ -479,14 +479,14 @@ ecma_builtin_helper_string_find_last_index (ecma_string_t *original_str_p, /**<
uint32_t original_length = ecma_string_get_length (original_str_p);
- ECMA_STRING_TO_UTF8_STRING (search_str_p, search_str_utf8_p, search_str_size);
- ECMA_STRING_TO_UTF8_STRING (original_str_p, original_str_utf8_p, original_str_size);
+ ECMA_STRING_TO_UTF8_STRING (search_str_p, search_str_utf8);
+ ECMA_STRING_TO_UTF8_STRING (original_str_p, original_str_utf8);
uint32_t ret_value = UINT32_MAX;
- if (original_str_size >= search_str_size)
+ if (original_str_utf8.size >= search_str_utf8.size)
{
- const lit_utf8_byte_t *end_p = original_str_utf8_p + original_str_size;
+ const lit_utf8_byte_t *end_p = original_str_utf8.ptr + original_str_utf8.size;
const lit_utf8_byte_t *current_p = end_p;
for (ecma_number_t i = original_length; i > position; i--)
@@ -494,7 +494,7 @@ ecma_builtin_helper_string_find_last_index (ecma_string_t *original_str_p, /**<
lit_utf8_decr (¤t_p);
}
- while (current_p + search_str_size > end_p)
+ while (current_p + search_str_utf8.size > end_p)
{
lit_utf8_decr (¤t_p);
position--;
@@ -502,7 +502,7 @@ ecma_builtin_helper_string_find_last_index (ecma_string_t *original_str_p, /**<
while (true)
{
- if (memcmp (current_p, search_str_utf8_p, search_str_size) == 0)
+ if (memcmp (current_p, search_str_utf8.ptr, search_str_utf8.size) == 0)
{
ret_value = position;
break;
@@ -517,8 +517,6 @@ ecma_builtin_helper_string_find_last_index (ecma_string_t *original_str_p, /**<
position--;
}
}
- ECMA_FINALIZE_UTF8_STRING (original_str_utf8_p, original_str_size);
- ECMA_FINALIZE_UTF8_STRING (search_str_utf8_p, search_str_size);
return ret_value;
} /* ecma_builtin_helper_string_find_last_index */
@@ -717,21 +715,21 @@ ecma_builtin_helper_string_find_index (ecma_string_t *original_str_p, /**< index
return start_pos;
}
- ECMA_STRING_TO_UTF8_STRING (search_str_p, search_str_utf8_p, search_str_size);
- ECMA_STRING_TO_UTF8_STRING (original_str_p, original_str_utf8_p, original_str_size);
+ ECMA_STRING_TO_UTF8_STRING (search_str_p, search_str_utf8);
+ ECMA_STRING_TO_UTF8_STRING (original_str_p, original_str_utf8);
- const lit_utf8_byte_t *str_current_p = original_str_utf8_p;
+ const lit_utf8_byte_t *str_current_p = original_str_utf8.ptr;
- for (ecma_number_t i = 0; i < start_pos; i++)
+ for (uint32_t i = 0; i < start_pos; i++)
{
lit_utf8_incr (&str_current_p);
}
- const lit_utf8_byte_t *original_end_p = original_str_utf8_p + original_str_size;
+ const lit_utf8_byte_t *original_end_p = original_str_utf8.ptr + original_str_utf8.size;
- while (!((size_t) (original_end_p - str_current_p) < search_str_size))
+ while (!((size_t) (original_end_p - str_current_p) < search_str_utf8.size))
{
- if (memcmp (str_current_p, search_str_utf8_p, search_str_size) == 0)
+ if (memcmp (str_current_p, search_str_utf8.ptr, search_str_utf8.size) == 0)
{
match_found = start_pos;
break;
@@ -741,9 +739,6 @@ ecma_builtin_helper_string_find_index (ecma_string_t *original_str_p, /**< index
start_pos++;
}
- ECMA_FINALIZE_UTF8_STRING (original_str_utf8_p, original_str_size);
- ECMA_FINALIZE_UTF8_STRING (search_str_utf8_p, search_str_size);
-
return match_found;
} /* ecma_builtin_helper_string_find_index */
@@ -865,14 +860,11 @@ ecma_builtin_replace_substitute (ecma_replace_context_t *ctx_p) /**< replace con
JERRY_ASSERT (ctx_p->matched_p == NULL
|| (ctx_p->matched_p >= ctx_p->string_p && ctx_p->matched_p <= ctx_p->string_p + ctx_p->string_size));
- lit_utf8_size_t replace_size;
- uint8_t replace_flags = ECMA_STRING_FLAG_IS_ASCII;
- const lit_utf8_byte_t *replace_buf_p =
- ecma_string_get_chars (ctx_p->replace_str_p, &replace_size, NULL, NULL, &replace_flags);
+ ECMA_STRING_TO_UTF8_STRING (ctx_p->replace_str_p, replace);
- const lit_utf8_byte_t *const replace_end_p = replace_buf_p + replace_size;
- const lit_utf8_byte_t *curr_p = replace_buf_p;
- const lit_utf8_byte_t *last_inserted_end_p = replace_buf_p;
+ const lit_utf8_byte_t *const replace_end_p = replace.ptr + replace.size;
+ const lit_utf8_byte_t *curr_p = replace.ptr;
+ const lit_utf8_byte_t *last_inserted_end_p = replace.ptr;
while (curr_p < replace_end_p)
{
@@ -1013,11 +1005,6 @@ ecma_builtin_replace_substitute (ecma_replace_context_t *ctx_p) /**< replace con
ecma_stringbuilder_append_raw (&(ctx_p->builder),
last_inserted_end_p,
(lit_utf8_size_t) (replace_end_p - last_inserted_end_p));
-
- if (replace_flags & ECMA_STRING_FLAG_MUST_BE_FREED)
- {
- jmem_heap_free_block ((void *) replace_buf_p, replace_size);
- }
} /* ecma_builtin_replace_substitute */
/**
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-intrinsic.c b/jerry-core/ecma/builtin-objects/ecma-builtin-intrinsic.c
index 66519dcdcd..9fc229b9b6 100644
--- a/jerry-core/ecma/builtin-objects/ecma-builtin-intrinsic.c
+++ b/jerry-core/ecma/builtin-objects/ecma-builtin-intrinsic.c
@@ -241,11 +241,11 @@ ecma_builtin_intrinsic_dispatch_routine (uint8_t builtin_routine_id, /**< built-
return ECMA_VALUE_ERROR;
}
- ECMA_STRING_TO_UTF8_STRING (to_str_p, start_p, input_start_size);
+ ECMA_STRING_TO_UTF8_STRING (to_str_p, start);
lit_utf8_size_t size;
- const lit_utf8_byte_t *input_start_p = start_p;
- const lit_utf8_byte_t *input_str_end_p = start_p + input_start_size;
+ const lit_utf8_byte_t *input_start_p = start.ptr;
+ const lit_utf8_byte_t *input_str_end_p = start.ptr + start.size;
ecma_string_t *ret_str_p;
if (builtin_routine_id == ECMA_INTRINSIC_STRING_TRIM_START)
@@ -261,7 +261,6 @@ ecma_builtin_intrinsic_dispatch_routine (uint8_t builtin_routine_id, /**< built-
ret_str_p = ecma_new_ecma_string_from_utf8 (input_start_p, size);
}
- ECMA_FINALIZE_UTF8_STRING (start_p, input_start_size);
ecma_value_t result = ecma_make_string_value (ret_str_p);
ecma_deref_ecma_string (to_str_p);
return result;
@@ -279,19 +278,18 @@ ecma_builtin_intrinsic_dispatch_routine (uint8_t builtin_routine_id, /**< built-
}
ecma_value_t result;
- ECMA_STRING_TO_UTF8_STRING (str_p, string_buff, string_buff_size);
+ ECMA_STRING_TO_UTF8_STRING (str_p, string_buff);
if (builtin_routine_id == ECMA_INTRINSIC_PARSE_INT)
{
- result = ecma_number_parse_int (string_buff, string_buff_size, arguments_list_p[1]);
+ result = ecma_number_parse_int (string_buff.ptr, string_buff.size, arguments_list_p[1]);
}
else
{
JERRY_ASSERT (builtin_routine_id == ECMA_INTRINSIC_PARSE_FLOAT);
- result = ecma_number_parse_float (string_buff, string_buff_size);
+ result = ecma_number_parse_float (string_buff.ptr, string_buff.size);
}
- ECMA_FINALIZE_UTF8_STRING (string_buff, string_buff_size);
ecma_deref_ecma_string (str_p);
return result;
}
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-json.c b/jerry-core/ecma/builtin-objects/ecma-builtin-json.c
index 11a6871b60..84e398774d 100644
--- a/jerry-core/ecma/builtin-objects/ecma-builtin-json.c
+++ b/jerry-core/ecma/builtin-objects/ecma-builtin-json.c
@@ -844,9 +844,8 @@ ecma_builtin_json_parse (ecma_value_t arg1, /**< string argument */
return ECMA_VALUE_ERROR;
}
- ECMA_STRING_TO_UTF8_STRING (text_string_p, str_start_p, string_size);
- ecma_value_t result = ecma_builtin_json_parse_buffer (str_start_p, string_size);
- ECMA_FINALIZE_UTF8_STRING (str_start_p, string_size);
+ ECMA_STRING_TO_UTF8_STRING (text_string_p, str_start);
+ ecma_value_t result = ecma_builtin_json_parse_buffer (str_start.ptr, str_start.size);
ecma_deref_ecma_string (text_string_p);
if (!ECMA_IS_VALUE_ERROR (result) && ecma_op_is_callable (arg2))
@@ -878,10 +877,10 @@ static void
ecma_builtin_json_quote (ecma_stringbuilder_t *builder_p, /**< builder for the result */
ecma_string_t *string_p) /**< string that should be quoted */
{
- ECMA_STRING_TO_UTF8_STRING (string_p, string_buff, string_buff_size);
- const lit_utf8_byte_t *str_p = string_buff;
- const lit_utf8_byte_t *regular_str_start_p = string_buff;
- const lit_utf8_byte_t *str_end_p = str_p + string_buff_size;
+ ECMA_STRING_TO_UTF8_STRING (string_p, string_buff);
+ const lit_utf8_byte_t *str_p = string_buff.ptr;
+ const lit_utf8_byte_t *regular_str_start_p = string_buff.ptr;
+ const lit_utf8_byte_t *str_end_p = string_buff.ptr + string_buff.size;
ecma_stringbuilder_append_byte (builder_p, LIT_CHAR_DOUBLE_QUOTE);
@@ -974,8 +973,6 @@ ecma_builtin_json_quote (ecma_stringbuilder_t *builder_p, /**< builder for the r
ecma_stringbuilder_append_raw (builder_p, regular_str_start_p, (lit_utf8_size_t) (str_end_p - regular_str_start_p));
ecma_stringbuilder_append_byte (builder_p, LIT_CHAR_DOUBLE_QUOTE);
-
- ECMA_FINALIZE_UTF8_STRING (string_buff, string_buff_size);
} /* ecma_builtin_json_quote */
static ecma_value_t ecma_builtin_json_serialize_property (ecma_json_stringify_context_t *context_p,
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.c b/jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.c
index 1d212f5f7c..be57acc120 100644
--- a/jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.c
+++ b/jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.c
@@ -525,7 +525,7 @@ ecma_builtin_number_prototype_object_to_number_convert (ecma_number_t this_num,
}
/* Append exponent part */
- lit_utf8_size_t exp_size = ecma_uint32_to_utf8_string ((uint32_t) exponent, digits, 3);
+ lit_utf8_size_t exp_size = ecma_uint32_to_utf8_string ((uint32_t) exponent, digits, 3 + 1);
ecma_stringbuilder_append_raw (&builder, digits, exp_size);
return ecma_make_string_value (ecma_stringbuilder_finalize (&builder));
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-regexp-prototype.c b/jerry-core/ecma/builtin-objects/ecma-builtin-regexp-prototype.c
index 94c0384dd8..ff01f07946 100644
--- a/jerry-core/ecma/builtin-objects/ecma-builtin-regexp-prototype.c
+++ b/jerry-core/ecma/builtin-objects/ecma-builtin-regexp-prototype.c
@@ -131,10 +131,10 @@ ecma_op_escape_regexp_pattern (ecma_string_t *pattern_str_p) /**< RegExp pattern
{
ecma_stringbuilder_t builder = ecma_stringbuilder_create ();
- ECMA_STRING_TO_UTF8_STRING (pattern_str_p, pattern_start_p, pattern_start_size);
+ ECMA_STRING_TO_UTF8_STRING (pattern_str_p, pattern_start);
- const lit_utf8_byte_t *pattern_str_curr_p = pattern_start_p;
- const lit_utf8_byte_t *pattern_str_end_p = pattern_start_p + pattern_start_size;
+ const lit_utf8_byte_t *pattern_str_curr_p = pattern_start.ptr;
+ const lit_utf8_byte_t *pattern_str_end_p = pattern_start.ptr + pattern_start.size;
while (pattern_str_curr_p < pattern_str_end_p)
{
@@ -182,8 +182,6 @@ ecma_op_escape_regexp_pattern (ecma_string_t *pattern_str_p) /**< RegExp pattern
}
}
- ECMA_FINALIZE_UTF8_STRING (pattern_start_p, pattern_start_size);
-
return ecma_make_string_value (ecma_stringbuilder_finalize (&builder));
} /* ecma_op_escape_regexp_pattern */
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 8616fbf5a5..323bc5b448 100644
--- a/jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.c
+++ b/jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.c
@@ -589,35 +589,32 @@ ecma_builtin_string_prototype_object_replace_helper (ecma_value_t this_value, /*
}
}
- uint8_t input_flags = ECMA_STRING_FLAG_IS_ASCII;
- replace_ctx.string_p = ecma_string_get_chars (input_str_p, &(replace_ctx.string_size), NULL, NULL, &input_flags);
+ ECMA_STRING_TO_UTF8_STRING (input_str_p, string);
+ replace_ctx.string_p = string.ptr;
+ replace_ctx.string_size = string.size;
- lit_utf8_size_t search_size;
- lit_utf8_size_t search_length;
- uint8_t search_flags = ECMA_STRING_FLAG_IS_ASCII;
- const lit_utf8_byte_t *search_buf_p =
- ecma_string_get_chars (search_str_p, &search_size, &search_length, NULL, &search_flags);
+ ECMA_STRING_TO_UTF8_STRING_AND_LENGTH (search_str_p, search);
ecma_string_t *result_string_p = NULL;
- if (replace_ctx.string_size >= search_size)
+ if (replace_ctx.string_size >= search.size)
{
replace_ctx.builder = ecma_stringbuilder_create ();
- replace_ctx.matched_size = search_size;
+ replace_ctx.matched_size = search.size;
const lit_utf8_byte_t *const input_end_p = replace_ctx.string_p + replace_ctx.string_size;
- const lit_utf8_byte_t *const loop_end_p = input_end_p - search_size;
+ const lit_utf8_byte_t *const loop_end_p = input_end_p - search.size;
const lit_utf8_byte_t *last_match_end_p = replace_ctx.string_p;
const lit_utf8_byte_t *curr_p = replace_ctx.string_p;
lit_utf8_size_t pos = 0;
while (curr_p <= loop_end_p)
{
- if (!memcmp (curr_p, search_buf_p, search_size))
+ if (!memcmp (curr_p, search.ptr, search.size))
{
const lit_utf8_size_t prefix_size = (lit_utf8_size_t) (curr_p - last_match_end_p);
ecma_stringbuilder_append_raw (&replace_ctx.builder, last_match_end_p, prefix_size);
- last_match_end_p = curr_p + search_size;
+ last_match_end_p = curr_p + search.size;
if (replace_ctx.replace_str_p == NULL)
{
@@ -661,7 +658,7 @@ ecma_builtin_string_prototype_object_replace_helper (ecma_value_t this_value, /*
break;
}
- if (search_size != 0)
+ if (search.size != 0)
{
curr_p = last_match_end_p;
pos += search_length;
@@ -688,15 +685,6 @@ ecma_builtin_string_prototype_object_replace_helper (ecma_value_t this_value, /*
result = ecma_make_string_value (result_string_p);
cleanup_replace:
- if (input_flags & ECMA_STRING_FLAG_MUST_BE_FREED)
- {
- jmem_heap_free_block ((void *) replace_ctx.string_p, replace_ctx.string_size);
- }
-
- if (search_flags & ECMA_STRING_FLAG_MUST_BE_FREED)
- {
- jmem_heap_free_block ((void *) search_buf_p, search_size);
- }
if (replace_ctx.replace_str_p != NULL)
{
@@ -967,22 +955,18 @@ ecma_builtin_string_prototype_object_split (ecma_value_t this_value, /**< this a
goto cleanup_separator;
}
- lit_utf8_size_t string_size;
- uint8_t string_flags = ECMA_STRING_FLAG_IS_ASCII;
- const lit_utf8_byte_t *string_buffer_p = ecma_string_get_chars (string_p, &string_size, NULL, NULL, &string_flags);
- lit_utf8_size_t separator_size;
- uint8_t separator_flags = ECMA_STRING_FLAG_IS_ASCII;
- const lit_utf8_byte_t *separator_buffer_p =
- ecma_string_get_chars (separator_p, &separator_size, NULL, NULL, &separator_flags);
+ ECMA_STRING_TO_UTF8_STRING (string_p, string);
+
+ ECMA_STRING_TO_UTF8_STRING (separator_p, separator);
- const lit_utf8_byte_t *const string_end_p = string_buffer_p + string_size;
- const lit_utf8_byte_t *const compare_end_p = JERRY_MIN (string_end_p - separator_size + 1, string_end_p);
- const lit_utf8_byte_t *current_p = string_buffer_p;
- const lit_utf8_byte_t *last_str_begin_p = string_buffer_p;
+ const lit_utf8_byte_t *const string_end_p = string.ptr + string.size;
+ const lit_utf8_byte_t *const compare_end_p = JERRY_MIN (string_end_p - separator.size + 1, string_end_p);
+ const lit_utf8_byte_t *current_p = string.ptr;
+ const lit_utf8_byte_t *last_str_begin_p = string.ptr;
while (current_p < compare_end_p)
{
- if (!memcmp (current_p, separator_buffer_p, separator_size) && (last_str_begin_p != current_p + separator_size))
+ if (!memcmp (current_p, separator.ptr, separator.size) && (last_str_begin_p != current_p + separator.size))
{
ecma_string_t *substr_p =
ecma_new_ecma_string_from_utf8 (last_str_begin_p, (lit_utf8_size_t) (current_p - last_str_begin_p));
@@ -998,7 +982,7 @@ ecma_builtin_string_prototype_object_split (ecma_value_t this_value, /**< this a
goto cleanup_buffers;
}
- current_p += separator_size;
+ current_p += separator.size;
last_str_begin_p = current_p;
continue;
}
@@ -1016,16 +1000,6 @@ ecma_builtin_string_prototype_object_split (ecma_value_t this_value, /**< this a
ecma_deref_ecma_string (end_substr_p);
cleanup_buffers:
- if (string_flags & ECMA_STRING_FLAG_MUST_BE_FREED)
- {
- jmem_heap_free_block ((void *) string_buffer_p, string_size);
- }
-
- if (separator_flags & ECMA_STRING_FLAG_MUST_BE_FREED)
- {
- jmem_heap_free_block ((void *) separator_buffer_p, separator_size);
- }
-
cleanup_separator:
ecma_deref_ecma_string (separator_p);
cleanup_string:
@@ -1115,10 +1089,10 @@ ecma_builtin_string_prototype_object_conversion_helper (ecma_string_t *input_str
{
ecma_stringbuilder_t builder = ecma_stringbuilder_create ();
- ECMA_STRING_TO_UTF8_STRING (input_string_p, input_start_p, input_start_size);
+ ECMA_STRING_TO_UTF8_STRING (input_string_p, input_start);
- const lit_utf8_byte_t *input_curr_p = input_start_p;
- const lit_utf8_byte_t *input_str_end_p = input_start_p + input_start_size;
+ const lit_utf8_byte_t *input_curr_p = input_start.ptr;
+ const lit_utf8_byte_t *input_str_end_p = input_start.ptr + input_start.size;
while (input_curr_p < input_str_end_p)
{
@@ -1144,8 +1118,6 @@ ecma_builtin_string_prototype_object_conversion_helper (ecma_string_t *input_str
}
}
- ECMA_FINALIZE_UTF8_STRING (input_start_p, input_start_size);
-
return ecma_make_string_value (ecma_stringbuilder_finalize (&builder));
} /* ecma_builtin_string_prototype_object_conversion_helper */
diff --git a/jerry-core/ecma/operations/ecma-bigint.c b/jerry-core/ecma/operations/ecma-bigint.c
index 7a4464e0c9..b9a9b05ade 100644
--- a/jerry-core/ecma/operations/ecma-bigint.c
+++ b/jerry-core/ecma/operations/ecma-bigint.c
@@ -198,10 +198,9 @@ ecma_bigint_parse_string_value (ecma_value_t string, /**< ecma string */
{
JERRY_ASSERT (ecma_is_value_string (string));
- ECMA_STRING_TO_UTF8_STRING (ecma_get_string_from_value (string), string_buffer_p, string_buffer_size);
+ ECMA_STRING_TO_UTF8_STRING (ecma_get_string_from_value (string), string_buffer);
- ecma_value_t result = ecma_bigint_parse_string (string_buffer_p, string_buffer_size, options);
- ECMA_FINALIZE_UTF8_STRING (string_buffer_p, string_buffer_size);
+ ecma_value_t result = ecma_bigint_parse_string (string_buffer.ptr, string_buffer.size, options);
return result;
} /* ecma_bigint_parse_string_value */
diff --git a/jerry-core/ecma/operations/ecma-regexp-object.c b/jerry-core/ecma/operations/ecma-regexp-object.c
index e5b276aeae..c0f3da093c 100644
--- a/jerry-core/ecma/operations/ecma-regexp-object.c
+++ b/jerry-core/ecma/operations/ecma-regexp-object.c
@@ -63,10 +63,10 @@ ecma_regexp_parse_flags (ecma_string_t *flags_str_p, /**< Input string with flag
ecma_value_t ret_value = ECMA_VALUE_EMPTY;
uint16_t result_flags = RE_FLAG_EMPTY;
- ECMA_STRING_TO_UTF8_STRING (flags_str_p, flags_start_p, flags_start_size);
+ ECMA_STRING_TO_UTF8_STRING (flags_str_p, flags_start);
- 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;
+ const lit_utf8_byte_t *flags_str_curr_p = flags_start.ptr;
+ const lit_utf8_byte_t *flags_str_end_p = flags_start.ptr + flags_start.size;
while (flags_str_curr_p < flags_str_end_p)
{
@@ -119,8 +119,6 @@ ecma_regexp_parse_flags (ecma_string_t *flags_str_p, /**< Input string with flag
result_flags = (uint16_t) (result_flags | flag);
}
- ECMA_FINALIZE_UTF8_STRING (flags_start_p, flags_start_size);
-
*flags_p = result_flags;
return ret_value;
} /* ecma_regexp_parse_flags */
@@ -1601,17 +1599,13 @@ ecma_regexp_exec_helper (ecma_object_t *regexp_object_p, /**< RegExp object */
re_compiled_code_t *bc_p = ECMA_GET_INTERNAL_VALUE_POINTER (re_compiled_code_t, ext_object_p->u.cls.u3.value);
/* 3. */
- lit_utf8_size_t input_size;
- lit_utf8_size_t input_length;
- uint8_t input_flags = ECMA_STRING_FLAG_IS_ASCII;
- const lit_utf8_byte_t *input_buffer_p =
- ecma_string_get_chars (input_string_p, &input_size, &input_length, NULL, &input_flags);
+ ECMA_STRING_TO_UTF8_STRING_AND_LENGTH (input_string_p, input);
- const lit_utf8_byte_t *input_curr_p = input_buffer_p;
- const lit_utf8_byte_t *input_end_p = input_buffer_p + input_size;
+ const lit_utf8_byte_t *input_curr_p = input.ptr;
+ const lit_utf8_byte_t *input_end_p = input.ptr + input.size;
ecma_regexp_ctx_t re_ctx;
- ecma_regexp_initialize_context (&re_ctx, bc_p, input_buffer_p, input_end_p);
+ ecma_regexp_initialize_context (&re_ctx, bc_p, input.ptr, input_end_p);
/* 4. */
ecma_length_t index = 0;
@@ -1778,11 +1772,6 @@ ecma_regexp_exec_helper (ecma_object_t *regexp_object_p, /**< RegExp object */
cleanup_context:
ecma_regexp_cleanup_context (&re_ctx);
- if (input_flags & ECMA_STRING_FLAG_MUST_BE_FREED)
- {
- jmem_heap_free_block ((void *) input_buffer_p, input_size);
- }
-
return ret_value;
} /* ecma_regexp_exec_helper */
@@ -1970,17 +1959,14 @@ ecma_regexp_split_helper (ecma_value_t this_arg, /**< this value */
goto cleanup_string;
}
- lit_utf8_size_t flags_size;
- uint8_t flags_str_flags = ECMA_STRING_FLAG_IS_ASCII;
- const lit_utf8_byte_t *flags_buffer_p =
- ecma_string_get_chars (flags_str_p, &flags_size, NULL, NULL, &flags_str_flags);
+ ECMA_STRING_TO_UTF8_STRING (flags_str_p, flags_buffer);
bool unicode = false;
bool sticky = false;
/* 9-11. */
- const lit_utf8_byte_t *const flags_end_p = flags_buffer_p + flags_size;
- for (const lit_utf8_byte_t *current_p = flags_buffer_p; current_p < flags_end_p; ++current_p)
+ const lit_utf8_byte_t *const flags_end_p = flags_buffer.ptr + flags_buffer.size;
+ for (const lit_utf8_byte_t *current_p = flags_buffer.ptr; current_p < flags_end_p; ++current_p)
{
switch (*current_p)
{
@@ -1997,11 +1983,6 @@ ecma_regexp_split_helper (ecma_value_t this_arg, /**< this value */
}
}
- if (flags_str_flags & ECMA_STRING_FLAG_MUST_BE_FREED)
- {
- jmem_heap_free_block ((void *) flags_buffer_p, flags_size);
- }
-
/* 12. */
if (!sticky)
{
@@ -2270,9 +2251,9 @@ ecma_regexp_replace_helper_fast (ecma_replace_context_t *ctx_p, /**<replace cont
JERRY_ASSERT (bc_p != NULL);
- uint8_t string_flags = ECMA_STRING_FLAG_IS_ASCII;
- lit_utf8_size_t string_length;
- ctx_p->string_p = ecma_string_get_chars (string_p, &(ctx_p->string_size), &string_length, NULL, &string_flags);
+ ECMA_STRING_TO_UTF8_STRING_AND_LENGTH (string_p, string);
+ ctx_p->string_p = string.ptr;
+ ctx_p->string_size = string.size;
const lit_utf8_byte_t *const string_end_p = ctx_p->string_p + ctx_p->string_size;
const uint8_t *const bc_start_p = (const uint8_t *) (bc_p + 1);
@@ -2485,11 +2466,6 @@ ecma_regexp_replace_helper_fast (ecma_replace_context_t *ctx_p, /**<replace cont
ecma_regexp_cleanup_context (&re_ctx);
ecma_bytecode_deref ((ecma_compiled_code_t *) bc_p);
- if (string_flags & ECMA_STRING_FLAG_MUST_BE_FREED)
- {
- jmem_heap_free_block ((void *) ctx_p->string_p, ctx_p->string_size);
- }
-
return result;
} /* ecma_regexp_replace_helper_fast */
@@ -2554,8 +2530,6 @@ ecma_regexp_replace_helper (ecma_value_t this_arg, /**< this argument */
ecma_free_value (result);
- const lit_utf8_size_t string_length = ecma_string_get_length (string_p);
-
/* 10. */
if (replace_ctx.flags & RE_FLAG_GLOBAL)
{
@@ -2722,8 +2696,9 @@ ecma_regexp_replace_helper (ecma_value_t this_arg, /**< this argument */
}
}
- uint8_t string_flags = ECMA_STRING_FLAG_IS_ASCII;
- replace_ctx.string_p = ecma_string_get_chars (string_p, &(replace_ctx.string_size), NULL, NULL, &string_flags);
+ ECMA_STRING_TO_UTF8_STRING_AND_LENGTH (string_p, string);
+ replace_ctx.string_p = string.ptr;
+ replace_ctx.string_size = string.size;
/* 14. */
replace_ctx.builder = ecma_stringbuilder_create ();
@@ -2941,10 +2916,6 @@ ecma_regexp_replace_helper (ecma_value_t this_arg, /**< this argument */
ecma_stringbuilder_destroy (&replace_ctx.builder);
cleanup_chars:
- if (string_flags & ECMA_STRING_FLAG_MUST_BE_FREED)
- {
- jmem_heap_free_block ((void *) replace_ctx.string_p, replace_ctx.string_size);
- }
cleanup_results:
ecma_collection_free (results_p);
diff --git a/jerry-core/lit/lit-char-helpers.c b/jerry-core/lit/lit-char-helpers.c
index ca36a488fb..2b6af1f97f 100644
--- a/jerry-core/lit/lit-char-helpers.c
+++ b/jerry-core/lit/lit-char-helpers.c
@@ -974,10 +974,10 @@ bool
lit_find_char_in_string (ecma_string_t *str_p, /**< source string */
lit_utf8_byte_t c) /**< character to find*/
{
- ECMA_STRING_TO_UTF8_STRING (str_p, start_p, start_size);
+ ECMA_STRING_TO_UTF8_STRING (str_p, start);
- const lit_utf8_byte_t *str_curr_p = start_p;
- const lit_utf8_byte_t *str_end_p = start_p + start_size;
+ const lit_utf8_byte_t *str_curr_p = start.ptr;
+ const lit_utf8_byte_t *str_end_p = start.ptr + start.size;
bool have_char = false;
while (str_curr_p < str_end_p)
@@ -989,7 +989,5 @@ lit_find_char_in_string (ecma_string_t *str_p, /**< source string */
}
}
- ECMA_FINALIZE_UTF8_STRING (start_p, start_size);
-
return have_char;
} /* lit_find_char_in_string */
diff --git a/jerry-core/lit/lit-globals.h b/jerry-core/lit/lit-globals.h
index a970eee18e..2a3d78865a 100644
--- a/jerry-core/lit/lit-globals.h
+++ b/jerry-core/lit/lit-globals.h
@@ -118,4 +118,13 @@ typedef uint32_t lit_code_point_t;
*/
typedef uint32_t lit_string_hash_t;
+/**
+ * An UTF-8 string
+ */
+typedef struct
+{
+ const lit_utf8_byte_t *ptr; /**< pointer to UTF-8/CESU-8 string */
+ lit_utf8_size_t size; /**< string size excluding '\0' terminator */
+} lit_utf8_string_t;
+
#endif /* !LIT_GLOBALS_H */
diff --git a/jerry-core/parser/js/common.c b/jerry-core/parser/js/common.c
index eafd167704..ae1b4af2cf 100644
--- a/jerry-core/parser/js/common.c
+++ b/jerry-core/parser/js/common.c
@@ -254,9 +254,8 @@ util_print_literal_value (ecma_compiled_code_t *compiled_code_p, /**< compiled c
JERRY_DEBUG_MSG ("string(");
- ECMA_STRING_TO_UTF8_STRING (literal_p, chars_p, literal_size);
- util_print_chars (chars_p, literal_size);
- ECMA_FINALIZE_UTF8_STRING (chars_p, literal_size);
+ ECMA_STRING_TO_UTF8_STRING (literal_p, chars);
+ util_print_chars (chars.ptr, chars.size);
}
JERRY_DEBUG_MSG (")");
diff --git a/jerry-core/parser/js/js-parser-internal.h b/jerry-core/parser/js/js-parser-internal.h
index c6fb9004a4..f2e8e5b606 100644
--- a/jerry-core/parser/js/js-parser-internal.h
+++ b/jerry-core/parser/js/js-parser-internal.h
@@ -540,10 +540,8 @@ typedef struct
parser_saved_context_t *last_context_p; /**< last saved context */
parser_stack_iterator_t last_statement; /**< last statement position */
cbc_script_t *script_p; /**< current script */
- const uint8_t *source_start_p; /**< source start */
- lit_utf8_size_t source_size; /**< source size */
- const uint8_t *arguments_start_p; /**< function argument list start */
- lit_utf8_size_t arguments_size; /**< function argument list size */
+ lit_utf8_string_t source; /**< source start */
+ lit_utf8_string_t arguments; /**< function argument list */
ecma_value_t script_value; /**< current script as value */
ecma_value_t argument_list; /**< current argument list as value */
ecma_value_t user_value; /**< current user value */
diff --git a/jerry-core/parser/js/js-parser.c b/jerry-core/parser/js/js-parser.c
index 8f241b6a1a..afae768fcd 100644
--- a/jerry-core/parser/js/js-parser.c
+++ b/jerry-core/parser/js/js-parser.c
@@ -916,15 +916,15 @@ parser_post_processing (parser_context_t *context_p) /**< context */
{
extended_info |= CBC_EXTENDED_CODE_FLAGS_HAS_SOURCE_CODE_RANGE;
- const uint8_t *start_p = context_p->source_start_p;
+ const uint8_t *start_p = context_p->source.ptr;
const uint8_t *function_start_p = context_p->last_context_p->function_start_p;
- if (function_start_p < start_p || function_start_p >= start_p + context_p->source_size)
+ if (function_start_p < start_p || function_start_p >= start_p + context_p->source.size)
{
- JERRY_ASSERT (context_p->arguments_start_p != NULL && function_start_p >= context_p->arguments_start_p
- && function_start_p < context_p->arguments_start_p + context_p->arguments_size);
+ JERRY_ASSERT (context_p->arguments.ptr != NULL && function_start_p >= context_p->arguments.ptr
+ && function_start_p < context_p->arguments.ptr + context_p->arguments.size);
- start_p = context_p->arguments_start_p;
+ start_p = context_p->arguments.ptr;
extended_info |= CBC_EXTENDED_CODE_FLAGS_SOURCE_CODE_IN_ARGUMENTS;
}
@@ -1355,11 +1355,11 @@ parser_post_processing (parser_context_t *context_p) /**< context */
#if JERRY_FUNCTION_TO_STRING
if (context_p->last_context_p != NULL)
{
- const uint8_t *start_p = context_p->source_start_p;
+ const uint8_t *start_p = context_p->source.ptr;
if (extended_info & CBC_EXTENDED_CODE_FLAGS_SOURCE_CODE_IN_ARGUMENTS)
{
- start_p = context_p->arguments_start_p;
+ start_p = context_p->arguments.ptr;
}
const uint8_t *function_start_p = context_p->last_context_p->function_start_p;
@@ -1999,8 +1999,8 @@ parser_parse_source (void *source_p, /**< source code */
context.stack_limit = 0;
context.options_p = options_p;
context.script_p = NULL;
- context.arguments_start_p = NULL;
- context.arguments_size = 0;
+ context.arguments.ptr = NULL;
+ context.arguments.size = 0;
#if JERRY_MODULE_SYSTEM
if (context.global_status_flags & ECMA_PARSE_MODULE)
{
@@ -2040,7 +2040,7 @@ parser_parse_source (void *source_p, /**< source code */
ecma_string_t *string_p = ecma_get_string_from_value (context.argument_list);
uint8_t flags = ECMA_STRING_FLAG_EMPTY;
- context.arguments_start_p = ecma_string_get_chars (string_p, &context.arguments_size, NULL, NULL, &flags);
+ ecma_string_get_chars (string_p, &context.arguments, NULL, &flags);
if (flags & ECMA_STRING_FLAG_MUST_BE_FREED)
{
@@ -2050,8 +2050,8 @@ parser_parse_source (void *source_p, /**< source code */
if (!(context.global_status_flags & ECMA_PARSE_HAS_SOURCE_VALUE))
{
- context.source_start_p = ((parser_source_char_t *) source_p)->source_p;
- context.source_size = (lit_utf8_size_t) ((parser_source_char_t *) source_p)->source_size;
+ context.source.ptr = ((parser_source_char_t *) source_p)->source_p;
+ context.source.size = (lit_utf8_size_t) ((parser_source_char_t *) source_p)->source_size;
}
else
{
@@ -2062,7 +2062,7 @@ parser_parse_source (void *source_p, /**< source code */
ecma_string_t *string_p = ecma_get_string_from_value (source);
uint8_t flags = ECMA_STRING_FLAG_EMPTY;
- context.source_start_p = ecma_string_get_chars (string_p, &context.source_size, NULL, NULL, &flags);
+ ecma_string_get_chars (string_p, &context.source, NULL, &flags);
if (flags & ECMA_STRING_FLAG_MUST_BE_FREED)
{
@@ -2075,8 +2075,8 @@ parser_parse_source (void *source_p, /**< source code */
{
jerry_debugger_send_string (JERRY_DEBUGGER_SOURCE_CODE,
JERRY_DEBUGGER_NO_SUBTYPE,
- context.source_start_p,
- context.source_size);
+ context.source.ptr,
+ context.source.size);
}
#endif /* JERRY_DEBUGGER */
@@ -2160,7 +2160,7 @@ parser_parse_source (void *source_p, /**< source code */
if (context.is_show_opcodes)
{
- JERRY_DEBUG_MSG ("\n--- %s parsing start ---\n\n", (context.arguments_start_p == NULL) ? "Script" : "Function");
+ JERRY_DEBUG_MSG ("\n--- %s parsing start ---\n\n", (context.arguments.ptr == NULL) ? "Script" : "Function");
}
#endif /* JERRY_PARSER_DUMP_BYTE_CODE */
@@ -2176,15 +2176,15 @@ parser_parse_source (void *source_p, /**< source code */
return NULL;
}
- if (context.arguments_start_p == NULL)
+ if (context.arguments.ptr == NULL)
{
- context.source_p = context.source_start_p;
- context.source_end_p = context.source_start_p + context.source_size;
+ context.source_p = context.source.ptr;
+ context.source_end_p = context.source.ptr + context.source.size;
}
else
{
- context.source_p = context.arguments_start_p;
- context.source_end_p = context.arguments_start_p + context.arguments_size;
+ context.source_p = context.arguments.ptr;
+ context.source_end_p = context.arguments.ptr + context.arguments.size;
}
context.u.allocated_buffer_p = NULL;
@@ -2234,15 +2234,15 @@ parser_parse_source (void *source_p, /**< source code */
* lexer_next_token() must be immediately called. */
lexer_next_token (&context);
- if (context.arguments_start_p != NULL)
+ if (context.arguments.ptr != NULL)
{
parser_parse_function_arguments (&context, LEXER_EOS);
JERRY_ASSERT (context.next_scanner_info_p->type == SCANNER_TYPE_END_ARGUMENTS);
scanner_release_next (&context, sizeof (scanner_info_t));
- context.source_p = context.source_start_p;
- context.source_end_p = context.source_start_p + context.source_size;
+ context.source_p = context.source.ptr;
+ context.source_end_p = context.source.ptr + context.source.size;
lexer_init_line_info (&context);
lexer_next_token (&context);
@@ -2261,7 +2261,7 @@ parser_parse_source (void *source_p, /**< source code */
#endif /* JERRY_MODULE_SYSTEM */
else
{
- JERRY_ASSERT (context.next_scanner_info_p->source_p == context.source_start_p
+ JERRY_ASSERT (context.next_scanner_info_p->source_p == context.source.ptr
&& context.next_scanner_info_p->type == SCANNER_TYPE_FUNCTION);
if (scanner_is_context_needed (&context, PARSER_CHECK_GLOBAL_CONTEXT))
@@ -2300,7 +2300,7 @@ parser_parse_source (void *source_p, /**< source code */
&& context.stack.first_p != NULL && context.stack.first_p->next_p == NULL
&& context.stack.last_p == NULL);
- JERRY_ASSERT (context.arguments_start_p != NULL || !(context.status_flags & PARSER_ARGUMENTS_NEEDED));
+ JERRY_ASSERT (context.arguments.ptr != NULL || !(context.status_flags & PARSER_ARGUMENTS_NEEDED));
context.script_p->refs_and_type -= CBC_SCRIPT_REF_ONE;
@@ -2327,11 +2327,11 @@ parser_parse_source (void *source_p, /**< source code */
if (context.global_status_flags & ECMA_PARSE_INTERNAL_HAS_4_BYTE_MARKER)
{
- string_p = ecma_new_ecma_string_from_utf8_converted_to_cesu8 (context.source_start_p, context.source_size);
+ string_p = ecma_new_ecma_string_from_utf8_converted_to_cesu8 (context.source.ptr, context.source.size);
}
else
{
- string_p = ecma_new_ecma_string_from_utf8 (context.source_start_p, context.source_size);
+ string_p = ecma_new_ecma_string_from_utf8 (context.source.ptr, context.source.size);
}
context.script_p->source_code = ecma_make_string_value (string_p);
@@ -2359,7 +2359,7 @@ parser_parse_source (void *source_p, /**< source code */
if (context.is_show_opcodes)
{
JERRY_DEBUG_MSG ("\n%s parsing successfully completed. Total byte code size: %d bytes\n",
- (context.arguments_start_p == NULL) ? "Script" : "Function",
+ (context.arguments.ptr == NULL) ? "Script" : "Function",
(int) context.total_byte_code_size);
}
#endif /* JERRY_PARSER_DUMP_BYTE_CODE */
@@ -2410,7 +2410,7 @@ parser_parse_source (void *source_p, /**< source code */
#if JERRY_PARSER_DUMP_BYTE_CODE
if (context.is_show_opcodes)
{
- JERRY_DEBUG_MSG ("\n--- %s parsing end ---\n\n", (context.arguments_start_p == NULL) ? "Script" : "Function");
+ JERRY_DEBUG_MSG ("\n--- %s parsing end ---\n\n", (context.arguments.ptr == NULL) ? "Script" : "Function");
}
#endif /* JERRY_PARSER_DUMP_BYTE_CODE */
@@ -2418,12 +2418,12 @@ parser_parse_source (void *source_p, /**< source code */
if (context.global_status_flags & ECMA_PARSE_INTERNAL_FREE_SOURCE)
{
- jmem_heap_free_block ((void *) context.source_start_p, context.source_size);
+ jmem_heap_free_block ((void *) context.source.ptr, context.source.size + 1);
}
if (context.global_status_flags & ECMA_PARSE_INTERNAL_FREE_ARG_LIST)
{
- jmem_heap_free_block ((void *) context.arguments_start_p, context.arguments_size);
+ jmem_heap_free_block ((void *) context.arguments.ptr, context.arguments.size + 1);
}
if (compiled_code_p != NULL)
@@ -3360,12 +3360,9 @@ parser_parse_script (void *source_p, /**< source code */
return bytecode_p;
#else /* !JERRY_PARSER */
- JERRY_UNUSED (arg_list_p);
- JERRY_UNUSED (arg_list_size);
JERRY_UNUSED (source_p);
- JERRY_UNUSED (source_size);
JERRY_UNUSED (parse_opts);
- JERRY_UNUSED (source_name);
+ JERRY_UNUSED (options_p);
ecma_raise_syntax_error (ECMA_ERR_PARSER_NOT_SUPPORTED);
return NULL;
diff --git a/jerry-core/parser/js/js-scanner.c b/jerry-core/parser/js/js-scanner.c
index 30d6e977c6..8c6c8f36d1 100644
--- a/jerry-core/parser/js/js-scanner.c
+++ b/jerry-core/parser/js/js-scanner.c
@@ -2434,10 +2434,10 @@ scanner_scan_all (parser_context_t *context_p) /**< context */
PARSER_TRY (context_p->try_buffer)
{
- if (context_p->arguments_start_p == NULL)
+ if (context_p->arguments.ptr == NULL)
{
- context_p->source_p = context_p->source_start_p;
- context_p->source_end_p = context_p->source_start_p + context_p->source_size;
+ context_p->source_p = context_p->source.ptr;
+ context_p->source_end_p = context_p->source.ptr + context_p->source.size;
uint16_t status_flags =
(SCANNER_LITERAL_POOL_FUNCTION | SCANNER_LITERAL_POOL_NO_ARGUMENTS | SCANNER_LITERAL_POOL_CAN_EVAL);
@@ -2448,7 +2448,7 @@ scanner_scan_all (parser_context_t *context_p) /**< context */
}
scanner_literal_pool_t *literal_pool_p = scanner_push_literal_pool (context_p, &scanner_context, status_flags);
- literal_pool_p->source_p = context_p->source_start_p;
+ literal_pool_p->source_p = context_p->source.ptr;
parser_stack_push_uint8 (context_p, SCAN_STACK_SCRIPT);
@@ -2457,8 +2457,8 @@ scanner_scan_all (parser_context_t *context_p) /**< context */
}
else
{
- context_p->source_p = context_p->arguments_start_p;
- context_p->source_end_p = context_p->arguments_start_p + context_p->arguments_size;
+ context_p->source_p = context_p->arguments.ptr;
+ context_p->source_end_p = context_p->arguments.ptr + context_p->arguments.size;
uint16_t status_flags = SCANNER_LITERAL_POOL_FUNCTION;
@@ -3066,8 +3066,8 @@ scanner_scan_all (parser_context_t *context_p) /**< context */
scanner_context.end_arguments_p = scanner_info_p;
context_p->next_scanner_info_p = scanner_info_p;
- context_p->source_p = context_p->source_start_p;
- context_p->source_end_p = context_p->source_start_p + context_p->source_size;
+ context_p->source_p = context_p->source.ptr;
+ context_p->source_end_p = context_p->source.ptr + context_p->source.size;
lexer_init_line_info (context_p);
scanner_filter_arguments (context_p, &scanner_context);
@@ -3445,7 +3445,7 @@ scanner_scan_all (parser_context_t *context_p) /**< context */
{
scanner_info_t *info_p = context_p->next_scanner_info_p;
const uint8_t *source_start_p =
- (context_p->arguments_start_p == NULL ? context_p->source_start_p : context_p->arguments_start_p);
+ (context_p->arguments.ptr == NULL ? context_p->source.ptr : context_p->arguments.ptr);
while (info_p->type != SCANNER_TYPE_END)
{
@@ -3457,7 +3457,7 @@ scanner_scan_all (parser_context_t *context_p) /**< context */
case SCANNER_TYPE_END_ARGUMENTS:
{
JERRY_DEBUG_MSG (" END_ARGUMENTS\n");
- source_start_p = context_p->source_start_p;
+ source_start_p = context_p->source.ptr;
break;
}
case SCANNER_TYPE_FUNCTION:
diff --git a/jerry-core/parser/regexp/re-compiler.c b/jerry-core/parser/regexp/re-compiler.c
index a495616b5f..ea964b3cfa 100644
--- a/jerry-core/parser/regexp/re-compiler.c
+++ b/jerry-core/parser/regexp/re-compiler.c
@@ -121,18 +121,16 @@ re_compile_bytecode (ecma_string_t *pattern_str_p, /**< pattern */
re_initialize_regexp_bytecode (&re_ctx);
- ECMA_STRING_TO_UTF8_STRING (pattern_str_p, pattern_start_p, pattern_start_size);
+ ECMA_STRING_TO_UTF8_STRING (pattern_str_p, pattern_start);
- re_ctx.input_start_p = pattern_start_p;
- re_ctx.input_curr_p = (lit_utf8_byte_t *) pattern_start_p;
- re_ctx.input_end_p = pattern_start_p + pattern_start_size;
+ re_ctx.input_start_p = pattern_start.ptr;
+ re_ctx.input_curr_p = (lit_utf8_byte_t *) pattern_start.ptr;
+ re_ctx.input_end_p = pattern_start.ptr + pattern_start.size;
re_ctx.groups_count = -1;
/* Parse RegExp pattern */
ecma_value_t result = re_parse_alternative (&re_ctx, true);
- ECMA_FINALIZE_UTF8_STRING (pattern_start_p, pattern_start_size);
-
if (ECMA_IS_VALUE_ERROR (result))
{
/* Compilation failed, free bytecode. */
diff --git a/tests/unit-core/test-number-to-string.c b/tests/unit-core/test-number-to-string.c
index ed5fce2261..b53d089113 100644
--- a/tests/unit-core/test-number-to-string.c
+++ b/tests/unit-core/test-number-to-string.c
@@ -50,5 +50,17 @@ main (void)
}
}
+ lit_utf8_byte_t val_uint32_max_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED] = { 0 };
+ memset (val_uint32_max_buffer, 0xFF, sizeof (val_uint32_max_buffer));
+
+ TEST_ASSERT (ecma_string_get_uint32_size (UINT32_MAX) == 10);
+ TEST_ASSERT (ecma_string_get_uint32_size (0) == 1);
+ TEST_ASSERT (ecma_string_get_uint32_size (10) == 2);
+ lit_utf8_size_t digits = ecma_uint32_to_utf8_string (UINT32_MAX,
+ val_uint32_max_buffer,
+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
+ TEST_ASSERT (digits == 10);
+ TEST_ASSERT (val_uint32_max_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32] == 0);
+
return 0;
} /* main */