diff --git a/docs/API-EXAMPLE.md b/docs/API-EXAMPLE.md index 1f3e6d3f44..2cb4ec0246 100644 --- a/docs/API-EXAMPLE.md +++ b/docs/API-EXAMPLE.md @@ -192,17 +192,14 @@ print_value (const jerry_api_value_t * value_p) // String value case JERRY_API_DATA_TYPE_STRING: { - ssize_t neg_req_sz, sz; + jerry_api_size_t req_sz, sz; // determining required buffer size - neg_req_sz = jerry_api_string_to_char_buffer (value_p->v_string, - NULL, - 0); - assert (neg_req_sz < 0); - char * str_buf_p = (char*) malloc (-neg_req_sz); + req_sz = jerry_api_get_string_size (value_p->v_string); + char * str_buf_p = (char*) malloc (req_sz); sz = jerry_api_string_to_char_buffer (value_p->v_string, str_buf_p, - -neg_req_sz); - assert (sz == -neg_req_sz); + req_sz); + assert (sz == req_sz); printf ("%s", str_buf_p); diff --git a/docs/API-REFERENCE.md b/docs/API-REFERENCE.md index fd5cb2b085..850aee08a2 100644 --- a/docs/API-REFERENCE.md +++ b/docs/API-REFERENCE.md @@ -290,10 +290,10 @@ Copy string characters to specified buffer, append zero character at end of the **Prototype** ```c -ssize_t +jerry_api_size_t jerry_api_string_to_char_buffer (const jerry_api_string_t * string_p, char * buffer_p, - ssize_t buffer_size); + jerry_api_size_t buffer_size); ``` - `string_p` - pointer to a string; @@ -319,15 +319,13 @@ jerry_api_string_to_char_buffer (const jerry_api_string_t * string_p, if (is_string) { // neg_req_sz would be negative, as zero-size buffer is insufficient for any string - ssize_t neg_req_sz = jerry_api_string_to_char_buffer (val.string_p, - NULL, - 0); - char * str_buf_p = (char*) malloc (-neg_req_sz); + jerry_api_size_t req_sz = jerry_api_get_string_size (val.string_p); + char * str_buf_p = (char*) malloc (req_sz); // sz would be -neg_req_sz - size_t sz = jerry_api_string_to_char_buffer (val.string_p, - str_buf_p, - -neg_req_sz); + jerry_api_size_t sz = jerry_api_string_to_char_buffer (val.string_p, + str_buf_p, + req_sz); printf ("%s", str_buf_p); diff --git a/jerry-core/ecma/base/ecma-helpers-conversion.c b/jerry-core/ecma/base/ecma-helpers-conversion.c index 787155e4e2..275f2fcc76 100644 --- a/jerry-core/ecma/base/ecma-helpers-conversion.c +++ b/jerry-core/ecma/base/ecma-helpers-conversion.c @@ -394,9 +394,7 @@ ecma_utf8_string_to_number (const lit_utf8_byte_t *str_p, /**< utf-8 string */ return ECMA_NUMBER_ZERO; } - const ssize_t literal_len = end_p - begin_p + 1; - - if (literal_len > 2 + if ((end_p >= begin_p + 2) && begin_p[0] == dec_digits_range[0] && (begin_p[1] == hex_x_chars[0] || begin_p[1] == hex_x_chars[1])) @@ -779,15 +777,15 @@ ecma_utf8_string_to_number (const lit_utf8_byte_t *str_p, /**< utf-8 string */ * * @return number of bytes copied to buffer */ -ssize_t +lit_utf8_size_t ecma_uint32_to_utf8_string (uint32_t value, /**< value to convert */ lit_utf8_byte_t *out_buffer_p, /**< buffer for string */ - ssize_t buffer_size) /**< size of buffer */ + lit_utf8_size_t buffer_size) /**< size of buffer */ { const lit_utf8_byte_t digits[10] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }; lit_utf8_byte_t *p = out_buffer_p + buffer_size - 1; - size_t bytes_copied = 0; + lit_utf8_size_t bytes_copied = 0; do { @@ -806,11 +804,10 @@ ecma_uint32_to_utf8_string (uint32_t value, /**< value to convert */ if (likely (p != out_buffer_p)) { - ssize_t bytes_to_move = out_buffer_p + buffer_size - p; - memmove (out_buffer_p, p, (size_t) bytes_to_move); + memmove (out_buffer_p, p, bytes_copied); } - return (ssize_t) bytes_copied; + return bytes_copied; } /* ecma_uint32_to_utf8_string */ /** @@ -1299,7 +1296,7 @@ ecma_number_to_decimal (ecma_number_t num, /**< ecma-number */ lit_utf8_size_t ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */ lit_utf8_byte_t *buffer_p, /**< buffer for utf-8 string */ - ssize_t buffer_size) /**< size of buffer */ + lit_utf8_size_t buffer_size) /**< size of buffer */ { const lit_utf8_byte_t digits[10] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }; const lit_utf8_byte_t e_chars[2] = { 'e', 'E' }; @@ -1323,14 +1320,14 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */ // 2. *dst_p++ = digits[0]; - JERRY_ASSERT (dst_p - buffer_p <= (ssize_t) buffer_size); + JERRY_ASSERT (dst_p <= buffer_p + buffer_size); size = (lit_utf8_size_t) (dst_p - buffer_p); } else if (ecma_number_is_negative (num)) { // 3. *dst_p++ = minus_char; - ssize_t new_buffer_size = (buffer_size - (dst_p - buffer_p)); + lit_utf8_size_t new_buffer_size = (lit_utf8_size_t) ((buffer_p + buffer_size) - dst_p); size = 1 + ecma_number_to_utf8_string (ecma_number_negate (num), dst_p, new_buffer_size); } else if (ecma_number_is_infinity (num)) @@ -1349,7 +1346,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */ uint32_t num_uint32 = ecma_number_to_uint32 (num); if (ecma_uint32_to_number (num_uint32) == num) { - size = (lit_utf8_size_t) ecma_uint32_to_utf8_string (num_uint32, dst_p, buffer_size); + size = ecma_uint32_to_utf8_string (num_uint32, dst_p, buffer_size); } else { @@ -1366,7 +1363,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */ if (k <= n && n <= 21) { dst_p += n; - JERRY_ASSERT ((ssize_t) (dst_p - buffer_p) <= buffer_size); + JERRY_ASSERT (dst_p <= buffer_p + buffer_size); size = (lit_utf8_size_t) (dst_p - buffer_p); @@ -1385,7 +1382,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */ { // 7. dst_p += k + 1; - JERRY_ASSERT ((ssize_t) (dst_p - buffer_p) <= buffer_size); + JERRY_ASSERT (dst_p <= buffer_p + buffer_size); size = (lit_utf8_size_t) (dst_p - buffer_p); @@ -1407,7 +1404,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */ { // 8. dst_p += k - n + 1 + 1; - JERRY_ASSERT ((ssize_t) (dst_p - buffer_p) <= buffer_size); + JERRY_ASSERT (dst_p <= buffer_p + buffer_size); size = (lit_utf8_size_t) (dst_p - buffer_p); @@ -1441,7 +1438,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */ { // 10. dst_p += k + 1; - JERRY_ASSERT ((ssize_t) (dst_p - buffer_p) <= buffer_size); + JERRY_ASSERT (dst_p <= buffer_p + buffer_size); for (int32_t i = 0; i < k - 1; i++) { @@ -1457,14 +1454,14 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */ } // 9., 10. - JERRY_ASSERT ((ssize_t) (dst_p - buffer_p + 2) <= buffer_size); + JERRY_ASSERT (dst_p + 2 <= buffer_p + buffer_size); *dst_p++ = e_chars[0]; *dst_p++ = (n >= 1) ? plus_char : minus_char; int32_t t = (n >= 1) ? (n - 1) : -(n - 1); if (t == 0) { - JERRY_ASSERT ((ssize_t) (dst_p - buffer_p) <= buffer_size); + JERRY_ASSERT (dst_p <= buffer_p + buffer_size); *dst_p++ = digits[0]; } else @@ -1480,7 +1477,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */ while (t_mod != 0) { - JERRY_ASSERT ((ssize_t) (dst_p - buffer_p + 1) <= buffer_size); + JERRY_ASSERT (dst_p + 1 <= buffer_p + buffer_size); *dst_p++ = digits[t / t_mod]; t -= (t / t_mod) * t_mod; @@ -1488,7 +1485,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */ } } - JERRY_ASSERT ((ssize_t) (dst_p - buffer_p) <= buffer_size); + JERRY_ASSERT (dst_p <= buffer_p + buffer_size); size = (lit_utf8_size_t) (dst_p - buffer_p); } diff --git a/jerry-core/ecma/base/ecma-helpers-string.c b/jerry-core/ecma/base/ecma-helpers-string.c index acc468cfba..19f65e9f5c 100644 --- a/jerry-core/ecma/base/ecma-helpers-string.c +++ b/jerry-core/ecma/base/ecma-helpers-string.c @@ -204,11 +204,11 @@ ecma_new_ecma_string_from_uint32 (uint32_t uint32_number) /**< UInt32-represente string_desc_p->container = ECMA_STRING_CONTAINER_UINT32_IN_DESC; lit_utf8_byte_t byte_buf[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32]; - ssize_t bytes_copied = ecma_uint32_to_utf8_string (uint32_number, - byte_buf, - ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32); + lit_utf8_size_t bytes_copied = ecma_uint32_to_utf8_string (uint32_number, + byte_buf, + ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32); - string_desc_p->hash = lit_utf8_string_calc_hash (byte_buf, (lit_utf8_size_t) bytes_copied); + string_desc_p->hash = lit_utf8_string_calc_hash (byte_buf, bytes_copied); string_desc_p->u.common_field = 0; string_desc_p->u.uint32_number = uint32_number; @@ -340,15 +340,15 @@ ecma_concat_ecma_strings (ecma_string_t *string1_p, /**< first ecma-string */ const size_t data_size = new_size + sizeof (ecma_string_heap_header_t); ecma_string_heap_header_t *data_p = (ecma_string_heap_header_t *) mem_heap_alloc_block (data_size); - ssize_t bytes_copied = ecma_string_to_utf8_string (string1_p, - (lit_utf8_byte_t *) (data_p + 1), - (ssize_t) str1_size); - JERRY_ASSERT (bytes_copied > 0); + lit_utf8_size_t bytes_copied = ecma_string_to_utf8_string (string1_p, + (lit_utf8_byte_t *) (data_p + 1), + str1_size); + JERRY_ASSERT (bytes_copied == str1_size); bytes_copied = ecma_string_to_utf8_string (string2_p, (lit_utf8_byte_t *) (data_p + 1) + str1_size, - (ssize_t) str2_size); - JERRY_ASSERT (bytes_copied > 0); + str2_size); + JERRY_ASSERT (bytes_copied == str2_size); data_p->size = (uint16_t) new_size; data_p->length = (uint16_t) (ecma_string_get_length (string1_p) + ecma_string_get_length (string2_p)); @@ -558,10 +558,10 @@ ecma_string_to_number (const ecma_string_t *str_p) /**< ecma-string */ MEM_DEFINE_LOCAL_ARRAY (str_buffer_p, string_size, lit_utf8_byte_t); - ssize_t bytes_copied = ecma_string_to_utf8_string (str_p, - str_buffer_p, - (ssize_t) string_size); - JERRY_ASSERT (bytes_copied > 0); + 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); @@ -609,29 +609,22 @@ ecma_string_get_array_index (const ecma_string_t *str_p, /**< ecma-string */ /** * Convert ecma-string's contents to a cesu-8 string and put it to the buffer. + * It is the caller's responsibility to make sure that the string fits in the buffer. * - * @return number of bytes, actually copied to the buffer - if string's content was copied successfully; - * otherwise (in case size of buffer is insufficient) - negative number, which is calculated - * as negation of buffer size, that is required to hold the string's content. + * @return number of bytes, actually copied to the buffer. */ -ssize_t __attr_return_value_should_be_checked___ +lit_utf8_size_t __attr_return_value_should_be_checked___ ecma_string_to_utf8_string (const ecma_string_t *string_desc_p, /**< ecma-string descriptor */ lit_utf8_byte_t *buffer_p, /**< destination buffer pointer * (can be NULL if buffer_size == 0) */ - ssize_t buffer_size) /**< size of buffer */ + lit_utf8_size_t buffer_size) /**< size of buffer */ { JERRY_ASSERT (string_desc_p != NULL); JERRY_ASSERT (string_desc_p->refs > 0); JERRY_ASSERT (buffer_p != NULL || buffer_size == 0); - JERRY_ASSERT (buffer_size >= 0); + JERRY_ASSERT (ecma_string_get_size (string_desc_p) <= buffer_size); - ssize_t required_buffer_size = (ssize_t) ecma_string_get_size (string_desc_p); - - if (required_buffer_size > buffer_size - || buffer_size == 0) - { - return -required_buffer_size; - } + lit_utf8_size_t size; switch ((ecma_string_container_t) string_desc_p->container) { @@ -639,62 +632,53 @@ ecma_string_to_utf8_string (const ecma_string_t *string_desc_p, /**< ecma-string { const ecma_string_heap_header_t *data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t, string_desc_p->u.collection_cp); - - memcpy (buffer_p, data_p + 1, (size_t) data_p->size); + size = data_p->size; + memcpy (buffer_p, data_p + 1, size); break; } case ECMA_STRING_CONTAINER_LIT_TABLE: { - lit_literal_t lit = lit_get_literal_by_cp (string_desc_p->u.lit_cp); + const lit_literal_t lit = lit_get_literal_by_cp (string_desc_p->u.lit_cp); JERRY_ASSERT (LIT_RECORD_IS_CHARSET (lit)); - lit_literal_to_utf8_string (lit, buffer_p, (size_t) required_buffer_size); + size = lit_charset_literal_get_size (lit); + memcpy (buffer_p, lit_charset_literal_get_charset (lit), size); break; } case ECMA_STRING_CONTAINER_UINT32_IN_DESC: { - uint32_t uint32_number = string_desc_p->u.uint32_number; - ssize_t bytes_copied = ecma_uint32_to_utf8_string (uint32_number, buffer_p, required_buffer_size); - - JERRY_ASSERT (bytes_copied == required_buffer_size); - + const uint32_t uint32_number = string_desc_p->u.uint32_number; + size = ecma_uint32_to_utf8_string (uint32_number, buffer_p, buffer_size); break; } case ECMA_STRING_CONTAINER_HEAP_NUMBER: { - ecma_number_t *num_p = ECMA_GET_NON_NULL_POINTER (ecma_number_t, - string_desc_p->u.number_cp); - - lit_utf8_size_t size = ecma_number_to_utf8_string (*num_p, buffer_p, buffer_size); - - JERRY_ASSERT (required_buffer_size == (ssize_t) size); - + const ecma_number_t *num_p = ECMA_GET_NON_NULL_POINTER (ecma_number_t, + string_desc_p->u.number_cp); + size = ecma_number_to_utf8_string (*num_p, buffer_p, buffer_size); break; } case ECMA_STRING_CONTAINER_MAGIC_STRING: { const lit_magic_string_id_t id = string_desc_p->u.magic_string_id; - const lit_utf8_size_t bytes_to_copy = lit_get_magic_string_size (id); - - memcpy (buffer_p, lit_get_magic_string_utf8 (id), bytes_to_copy); - - JERRY_ASSERT (required_buffer_size == (ssize_t) bytes_to_copy); - + size = lit_get_magic_string_size (id); + memcpy (buffer_p, lit_get_magic_string_utf8 (id), size); break; } case ECMA_STRING_CONTAINER_MAGIC_STRING_EX: { const lit_magic_string_ex_id_t id = string_desc_p->u.magic_string_ex_id; - const size_t bytes_to_copy = lit_get_magic_string_ex_size (id); - - memcpy (buffer_p, lit_get_magic_string_ex_utf8 (id), bytes_to_copy); - - JERRY_ASSERT (required_buffer_size == (ssize_t) bytes_to_copy); - + size = lit_get_magic_string_ex_size (id); + memcpy (buffer_p, lit_get_magic_string_ex_utf8 (id), size); break; } + default: + { + JERRY_UNREACHABLE (); + } } - return required_buffer_size; + JERRY_ASSERT (size <= buffer_size); + return size; } /* ecma_string_to_utf8_string */ /** @@ -820,8 +804,8 @@ ecma_compare_ecma_strings_longpath (const ecma_string_t *string1_p, /* ecma-stri { utf8_string1_p = (lit_utf8_byte_t *) mem_heap_alloc_block ((size_t) strings_size); - ssize_t bytes_copied = ecma_string_to_utf8_string (string1_p, utf8_string1_p, (ssize_t) strings_size); - JERRY_ASSERT (bytes_copied > 0); + lit_utf8_size_t bytes_copied = ecma_string_to_utf8_string (string1_p, utf8_string1_p, strings_size); + JERRY_ASSERT (bytes_copied == strings_size); is_utf8_string1_on_heap = true; } @@ -844,8 +828,8 @@ ecma_compare_ecma_strings_longpath (const ecma_string_t *string1_p, /* ecma-stri { utf8_string2_p = (lit_utf8_byte_t *) mem_heap_alloc_block ((size_t) strings_size); - ssize_t bytes_copied = ecma_string_to_utf8_string (string2_p, utf8_string2_p, (ssize_t) strings_size); - JERRY_ASSERT (bytes_copied > 0); + lit_utf8_size_t bytes_copied = ecma_string_to_utf8_string (string2_p, utf8_string2_p, strings_size); + JERRY_ASSERT (bytes_copied == strings_size); is_utf8_string2_on_heap = true; } @@ -959,25 +943,20 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma- } else { - const ssize_t req_size = ecma_string_to_utf8_string (string1_p, utf8_string1_buffer, sizeof (utf8_string1_buffer)); + utf8_string1_size = ecma_string_get_size (string1_p); - if (req_size < 0) + if (sizeof (utf8_string1_buffer) < utf8_string1_size) { - lit_utf8_byte_t *heap_buffer_p = (lit_utf8_byte_t *) mem_heap_alloc_block ((size_t) -req_size); - - ssize_t bytes_copied = ecma_string_to_utf8_string (string1_p, heap_buffer_p, -req_size); - utf8_string1_size = (lit_utf8_size_t) bytes_copied; - - JERRY_ASSERT (bytes_copied > 0); - - utf8_string1_p = heap_buffer_p; + utf8_string1_p = (lit_utf8_byte_t *) mem_heap_alloc_block (utf8_string1_size); is_utf8_string1_on_heap = true; } else { utf8_string1_p = utf8_string1_buffer; - utf8_string1_size = (lit_utf8_size_t) req_size; } + + lit_utf8_size_t bytes_copied = ecma_string_to_utf8_string (string1_p, utf8_string1_p, utf8_string1_size); + JERRY_ASSERT (bytes_copied == utf8_string1_size); } if (string2_p->container == ECMA_STRING_CONTAINER_HEAP_CHUNKS) @@ -998,24 +977,20 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma- } else { - const ssize_t req_size = ecma_string_to_utf8_string (string2_p, utf8_string2_buffer, sizeof (utf8_string2_buffer)); - if (req_size < 0) - { - lit_utf8_byte_t *heap_buffer_p = (lit_utf8_byte_t *) mem_heap_alloc_block ((size_t) -req_size); - - ssize_t bytes_copied = ecma_string_to_utf8_string (string2_p, heap_buffer_p, -req_size); - utf8_string2_size = (lit_utf8_size_t) bytes_copied; + utf8_string2_size = ecma_string_get_size (string2_p); - JERRY_ASSERT (bytes_copied > 0); - - utf8_string2_p = heap_buffer_p; + if (sizeof (utf8_string2_buffer) < utf8_string2_size) + { + utf8_string2_p = (lit_utf8_byte_t *) mem_heap_alloc_block (utf8_string2_size); is_utf8_string2_on_heap = true; } else { utf8_string2_p = utf8_string2_buffer; - utf8_string2_size = (lit_utf8_size_t) req_size; } + + lit_utf8_size_t bytes_copied = ecma_string_to_utf8_string (string2_p, utf8_string2_p, utf8_string2_size); + JERRY_ASSERT (bytes_copied == utf8_string2_size); } bool is_first_less_than_second = lit_compare_utf8_strings_relational (utf8_string1_p, @@ -1202,8 +1177,8 @@ ecma_string_get_char_at_pos (const ecma_string_t *string_p, /**< ecma-string */ MEM_DEFINE_LOCAL_ARRAY (utf8_str_p, buffer_size, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (string_p, utf8_str_p, (ssize_t) buffer_size); - JERRY_ASSERT (sz > 0); + lit_utf8_size_t sz = ecma_string_to_utf8_string (string_p, utf8_str_p, buffer_size); + JERRY_ASSERT (sz == buffer_size); ch = lit_utf8_string_code_unit_at (utf8_str_p, buffer_size, index); @@ -1228,8 +1203,8 @@ ecma_string_get_byte_at_pos (const ecma_string_t *string_p, /**< ecma-string */ MEM_DEFINE_LOCAL_ARRAY (utf8_str_p, buffer_size, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (string_p, utf8_str_p, (ssize_t) buffer_size); - JERRY_ASSERT (sz > 0); + lit_utf8_size_t sz = ecma_string_to_utf8_string (string_p, utf8_str_p, buffer_size); + JERRY_ASSERT (sz == buffer_size); byte = utf8_str_p[index]; @@ -1275,8 +1250,8 @@ ecma_is_string_magic_longpath (const ecma_string_t *string_p, /**< ecma-string * { lit_utf8_byte_t utf8_string_buffer[LIT_MAGIC_STRING_LENGTH_LIMIT]; - ssize_t copied = ecma_string_to_utf8_string (string_p, utf8_string_buffer, (ssize_t) sizeof (utf8_string_buffer)); - JERRY_ASSERT (copied > 0); + 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)); return lit_is_utf8_string_magic (utf8_string_buffer, (lit_utf8_size_t) copied, out_id_p); } /* ecma_is_string_magic_longpath */ @@ -1296,8 +1271,8 @@ ecma_is_ex_string_magic_longpath (const ecma_string_t *string_p, /**< ecma-strin { lit_utf8_byte_t utf8_string_buffer[LIT_MAGIC_STRING_LENGTH_LIMIT]; - ssize_t copied = ecma_string_to_utf8_string (string_p, utf8_string_buffer, (ssize_t) sizeof (utf8_string_buffer)); - JERRY_ASSERT (copied > 0); + 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)); return lit_is_ex_utf8_string_magic (utf8_string_buffer, (lit_utf8_size_t) copied, out_id_p); } /* ecma_is_ex_string_magic_longpath */ @@ -1406,8 +1381,8 @@ ecma_string_substr (const ecma_string_t *string_p, /**< pointer to an ecma strin lit_utf8_size_t buffer_size = ecma_string_get_size (string_p); MEM_DEFINE_LOCAL_ARRAY (utf8_str_p, buffer_size, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (string_p, utf8_str_p, (ssize_t) buffer_size); - JERRY_ASSERT (sz >= 0); + lit_utf8_size_t sz = ecma_string_to_utf8_string (string_p, utf8_str_p, buffer_size); + JERRY_ASSERT (sz == buffer_size); /** * II. Extract substring @@ -1456,8 +1431,8 @@ ecma_string_trim (const ecma_string_t *string_p) /**< pointer to an ecma string { MEM_DEFINE_LOCAL_ARRAY (utf8_str_p, buffer_size, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (string_p, utf8_str_p, (ssize_t) buffer_size); - JERRY_ASSERT (sz >= 0); + 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; diff --git a/jerry-core/ecma/base/ecma-helpers.h b/jerry-core/ecma/base/ecma-helpers.h index 2e602552e1..90930ffb74 100644 --- a/jerry-core/ecma/base/ecma-helpers.h +++ b/jerry-core/ecma/base/ecma-helpers.h @@ -98,8 +98,8 @@ extern void ecma_deref_ecma_string (ecma_string_t *); extern ecma_number_t ecma_string_to_number (const ecma_string_t *); extern bool ecma_string_get_array_index (const ecma_string_t *, uint32_t *); -extern ssize_t __attr_return_value_should_be_checked___ -ecma_string_to_utf8_string (const ecma_string_t *, lit_utf8_byte_t *, ssize_t); +extern lit_utf8_size_t __attr_return_value_should_be_checked___ +ecma_string_to_utf8_string (const ecma_string_t *, lit_utf8_byte_t *, lit_utf8_size_t); extern bool ecma_compare_ecma_strings_equal_hashes (const ecma_string_t *, const ecma_string_t *); extern bool ecma_compare_ecma_strings (const ecma_string_t *, const ecma_string_t *); @@ -239,12 +239,12 @@ ecma_free_external_pointer_in_property (ecma_property_t *); /* ecma-helpers-conversion.c */ extern ecma_number_t ecma_utf8_string_to_number (const lit_utf8_byte_t *, lit_utf8_size_t); -extern ssize_t ecma_uint32_to_utf8_string (uint32_t, lit_utf8_byte_t *, ssize_t); +extern lit_utf8_size_t ecma_uint32_to_utf8_string (uint32_t, lit_utf8_byte_t *, lit_utf8_size_t); extern uint32_t ecma_number_to_uint32 (ecma_number_t); extern int32_t ecma_number_to_int32 (ecma_number_t); extern ecma_number_t ecma_int32_to_number (int32_t); extern ecma_number_t ecma_uint32_to_number (uint32_t); -extern lit_utf8_size_t ecma_number_to_utf8_string (ecma_number_t, lit_utf8_byte_t *, ssize_t); +extern lit_utf8_size_t ecma_number_to_utf8_string (ecma_number_t, lit_utf8_byte_t *, lit_utf8_size_t); #endif /* !JERRY_ECMA_HELPERS_H */ diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-date.c b/jerry-core/ecma/builtin-objects/ecma-builtin-date.c index ed3298ef79..1eaa968616 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-date.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-date.c @@ -208,8 +208,8 @@ ecma_builtin_date_parse (ecma_value_t this_arg __attr_unused___, /**< this argum 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); - ssize_t sz = ecma_string_to_utf8_string (date_str_p, date_start_p, (ssize_t) date_str_size); - JERRY_ASSERT (sz >= 0); + 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; diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-error-prototype.c b/jerry-core/ecma/builtin-objects/ecma-builtin-error-prototype.c index 9dc49c2d41..06c3005562 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-error-prototype.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-error-prototype.c @@ -132,43 +132,37 @@ ecma_builtin_error_prototype_object_to_string (ecma_value_t this_arg) /**< this } else { - const lit_utf8_size_t size = (ecma_string_get_size (name_string_p) + - ecma_string_get_size (msg_string_p) + - lit_get_magic_string_size (LIT_MAGIC_STRING_COLON_CHAR) + - lit_get_magic_string_size (LIT_MAGIC_STRING_SPACE_CHAR)); + const lit_utf8_size_t name_size = ecma_string_get_size (name_string_p); + const lit_utf8_size_t msg_size = ecma_string_get_size (msg_string_p); + const lit_utf8_size_t colon_size = lit_get_magic_string_size (LIT_MAGIC_STRING_COLON_CHAR); + const lit_utf8_size_t space_size = lit_get_magic_string_size (LIT_MAGIC_STRING_SPACE_CHAR); + const lit_utf8_size_t size = name_size + msg_size + colon_size + space_size; - const ssize_t buffer_size = (ssize_t) size; - ssize_t buffer_size_left = buffer_size; - - MEM_DEFINE_LOCAL_ARRAY (ret_str_buffer, buffer_size, lit_utf8_byte_t); + MEM_DEFINE_LOCAL_ARRAY (ret_str_buffer, size, lit_utf8_byte_t); lit_utf8_byte_t *ret_str_buffer_p = ret_str_buffer; - ssize_t bytes = ecma_string_to_utf8_string (name_string_p, ret_str_buffer_p, buffer_size_left); - JERRY_ASSERT (bytes >= 0 && buffer_size_left - bytes >= 0); - - buffer_size_left -= bytes; - ret_str_buffer_p = ret_str_buffer + buffer_size - buffer_size_left; + lit_utf8_size_t bytes = ecma_string_to_utf8_string (name_string_p, ret_str_buffer_p, name_size); + JERRY_ASSERT (bytes == name_size); + ret_str_buffer_p = ret_str_buffer_p + bytes; + JERRY_ASSERT (ret_str_buffer_p <= ret_str_buffer + size); ret_str_buffer_p = lit_copy_magic_string_to_buffer (LIT_MAGIC_STRING_COLON_CHAR, ret_str_buffer_p, - buffer_size_left); - buffer_size_left = buffer_size - (ret_str_buffer_p - ret_str_buffer); - JERRY_ASSERT (buffer_size_left >= 0); + colon_size); + JERRY_ASSERT (ret_str_buffer_p <= ret_str_buffer + size); ret_str_buffer_p = lit_copy_magic_string_to_buffer (LIT_MAGIC_STRING_SPACE_CHAR, ret_str_buffer_p, - buffer_size_left); - buffer_size_left = buffer_size - (ret_str_buffer_p - ret_str_buffer); - JERRY_ASSERT (buffer_size_left >= 0); - - bytes = ecma_string_to_utf8_string (msg_string_p, ret_str_buffer_p, buffer_size_left); - JERRY_ASSERT (bytes >= 0 && buffer_size_left - bytes >= 0); + space_size); + JERRY_ASSERT (ret_str_buffer_p <= ret_str_buffer + size); - buffer_size_left -= bytes; - JERRY_ASSERT (buffer_size_left >= 0); + bytes = ecma_string_to_utf8_string (msg_string_p, ret_str_buffer_p, msg_size); + JERRY_ASSERT (bytes == msg_size); + ret_str_buffer_p = ret_str_buffer_p + bytes; + JERRY_ASSERT (ret_str_buffer_p == ret_str_buffer + size); ret_str_p = ecma_new_ecma_string_from_utf8 (ret_str_buffer, - (jerry_api_size_t) (buffer_size - buffer_size_left)); + size); MEM_FINALIZE_LOCAL_ARRAY (ret_str_buffer); } diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-global.c b/jerry-core/ecma/builtin-objects/ecma-builtin-global.c index 114b13e21f..95fbe8f3be 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-global.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-global.c @@ -88,8 +88,8 @@ ecma_builtin_global_object_print (ecma_value_t this_arg __attr_unused___, /**< t utf8_str_size, lit_utf8_byte_t); - ssize_t actual_sz = ecma_string_to_utf8_string (str_p, utf8_str_p, (ssize_t) utf8_str_size); - JERRY_ASSERT (actual_sz == (ssize_t) utf8_str_size); + lit_utf8_size_t actual_sz = ecma_string_to_utf8_string (str_p, utf8_str_p, utf8_str_size); + JERRY_ASSERT (actual_sz == utf8_str_size); lit_utf8_byte_t *utf8_str_curr_p = utf8_str_p; const lit_utf8_byte_t *utf8_str_end_p = utf8_str_p + utf8_str_size; @@ -212,10 +212,10 @@ ecma_builtin_global_object_parse_int (ecma_value_t this_arg __attr_unused___, /* { MEM_DEFINE_LOCAL_ARRAY (string_buff, str_size, lit_utf8_byte_t); - ssize_t bytes_copied = ecma_string_to_utf8_string (number_str_p, - string_buff, - (ssize_t) str_size); - JERRY_ASSERT (bytes_copied >= 0); + 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; @@ -437,10 +437,10 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___, { MEM_DEFINE_LOCAL_ARRAY (string_buff, str_size, lit_utf8_byte_t); - ssize_t bytes_copied = ecma_string_to_utf8_string (number_str_p, - string_buff, - (ssize_t) str_size); - JERRY_ASSERT (bytes_copied >= 0); + 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; @@ -771,10 +771,10 @@ ecma_builtin_global_object_decode_uri_helper (ecma_value_t uri __attr_unused___, input_size + 1, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (input_string_p, - input_start_p, - (ssize_t) (input_size)); - JERRY_ASSERT (sz >= 0); + lit_utf8_size_t sz = ecma_string_to_utf8_string (input_string_p, + input_start_p, + input_size); + JERRY_ASSERT (sz == input_size); input_start_p[input_size] = LIT_BYTE_NULL; @@ -1049,10 +1049,10 @@ ecma_builtin_global_object_encode_uri_helper (ecma_value_t uri, /**< uri argumen input_size, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (input_string_p, - input_start_p, - (ssize_t) (input_size)); - JERRY_ASSERT (sz >= 0); + lit_utf8_size_t sz = ecma_string_to_utf8_string (input_string_p, + input_start_p, + input_size); + JERRY_ASSERT (sz == input_size); /* * The URI encoding has two major phases: first we validate the input, @@ -1270,10 +1270,10 @@ ecma_builtin_global_object_escape (ecma_value_t this_arg __attr_unused___, /**< input_size, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (input_string_p, - input_start_p, - (ssize_t) (input_size)); - JERRY_ASSERT (sz >= 0); + lit_utf8_size_t sz = ecma_string_to_utf8_string (input_string_p, + input_start_p, + input_size); + JERRY_ASSERT (sz == input_size); /* * The escape routine has two major phases: first we compute @@ -1390,8 +1390,8 @@ ecma_builtin_global_object_unescape (ecma_value_t this_arg __attr_unused___, /** /* 3. */ MEM_DEFINE_LOCAL_ARRAY (input_start_p, input_size, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (input_string_p, input_start_p, (ssize_t) (input_size)); - JERRY_ASSERT (sz >= 0); + lit_utf8_size_t sz = ecma_string_to_utf8_string (input_string_p, input_start_p, input_size); + JERRY_ASSERT (sz == input_size); lit_utf8_byte_t *input_curr_p = input_start_p; lit_utf8_byte_t *input_end_p = input_start_p + input_size; diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c b/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c index c7b9b72efb..47742656f1 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c @@ -84,11 +84,10 @@ ecma_builtin_helper_object_to_string (const ecma_value_t this_arg) /**< this arg /* Building string "[object #type#]" where type is 'Undefined', 'Null' or one of possible object's classes. The string with null character is maximum 19 characters long. */ - const ssize_t buffer_size = 19; + const lit_utf8_size_t buffer_size = 19; MEM_DEFINE_LOCAL_ARRAY (str_buffer, buffer_size, lit_utf8_byte_t); lit_utf8_byte_t *buffer_ptr = str_buffer; - ssize_t buffer_size_left = buffer_size; const lit_magic_string_id_t magic_string_ids[] = { @@ -101,13 +100,12 @@ ecma_builtin_helper_object_to_string (const ecma_value_t this_arg) /**< this arg for (uint32_t i = 0; i < sizeof (magic_string_ids) / sizeof (lit_magic_string_id_t); ++i) { - buffer_ptr = lit_copy_magic_string_to_buffer (magic_string_ids[i], buffer_ptr, buffer_size_left); - buffer_size_left = buffer_size - (buffer_ptr - str_buffer); + buffer_ptr = lit_copy_magic_string_to_buffer (magic_string_ids[i], buffer_ptr, + (lit_utf8_size_t) ((str_buffer + buffer_size) - buffer_ptr)); + JERRY_ASSERT (buffer_ptr <= str_buffer + buffer_size); } - JERRY_ASSERT (buffer_size_left >= 0); - - ret_string_p = ecma_new_ecma_string_from_utf8 (str_buffer, (lit_utf8_size_t) (buffer_size - buffer_size_left)); + ret_string_p = ecma_new_ecma_string_from_utf8 (str_buffer, (lit_utf8_size_t) (buffer_ptr - str_buffer)); MEM_FINALIZE_LOCAL_ARRAY (str_buffer); @@ -588,10 +586,10 @@ ecma_builtin_helper_string_find_index (ecma_string_t *original_str_p, /**< index original_size, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (original_str_p, - original_str_utf8_p, - (ssize_t) (original_size)); - JERRY_ASSERT (sz >= 0); + 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_length_t index = start_pos; @@ -606,10 +604,10 @@ ecma_builtin_helper_string_find_index (ecma_string_t *original_str_p, /**< index search_size, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (search_str_p, - search_str_utf8_p, - (ssize_t) (search_size)); - JERRY_ASSERT (sz >= 0); + 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; diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-json.c b/jerry-core/ecma/builtin-objects/ecma-builtin-json.c index 0c0fccac66..bdebff2890 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-json.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-json.c @@ -710,12 +710,12 @@ ecma_builtin_json_parse (ecma_value_t this_arg __attr_unused___, /**< 'this' arg ecma_string_t *string_p = ecma_get_string_from_value (string); ecma_length_t string_size = (uint32_t) ecma_string_get_size (string_p); - size_t buffer_size = sizeof (lit_utf8_byte_t) * (string_size + 1); + 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); - ssize_t sz = ecma_string_to_utf8_string (string_p, str_start_p, (ssize_t) buffer_size); - JERRY_ASSERT (sz == (ssize_t) string_size); + 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; @@ -1068,11 +1068,11 @@ ecma_builtin_json_quote (ecma_string_t *string_p) /**< string that should be quo MEM_DEFINE_LOCAL_ARRAY (string_buff, string_size, lit_utf8_byte_t); - ssize_t bytes_copied = ecma_string_to_utf8_string (string_p, - string_buff, - (ssize_t) string_size); + lit_utf8_size_t bytes_copied = ecma_string_to_utf8_string (string_p, + string_buff, + string_size); - JERRY_ASSERT (bytes_copied > 0 || !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; 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 26aa50c264..fa99a39c56 100644 --- a/jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.c +++ b/jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.c @@ -1204,10 +1204,10 @@ ecma_builtin_string_prototype_object_replace_main (ecma_builtin_replace_search_c replace_size, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (replace_string_p, - replace_start_p, - (ssize_t) (replace_size)); - JERRY_ASSERT (sz >= 0); + lit_utf8_size_t sz = ecma_string_to_utf8_string (replace_string_p, + replace_start_p, + replace_size); + JERRY_ASSERT (sz == replace_size); context_p->replace_string_p = replace_string_p; context_p->replace_str_curr_p = replace_start_p; @@ -2079,10 +2079,10 @@ ecma_builtin_string_prototype_object_conversion_helper (ecma_value_t this_arg, / input_size, lit_utf8_byte_t); - ssize_t sz = ecma_string_to_utf8_string (input_string_p, - input_start_p, - (ssize_t) (input_size)); - JERRY_ASSERT (sz >= 0); + lit_utf8_size_t sz = ecma_string_to_utf8_string (input_string_p, + input_start_p, + input_size); + JERRY_ASSERT (sz == input_size); /* * The URI encoding has two major phases: first we compute @@ -2097,8 +2097,8 @@ ecma_builtin_string_prototype_object_conversion_helper (ecma_value_t this_arg, / { ecma_char_t character = lit_utf8_read_next (&input_str_curr_p); ecma_char_t character_buffer[LIT_MAXIMUM_OTHER_CASE_LENGTH]; + ecma_length_t character_length; lit_utf8_byte_t utf8_byte_buffer[LIT_CESU8_MAX_BYTES_IN_CODE_POINT]; - lit_utf8_size_t character_length; if (lower_case) { @@ -2115,7 +2115,7 @@ ecma_builtin_string_prototype_object_conversion_helper (ecma_value_t this_arg, / JERRY_ASSERT (character_length >= 1 && character_length <= LIT_MAXIMUM_OTHER_CASE_LENGTH); - for (lit_utf8_size_t i = 0; i < character_length; i++) + for (ecma_length_t i = 0; i < character_length; i++) { output_length += lit_code_unit_to_utf8 (character_buffer[i], utf8_byte_buffer); } @@ -2136,7 +2136,7 @@ ecma_builtin_string_prototype_object_conversion_helper (ecma_value_t this_arg, / { ecma_char_t character = lit_utf8_read_next (&input_str_curr_p); ecma_char_t character_buffer[LIT_MAXIMUM_OTHER_CASE_LENGTH]; - lit_utf8_size_t character_length; + ecma_length_t character_length; if (lower_case) { @@ -2153,7 +2153,7 @@ ecma_builtin_string_prototype_object_conversion_helper (ecma_value_t this_arg, / JERRY_ASSERT (character_length >= 1 && character_length <= LIT_MAXIMUM_OTHER_CASE_LENGTH); - for (lit_utf8_size_t i = 0; i < character_length; i++) + for (ecma_length_t i = 0; i < character_length; i++) { output_char_p += lit_code_unit_to_utf8 (character_buffer[i], output_char_p); } diff --git a/jerry-core/ecma/operations/ecma-eval.c b/jerry-core/ecma/operations/ecma-eval.c index 1144507ba8..9ae6744cc7 100644 --- a/jerry-core/ecma/operations/ecma-eval.c +++ b/jerry-core/ecma/operations/ecma-eval.c @@ -56,14 +56,13 @@ ecma_op_eval (ecma_string_t *code_p, /**< code string */ chars_num, lit_utf8_byte_t); - const ssize_t buf_size = (ssize_t) chars_num; - ssize_t buffer_size_req = ecma_string_to_utf8_string (code_p, - code_utf8_buffer_p, - buf_size); - JERRY_ASSERT (buffer_size_req == buf_size); + 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); ret_value = ecma_op_eval_chars_buffer ((jerry_api_char_t *) code_utf8_buffer_p, - (size_t) buf_size, + chars_num, is_direct, is_called_from_strict_mode_code); diff --git a/jerry-core/ecma/operations/ecma-regexp-object.c b/jerry-core/ecma/operations/ecma-regexp-object.c index da2ee9c4c1..97d4eff0da 100644 --- a/jerry-core/ecma/operations/ecma-regexp-object.c +++ b/jerry-core/ecma/operations/ecma-regexp-object.c @@ -79,8 +79,8 @@ re_parse_regexp_flags (ecma_string_t *flags_str_p, /**< Input string with flags 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); - ssize_t sz = ecma_string_to_utf8_string (flags_str_p, flags_start_p, (ssize_t) flags_str_size); - JERRY_ASSERT (sz >= 0); + 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; @@ -349,7 +349,7 @@ re_canonicalize (ecma_char_t ch, /**< character */ { /* 2. */ ecma_char_t u[LIT_MAXIMUM_OTHER_CASE_LENGTH]; - lit_utf8_size_t size = lit_char_to_upper_case (ch, u, LIT_MAXIMUM_OTHER_CASE_LENGTH); + ecma_length_t size = lit_char_to_upper_case (ch, u, LIT_MAXIMUM_OTHER_CASE_LENGTH); /* 3. */ if (size == 1) @@ -1281,8 +1281,8 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */ re_matcher_ctx_t re_ctx; lit_utf8_byte_t *input_curr_p = NULL; - ssize_t sz = ecma_string_to_utf8_string (input_string_p, input_buffer_p, (ssize_t) input_string_size); - JERRY_ASSERT (sz >= 0); + 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) { diff --git a/jerry-core/jerry-api.h b/jerry-core/jerry-api.h index 555b0088f6..1ee3969463 100644 --- a/jerry-core/jerry-api.h +++ b/jerry-core/jerry-api.h @@ -269,7 +269,7 @@ jerry_api_value_t jerry_api_create_object_value (jerry_api_object_t *value); */ jerry_api_value_t jerry_api_create_string_value (jerry_api_string_t *value); -ssize_t jerry_api_string_to_char_buffer (const jerry_api_string_t *, jerry_api_char_t *, ssize_t); +jerry_api_size_t jerry_api_string_to_char_buffer (const jerry_api_string_t *, jerry_api_char_t *, jerry_api_size_t); jerry_api_string_t *jerry_api_acquire_string (jerry_api_string_t *); jerry_api_object_t *jerry_api_acquire_object (jerry_api_object_t *); diff --git a/jerry-core/jerry.c b/jerry-core/jerry.c index 0152026356..443fcf8d4a 100644 --- a/jerry-core/jerry.c +++ b/jerry-core/jerry.c @@ -548,19 +548,18 @@ jerry_api_convert_eval_completion_to_retval (jerry_api_value_t *retval_p, /**< [ */ /** - * Copy string characters to specified buffer. + * Copy string characters to specified buffer. It is the caller's responsibility + * to make sure that the string fits in the buffer. * * Note: * '\0' could occur in characters. * - * @return number of bytes, actually copied to the buffer - if string's content was copied successfully; - * otherwise (in case size of buffer is insufficient) - negative number, which is calculated - * as negation of buffer size, that is required to hold the string's content. + * @return number of bytes, actually copied to the buffer. */ -ssize_t +jerry_api_size_t jerry_api_string_to_char_buffer (const jerry_api_string_t *string_p, /**< string descriptor */ jerry_api_char_t *buffer_p, /**< [out] output characters buffer */ - ssize_t buffer_size) /**< size of output buffer */ + jerry_api_size_t buffer_size) /**< size of output buffer */ { jerry_assert_api_available (); diff --git a/jerry-core/lit/lit-char-helpers.c b/jerry-core/lit/lit-char-helpers.c index b86b27ccd0..e884bcb64f 100644 --- a/jerry-core/lit/lit-char-helpers.c +++ b/jerry-core/lit/lit-char-helpers.c @@ -353,10 +353,10 @@ lit_char_is_word_char (ecma_char_t c) /**< code unit */ * @return the length of the lowercase character sequence * which is always between 1 and LIT_MAXIMUM_OTHER_CASE_LENGTH. */ -lit_utf8_size_t +ecma_length_t lit_char_to_lower_case (ecma_char_t character, /**< input character value */ ecma_char_t *output_buffer_p, /**< [out] buffer for the result characters */ - size_t buffer_size) /**< buffer size */ + ecma_length_t buffer_size) /**< buffer size */ { TODO ("Needs a proper lower case implementation. See issue #323."); @@ -387,10 +387,10 @@ lit_char_to_lower_case (ecma_char_t character, /**< input character value */ * @return the length of the uppercase character sequence * which is always between 1 and LIT_MAXIMUM_OTHER_CASE_LENGTH. */ -lit_utf8_size_t +ecma_length_t lit_char_to_upper_case (ecma_char_t character, /**< input character value */ ecma_char_t *output_buffer_p, /**< buffer for the result characters */ - size_t buffer_size) /**< buffer size */ + ecma_length_t buffer_size) /**< buffer size */ { TODO ("Needs a proper upper case implementation. See issue #323."); diff --git a/jerry-core/lit/lit-char-helpers.h b/jerry-core/lit/lit-char-helpers.h index a01c2aed21..7a438fb825 100644 --- a/jerry-core/lit/lit-char-helpers.h +++ b/jerry-core/lit/lit-char-helpers.h @@ -234,7 +234,7 @@ extern bool lit_char_is_word_char (ecma_char_t); */ #define LIT_MAXIMUM_OTHER_CASE_LENGTH (3) -lit_utf8_size_t lit_char_to_lower_case (ecma_char_t, ecma_char_t *, size_t); -lit_utf8_size_t lit_char_to_upper_case (ecma_char_t, ecma_char_t *, size_t); +ecma_length_t lit_char_to_lower_case (ecma_char_t, ecma_char_t *, ecma_length_t); +ecma_length_t lit_char_to_upper_case (ecma_char_t, ecma_char_t *, ecma_length_t); #endif /* LIT_CHAR_HELPERS_H */ diff --git a/jerry-core/lit/lit-literal.c b/jerry-core/lit/lit-literal.c index 4531996a89..323617a7cd 100644 --- a/jerry-core/lit/lit-literal.c +++ b/jerry-core/lit/lit-literal.c @@ -520,63 +520,6 @@ lit_literal_equal_type (lit_literal_t lit1, /**< first literal */ return lit_literal_equal (lit1, lit2); } /* lit_literal_equal_type */ -/** - * Get the contents of the literal as a zero-terminated string. - * If literal is a magic string record, the corresponding string is not copied to the buffer, - * but is returned directly. - * - * @return pointer to the zero-terminated string. - */ -const lit_utf8_byte_t * -lit_literal_to_utf8_string (lit_literal_t lit, /**< literal to be processed */ - lit_utf8_byte_t *buff_p, /**< buffer to use as a string storage */ - size_t size) /**< size of the buffer */ -{ - JERRY_ASSERT (buff_p != NULL && size > 0); - - switch (lit->type) - { - case LIT_RECORD_TYPE_CHARSET: - { - const size_t str_size = lit_charset_literal_get_size (lit); - memcpy (buff_p, lit_charset_literal_get_charset (lit), (size > str_size) ? str_size : size); - return buff_p; - } - case LIT_RECORD_TYPE_MAGIC_STR: - { - return lit_get_magic_string_utf8 (lit_magic_literal_get_magic_str_id (lit)); - } - case LIT_RECORD_TYPE_MAGIC_STR_EX: - { - return lit_get_magic_string_ex_utf8 (lit_magic_literal_get_magic_str_ex_id (lit)); - } - case LIT_RECORD_TYPE_NUMBER: - { - ecma_number_t number = lit_number_literal_get_number (lit); - ecma_number_to_utf8_string (number, buff_p, (ssize_t) size); - return buff_p; - } - } - - JERRY_UNREACHABLE (); -} /* lit_literal_to_utf8_string */ - -/** - * Get the contents of the literal as a C string. - * If literal holds a very long string, it would be trimmed to ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER characters. - * - * @return pointer to the C string. - */ -const char * -lit_literal_to_str_internal_buf (lit_literal_t lit) /**< literal */ -{ - static lit_utf8_byte_t buff[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER + 1]; - memset (buff, 0, sizeof (buff)); - - return (const char *) lit_literal_to_utf8_string (lit, buff, sizeof (buff) - 1); -} /* lit_literal_to_str_internal_buf */ - - /** * Check if literal really exists in the storage * diff --git a/jerry-core/lit/lit-literal.h b/jerry-core/lit/lit-literal.h index 5a5a662fa8..50dd0727ed 100644 --- a/jerry-core/lit/lit-literal.h +++ b/jerry-core/lit/lit-literal.h @@ -49,9 +49,6 @@ extern bool lit_literal_equal_type_num (lit_literal_t, ecma_number_t); extern bool lit_literal_equal_type (lit_literal_t, lit_literal_t); extern bool lit_literal_equal_charset (lit_literal_t, const lit_utf8_byte_t *, lit_utf8_size_t); -extern const lit_utf8_byte_t *lit_literal_to_utf8_string (lit_literal_t, lit_utf8_byte_t *, size_t); -extern const char *lit_literal_to_str_internal_buf (lit_literal_t); - extern lit_literal_t lit_get_literal_by_cp (lit_cpointer_t); extern ecma_number_t lit_number_literal_get_number (lit_literal_t); diff --git a/jerry-core/lit/lit-magic-strings.c b/jerry-core/lit/lit-magic-strings.c index 82e0abc4ae..50cd22055f 100644 --- a/jerry-core/lit/lit-magic-strings.c +++ b/jerry-core/lit/lit-magic-strings.c @@ -257,14 +257,14 @@ lit_compare_utf8_string_and_magic_string_ex (const lit_utf8_byte_t *string_p, /* extern lit_utf8_byte_t * lit_copy_magic_string_to_buffer (lit_magic_string_id_t id, /**< magic string id */ lit_utf8_byte_t *buffer_p, /**< destination buffer */ - ssize_t buffer_size) /**< size of buffer */ + lit_utf8_size_t buffer_size) /**< size of buffer */ { const lit_utf8_byte_t *magic_string_bytes_p = lit_get_magic_string_utf8 (id); lit_utf8_size_t magic_string_bytes_count = lit_get_magic_string_size (id); const lit_utf8_byte_t *str_iter_p = magic_string_bytes_p; lit_utf8_byte_t *buf_iter_p = buffer_p; - ssize_t bytes_copied = 0; + lit_utf8_size_t bytes_copied = 0; while (magic_string_bytes_count--) { diff --git a/jerry-core/lit/lit-magic-strings.h b/jerry-core/lit/lit-magic-strings.h index cc2ecf66ad..a1fd1a45a4 100644 --- a/jerry-core/lit/lit-magic-strings.h +++ b/jerry-core/lit/lit-magic-strings.h @@ -62,6 +62,6 @@ extern bool lit_compare_utf8_string_and_magic_string (const lit_utf8_byte_t *, l extern bool lit_compare_utf8_string_and_magic_string_ex (const lit_utf8_byte_t *, lit_utf8_size_t, lit_magic_string_ex_id_t); -extern lit_utf8_byte_t *lit_copy_magic_string_to_buffer (lit_magic_string_id_t, lit_utf8_byte_t *, ssize_t); +extern lit_utf8_byte_t *lit_copy_magic_string_to_buffer (lit_magic_string_id_t, lit_utf8_byte_t *, lit_utf8_size_t); #endif /* LIT_MAGIC_STRINGS_H */ diff --git a/jerry-core/parser/regexp/re-compiler.c b/jerry-core/parser/regexp/re-compiler.c index f694564cf4..abc24ea7be 100644 --- a/jerry-core/parser/regexp/re-compiler.c +++ b/jerry-core/parser/regexp/re-compiler.c @@ -545,8 +545,8 @@ re_compile_bytecode (re_compiled_code_t **out_bytecode_p, /**< [out] pointer to 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); - ssize_t sz = ecma_string_to_utf8_string (pattern_str_p, pattern_start_p, (ssize_t) pattern_str_size); - JERRY_ASSERT (sz >= 0); + 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); re_parser_ctx_t parser_ctx; parser_ctx.input_start_p = pattern_start_p; diff --git a/main-unix.c b/main-unix.c index bcb52e96eb..4bf5d9e26c 100644 --- a/main-unix.c +++ b/main-unix.c @@ -560,8 +560,8 @@ main (int argc, jerry_api_size_t err_str_size = jerry_api_get_string_size (err_str_p); JERRY_ASSERT (err_str_size < 256); - ssize_t sz = jerry_api_string_to_char_buffer (err_str_p, err_str_buf, err_str_size); - JERRY_ASSERT (sz > 0); + jerry_api_size_t sz = jerry_api_string_to_char_buffer (err_str_p, err_str_buf, err_str_size); + JERRY_ASSERT (sz == err_str_size); err_str_buf[err_str_size] = 0; JERRY_ERROR_MSG ("%s\n", err_str_buf); diff --git a/tests/unit/test-api.c b/tests/unit/test-api.c index 20db6d4c2f..8457d9cead 100644 --- a/tests/unit/test-api.c +++ b/tests/unit/test-api.c @@ -116,16 +116,16 @@ handler (const jerry_api_object_t *function_obj_p, const jerry_api_length_t args_cnt) { char buffer[32]; - ssize_t sz; + jerry_api_size_t sz; printf ("ok %p %p %p %d %p\n", function_obj_p, this_p, args_p, args_cnt, ret_val_p); JERRY_ASSERT (args_cnt == 2); JERRY_ASSERT (args_p[0].type == JERRY_API_DATA_TYPE_STRING); - sz = jerry_api_string_to_char_buffer (args_p[0].u.v_string, NULL, 0); - JERRY_ASSERT (sz == -1); - sz = jerry_api_string_to_char_buffer (args_p[0].u.v_string, (jerry_api_char_t *) buffer, -sz); + sz = jerry_api_get_string_size (args_p[0].u.v_string); + JERRY_ASSERT (sz == 1); + sz = jerry_api_string_to_char_buffer (args_p[0].u.v_string, (jerry_api_char_t *) buffer, sz); JERRY_ASSERT (sz == 1); JERRY_ASSERT (!strncmp (buffer, "1", (size_t) sz)); @@ -239,7 +239,7 @@ static bool foreach (const jerry_api_string_t *name, const jerry_api_value_t *value, void *user_data) { char str_buf_p[128]; - ssize_t sz = jerry_api_string_to_char_buffer (name, (jerry_api_char_t *)str_buf_p, 128); + jerry_api_size_t sz = jerry_api_string_to_char_buffer (name, (jerry_api_char_t *)str_buf_p, 128); str_buf_p[sz] = '\0'; if (!strncmp (str_buf_p, "alpha", (size_t)sz)) @@ -274,7 +274,7 @@ static bool foreach (const jerry_api_string_t *name, else if (!strncmp (str_buf_p, "echo", (size_t)sz)) { JERRY_ASSERT (value->type == JERRY_API_DATA_TYPE_STRING); - ssize_t echo_sz = jerry_api_string_to_char_buffer (value->u.v_string, (jerry_api_char_t *)str_buf_p, 128); + jerry_api_size_t echo_sz = jerry_api_string_to_char_buffer (value->u.v_string, (jerry_api_char_t *)str_buf_p, 128); str_buf_p[echo_sz] = '\0'; JERRY_ASSERT (!strncmp (str_buf_p, "foobar", (size_t)echo_sz)); } @@ -294,10 +294,10 @@ static bool foreach_exception (const jerry_api_string_t *name, const jerry_api_v UNUSED (value); UNUSED (user_data); char str_buf_p[128]; - ssize_t sz = jerry_api_string_to_char_buffer (name, (jerry_api_char_t *)str_buf_p, 128); + jerry_api_size_t sz = jerry_api_string_to_char_buffer (name, (jerry_api_char_t *) str_buf_p, 128); str_buf_p[sz] = '\0'; - if (!strncmp (str_buf_p, "foxtrot", (size_t)sz)) + if (!strncmp (str_buf_p, "foxtrot", (size_t) sz)) { JERRY_ASSERT (false); } @@ -326,7 +326,7 @@ main (void) jerry_init (JERRY_FLAG_EMPTY); bool is_ok, is_exception; - ssize_t sz; + jerry_api_size_t sz; jerry_api_value_t val_t, val_foo, val_bar, val_A, val_A_prototype, val_a, val_a_foo, val_value_field, val_p, val_np; jerry_api_value_t val_external, val_external_construct, val_call_external; jerry_api_object_t *global_obj_p, *obj_p; @@ -346,7 +346,7 @@ main (void) // Test corner case for jerry_api_string_to_char_buffer test_api_init_api_value_string (&args[0], ""); - sz = jerry_api_string_to_char_buffer (args[0].u.v_string, NULL, 0); + sz = jerry_api_get_string_size (args[0].u.v_string); JERRY_ASSERT (sz == 0); jerry_api_release_value (&args[0]); @@ -396,9 +396,9 @@ main (void) is_ok = jerry_api_call_function (val_foo.u.v_object, NULL, &res, args, 2); JERRY_ASSERT (is_ok && res.type == JERRY_API_DATA_TYPE_STRING); - sz = jerry_api_string_to_char_buffer (res.u.v_string, NULL, 0); - JERRY_ASSERT (sz == -4); - sz = jerry_api_string_to_char_buffer (res.u.v_string, (jerry_api_char_t *) buffer, -sz); + sz = jerry_api_get_string_size (res.u.v_string); + JERRY_ASSERT (sz == 4); + sz = jerry_api_string_to_char_buffer (res.u.v_string, (jerry_api_char_t *) buffer, sz); JERRY_ASSERT (sz == 4); jerry_api_release_value (&res); JERRY_ASSERT (!strncmp (buffer, "abcd", (size_t) sz)); @@ -496,9 +496,9 @@ main (void) jerry_api_release_value (&val_call_external); JERRY_ASSERT (is_ok && res.type == JERRY_API_DATA_TYPE_STRING); - sz = jerry_api_string_to_char_buffer (res.u.v_string, NULL, 0); - JERRY_ASSERT (sz == -19); - sz = jerry_api_string_to_char_buffer (res.u.v_string, (jerry_api_char_t *) buffer, -sz); + sz = jerry_api_get_string_size (res.u.v_string); + JERRY_ASSERT (sz == 19); + sz = jerry_api_string_to_char_buffer (res.u.v_string, (jerry_api_char_t *) buffer, sz); JERRY_ASSERT (sz == 19); jerry_api_release_value (&res); JERRY_ASSERT (!strncmp (buffer, "string from handler", (size_t) sz)); @@ -738,9 +738,9 @@ main (void) JERRY_ASSERT (is_ok && res.type == JERRY_API_DATA_TYPE_STRING); - sz = jerry_api_string_to_char_buffer (res.u.v_string, NULL, 0); - JERRY_ASSERT (sz == -20); - sz = jerry_api_string_to_char_buffer (res.u.v_string, (jerry_api_char_t *) buffer, -sz); + sz = jerry_api_get_string_size (res.u.v_string); + JERRY_ASSERT (sz == 20); + sz = jerry_api_string_to_char_buffer (res.u.v_string, (jerry_api_char_t *) buffer, sz); JERRY_ASSERT (sz == 20); jerry_api_release_value (&res); JERRY_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz));