Change ecma_length_t and jerry_api_length_t from uint16_t to uint32_t.

JerryScript-DCO-1.0-Signed-off-by: Andrey Shitov [email protected]

jerry-core/ecma/base/ecma-globals.h

@@ -696,12 +696,12 @@ typedef double ecma_number_t;
  */
 typedef struct
 {
-  /** Compressed pointer to next chunk with collection's data */
-  mem_cpointer_t next_chunk_cp;
-
   /** Number of elements in the collection */
   ecma_length_t unit_number;
 
+  /** Compressed pointer to next chunk with collection's data */
+  mem_cpointer_t next_chunk_cp;
+
   /** Place for the collection's data */
   uint8_t data[ sizeof (uint64_t) - sizeof (mem_cpointer_t) - sizeof (ecma_length_t) ];
 } ecma_collection_header_t;

jerry-core/ecma/base/ecma-helpers-string.cpp

@@ -467,7 +467,7 @@ ecma_new_ecma_string_from_uint32 (uint32_t uint32_number) /**< UInt32-represente
   ssize_t chars_copied = ecma_uint32_to_string (uint32_number,
                                                 char_buf,
                                                 ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
-  JERRY_ASSERT ((ecma_length_t) chars_copied == chars_copied);
+  JERRY_ASSERT ((ssize_t) ((ecma_length_t) chars_copied) == chars_copied);
 
   JERRY_ASSERT (string_desc_p->hash == ecma_chars_buffer_calc_hash_last_chars (char_buf,
                                                                                ecma_zt_string_length (char_buf)));
@@ -906,7 +906,7 @@ ecma_string_to_number (const ecma_string_t *str_p) /**< ecma-string */
     case ECMA_STRING_CONTAINER_MAGIC_STRING:
     case ECMA_STRING_CONTAINER_MAGIC_STRING_EX:
     {
-      const int32_t string_len = ecma_string_get_length (str_p);
+      const ecma_length_t string_len = ecma_string_get_length (str_p);
       const size_t string_buf_size = (size_t) (string_len + 1) * sizeof (ecma_char_t);
 
       ecma_char_t *str_buffer_p = (ecma_char_t*) mem_heap_alloc_block (string_buf_size, MEM_HEAP_ALLOC_SHORT_TERM);
@@ -948,7 +948,7 @@ ecma_string_to_zt_string (const ecma_string_t *string_desc_p, /**< ecma-string d
   JERRY_ASSERT (buffer_p != NULL || buffer_size == 0);
   JERRY_ASSERT (buffer_size >= 0);
 
-  ssize_t required_buffer_size = ((ecma_string_get_length (string_desc_p) + 1) * ((ssize_t) sizeof (ecma_char_t)));
+  ssize_t required_buffer_size = (ssize_t) ((ecma_string_get_length (string_desc_p) + 1) * sizeof (ecma_char_t));
 
   if (required_buffer_size > buffer_size
       || buffer_size == 0)
@@ -990,7 +990,7 @@ ecma_string_to_zt_string (const ecma_string_t *string_desc_p, /**< ecma-string d
 
       ecma_length_t length = ecma_number_to_zt_string (*num_p, buffer_p, buffer_size);
 
-      JERRY_ASSERT (required_buffer_size == (length + 1) * ((ssize_t) sizeof (ecma_char_t)));
+      JERRY_ASSERT (required_buffer_size == (ssize_t) ((length + 1) * sizeof (ecma_char_t)));
 
       break;
     }
@@ -1093,15 +1093,15 @@ ecma_compare_ecma_strings_longpath (const ecma_string_t *string1_p, /* ecma-stri
     }
   }
 
-  const int32_t string1_len = ecma_string_get_length (string1_p);
-  const int32_t string2_len = ecma_string_get_length (string2_p);
+  const ecma_length_t string1_len = ecma_string_get_length (string1_p);
+  const ecma_length_t string2_len = ecma_string_get_length (string2_p);
 
   if (string1_len != string2_len)
   {
     return false;
   }
 
-  const int32_t strings_len = string1_len;
+  const ecma_length_t strings_len = string1_len;
 
   if (strings_len == 0)
   {
@@ -1348,7 +1348,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
  *
  * @return number of characters in the string
  */
-int32_t
+ecma_length_t
 ecma_string_get_length (const ecma_string_t *string_p) /**< ecma-string */
 {
   ecma_string_container_t container = (ecma_string_container_t) string_p->container;
@@ -1385,7 +1385,7 @@ ecma_string_get_length (const ecma_string_t *string_p) /**< ecma-string */
       1000000000u
     };
 
-    int32_t length = 1;
+    ecma_length_t length = 1;
 
     while (length < max_uint32_len
            && uint32_number >= nums_with_ascending_length[length])

jerry-core/ecma/base/ecma-helpers-values-collection.cpp

@@ -191,19 +191,19 @@ ecma_collection_iterator_next (ecma_collection_iterator_t *iterator_p) /**< cont
   {
     JERRY_ASSERT (iterator_p->current_index == 0);
     iterator_p->current_value_p = (ecma_value_t*) iterator_p->header_p->data;
-
-    return true;
   }
-
-  if (iterator_p->current_index + 1 == iterator_p->header_p->unit_number)
+  else
   {
-    return false;
-  }
+    if (iterator_p->current_index + 1 == iterator_p->header_p->unit_number)
+    {
+      return false;
+    }
 
-  JERRY_ASSERT (iterator_p->current_index + 1 < iterator_p->header_p->unit_number);
+    JERRY_ASSERT (iterator_p->current_index + 1 < iterator_p->header_p->unit_number);
 
-  iterator_p->current_index++;
-  iterator_p->current_value_p++;
+    iterator_p->current_index++;
+    iterator_p->current_value_p++;
+  }
 
   if (iterator_p->current_value_p == iterator_p->current_chunk_end_p)
   {

jerry-core/ecma/base/ecma-helpers.h

@@ -133,7 +133,7 @@ extern bool ecma_compare_ecma_strings (const ecma_string_t *string1_p,
                                        const ecma_string_t *string2_p);
 extern bool ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p,
                                                   const ecma_string_t *string2_p);
-extern int32_t ecma_string_get_length (const ecma_string_t *string_p);
+extern ecma_length_t ecma_string_get_length (const ecma_string_t *string_p);
 extern ecma_char_t ecma_string_get_char_at_pos (const ecma_string_t *string_p, uint32_t index);
 extern bool ecma_compare_zt_strings (const ecma_char_t *string1_p, const ecma_char_t *string2_p);
 extern bool ecma_compare_zt_strings_relational (const ecma_char_t *string1_p, const ecma_char_t *string2_p);

jerry-core/ecma/builtin-objects/ecma-builtin-error-prototype.cpp

@@ -134,12 +134,12 @@ ecma_builtin_error_prototype_object_to_string (ecma_value_t this_arg) /**< this
           const ecma_char_t *colon_zt_magic_string_p = lit_get_magic_string_zt (LIT_MAGIC_STRING_COLON_CHAR);
           const ecma_char_t *space_zt_magic_string_p = lit_get_magic_string_zt (LIT_MAGIC_STRING_SPACE_CHAR);
 
-          const int32_t len = (ecma_string_get_length (name_string_p) +
-                               ecma_string_get_length (msg_string_p) +
-                               ecma_zt_string_length (colon_zt_magic_string_p) +
-                               ecma_zt_string_length (space_zt_magic_string_p));
+          const ecma_length_t len = (ecma_string_get_length (name_string_p) +
+                                     ecma_string_get_length (msg_string_p) +
+                                     ecma_zt_string_length (colon_zt_magic_string_p) +
+                                     ecma_zt_string_length (space_zt_magic_string_p));
 
-          const ssize_t buffer_size = (len + 1) * (ssize_t) sizeof (ecma_char_t);
+          const ssize_t buffer_size = (ssize_t) ((len + 1) * sizeof (ecma_char_t));
           ssize_t buffer_size_left = buffer_size;
 
           MEM_DEFINE_LOCAL_ARRAY (ret_str_buffer, buffer_size, ecma_char_t);

jerry-core/ecma/builtin-objects/ecma-builtin-global.cpp

@@ -108,7 +108,7 @@ ecma_builtin_global_object_parse_int (ecma_value_t this_arg __attr_unused___, /*
   ECMA_TRY_CATCH (string_var, ecma_op_to_string (string), ret_value);
 
   ecma_string_t *number_str_p = ecma_get_string_from_value (string_var);
-  int32_t string_len = ecma_string_get_length (number_str_p);
+  ecma_length_t string_len = ecma_string_get_length (number_str_p);
 
   MEM_DEFINE_LOCAL_ARRAY (zt_string_buff, string_len + 1, ecma_char_t);
 
@@ -119,9 +119,9 @@ ecma_builtin_global_object_parse_int (ecma_value_t this_arg __attr_unused___, /*
   JERRY_ASSERT (bytes_copied > 0);
 
   /* 2. Remove leading whitespace. */
-  int32_t start = string_len;
-  int32_t end = string_len;
-  for (int i = 0; i < end; i++)
+  ecma_length_t start = string_len;
+  ecma_length_t end = string_len;
+  for (ecma_length_t i = 0; i < end; i++)
   {
     if (!(isspace (zt_string_buff[i])))
     {
@@ -190,7 +190,7 @@ ecma_builtin_global_object_parse_int (ecma_value_t this_arg __attr_unused___, /*
     }
 
     /* 11. Check if characters are in [0, Radix - 1]. We also convert them to number values in the process. */
-    for (int i = start; i < end; i++)
+    for (ecma_length_t i = start; i < end; i++)
     {
       if ((zt_string_buff[i]) >= 'a' && zt_string_buff[i] <= 'z')
       {
@@ -233,7 +233,7 @@ ecma_builtin_global_object_parse_int (ecma_value_t this_arg __attr_unused___, /*
     ecma_number_t multiplier = 1.0f;
 
     /* 13. and 14. */
-    for (int i = end - 1; i >= start; i--)
+    for (int32_t i = (int32_t) end - 1; i >= (int32_t) start; i--)
     {
       *value_p += (ecma_number_t) zt_string_buff[i] * multiplier;
       multiplier *= (ecma_number_t) rad;
@@ -273,7 +273,7 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___,
   ECMA_TRY_CATCH (string_var, ecma_op_to_string (string), ret_value);
 
   ecma_string_t *number_str_p = ecma_get_string_from_value (string_var);
-  int32_t string_len = ecma_string_get_length (number_str_p);
+  ecma_length_t string_len = ecma_string_get_length (number_str_p);
 
   MEM_DEFINE_LOCAL_ARRAY (zt_string_buff, string_len + 1, ecma_char_t);
 
@@ -284,8 +284,8 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___,
   JERRY_ASSERT (bytes_copied > 0);
 
   /* 2. Find first non whitespace char. */
-  int32_t start = 0;
-  for (int i = 0; i < string_len; i++)
+  ecma_length_t start = 0;
+  for (ecma_length_t i = 0; i < string_len; i++)
   {
     if (!isspace (zt_string_buff[i]))
     {
@@ -312,7 +312,7 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___,
   /* Check if string is equal to "Infinity". */
   const ecma_char_t *infinity_zt_str_p = lit_get_magic_string_zt (LIT_MAGIC_STRING_INFINITY_UL);
 
-  for (int i = 0; infinity_zt_str_p[i] == zt_string_buff[start + i]; i++)
+  for (ecma_length_t i = 0; infinity_zt_str_p[i] == zt_string_buff[start + i]; i++)
   {
     if (infinity_zt_str_p[i + 1] == 0)
     {
@@ -324,8 +324,8 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___,
 
   if (ecma_is_completion_value_empty (ret_value))
   {
-    int32_t current = start;
-    int32_t end = string_len;
+    ecma_length_t current = start;
+    ecma_length_t end = string_len;
     bool has_whole_part = false;
     bool has_fraction_part = false;
 
@@ -334,7 +334,7 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___,
       has_whole_part = true;
 
       /* Check digits of whole part. */
-      for (int i = current; i < string_len; i++, current++)
+      for (ecma_length_t i = current; i < string_len; i++, current++)
       {
         if (!isdigit (zt_string_buff[current]))
         {
@@ -355,7 +355,7 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___,
         has_fraction_part = true;
 
         /* Check digits of fractional part. */
-        for (int i = current; i < string_len; i++, current++)
+        for (ecma_length_t i = current; i < string_len; i++, current++)
         {
           if (!isdigit (zt_string_buff[current]))
           {
@@ -383,7 +383,7 @@ ecma_builtin_global_object_parse_float (ecma_value_t this_arg __attr_unused___,
       {
 
         /* Check digits of exponent part. */
-        for (int i = current; i < string_len; i++, current++)
+        for (ecma_length_t i = current; i < string_len; i++, current++)
         {
           if (!isdigit (zt_string_buff[current]))
           {

jerry-core/ecma/builtin-objects/ecma-builtin-regexp-prototype.cpp

@@ -77,11 +77,11 @@ ecma_builtin_regexp_prototype_exec (ecma_value_t this_arg, /**< this argument */
     ecma_string_t *input_str_p = ecma_get_string_from_value (input_str_value);
 
     /* Convert ecma_String_t *to regexp_bytecode_t* */
-    int32_t input_str_len = ecma_string_get_length (input_str_p);
+    ecma_length_t input_str_len = ecma_string_get_length (input_str_p);
 
     MEM_DEFINE_LOCAL_ARRAY (input_zt_str_p, input_str_len + 1, ecma_char_t);
 
-    ssize_t zt_str_size = (ssize_t) sizeof (ecma_char_t) * (input_str_len + 1);
+    ssize_t zt_str_size = (ssize_t) (sizeof (ecma_char_t) * (input_str_len + 1));
     ecma_string_to_zt_string (input_str_p, input_zt_str_p, zt_str_size);
 
     ret_value = ecma_regexp_exec_helper (obj_p, bytecode_p, input_zt_str_p);

jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.cpp

@@ -163,8 +163,6 @@ ecma_builtin_string_prototype_object_concat (ecma_value_t this_arg, /**< this ar
   /* 4 */
   ecma_string_t *string_to_return = ecma_copy_or_ref_ecma_string (ecma_get_string_from_value (to_string_val));
 
-  JERRY_ASSERT (ecma_string_get_length (string_to_return) >= 0);
-
   /* 5 */
   for (uint32_t arg_index = 0;
        arg_index < arguments_number && ecma_is_completion_value_empty (ret_value);
@@ -329,8 +327,6 @@ ecma_builtin_string_prototype_object_slice (ecma_value_t this_arg, /**< this arg
   /* 3. */
   ecma_string_t *get_string_val = ecma_get_string_from_value (to_string_val);
 
-  JERRY_ASSERT (ecma_string_get_length (get_string_val) >= 0);
-
   const uint32_t len = (uint32_t) ecma_string_get_length (get_string_val);
 
   /* 4. 6. */
@@ -509,7 +505,6 @@ ecma_builtin_string_prototype_object_trim (ecma_value_t this_arg) /**< this argu
                   ret_value);
 
   ecma_string_t *original_string_p = ecma_get_string_from_value (to_string_val);
-  JERRY_ASSERT (ecma_string_get_length (original_string_p) >= 0);
 
   /* 3 */
   const uint32_t len = (uint32_t) ecma_string_get_length (original_string_p);

jerry-core/ecma/builtin-objects/ecma-builtins.cpp

@@ -601,7 +601,7 @@ ecma_builtin_bin_search_for_magic_string_id_in_array (const lit_magic_string_id_
 #endif /* !JERRY_NDEBUG */
 
   int32_t min = 0;
-  int32_t max = array_length - 1;
+  int32_t max = (int32_t) array_length - 1;
 
   while (min <= max)
   {

jerry-core/ecma/operations/ecma-eval.cpp

@@ -46,12 +46,12 @@ ecma_op_eval (ecma_string_t *code_p, /**< code string */
 {
   ecma_completion_value_t ret_value;
 
-  int32_t chars_num = ecma_string_get_length (code_p);
+  ecma_length_t chars_num = ecma_string_get_length (code_p);
   MEM_DEFINE_LOCAL_ARRAY (code_zt_buffer_p,
                           chars_num + 1,
                           ecma_char_t);
 
-  const ssize_t buf_size = (ssize_t) sizeof (ecma_char_t) * (chars_num + 1);
+  const ssize_t buf_size = (ssize_t) (sizeof (ecma_char_t) * (chars_num + 1));
   ssize_t buffer_size_req = ecma_string_to_zt_string (code_p,
                                                       code_zt_buffer_p,
                                                       buf_size);

jerry-core/ecma/operations/ecma-objects-arguments.cpp

@@ -151,7 +151,7 @@ ecma_op_create_arguments_object (ecma_object_t *func_obj_p, /**< callee function
       }
       JERRY_ASSERT (param_index == formal_params_number);
 
-      for (int32_t indx = formal_params_number - 1;
+      for (int32_t indx = (int32_t) formal_params_number - 1;
            indx >= 0;
            indx--)
       {
@@ -161,7 +161,7 @@ ecma_op_create_arguments_object (ecma_object_t *func_obj_p, /**< callee function
 
         // ii.
         for (int32_t indx2 = indx + 1;
-             indx2 < formal_params_number;
+             indx2 < (int32_t) formal_params_number;
              indx2++)
         {
           if (ecma_compare_ecma_strings (name_p, formal_params[indx2]))

jerry-core/ecma/operations/ecma-regexp-object.cpp

@@ -72,9 +72,9 @@ re_parse_regexp_flags (ecma_string_t *flags_str_p, /**< Input string with flags
 {
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
 
-  int32_t flags_str_len = ecma_string_get_length (flags_str_p);
+  ecma_length_t flags_str_len = ecma_string_get_length (flags_str_p);
   MEM_DEFINE_LOCAL_ARRAY (flags_start_p, flags_str_len + 1, ecma_char_t);
-  ssize_t zt_str_size = (ssize_t) sizeof (ecma_char_t) * (flags_str_len + 1);
+  ssize_t zt_str_size = (ssize_t) (sizeof (ecma_char_t) * (flags_str_len + 1));
   ecma_string_to_zt_string (flags_str_p, flags_start_p, zt_str_size);
 
   ecma_char_t *flags_char_p = flags_start_p;
@@ -1181,7 +1181,7 @@ ecma_regexp_exec_helper (ecma_object_t *obj_p, /**< RegExp object */
                          const ecma_char_t *str_p) /**< start of the input string */
 {
   ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
-  int32_t input_length = ecma_zt_string_length (str_p);
+  ecma_length_t input_length = ecma_zt_string_length (str_p);
   re_matcher_ctx_t re_ctx;
   re_ctx.input_start_p = str_p;
   re_ctx.input_end_p = str_p + strlen ((char *) str_p);
@@ -1232,7 +1232,7 @@ ecma_regexp_exec_helper (ecma_object_t *obj_p, /**< RegExp object */
   const ecma_char_t *sub_str_p;
   while (str_p && str_p <= re_ctx.input_end_p && ecma_is_completion_value_empty (ret_value))
   {
-    if (index < 0 || index > input_length)
+    if (index < 0 || index > (int32_t) input_length)
     {
       ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
       ecma_number_t *lastindex_num_p = ecma_alloc_number ();

jerry-core/ecma/operations/ecma-string-object.cpp

@@ -70,8 +70,7 @@ ecma_op_create_string_object (const ecma_value_t *arguments_list_p, /**< list of
       JERRY_ASSERT (ecma_is_value_string (ecma_get_completion_value_value (to_str_arg_value)));
       prim_prop_str_value_p = ecma_get_string_from_completion_value (to_str_arg_value);
 
-      int32_t string_len = ecma_string_get_length (prim_prop_str_value_p);
-      JERRY_ASSERT (string_len >= 0);
+      ecma_length_t string_len = ecma_string_get_length (prim_prop_str_value_p);
 
       length_value = ecma_uint32_to_number ((uint32_t) string_len);
     }
@@ -174,8 +173,7 @@ ecma_op_string_object_get_own_property (ecma_object_t *obj_p, /**< the string ob
                                                                prim_value_prop_p->u.internal_property.value);
 
   // 6.
-  int32_t length = ecma_string_get_length (prim_value_str_p);
-  JERRY_ASSERT (length >= 0);
+  ecma_length_t length = ecma_string_get_length (prim_value_str_p);
 
   ecma_property_t *new_prop_p;