Fix wrong indentations of function parameters

Zsolt Borbély · Zsolt Borbély · commit 7813801cd32c · 2016-05-02T13:38:28.000+02:00
JerryScript-DCO-1.0-Signed-off-by: Zsolt Borbély zsborbely.u-szeged@partner.samsung.com
diff --git a/jerry-core/ecma/base/ecma-helpers-conversion.c b/jerry-core/ecma/base/ecma-helpers-conversion.c
@@ -632,10 +632,10 @@ ecma_utf8_string_to_number (const lit_utf8_byte_t *str_p, /**< utf-8 string */
    */
   ECMA_NUMBER_CONVERSION_128BIT_INTEGER (fraction_uint128);
   ECMA_NUMBER_CONVERSION_128BIT_INTEGER_INIT (fraction_uint128,
-                                             0ull,
-                                             fraction_uint64 >> 32u,
-                                             (uint32_t) fraction_uint64,
-                                             0ull);
+                                              0ull,
+                                              fraction_uint64 >> 32u,
+                                              (uint32_t) fraction_uint64,
+                                              0ull);
 
   /* Normalizing mantissa */
   JERRY_ASSERT (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128, 124));
diff --git a/jerry-core/ecma/base/ecma-helpers-string.c b/jerry-core/ecma/base/ecma-helpers-string.c
@@ -1051,7 +1051,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
   if (ECMA_STRING_GET_CONTAINER (string1_p) == ECMA_STRING_CONTAINER_HEAP_CHUNKS)
   {
     const ecma_string_heap_header_t *const data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
-                                                                         string1_p->u.collection_cp);
+                                                                               string1_p->u.collection_cp);
 
     utf8_string1_p = (lit_utf8_byte_t *) (data_p + 1);
     utf8_string1_size = (lit_utf8_size_t) data_p->size;
@@ -1085,7 +1085,7 @@ ecma_compare_ecma_strings_relational (const ecma_string_t *string1_p, /**< ecma-
   if (ECMA_STRING_GET_CONTAINER (string2_p) == ECMA_STRING_CONTAINER_HEAP_CHUNKS)
   {
     const ecma_string_heap_header_t *const data_p = ECMA_GET_NON_NULL_POINTER (ecma_string_heap_header_t,
-                                                                         string2_p->u.collection_cp);
+                                                                               string2_p->u.collection_cp);
 
     utf8_string2_p = (lit_utf8_byte_t *) (data_p + 1);
     utf8_string2_size = (lit_utf8_size_t) data_p->size;
diff --git a/jerry-core/ecma/base/ecma-helpers.c b/jerry-core/ecma/base/ecma-helpers.c
@@ -1105,7 +1105,7 @@ ecma_get_internal_property_value (const ecma_property_t *prop_p) /**< property *
  */
 inline void __attr_always_inline___
 ecma_set_internal_property_value (ecma_property_t *prop_p, /**< property */
-                                    ecma_value_t value) /**< value to set */
+                                  ecma_value_t value) /**< value to set */
 {
   JERRY_ASSERT (ECMA_PROPERTY_GET_TYPE (prop_p) == ECMA_PROPERTY_TYPE_INTERNAL);
 
diff --git a/jerry-core/ecma/base/ecma-property-hashmap.c b/jerry-core/ecma/base/ecma-property-hashmap.c
@@ -411,7 +411,7 @@ ecma_property_hashmap_find (ecma_property_hashmap_t *hashmap_p, /**< hashmap */
    * chain, and sets the property_found variable. */
   bool property_found = false;
   ecma_property_header_t *prop_iter_p = ECMA_GET_POINTER (ecma_property_header_t,
-                                        hashmap_p->header.next_property_cp);
+                                                          hashmap_p->header.next_property_cp);
 
   while (prop_iter_p != NULL && !property_found)
   {
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.c b/jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.c
@@ -826,8 +826,8 @@ ecma_builtin_array_prototype_object_shift (ecma_value_t this_arg) /**< this argu
  */
 static ecma_value_t
 ecma_builtin_array_prototype_object_slice (ecma_value_t this_arg, /**< 'this' argument */
-                              ecma_value_t arg1, /**< start */
-                              ecma_value_t arg2) /**< end */
+                                           ecma_value_t arg1, /**< start */
+                                           ecma_value_t arg2) /**< end */
 {
   ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
 
@@ -1352,8 +1352,8 @@ ecma_builtin_array_prototype_object_sort (ecma_value_t this_arg, /**< this argum
  */
 static ecma_value_t
 ecma_builtin_array_prototype_object_splice (ecma_value_t this_arg, /**< this argument */
-                                          const ecma_value_t args[], /**< arguments list */
-                                          ecma_length_t args_number) /**< number of arguments */
+                                            const ecma_value_t args[], /**< arguments list */
+                                            ecma_length_t args_number) /**< number of arguments */
 {
   ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
 
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.h b/jerry-core/ecma/builtin-objects/ecma-builtin-helpers.h
@@ -119,7 +119,7 @@ extern ecma_number_t ecma_date_make_date (ecma_number_t, ecma_number_t);
 extern ecma_number_t ecma_date_time_clip (ecma_number_t);
 extern ecma_number_t ecma_date_timezone_offset (ecma_number_t);
 extern ecma_value_t ecma_date_set_internal_property (ecma_value_t, ecma_number_t,
-                                                                ecma_number_t, ecma_date_timezone_t);
+                                                     ecma_number_t, ecma_date_timezone_t);
 
 extern ecma_value_t ecma_date_value_to_string (ecma_number_t);
 extern ecma_value_t ecma_date_value_to_utc_string (ecma_number_t);
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtins.c b/jerry-core/ecma/builtin-objects/ecma-builtins.c
@@ -308,7 +308,7 @@ ecma_builtin_try_to_instantiate_property (ecma_object_t *object_p, /**< object *
        */
 
       ecma_property_t *desc_prop_p = ecma_get_internal_property (object_p,
-                                                               ECMA_INTERNAL_PROPERTY_BUILT_IN_ROUTINE_DESC);
+                                                                 ECMA_INTERNAL_PROPERTY_BUILT_IN_ROUTINE_DESC);
       uint64_t builtin_routine_desc = ecma_get_internal_property_value (desc_prop_p);
 
       JERRY_STATIC_ASSERT (sizeof (uint8_t) * JERRY_BITSINBYTE == ECMA_BUILTIN_ROUTINE_ID_LENGTH_VALUE_WIDTH,
diff --git a/jerry-core/ecma/operations/ecma-objects-arguments.c b/jerry-core/ecma/operations/ecma-objects-arguments.c
@@ -443,7 +443,7 @@ ecma_op_arguments_object_define_own_property (ecma_object_t *obj_p, /**< the obj
         /* emulating execution of function described by MakeArgSetter */
         ecma_property_t *scope_prop_p = ecma_get_internal_property (map_p, ECMA_INTERNAL_PROPERTY_SCOPE);
         ecma_object_t *lex_env_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_object_t,
-                                                                   ECMA_PROPERTY_VALUE_PTR (scope_prop_p)->value);
+                                                                    ECMA_PROPERTY_VALUE_PTR (scope_prop_p)->value);
 
         ecma_property_t *mapped_prop_p = ecma_op_object_get_own_property (map_p, property_name_p);
         ecma_value_t arg_name_prop_value = ecma_get_named_data_property_value (mapped_prop_p);
diff --git a/jerry-core/jerry.c b/jerry-core/jerry.c
@@ -1154,8 +1154,8 @@ bool jerry_api_get_object_field_value (jerry_api_object_t *object_p, /**< object
  */
 bool
 jerry_api_foreach_object_field (jerry_api_object_t *object_p, /**< object */
-                               jerry_object_field_foreach_t foreach_p, /**< foreach function */
-                               void *user_data_p) /**< user data for foreach function */
+                                jerry_object_field_foreach_t foreach_p, /**< foreach function */
+                                void *user_data_p) /**< user data for foreach function */
 {
   jerry_assert_api_available ();
 
diff --git a/jerry-core/lit/lit-strings.c b/jerry-core/lit/lit-strings.c
@@ -127,7 +127,7 @@ lit_is_utf8_string_valid (const lit_utf8_byte_t *utf8_buf_p, /**< utf-8 string *
  */
 bool
 lit_is_cesu8_string_valid (const lit_utf8_byte_t *utf8_buf_p, /**< utf-8 string */
-                          lit_utf8_size_t buf_size) /**< string size */
+                           lit_utf8_size_t buf_size) /**< string size */
 {
   lit_utf8_size_t idx = 0;
 
@@ -341,7 +341,7 @@ lit_read_code_point_from_utf8 (const lit_utf8_byte_t *buf_p, /**< buffer with ch
  */
 lit_utf8_size_t
 lit_read_code_unit_from_utf8 (const lit_utf8_byte_t *buf_p, /**< buffer with characters */
-                               ecma_char_t *code_point) /**< [out] code point */
+                              ecma_char_t *code_point) /**< [out] code point */
 {
   JERRY_ASSERT (buf_p);
 
diff --git a/jerry-core/parser/js/js-lexer.c b/jerry-core/parser/js/js-lexer.c
@@ -1167,7 +1167,7 @@ lexer_process_char_literal (parser_context_t *context_p, /**< context */
   uint32_t literal_index = 0;
 
   JERRY_ASSERT (literal_type == LEXER_IDENT_LITERAL
-                 || literal_type == LEXER_STRING_LITERAL);
+                || literal_type == LEXER_STRING_LITERAL);
 
   JERRY_ASSERT (literal_type != LEXER_IDENT_LITERAL || length <= PARSER_MAXIMUM_IDENT_LENGTH);
   JERRY_ASSERT (literal_type != LEXER_STRING_LITERAL || length <= PARSER_MAXIMUM_STRING_LENGTH);
@@ -1232,7 +1232,7 @@ lexer_construct_literal_object (parser_context_t *context_p, /**< context */
   uint8_t local_byte_array[LEXER_MAX_LITERAL_LOCAL_BUFFER_SIZE];
 
   JERRY_ASSERT (literal_p->type == LEXER_IDENT_LITERAL
-                 || literal_p->type == LEXER_STRING_LITERAL);
+                || literal_p->type == LEXER_STRING_LITERAL);
   JERRY_ASSERT (context_p->allocated_buffer_p == NULL);
 
   destination_start_p = local_byte_array;
@@ -1435,9 +1435,9 @@ lexer_construct_literal_object (parser_context_t *context_p, /**< context */
           JERRY_ASSERT (character >= 0x10000);
           character -= 0x10000;
           destination_p += lit_char_to_utf8_bytes (destination_p,
-                                               (ecma_char_t) (0xd800 | (character >> 10)));
+                                                   (ecma_char_t) (0xd800 | (character >> 10)));
           destination_p += lit_char_to_utf8_bytes (destination_p,
-                                               (ecma_char_t) (0xdc00 | (character & LIT_UTF16_LAST_10_BITS_MASK)));
+                                                   (ecma_char_t) (0xdc00 | (character & LIT_UTF16_LAST_10_BITS_MASK)));
           source_p += 4;
           continue;
         }
@@ -1662,7 +1662,7 @@ lexer_construct_regexp_object (parser_context_t *context_p, /**< context */
   lit_utf8_size_t length;
 
   JERRY_ASSERT (context_p->token.type == LEXER_DIVIDE
-                 || context_p->token.type == LEXER_ASSIGN_DIVIDE);
+                || context_p->token.type == LEXER_ASSIGN_DIVIDE);
 
   if (context_p->token.type == LEXER_ASSIGN_DIVIDE)
   {
@@ -1850,7 +1850,7 @@ lexer_expect_identifier (parser_context_t *context_p, /**< context */
                          uint8_t literal_type) /**< literal type */
 {
   JERRY_ASSERT (literal_type == LEXER_STRING_LITERAL
-                 || literal_type == LEXER_IDENT_LITERAL);
+                || literal_type == LEXER_IDENT_LITERAL);
 
   skip_spaces (context_p);
   context_p->token.line = context_p->line;
diff --git a/jerry-core/parser/js/js-parser-expr.c b/jerry-core/parser/js/js-parser-expr.c
@@ -693,12 +693,12 @@ parser_process_unary_expression (parser_context_t *context_p) /**< context */
 
         lexer_expect_identifier (context_p, LEXER_STRING_LITERAL);
         JERRY_ASSERT (context_p->token.type == LEXER_LITERAL
-                       && context_p->token.lit_location.type == LEXER_STRING_LITERAL);
+                      && context_p->token.lit_location.type == LEXER_STRING_LITERAL);
 
         if (context_p->last_cbc_opcode == CBC_PUSH_LITERAL)
         {
           JERRY_ASSERT (CBC_ARGS_EQ (CBC_PUSH_PROP_LITERAL_LITERAL,
-                                      CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2));
+                                     CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2));
           context_p->last_cbc_opcode = CBC_PUSH_PROP_LITERAL_LITERAL;
           context_p->last_cbc.value = context_p->lit_object.index;
         }
@@ -1162,19 +1162,19 @@ parser_append_binary_token (parser_context_t *context_p) /**< context */
     else if (context_p->last_cbc_opcode == CBC_PUSH_PROP_LITERAL)
     {
       JERRY_ASSERT (CBC_SAME_ARGS (CBC_PUSH_PROP_LITERAL,
-                                    CBC_PUSH_PROP_LITERAL_REFERENCE));
+                                   CBC_PUSH_PROP_LITERAL_REFERENCE));
       context_p->last_cbc_opcode = CBC_PUSH_PROP_LITERAL_REFERENCE;
     }
     else if (context_p->last_cbc_opcode == CBC_PUSH_PROP_LITERAL_LITERAL)
     {
       JERRY_ASSERT (CBC_SAME_ARGS (CBC_PUSH_PROP_LITERAL_LITERAL,
-                                    CBC_PUSH_PROP_LITERAL_LITERAL_REFERENCE));
+                                   CBC_PUSH_PROP_LITERAL_LITERAL_REFERENCE));
       context_p->last_cbc_opcode = CBC_PUSH_PROP_LITERAL_LITERAL_REFERENCE;
     }
     else if (context_p->last_cbc_opcode == CBC_PUSH_PROP_THIS_LITERAL)
     {
       JERRY_ASSERT (CBC_SAME_ARGS (CBC_PUSH_PROP_THIS_LITERAL,
-                                    CBC_PUSH_PROP_THIS_LITERAL_REFERENCE));
+                                   CBC_PUSH_PROP_THIS_LITERAL_REFERENCE));
       context_p->last_cbc_opcode = CBC_PUSH_PROP_THIS_LITERAL_REFERENCE;
     }
     else
@@ -1239,7 +1239,7 @@ parser_process_binary_opcodes (parser_context_t *context_p, /**< context */
         if (opcode == CBC_ASSIGN_SET_IDENT)
         {
           JERRY_ASSERT (CBC_ARGS_EQ (CBC_ASSIGN_LITERAL_SET_IDENT,
-                                      CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2));
+                                     CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2));
           context_p->last_cbc.value = parser_stack_pop_uint16 (context_p);
           context_p->last_cbc_opcode = CBC_ASSIGN_LITERAL_SET_IDENT;
           continue;
@@ -1274,7 +1274,7 @@ parser_process_binary_opcodes (parser_context_t *context_p, /**< context */
       if (context_p->last_cbc_opcode == CBC_PUSH_LITERAL)
       {
         JERRY_ASSERT (CBC_ARGS_EQ (opcode + CBC_BINARY_LVALUE_WITH_LITERAL,
-                                    CBC_HAS_LITERAL_ARG));
+                                   CBC_HAS_LITERAL_ARG));
         context_p->last_cbc_opcode = (uint16_t) (opcode + CBC_BINARY_LVALUE_WITH_LITERAL);
         continue;
       }
@@ -1299,7 +1299,7 @@ parser_process_binary_opcodes (parser_context_t *context_p, /**< context */
       else if (context_p->last_cbc_opcode == CBC_PUSH_TWO_LITERALS)
       {
         JERRY_ASSERT (CBC_ARGS_EQ (opcode + CBC_BINARY_WITH_TWO_LITERALS,
-                                    CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2));
+                                   CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2));
         context_p->last_cbc_opcode = (uint16_t) (opcode + CBC_BINARY_WITH_TWO_LITERALS);
         continue;
       }
diff --git a/jerry-core/parser/js/js-parser-mem.c b/jerry-core/parser/js/js-parser-mem.c
@@ -263,7 +263,7 @@ parser_list_get (parser_list_t *list_p, /**< parser list */
 
   JERRY_ASSERT (page_p != NULL);
   JERRY_ASSERT (page_p != list_p->data.last_p
-                 || (index * list_p->item_size < list_p->data.last_position));
+                || (index * list_p->item_size < list_p->data.last_position));
   return page_p->bytes + (index * list_p->item_size);
 } /* parser_list_get */
 
@@ -358,7 +358,7 @@ parser_stack_push_uint8 (parser_context_t *context_p, /**< context */
    * parser_stack_push() pushes not fully initialized structures.
    * More precisely when the last byte of the structure is uninitialized. */
   JERRY_ASSERT (page_p == NULL
-                 || context_p->stack_top_uint8 == page_p->bytes[context_p->stack.last_position - 1]);
+                || context_p->stack_top_uint8 == page_p->bytes[context_p->stack.last_position - 1]);
 
   if (context_p->stack.last_position >= PARSER_STACK_PAGE_SIZE)
   {
@@ -391,7 +391,7 @@ parser_stack_pop_uint8 (parser_context_t *context_p) /**< context */
   parser_mem_page_t *page_p = context_p->stack.first_p;
 
   JERRY_ASSERT (page_p != NULL
-                 && context_p->stack_top_uint8 == page_p->bytes[context_p->stack.last_position - 1]);
+                && context_p->stack_top_uint8 == page_p->bytes[context_p->stack.last_position - 1]);
 
   context_p->stack.last_position--;
 
@@ -430,7 +430,7 @@ parser_stack_push_uint16 (parser_context_t *context_p, /**< context */
     parser_mem_page_t *page_p = context_p->stack.first_p;
 
     JERRY_ASSERT (page_p != NULL
-                   && context_p->stack_top_uint8 == page_p->bytes[context_p->stack.last_position - 1]);
+                  && context_p->stack_top_uint8 == page_p->bytes[context_p->stack.last_position - 1]);
 
     page_p->bytes[context_p->stack.last_position++] = (uint8_t) (uint16_value >> 8);
     page_p->bytes[context_p->stack.last_position++] = (uint8_t) uint16_value;
@@ -458,7 +458,7 @@ parser_stack_pop_uint16 (parser_context_t *context_p) /**< context */
     parser_mem_page_t *page_p = context_p->stack.first_p;
 
     JERRY_ASSERT (page_p != NULL
-                   && context_p->stack_top_uint8 == page_p->bytes[context_p->stack.last_position - 1]);
+                  && context_p->stack_top_uint8 == page_p->bytes[context_p->stack.last_position - 1]);
 
     value |= ((uint32_t) page_p->bytes[context_p->stack.last_position - 2]) << 8;
     context_p->stack_top_uint8 = page_p->bytes[context_p->stack.last_position - 3];
diff --git a/jerry-core/parser/js/js-parser-scanner.c b/jerry-core/parser/js/js-parser-scanner.c
@@ -586,8 +586,8 @@ parser_scan_until (parser_context_t *context_p, /**< context */
       case SCAN_MODE_FUNCTION_ARGUMENTS:
       {
         JERRY_ASSERT (stack_top == SCAN_STACK_BLOCK_STATEMENT
-                       || stack_top == SCAN_STACK_BLOCK_EXPRESSION
-                       || stack_top == SCAN_STACK_BLOCK_PROPERTY);
+                      || stack_top == SCAN_STACK_BLOCK_EXPRESSION
+                      || stack_top == SCAN_STACK_BLOCK_PROPERTY);
 
         if (context_p->token.type == LEXER_LITERAL
             && context_p->token.lit_location.type == LEXER_IDENT_LITERAL)
diff --git a/jerry-core/parser/js/js-parser-statm.c b/jerry-core/parser/js/js-parser-statm.c
diff --git a/jerry-core/parser/js/js-parser.c b/jerry-core/parser/js/js-parser.c
diff --git a/jerry-core/vm/vm.c b/jerry-core/vm/vm.c

Original file line number	Diff line number	Diff line change
`@@ -1105,7 +1105,7 @@ ecma_get_internal_property_value (const ecma_property_t prop_p) /< property `
`1105`	`1105`	`*/`
`1106`	`1106`	`inline void __attr_always_inline___`
`1107`	`1107`	`ecma_set_internal_property_value (ecma_property_t prop_p, /< property /`
`1108`		`- ecma_value_t value) /*< value to set /`
	`1108`	`+ ecma_value_t value) /*< value to set /`
`1109`	`1109`	`{`
`1110`	`1110`	`JERRY_ASSERT (ECMA_PROPERTY_GET_TYPE (prop_p) == ECMA_PROPERTY_TYPE_INTERNAL);`
`1111`	`1111`
Original file line number	Diff line number	Diff line change
`@@ -411,7 +411,7 @@ ecma_property_hashmap_find (ecma_property_hashmap_t hashmap_p, /< hashmap /`
`411`	`411`	`* chain, and sets the property_found variable. */`
`412`	`412`	`bool property_found = false;`
`413`	`413`	`ecma_property_header_t *prop_iter_p = ECMA_GET_POINTER (ecma_property_header_t,`
`414`		`- hashmap_p->header.next_property_cp);`
	`414`	`+ hashmap_p->header.next_property_cp);`
`415`	`415`
`416`	`416`	`while (prop_iter_p != NULL && !property_found)`
`417`	`417`	`{`