Fixes ecma_uint32_to_utf8_string that fill \0 at the end of string

lygstate · lygstate · commit eafb1b1ec17d · 2024-12-11T19:19:16.000Z
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
@@ -659,7 +659,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
   {
@@ -672,12 +673,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 */
@@ -865,7 +867,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);
   }
 
@@ -932,7 +934,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);
 
@@ -1065,8 +1066,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);
@@ -1176,7 +1178,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;
@@ -1274,11 +1276,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;
@@ -1325,11 +1327,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;
@@ -1694,8 +1696,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))
   {
@@ -1707,7 +1709,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;
     }
   }
@@ -1723,7 +1725,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;
     }
   }
@@ -1738,7 +1740,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;
     }
   }
@@ -1754,7 +1756,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;
     }
   }
@@ -2039,7 +2041,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))
   {
@@ -2064,7 +2066,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];
       }
@@ -2110,7 +2114,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
@@ -111,7 +111,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));
 
@@ -120,13 +120,13 @@ typedef enum
  * No allocation needed by providing a uint32 string buffer
  *
  */
-#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
@@ -513,6 +513,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
`@@ -659,7 +659,8 @@ ecma_uint32_to_utf8_string (uint32_t value, /*< value to convert /`
`659`	`659`	`lit_utf8_byte_t out_buffer_p, /< buffer for string /`
`660`	`660`	`lit_utf8_size_t buffer_size) /*< size of buffer /`
`661`	`661`	`{`
`662`		`- lit_utf8_byte_t *buf_p = out_buffer_p + buffer_size;`
	`662`	`+ lit_utf8_byte_t *buf_p_tail = out_buffer_p + buffer_size - 1;`
	`663`	`+ lit_utf8_byte_t *buf_p = buf_p_tail;`
`663`	`664`
`664`	`665`	`do`
`665`	`666`	`{`
`@@ -672,12 +673,13 @@ ecma_uint32_to_utf8_string (uint32_t value, /*< value to convert /`
`672`	`673`
`673`	`674`	`JERRY_ASSERT (buf_p >= out_buffer_p);`
`674`	`675`
`675`		`- lit_utf8_size_t bytes_copied = (lit_utf8_size_t) (out_buffer_p + buffer_size - buf_p);`
	`676`	`+ lit_utf8_size_t bytes_copied = (lit_utf8_size_t) (buf_p_tail - buf_p);`
`676`	`677`
`677`	`678`	`if (JERRY_LIKELY (buf_p != out_buffer_p))`
`678`	`679`	`{`
`679`	`680`	`memmove (out_buffer_p, buf_p, bytes_copied);`
`680`	`681`	`}`
	`682`	`+ buf_p[bytes_copied] = '\0';`
`681`	`683`
`682`	`684`	`return bytes_copied;`
`683`	`685`	`} /* ecma_uint32_to_utf8_string */`
`@@ -865,7 +867,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /*< ecma-number /`
`865`	`867`	`if (((ecma_number_t) num_uint32) == num)`
`866`	`868`	`{`
`867`	`869`	`dst_p += ecma_uint32_to_utf8_string (num_uint32, dst_p, (lit_utf8_size_t) (buffer_p + buffer_size - dst_p));`
`868`		`- JERRY_ASSERT (dst_p <= buffer_p + buffer_size);`
	`870`	`+ JERRY_ASSERT (dst_p < buffer_p + buffer_size);`
`869`	`871`	`return (lit_utf8_size_t) (dst_p - buffer_p);`
`870`	`872`	`}`
`871`	`873`
`@@ -932,7 +934,7 @@ ecma_number_to_utf8_string (ecma_number_t num, /*< ecma-number /`
`932`	`934`
`933`	`935`	`dst_p += ecma_uint32_to_utf8_string (t, dst_p, (lit_utf8_size_t) (buffer_p + buffer_size - dst_p));`
`934`	`936`
`935`		`- JERRY_ASSERT (dst_p <= buffer_p + buffer_size);`
	`937`	`+ JERRY_ASSERT (dst_p < buffer_p + buffer_size);`
`936`	`938`
`937`	`939`	`return (lit_utf8_size_t) (dst_p - buffer_p);`
`938`	`940`	`} /* 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`
`@@ -1065,8 +1066,9 @@ ecma_uint32_to_buffer (uint32_t num, /*< number /`
`1065`	`1066`	`lit_utf8_byte_t buffer_p /< destination buffer /,`
`1066`	`1067`	`lit_utf8_size_t buffer_size /*< buffer size /)`
`1067`	`1068`	`{`
`1068`		`- lit_utf8_byte_t digits[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];`
`1069`		`- lit_utf8_size_t digit_count = ecma_uint32_to_utf8_string (num, digits, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`1069`	`+ lit_utf8_byte_t digits[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];`
	`1070`	`+ lit_utf8_size_t digit_count =`
	`1071`	`+ ecma_uint32_to_utf8_string (num, digits, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`1070`	`1072`
`1071`	`1073`	`digit_count = JERRY_MIN (buffer_size, digit_count);`
`1072`	`1074`	`memcpy (buffer_p, digits, digit_count);`
`@@ -1176,7 +1178,7 @@ ecma_string_to_cesu8_bytes (const ecma_string_t string_desc_p, /*< ecma-string`
`1176`	`1178`	`*`
`1177`	`1179`	`* @return size in bytes`
`1178`	`1180`	`*/`
`1179`		`-static inline lit_utf8_size_t JERRY_ATTR_ALWAYS_INLINE`
	`1181`	`+extern inline lit_utf8_size_t JERRY_ATTR_ALWAYS_INLINE`
`1180`	`1182`	`ecma_string_get_uint32_size (const uint32_t uint32_number) /*< number in the string-descriptor /`
`1181`	`1183`	`{`
`1182`	`1184`	`uint32_t prev_number = 1;`
`@@ -1274,11 +1276,11 @@ ecma_string_get_chars (const ecma_string_t string_p, /< ecma-string /`
`1274`	`1276`	`}`
`1275`	`1277`	`else`
`1276`	`1278`	`{`
`1277`		`- result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size);`
	`1279`	`+ result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size + 1);`
`1278`	`1280`	`*flags_p \|= ECMA_STRING_FLAG_MUST_BE_FREED;`
`1279`	`1281`	`}`
`1280`	`1282`
`1281`		`- length = ecma_uint32_to_utf8_string (uint32_number, (lit_utf8_byte_t *) result_p, size);`
	`1283`	`+ length = ecma_uint32_to_utf8_string (uint32_number, (lit_utf8_byte_t *) result_p, size + 1);`
`1282`	`1284`
`1283`	`1285`	`JERRY_ASSERT (length == size);`
`1284`	`1286`	`*flags_p \|= ECMA_STRING_FLAG_IS_UINT32;`
`@@ -1325,11 +1327,11 @@ ecma_string_get_chars (const ecma_string_t string_p, /< ecma-string /`
`1325`	`1327`	`}`
`1326`	`1328`	`else`
`1327`	`1329`	`{`
`1328`		`- result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size);`
	`1330`	`+ result_p = (const lit_utf8_byte_t *) jmem_heap_alloc_block (size + 1);`
`1329`	`1331`	`*flags_p \|= ECMA_STRING_FLAG_MUST_BE_FREED;`
`1330`	`1332`	`}`
`1331`	`1333`
`1332`		`- length = ecma_uint32_to_utf8_string (string_p->u.uint32_number, (lit_utf8_byte_t *) result_p, size);`
	`1334`	`+ length = ecma_uint32_to_utf8_string (string_p->u.uint32_number, (lit_utf8_byte_t *) result_p, size + 1);`
`1333`	`1335`
`1334`	`1336`	`JERRY_ASSERT (length == size);`
`1335`	`1337`	`*flags_p \|= ECMA_STRING_FLAG_IS_UINT32 \| ECMA_STRING_FLAG_REHASH_NEEDED;`
`@@ -1694,8 +1696,8 @@ ecma_compare_ecma_strings_relational (const ecma_string_t string1_p, /*< ecma-`
`1694`	`1696`	`const lit_utf8_byte_t utf8_string1_p, utf8_string2_p;`
`1695`	`1697`	`lit_utf8_size_t utf8_string1_size, utf8_string2_size;`
`1696`	`1698`
`1697`		`- lit_utf8_byte_t uint32_to_string_buffer1[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];`
`1698`		`- lit_utf8_byte_t uint32_to_string_buffer2[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];`
	`1699`	`+ lit_utf8_byte_t uint32_to_string_buffer1[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];`
	`1700`	`+ lit_utf8_byte_t uint32_to_string_buffer2[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];`
`1699`	`1701`
`1700`	`1702`	`if (ECMA_IS_DIRECT_STRING (string1_p))`
`1701`	`1703`	`{`
`@@ -1707,7 +1709,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t string1_p, /*< ecma-`
`1707`	`1709`	`{`
`1708`	`1710`	`utf8_string1_size = ecma_uint32_to_utf8_string ((uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string1_p),`
`1709`	`1711`	`uint32_to_string_buffer1,`
`1710`		`- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`1712`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`1711`	`1713`	`utf8_string1_p = uint32_to_string_buffer1;`
`1712`	`1714`	`}`
`1713`	`1715`	`}`
`@@ -1723,7 +1725,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t string1_p, /*< ecma-`
`1723`	`1725`	`{`
`1724`	`1726`	`utf8_string1_size = ecma_uint32_to_utf8_string (string1_p->u.uint32_number,`
`1725`	`1727`	`uint32_to_string_buffer1,`
`1726`		`- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`1728`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`1727`	`1729`	`utf8_string1_p = uint32_to_string_buffer1;`
`1728`	`1730`	`}`
`1729`	`1731`	`}`
`@@ -1738,7 +1740,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t string1_p, /*< ecma-`
`1738`	`1740`	`{`
`1739`	`1741`	`utf8_string2_size = ecma_uint32_to_utf8_string ((uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string2_p),`
`1740`	`1742`	`uint32_to_string_buffer2,`
`1741`		`- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`1743`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`1742`	`1744`	`utf8_string2_p = uint32_to_string_buffer2;`
`1743`	`1745`	`}`
`1744`	`1746`	`}`
`@@ -1754,7 +1756,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t string1_p, /*< ecma-`
`1754`	`1756`	`{`
`1755`	`1757`	`utf8_string2_size = ecma_uint32_to_utf8_string (string2_p->u.uint32_number,`
`1756`	`1758`	`uint32_to_string_buffer2,`
`1757`		`- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`1759`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`1758`	`1760`	`utf8_string2_p = uint32_to_string_buffer2;`
`1759`	`1761`	`}`
`1760`	`1762`	`}`
`@@ -2039,7 +2041,7 @@ ecma_string_get_char_at_pos (const ecma_string_t string_p, /< ecma-string /`
`2039`	`2041`	`{`
`2040`	`2042`	`JERRY_ASSERT (index < ecma_string_get_length (string_p));`
`2041`	`2043`
`2042`		`- lit_utf8_byte_t uint32_to_string_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];`
	`2044`	`+ lit_utf8_byte_t uint32_to_string_buffer[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED];`
`2043`	`2045`
`2044`	`2046`	`if (ECMA_IS_DIRECT_STRING (string_p))`
`2045`	`2047`	`{`
`@@ -2064,7 +2066,9 @@ ecma_string_get_char_at_pos (const ecma_string_t string_p, /< ecma-string /`
`2064`	`2066`	`JERRY_ASSERT (ECMA_GET_DIRECT_STRING_TYPE (string_p) == ECMA_DIRECT_STRING_UINT);`
`2065`	`2067`	`uint32_t uint32_number = (uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string_p);`
`2066`	`2068`
`2067`		`- ecma_uint32_to_utf8_string (uint32_number, uint32_to_string_buffer, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`2069`	`+ ecma_uint32_to_utf8_string (uint32_number,`
	`2070`	`+ uint32_to_string_buffer,`
	`2071`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`2068`	`2072`
`2069`	`2073`	`return (ecma_char_t) uint32_to_string_buffer[index];`
`2070`	`2074`	`}`
`@@ -2110,7 +2114,7 @@ ecma_string_get_char_at_pos (const ecma_string_t string_p, /< ecma-string /`
`2110`	`2114`	`{`
`2111`	`2115`	`ecma_uint32_to_utf8_string (string_p->u.uint32_number,`
`2112`	`2116`	`uint32_to_string_buffer,`
`2113`		`- ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);`
	`2117`	`+ ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32_WITH_ZERO_TERMINATED);`
`2114`	`2118`
`2115`	`2119`	`return (ecma_char_t) uint32_to_string_buffer[index];`
`2116`	`2120`	`}`
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)`