archive-gh-me/jerryscript
1
0
Fork 0
mirror of https://github.com/jerryscript-project/jerryscript.git synced 2025-12-15 16:29:21 +00:00
Code Issues Projects Releases Wiki Activity

Fix problems arising from incorrect use of various size types

Browse Source 
E.g.,
* `ssize_t` was used where `lit_utf8_size_t` or `jerry_api_size_t`
  would have been correct,
* `lit_utf8_size_t` was used where `ecma_length_t` would have been
  correct.

Note, the patch also includes internal and public API changes:
* `ecma_string_to_utf8_string` does not return negative value if
   output buffer is not large enough to contain the string; the
   buffer is expected to be large enough. (`ecma_string_get_size`
   can be used to retrieve the required size.)
* `jerry_api_string_to_char_buffer` adapts the same logic (and
  `jerry_api_get_string_size` can be used to determine the
  required size of the buffer).

Related issue: #942

JerryScript-DCO-1.0-Signed-off-by: Akos Kiss akiss@inf.u-szeged.hu
This commit is contained in:
Akos Kiss 2016-03-07 19:08:57 +01:00
parent ce2fc3ccfd
commit 25b0750756
24 changed files with 228 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
docs/API-EXAMPLE.md
View File

@ -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);

16
docs/API-REFERENCE.md
View File

@ -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);

39
jerry-core/ecma/base/ecma-helpers-conversion.c
View File

@ -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);
}

163
jerry-core/ecma/base/ecma-helpers-string.c
View File

@ -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)
utf8_string2_size = ecma_string_get_size (string2_p);
if (sizeof (utf8_string2_buffer) < utf8_string2_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 (string2_p, heap_buffer_p, -req_size);
utf8_string2_size = (lit_utf8_size_t) bytes_copied;
JERRY_ASSERT (bytes_copied > 0);
utf8_string2_p = heap_buffer_p;
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;

8
jerry-core/ecma/base/ecma-helpers.h
View File

@ -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 */

4
jerry-core/ecma/builtin-objects/ecma-builtin-date.c
View File

@ -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;

44
jerry-core/ecma/builtin-objects/ecma-builtin-error-prototype.c
View File

@ -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);
space_size);
JERRY_ASSERT (ret_str_buffer_p <= ret_str_buffer + size);
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);
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);
}

48
jerry-core/ecma/builtin-objects/ecma-builtin-global.c
View File

@ -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;

28
jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c
View File

@ -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;

14
jerry-core/ecma/builtin-objects/ecma-builtin-json.c
View File

@ -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;

24
jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.c
View File

@ -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);
}

11
jerry-core/ecma/operations/ecma-eval.c
View File

@ -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);

10
jerry-core/ecma/operations/ecma-regexp-object.c
View File

@ -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)
{

2
jerry-core/jerry-api.h
View File

@ -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 *);

11
jerry-core/jerry.c
View File

@ -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 ();

8
jerry-core/lit/lit-char-helpers.c
View File

@ -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.");

4
jerry-core/lit/lit-char-helpers.h
View File

@ -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 */

57
jerry-core/lit/lit-literal.c
View File

@ -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
*

3
jerry-core/lit/lit-literal.h
View File

@ -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);

4
jerry-core/lit/lit-magic-strings.c
View File

@ -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--)
{

2
jerry-core/lit/lit-magic-strings.h
View File

@ -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 */

4
jerry-core/parser/regexp/re-compiler.c
View File

@ -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;

4
main-unix.c
View File

@ -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);

38
tests/unit/test-api.c
View File

@ -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));