Fixes ecma_uint32_to_utf8_string that fill \0 at the end of string

lygstate · lygstate · commit db5ec79c0153 · 2024-12-17T17:48:13.000+08:00
Closes: #5194 JerryScript-DCO-1.0-Signed-off-by: Yonggang Luo luoyonggang@gmail.com
diff --git a/jerry-core/api/jerry-snapshot.c b/jerry-core/api/jerry-snapshot.c
@@ -1502,11 +1502,13 @@ jerry_append_number_to_buffer (uint8_t *buffer_p, /**< buffer */
                                uint8_t *buffer_end_p, /**< the end of the buffer */
                                lit_utf8_size_t number) /**< number */
 {
-  lit_utf8_byte_t uint32_to_str_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
+  lit_utf8_byte_t uint32_to_str_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];
   lit_utf8_size_t utf8_str_size =
-    ecma_uint32_to_utf8_string (number, uint32_to_str_buffer, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+    ecma_uint32_to_utf8_string (number,
+                                uint32_to_str_buffer,
+                                ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
 
-  JERRY_ASSERT (utf8_str_size <= ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+  JERRY_ASSERT (utf8_str_size < ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
 
   return jerry_append_chars_to_buffer (buffer_p,
                                        buffer_end_p,
diff --git a/jerry-core/ecma/base/ecma-globals.h b/jerry-core/ecma/base/ecma-globals.h
@@ -1379,6 +1379,12 @@ typedef float ecma_number_t;
  */
 #define ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32 10
 
+/**
+ * Maximum number of characters in string representation of ecma-uint32 plus one.
+ * That is the '\0' terminator
+ */
+#define ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED (ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32 + 1)
+
 /**
  * String is not a valid array index.
  */
diff --git a/jerry-core/ecma/base/ecma-helpers-conversion.c b/jerry-core/ecma/base/ecma-helpers-conversion.c
@@ -662,7 +662,8 @@ ecma_uint32_to_utf8_string (uint32_t value, /**< value to convert */
                             lit_utf8_byte_t *out_buffer_p, /**< buffer for string */
                             lit_utf8_size_t buffer_size) /**< size of buffer */
 {
-  lit_utf8_byte_t *buf_p = out_buffer_p + buffer_size;
+  lit_utf8_byte_t *buf_p_tail = out_buffer_p + buffer_size - 1;
+  lit_utf8_byte_t *buf_p = buf_p_tail;
 
   do
   {
@@ -675,12 +676,13 @@ ecma_uint32_to_utf8_string (uint32_t value, /**< value to convert */
 
   JERRY_ASSERT (buf_p >= out_buffer_p);
 
-  lit_utf8_size_t bytes_copied = (lit_utf8_size_t) (out_buffer_p + buffer_size - buf_p);
+  lit_utf8_size_t bytes_copied = (lit_utf8_size_t) (buf_p_tail - buf_p);
 
   if (JERRY_LIKELY (buf_p != out_buffer_p))
   {
     memmove (out_buffer_p, buf_p, bytes_copied);
   }
+  buf_p[bytes_copied] = '\0';
 
   return bytes_copied;
 } /* ecma_uint32_to_utf8_string */
@@ -868,7 +870,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */
   if (((ecma_number_t) num_uint32) == num)
   {
     dst_p += ecma_uint32_to_utf8_string (num_uint32, dst_p, (lit_utf8_size_t) (buffer_p + buffer_size - dst_p));
-    JERRY_ASSERT (dst_p <= buffer_p + buffer_size);
+    JERRY_ASSERT (dst_p < buffer_p + buffer_size);
     return (lit_utf8_size_t) (dst_p - buffer_p);
   }
 
@@ -935,7 +937,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /**< ecma-number */
 
   dst_p += ecma_uint32_to_utf8_string (t, dst_p, (lit_utf8_size_t) (buffer_p + buffer_size - dst_p));
 
-  JERRY_ASSERT (dst_p <= buffer_p + buffer_size);
+  JERRY_ASSERT (dst_p < buffer_p + buffer_size);
 
   return (lit_utf8_size_t) (dst_p - buffer_p);
 } /* ecma_number_to_utf8_string */
diff --git a/jerry-core/ecma/base/ecma-helpers-string.c b/jerry-core/ecma/base/ecma-helpers-string.c
@@ -746,7 +746,8 @@ ecma_append_chars_to_string (ecma_string_t *string1_p, /**< base ecma-string */
     return ecma_get_magic_string (magic_string_id);
   }
 
-  if ((cesu8_string1_flags & ECMA_STRING_FLAG_IS_UINT32) && new_size < ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32)
+  if ((cesu8_string1_flags & ECMA_STRING_FLAG_IS_UINT32)
+      && new_size < ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED)
   {
     memcpy (cesu8_string1_uint32_buffer + cesu8_string1.size, cesu8_string2_p, cesu8_string2_size);
 
@@ -1061,8 +1062,9 @@ ecma_uint32_to_buffer (uint32_t num, /**< number */
                        lit_utf8_byte_t *buffer_p /**< destination buffer */,
                        lit_utf8_size_t buffer_size /**< buffer size */)
 {
-  lit_utf8_byte_t digits[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
-  lit_utf8_size_t digit_count = ecma_uint32_to_utf8_string (num, digits, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+  lit_utf8_byte_t digits[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];
+  lit_utf8_size_t digit_count =
+    ecma_uint32_to_utf8_string (num, digits, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
 
   digit_count = JERRY_MIN (buffer_size, digit_count);
   memcpy (buffer_p, digits, digit_count);
@@ -1170,7 +1172,7 @@ ecma_string_to_cesu8_bytes (const ecma_string_t *string_desc_p, /**< ecma-string
  *
  * @return size in bytes
  */
-static inline lit_utf8_size_t JERRY_ATTR_ALWAYS_INLINE
+extern inline lit_utf8_size_t JERRY_ATTR_ALWAYS_INLINE
 ecma_string_get_uint32_size (const uint32_t uint32_number) /**< number in the string-descriptor */
 {
   uint32_t prev_number = 1;
@@ -1268,11 +1270,11 @@ ecma_string_get_chars (const ecma_string_t *string_p, /**< ecma-string */
         }
         else
         {
-          result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size);
+          result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size + 1);
           *flags_p |= ECMA_STRING_FLAG_MUST_BE_FREED;
         }
 
-        length = ecma_uint32_to_utf8_string (uint32_number, (lit_utf8_byte_t *) result_p, size);
+        length = ecma_uint32_to_utf8_string (uint32_number, (lit_utf8_byte_t *) result_p, size + 1);
 
         JERRY_ASSERT (length == size);
         *flags_p |= ECMA_STRING_FLAG_IS_UINT32;
@@ -1319,11 +1321,11 @@ ecma_string_get_chars (const ecma_string_t *string_p, /**< ecma-string */
         }
         else
         {
-          result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size);
+          result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size + 1);
           *flags_p |= ECMA_STRING_FLAG_MUST_BE_FREED;
         }
 
-        length = ecma_uint32_to_utf8_string (string_p->u.uint32_number, (lit_utf8_byte_t *) result_p, size);
+        length = ecma_uint32_to_utf8_string (string_p->u.uint32_number, (lit_utf8_byte_t *) result_p, size + 1);
 
         JERRY_ASSERT (length == size);
         *flags_p |= ECMA_STRING_FLAG_IS_UINT32 | ECMA_STRING_FLAG_REHASH_NEEDED;
@@ -1689,8 +1691,8 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
   const lit_utf8_byte_t *utf8_string1_p, *utf8_string2_p;
   lit_utf8_size_t utf8_string1_size, utf8_string2_size;
 
-  lit_utf8_byte_t uint32_to_string_buffer1[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
-  lit_utf8_byte_t uint32_to_string_buffer2[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
+  lit_utf8_byte_t uint32_to_string_buffer1[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];
+  lit_utf8_byte_t uint32_to_string_buffer2[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];
 
   if (ECMA_IS_DIRECT_STRING (string1_p))
   {
@@ -1702,7 +1704,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
     {
       utf8_string1_size = ecma_uint32_to_utf8_string ((uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string1_p),
                                                       uint32_to_string_buffer1,
-                                                      ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+                                                      ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
       utf8_string1_p = uint32_to_string_buffer1;
     }
   }
@@ -1718,7 +1720,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
     {
       utf8_string1_size = ecma_uint32_to_utf8_string (string1_p->u.uint32_number,
                                                       uint32_to_string_buffer1,
-                                                      ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+                                                      ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
       utf8_string1_p = uint32_to_string_buffer1;
     }
   }
@@ -1733,7 +1735,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
     {
       utf8_string2_size = ecma_uint32_to_utf8_string ((uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string2_p),
                                                       uint32_to_string_buffer2,
-                                                      ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+                                                      ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
       utf8_string2_p = uint32_to_string_buffer2;
     }
   }
@@ -1749,7 +1751,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
     {
       utf8_string2_size = ecma_uint32_to_utf8_string (string2_p->u.uint32_number,
                                                       uint32_to_string_buffer2,
-                                                      ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+                                                      ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
       utf8_string2_p = uint32_to_string_buffer2;
     }
   }
@@ -2034,7 +2036,7 @@ ecma_string_get_char_at_pos (const ecma_string_t *string_p, /**< ecma-string */
 {
   JERRY_ASSERT (index < ecma_string_get_length (string_p));
 
-  lit_utf8_byte_t uint32_to_string_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
+  lit_utf8_byte_t uint32_to_string_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];
 
   if (ECMA_IS_DIRECT_STRING (string_p))
   {
@@ -2059,7 +2061,9 @@ ecma_string_get_char_at_pos (const ecma_string_t *string_p, /**< ecma-string */
         JERRY_ASSERT (ECMA_GET_DIRECT_STRING_TYPE (string_p) == ECMA_DIRECT_STRING_UINT);
         uint32_t uint32_number = (uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string_p);
 
-        ecma_uint32_to_utf8_string (uint32_number, uint32_to_string_buffer, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+        ecma_uint32_to_utf8_string (uint32_number,
+                                    uint32_to_string_buffer,
+                                    ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
 
         return (ecma_char_t) uint32_to_string_buffer[index];
       }
@@ -2105,7 +2109,7 @@ ecma_string_get_char_at_pos (const ecma_string_t *string_p, /**< ecma-string */
     {
       ecma_uint32_to_utf8_string (string_p->u.uint32_number,
                                   uint32_to_string_buffer,
-                                  ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
+                                  ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
 
       return (ecma_char_t) uint32_to_string_buffer[index];
     }
diff --git a/jerry-core/ecma/base/ecma-helpers.h b/jerry-core/ecma/base/ecma-helpers.h
@@ -113,7 +113,7 @@ typedef enum
                                    utf8_str) /**< [out] lit_utf8_string_t to get */                    \
   lit_utf8_string_t utf8_str;                                                                          \
   uint8_t utf8_str##_flags = ECMA_STRING_FLAG_EMPTY;                                                   \
-  lit_utf8_byte_t utf8_str##_uint32_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];                      \
+  lit_utf8_byte_t utf8_str##_uint32_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED]; \
   (void) ecma_string_get_chars (ecma_str_ptr, &utf8_str, utf8_str##_uint32_buffer, &utf8_str##_flags); \
   JERRY_ASSERT (!(utf8_str##_flags & ECMA_STRING_FLAG_MUST_BE_FREED));
 
@@ -125,13 +125,13 @@ typedef enum
  * The string length name is `utf8_str##_length`
  *
  */
-#define ECMA_STRING_TO_UTF8_STRING_AND_LENGTH(ecma_str_ptr, /**< ecma string pointer */           \
-                                              utf8_str) /**< [out] lit_utf8_string_t to get */    \
-  lit_utf8_string_t utf8_str;                                                                     \
-  uint8_t utf8_str##_flags = ECMA_STRING_FLAG_IS_ASCII;                                           \
-  lit_utf8_byte_t utf8_str##_uint32_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];                 \
-  lit_utf8_size_t utf8_str##_length =                                                             \
-    ecma_string_get_chars (ecma_str_ptr, &utf8_str, utf8_str##_uint32_buffer, &utf8_str##_flags); \
+#define ECMA_STRING_TO_UTF8_STRING_AND_LENGTH(ecma_str_ptr, /**< ecma string pointer */                \
+                                              utf8_str) /**< [out] lit_utf8_string_t to get */         \
+  lit_utf8_string_t utf8_str;                                                                          \
+  uint8_t utf8_str##_flags = ECMA_STRING_FLAG_IS_ASCII;                                                \
+  lit_utf8_byte_t utf8_str##_uint32_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED]; \
+  lit_utf8_size_t utf8_str##_length =                                                                  \
+    ecma_string_get_chars (ecma_str_ptr, &utf8_str, utf8_str##_uint32_buffer, &utf8_str##_flags);      \
   JERRY_ASSERT (!(utf8_str##_flags & ECMA_STRING_FLAG_MUST_BE_FREED));
 
 #ifdef ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY
@@ -518,6 +518,7 @@ ecma_number_t ecma_utf8_string_to_number_by_radix (const lit_utf8_byte_t *str_p,
                                                    lit_utf8_size_t str_size,
                                                    uint32_t radix,
                                                    uint32_t option);
+lit_utf8_size_t ecma_string_get_uint32_size (const uint32_t uint32_number);
 lit_utf8_size_t ecma_uint32_to_utf8_string (uint32_t value, lit_utf8_byte_t *out_buffer_p, lit_utf8_size_t buffer_size);
 uint32_t ecma_number_to_uint32 (ecma_number_t num);
 int32_t ecma_number_to_int32 (ecma_number_t num);
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.c b/jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.c
@@ -525,7 +525,7 @@ ecma_builtin_number_prototype_object_to_number_convert (ecma_number_t this_num,
     }
 
     /* Append exponent part */
-    lit_utf8_size_t exp_size = ecma_uint32_to_utf8_string ((uint32_t) exponent, digits, 3);
+    lit_utf8_size_t exp_size = ecma_uint32_to_utf8_string ((uint32_t) exponent, digits, 3 + 1);
     ecma_stringbuilder_append_raw (&builder, digits, exp_size);
 
     return ecma_make_string_value (ecma_stringbuilder_finalize (&builder));
diff --git a/jerry-core/parser/js/js-parser.c b/jerry-core/parser/js/js-parser.c
@@ -2418,12 +2418,12 @@ parser_parse_source (void *source_p, /**< source code */
 
   if (context.global_status_flags & ECMA_PARSE_INTERNAL_FREE_SOURCE)
   {
-    jmem_heap_free_block ((void *) context.source.ptr, context.source.size);
+    jmem_heap_free_block ((void *) context.source.ptr, context.source.size + 1);
   }
 
   if (context.global_status_flags & ECMA_PARSE_INTERNAL_FREE_ARG_LIST)
   {
-    jmem_heap_free_block ((void *) context.arguments.ptr, context.arguments.size);
+    jmem_heap_free_block ((void *) context.arguments.ptr, context.arguments.size + 1);
   }
 
   if (compiled_code_p != NULL)
diff --git a/tests/unit-core/test-number-to-string.c b/tests/unit-core/test-number-to-string.c
@@ -50,5 +50,17 @@ main (void)
     }
   }
 
+  lit_utf8_byte_t val_uint32_max_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED] = { 0 };
+  memset (val_uint32_max_buffer, 0xFF, sizeof (val_uint32_max_buffer));
+
+  TEST_ASSERT (ecma_string_get_uint32_size (UINT32_MAX) == 10);
+  TEST_ASSERT (ecma_string_get_uint32_size (0) == 1);
+  TEST_ASSERT (ecma_string_get_uint32_size (10) == 2);
+  lit_utf8_size_t digits = ecma_uint32_to_utf8_string (UINT32_MAX,
+                                                       val_uint32_max_buffer,
+                                                       ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);
+  TEST_ASSERT (digits == 10);
+  TEST_ASSERT (val_uint32_max_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32] == 0);
+
   return 0;
 } /* main */

Original file line number	Diff line number	Diff line change
`@@ -662,7 +662,8 @@ ecma_uint32_to_utf8_string (uint32_t value, /*< value to convert /`
`662`	`662`	`lit_utf8_byte_t out_buffer_p, /< buffer for string /`
`663`	`663`	`lit_utf8_size_t buffer_size) /*< size of buffer /`
`664`	`664`	`{`
`665`		`- lit_utf8_byte_t *buf_p = out_buffer_p + buffer_size;`
	`665`	`+ lit_utf8_byte_t *buf_p_tail = out_buffer_p + buffer_size - 1;`
	`666`	`+ lit_utf8_byte_t *buf_p = buf_p_tail;`
`666`	`667`
`667`	`668`	`do`
`668`	`669`	`{`
`@@ -675,12 +676,13 @@ ecma_uint32_to_utf8_string (uint32_t value, /*< value to convert /`
`675`	`676`
`676`	`677`	`JERRY_ASSERT (buf_p >= out_buffer_p);`
`677`	`678`
`678`		`- lit_utf8_size_t bytes_copied = (lit_utf8_size_t) (out_buffer_p + buffer_size - buf_p);`
	`679`	`+ lit_utf8_size_t bytes_copied = (lit_utf8_size_t) (buf_p_tail - buf_p);`
`679`	`680`
`680`	`681`	`if (JERRY_LIKELY (buf_p != out_buffer_p))`
`681`	`682`	`{`
`682`	`683`	`memmove (out_buffer_p, buf_p, bytes_copied);`
`683`	`684`	`}`
	`685`	`+ buf_p[bytes_copied] = '\0';`
`684`	`686`
`685`	`687`	`return bytes_copied;`
`686`	`688`	`} /* ecma_uint32_to_utf8_string */`
`@@ -868,7 +870,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /*< ecma-number /`
`868`	`870`	`if (((ecma_number_t) num_uint32) == num)`
`869`	`871`	`{`
`870`	`872`	`dst_p += ecma_uint32_to_utf8_string (num_uint32, dst_p, (lit_utf8_size_t) (buffer_p + buffer_size - dst_p));`
`871`		`- JERRY_ASSERT (dst_p <= buffer_p + buffer_size);`
	`873`	`+ JERRY_ASSERT (dst_p < buffer_p + buffer_size);`
`872`	`874`	`return (lit_utf8_size_t) (dst_p - buffer_p);`
`873`	`875`	`}`
`874`	`876`
`@@ -935,7 +937,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /*< ecma-number /`
`935`	`937`
`936`	`938`	`dst_p += ecma_uint32_to_utf8_string (t, dst_p, (lit_utf8_size_t) (buffer_p + buffer_size - dst_p));`
`937`	`939`
`938`		`- JERRY_ASSERT (dst_p <= buffer_p + buffer_size);`
	`940`	`+ JERRY_ASSERT (dst_p < buffer_p + buffer_size);`
`939`	`941`
`940`	`942`	`return (lit_utf8_size_t) (dst_p - buffer_p);`
`941`	`943`	`} /* ecma_number_to_utf8_string */`
Original file line number	Diff line number	Diff line change
`@@ -746,7 +746,8 @@ ecma_append_chars_to_string (ecma_string_t string1_p, /< base ecma-string /`
`746`	`746`	`return ecma_get_magic_string (magic_string_id);`
`747`	`747`	`}`
`748`	`748`
`749`		`- if ((cesu8_string1_flags & ECMA_STRING_FLAG_IS_UINT32) && new_size < ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32)`
	`749`	`+ if ((cesu8_string1_flags & ECMA_STRING_FLAG_IS_UINT32)`
	`750`	`+ && new_size < ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED)`
`750`	`751`	`{`
`751`	`752`	`memcpy (cesu8_string1_uint32_buffer + cesu8_string1.size, cesu8_string2_p, cesu8_string2_size);`
`752`	`753`
`@@ -1061,8 +1062,9 @@ ecma_uint32_to_buffer (uint32_t num, /*< number /`
`1061`	`1062`	`lit_utf8_byte_t buffer_p /< destination buffer /,`
`1062`	`1063`	`lit_utf8_size_t buffer_size /*< buffer size /)`
`1063`	`1064`	`{`
`1064`		`- lit_utf8_byte_t digits[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];`
`1065`		`- lit_utf8_size_t digit_count = ecma_uint32_to_utf8_string (num, digits, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`1065`	`+ lit_utf8_byte_t digits[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];`
	`1066`	`+ lit_utf8_size_t digit_count =`
	`1067`	`+ ecma_uint32_to_utf8_string (num, digits, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`1066`	`1068`
`1067`	`1069`	`digit_count = JERRY_MIN (buffer_size, digit_count);`
`1068`	`1070`	`memcpy (buffer_p, digits, digit_count);`
`@@ -1170,7 +1172,7 @@ ecma_string_to_cesu8_bytes (const ecma_string_t string_desc_p, /*< ecma-string`
`1170`	`1172`	`*`
`1171`	`1173`	`* @return size in bytes`
`1172`	`1174`	`*/`
`1173`		`-static inline lit_utf8_size_t JERRY_ATTR_ALWAYS_INLINE`
	`1175`	`+extern inline lit_utf8_size_t JERRY_ATTR_ALWAYS_INLINE`
`1174`	`1176`	`ecma_string_get_uint32_size (const uint32_t uint32_number) /*< number in the string-descriptor /`
`1175`	`1177`	`{`
`1176`	`1178`	`uint32_t prev_number = 1;`
`@@ -1268,11 +1270,11 @@ ecma_string_get_chars (const ecma_string_t string_p, /< ecma-string /`
`1268`	`1270`	`}`
`1269`	`1271`	`else`
`1270`	`1272`	`{`
`1271`		`- result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size);`
	`1273`	`+ result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size + 1);`
`1272`	`1274`	`*flags_p \|= ECMA_STRING_FLAG_MUST_BE_FREED;`
`1273`	`1275`	`}`
`1274`	`1276`
`1275`		`- length = ecma_uint32_to_utf8_string (uint32_number, (lit_utf8_byte_t *) result_p, size);`
	`1277`	`+ length = ecma_uint32_to_utf8_string (uint32_number, (lit_utf8_byte_t *) result_p, size + 1);`
`1276`	`1278`
`1277`	`1279`	`JERRY_ASSERT (length == size);`
`1278`	`1280`	`*flags_p \|= ECMA_STRING_FLAG_IS_UINT32;`
`@@ -1319,11 +1321,11 @@ ecma_string_get_chars (const ecma_string_t string_p, /< ecma-string /`
`1319`	`1321`	`}`
`1320`	`1322`	`else`
`1321`	`1323`	`{`
`1322`		`- result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size);`
	`1324`	`+ result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size + 1);`
`1323`	`1325`	`*flags_p \|= ECMA_STRING_FLAG_MUST_BE_FREED;`
`1324`	`1326`	`}`
`1325`	`1327`
`1326`		`- length = ecma_uint32_to_utf8_string (string_p->u.uint32_number, (lit_utf8_byte_t *) result_p, size);`
	`1328`	`+ length = ecma_uint32_to_utf8_string (string_p->u.uint32_number, (lit_utf8_byte_t *) result_p, size + 1);`
`1327`	`1329`
`1328`	`1330`	`JERRY_ASSERT (length == size);`
`1329`	`1331`	`*flags_p \|= ECMA_STRING_FLAG_IS_UINT32 \| ECMA_STRING_FLAG_REHASH_NEEDED;`
`@@ -1689,8 +1691,8 @@ ecma_compare_ecma_strings_relational (const ecma_string_t string1_p, /*< ecma-`
`1689`	`1691`	`const lit_utf8_byte_t utf8_string1_p, utf8_string2_p;`
`1690`	`1692`	`lit_utf8_size_t utf8_string1_size, utf8_string2_size;`
`1691`	`1693`
`1692`		`- lit_utf8_byte_t uint32_to_string_buffer1[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];`
`1693`		`- lit_utf8_byte_t uint32_to_string_buffer2[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];`
	`1694`	`+ lit_utf8_byte_t uint32_to_string_buffer1[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];`
	`1695`	`+ lit_utf8_byte_t uint32_to_string_buffer2[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];`
`1694`	`1696`
`1695`	`1697`	`if (ECMA_IS_DIRECT_STRING (string1_p))`
`1696`	`1698`	`{`
`@@ -1702,7 +1704,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t string1_p, /*< ecma-`
`1702`	`1704`	`{`
`1703`	`1705`	`utf8_string1_size = ecma_uint32_to_utf8_string ((uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string1_p),`
`1704`	`1706`	`uint32_to_string_buffer1,`
`1705`		`- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`1707`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`1706`	`1708`	`utf8_string1_p = uint32_to_string_buffer1;`
`1707`	`1709`	`}`
`1708`	`1710`	`}`
`@@ -1718,7 +1720,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t string1_p, /*< ecma-`
`1718`	`1720`	`{`
`1719`	`1721`	`utf8_string1_size = ecma_uint32_to_utf8_string (string1_p->u.uint32_number,`
`1720`	`1722`	`uint32_to_string_buffer1,`
`1721`		`- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`1723`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`1722`	`1724`	`utf8_string1_p = uint32_to_string_buffer1;`
`1723`	`1725`	`}`
`1724`	`1726`	`}`
`@@ -1733,7 +1735,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t string1_p, /*< ecma-`
`1733`	`1735`	`{`
`1734`	`1736`	`utf8_string2_size = ecma_uint32_to_utf8_string ((uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string2_p),`
`1735`	`1737`	`uint32_to_string_buffer2,`
`1736`		`- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`1738`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`1737`	`1739`	`utf8_string2_p = uint32_to_string_buffer2;`
`1738`	`1740`	`}`
`1739`	`1741`	`}`
`@@ -1749,7 +1751,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t string1_p, /*< ecma-`
`1749`	`1751`	`{`
`1750`	`1752`	`utf8_string2_size = ecma_uint32_to_utf8_string (string2_p->u.uint32_number,`
`1751`	`1753`	`uint32_to_string_buffer2,`
`1752`		`- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`1754`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`1753`	`1755`	`utf8_string2_p = uint32_to_string_buffer2;`
`1754`	`1756`	`}`
`1755`	`1757`	`}`
`@@ -2034,7 +2036,7 @@ ecma_string_get_char_at_pos (const ecma_string_t string_p, /< ecma-string /`
`2034`	`2036`	`{`
`2035`	`2037`	`JERRY_ASSERT (index < ecma_string_get_length (string_p));`
`2036`	`2038`
`2037`		`- lit_utf8_byte_t uint32_to_string_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];`
	`2039`	`+ lit_utf8_byte_t uint32_to_string_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];`
`2038`	`2040`
`2039`	`2041`	`if (ECMA_IS_DIRECT_STRING (string_p))`
`2040`	`2042`	`{`
`@@ -2059,7 +2061,9 @@ ecma_string_get_char_at_pos (const ecma_string_t string_p, /< ecma-string /`
`2059`	`2061`	`JERRY_ASSERT (ECMA_GET_DIRECT_STRING_TYPE (string_p) == ECMA_DIRECT_STRING_UINT);`
`2060`	`2062`	`uint32_t uint32_number = (uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string_p);`
`2061`	`2063`
`2062`		`- ecma_uint32_to_utf8_string (uint32_number, uint32_to_string_buffer, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`2064`	`+ ecma_uint32_to_utf8_string (uint32_number,`
	`2065`	`+ uint32_to_string_buffer,`
	`2066`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`2063`	`2067`
`2064`	`2068`	`return (ecma_char_t) uint32_to_string_buffer[index];`
`2065`	`2069`	`}`
`@@ -2105,7 +2109,7 @@ ecma_string_get_char_at_pos (const ecma_string_t string_p, /< ecma-string /`
`2105`	`2109`	`{`
`2106`	`2110`	`ecma_uint32_to_utf8_string (string_p->u.uint32_number,`
`2107`	`2111`	`uint32_to_string_buffer,`
`2108`		`- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`2112`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`2109`	`2113`
`2110`	`2114`	`return (ecma_char_t) uint32_to_string_buffer[index];`
`2111`	`2115`	`}`
Original file line number	Diff line number	Diff line change
`@@ -525,7 +525,7 @@ ecma_builtin_number_prototype_object_to_number_convert (ecma_number_t this_num,`
`525`	`525`	`}`
`526`	`526`
`527`	`527`	`/* Append exponent part */`
`528`		`- lit_utf8_size_t exp_size = ecma_uint32_to_utf8_string ((uint32_t) exponent, digits, 3);`
	`528`	`+ lit_utf8_size_t exp_size = ecma_uint32_to_utf8_string ((uint32_t) exponent, digits, 3 + 1);`
`529`	`529`	`ecma_stringbuilder_append_raw (&builder, digits, exp_size);`
`530`	`530`
`531`	`531`	`return ecma_make_string_value (ecma_stringbuilder_finalize (&builder));`
Original file line number	Diff line number	Diff line change
`@@ -2418,12 +2418,12 @@ parser_parse_source (void source_p, /< source code /`
`2418`	`2418`
`2419`	`2419`	`if (context.global_status_flags & ECMA_PARSE_INTERNAL_FREE_SOURCE)`
`2420`	`2420`	`{`
`2421`		`- jmem_heap_free_block ((void *) context.source.ptr, context.source.size);`
	`2421`	`+ jmem_heap_free_block ((void *) context.source.ptr, context.source.size + 1);`
`2422`	`2422`	`}`
`2423`	`2423`
`2424`	`2424`	`if (context.global_status_flags & ECMA_PARSE_INTERNAL_FREE_ARG_LIST)`
`2425`	`2425`	`{`
`2426`		`- jmem_heap_free_block ((void *) context.arguments.ptr, context.arguments.size);`
	`2426`	`+ jmem_heap_free_block ((void *) context.arguments.ptr, context.arguments.size + 1);`
`2427`	`2427`	`}`
`2428`	`2428`
`2429`	`2429`	`if (compiled_code_p != NULL)`