fix style errors in libjsparser

src/libjsparser/lexer.c

@@ -519,7 +519,12 @@ convert_seen_name_to_token (token_type tt, const char *string)
     if ((string == NULL && current_token_equals_to (current_string))
         || (string != NULL && !__strcmp (current_string, string)))
     {
-      ret_val = (token) { .type = tt, .data.uid = i };
+      ret_val = (token)
+      {
+        .type = tt,
+        .data.uid = i
+      };
+
       break;
     }
 
@@ -566,7 +571,11 @@ add_token_to_seen_names (token_type tt, const char *string)
     __memcpy (current_string, string, __strlen (string) + 1);
   }
 
-  ret_val = (token) { .type = tt, .data.uid = seen_names_count++ };
+  ret_val = (token)
+  {
+    .type = tt,
+    .data.uid = seen_names_count++
+  };
 
   return ret_val;
 }
@@ -1190,6 +1199,7 @@ replace_comment_by_newline (void)
     {
       consume_char ();
       consume_char ();
+
       if (was_newlines)
       {
         return true;
@@ -1283,7 +1293,7 @@ lexer_next_token_private (void)
 
   if (c == '/' && LA (1) == '/')
   {
-    replace_comment_by_newline ();;
+    replace_comment_by_newline ();
     return lexer_next_token_private ();
   }
 
@@ -1313,28 +1323,33 @@ lexer_next_token_private (void)
     case '|': IF_LA_IS_OR ('|', TOK_DOUBLE_OR, '=', TOK_OR_EQ, TOK_OR);
 
     case '<':
+    {
       switch (LA (1))
       {
         case '<': IF_LA_N_IS ('=', TOK_LSHIFT_EQ, TOK_LSHIFT, 2);
         case '=': RETURN_PUNC_EX (TOK_LESS_EQ, 2);
         default: RETURN_PUNC (TOK_LESS);
       }
-
+    }
     case '>':
+    {
       switch (LA (1))
       {
         case '>':
+        {
           switch (LA (2))
           {
             case '>': IF_LA_N_IS ('=', TOK_RSHIFT_EX_EQ, TOK_RSHIFT_EX, 3);
             case '=': RETURN_PUNC_EX (TOK_RSHIFT_EQ, 3);
             default: RETURN_PUNC_EX (TOK_RSHIFT, 2);
           }
+        }
         case '=': RETURN_PUNC_EX (TOK_GREATER_EQ, 2);
         default: RETURN_PUNC (TOK_GREATER);
       }
-
+    }
     case '=':
+    {
       if (LA (1) == '=')
       {
         IF_LA_N_IS ('=', TOK_TRIPLE_EQ, TOK_DOUBLE_EQ, 2);
@@ -1343,8 +1358,9 @@ lexer_next_token_private (void)
       {
         RETURN_PUNC (TOK_EQ);
       }
-
+    }
     case '!':
+    {
       if (LA (1) == '=')
       {
         IF_LA_N_IS ('=', TOK_NOT_DOUBLE_EQ, TOK_NOT_EQ, 2);
@@ -1353,7 +1369,7 @@ lexer_next_token_private (void)
       {
         RETURN_PUNC (TOK_NOT);
       }
-
+    }
     default: JERRY_UNREACHABLE ();
   }
   parser_fatal (ERR_NON_CHAR);

src/libjsparser/parser.c

@@ -216,6 +216,7 @@ token_after_newlines_must_be_keyword (keyword kw)
 }
 
 #if 0
+
 static void
 insert_semicolon (void)
 {
@@ -342,15 +343,21 @@ rewrite_rewritable_opcodes (rewritable_opcode_type type, opcode_counter_t oc)
     switch (type)
     {
       case REWRITABLE_CONTINUE:
+      {
         REWRITE_OPCODE_1 (op.oc_stack[i], jmp_up, oc);
         break;
+      }
       case REWRITABLE_BREAK:
+      {
         REWRITE_OPCODE_1 (op.oc_stack[i], jmp_down, oc);
         break;
+      }
       default:
+      {
         JERRY_UNREACHABLE ();
       }
     }
+  }
 
   if (op.oc_stack)
   {
@@ -408,7 +415,6 @@ dump_intrinsic (T_IDX obj, T_IDX args[3])
 
   JERRY_UNREACHABLE ();
 }
-
 /* property_name
   : Identifier
   | StringLiteral
@@ -424,17 +430,21 @@ parse_property_name (void)
     case TOK_NAME:
     case TOK_STRING:
     case TOK_NUMBER:
+    {
       return tok.data.uid;
-
+    }
     case TOK_SMALL_INT:
+    {
       lhs = next_temp_name ();
       DUMP_OPCODE_3 (assignment, lhs, OPCODE_ARG_TYPE_SMALLINT, tok.data.uid);
       return lhs;
-
+    }
     default:
+    {
       JERRY_UNREACHABLE ();
     }
   }
+}
 
 /* property_name_and_value
   : property_name LT!* ':' LT!* assignment_expression
@@ -528,21 +538,26 @@ dump_varg_end (T_IDX current_param, T_IDX params[3])
   switch (current_param)
   {
     case 0:
+    {
       DUMP_OPCODE_1 (varg_1_end, params[0]);
       break;
-
+    }
     case 1:
+    {
       DUMP_OPCODE_2 (varg_2_end, params[0], params[1]);
       break;
-
+    }
     case 2:
+    {
       DUMP_OPCODE_3 (varg_3_end, params[0], params[1], params[2]);
       break;
-
+    }
     default:
+    {
       JERRY_UNREACHABLE ();
     }
   }
+}
 
 typedef enum
 {
@@ -562,28 +577,31 @@ static T_IDX
 parse_argument_list (argument_list_type alt, T_IDX obj)
 {
   token_type open_tt, close_tt;
-  T_IDX first_opcode_args_count,
+  T_IDX first_opcode_args_count;
-        lhs = 0,
+  T_IDX lhs = 0;
-        args[3+1/* +1 for stack protector */],
+  T_IDX args[3 + 1/* +1 for stack protector */];
-        current_arg = 0;
+  T_IDX current_arg = 0;
 
   switch (alt)
   {
     case AL_FUNC_DECL:
+    {
       open_tt = TOK_OPEN_PAREN; // Openning token
       close_tt = TOK_CLOSE_PAREN; // Ending token
       first_opcode_args_count = 2; // Maximum number of arguments in first opcode
       break;
-
+    }
     case AL_FUNC_EXPR:
     case AL_CONSTRUCT_EXPR:
+    {
       open_tt = TOK_OPEN_PAREN;
       close_tt = TOK_CLOSE_PAREN;
       first_opcode_args_count = 1;
       lhs = next_temp_name ();
       break;
-
+    }
     case AL_CALL_EXPR:
+    {
       open_tt = TOK_OPEN_PAREN;
       close_tt = TOK_CLOSE_PAREN;
       first_opcode_args_count = 1;
@@ -593,24 +611,28 @@ parse_argument_list (argument_list_type alt, T_IDX obj)
       }
       lhs = next_temp_name ();
       break;
-
+    }
     case AL_ARRAY_LIT:
+    {
       open_tt = TOK_OPEN_SQUARE;
       close_tt = TOK_CLOSE_SQUARE;
       first_opcode_args_count = 2;
       lhs = next_temp_name ();
       break;
-
+    }
     case AL_OBJECT_LIT:
+    {
       open_tt = TOK_OPEN_BRACE;
       close_tt = TOK_CLOSE_BRACE;
       first_opcode_args_count = 2;
       lhs = next_temp_name ();
       break;
-
+    }
     default:
+    {
       JERRY_UNREACHABLE ();
     }
+  }
 
   current_token_must_be (open_tt);
 
@@ -627,36 +649,44 @@ parse_argument_list (argument_list_type alt, T_IDX obj)
           switch (alt)
           {
             case AL_FUNC_DECL:
+            {
               DUMP_OPCODE_3 (func_decl_n, obj, args[0], args[1]);
               break;
-
+            }
             case AL_FUNC_EXPR:
+            {
               DUMP_OPCODE_3 (func_expr_n, lhs, obj, args[0]);
               break;
-
+            }
             case AL_ARRAY_LIT:
+            {
               DUMP_OPCODE_3 (array_n, lhs, args[0], args[1]);
               break;
-
+            }
             case AL_OBJECT_LIT:
+            {
               DUMP_OPCODE_3 (obj_n, lhs, args[0], args[1]);
               break;
-
+            }
             case AL_CONSTRUCT_EXPR:
+            {
               DUMP_OPCODE_3 (construct_n, lhs, obj, args[0]);
               break;
-
+            }
             case AL_CALL_EXPR:
+            {
               if (is_intrinsic (obj))
               {
                 parser_fatal (ERR_PARSER);
               }
               DUMP_OPCODE_3 (call_n, lhs, obj, args[0]);
               break;
-
+            }
             default:
+            {
               JERRY_UNREACHABLE ();
             }
+          }
           current_arg = 0;
           is_first_opcode = false;
         }
@@ -669,24 +699,29 @@ parse_argument_list (argument_list_type alt, T_IDX obj)
       switch (alt)
       {
         case AL_FUNC_DECL:
+        {
           current_token_must_be (TOK_NAME);
           args[current_arg] = tok.data.uid;
           break;
-
+        }
         case AL_FUNC_EXPR:
         case AL_ARRAY_LIT:
         case AL_CONSTRUCT_EXPR:
         case AL_CALL_EXPR:
+        {
           args[current_arg] = parse_assignment_expression ();
           break;
-
+        }
         case AL_OBJECT_LIT:
+        {
           args[current_arg] = parse_property_assignment ();
           break;
-
+        }
         default:
+        {
           JERRY_UNREACHABLE ();
         }
+      }
 
       skip_newlines ();
       if (tok.type != TOK_COMMA)
@@ -706,26 +741,32 @@ parse_argument_list (argument_list_type alt, T_IDX obj)
         switch (alt)
         {
           case AL_FUNC_DECL:
+          {
             DUMP_OPCODE_2 (func_decl_1, obj, args[0]);
             break;
-
+          }
           case AL_FUNC_EXPR:
+          {
             DUMP_OPCODE_3 (func_expr_1, lhs, obj, args[0]);
             break;
-
+          }
           case AL_ARRAY_LIT:
+          {
             DUMP_OPCODE_2 (array_1, lhs, args[0]);
             break;
-
+          }
           case AL_OBJECT_LIT:
+          {
             DUMP_OPCODE_2 (obj_1, lhs, args[0]);
             break;
-
+          }
           case AL_CONSTRUCT_EXPR:
+          {
             DUMP_OPCODE_3 (construct_1, lhs, obj, args[0]);
             break;
-
+          }
           case AL_CALL_EXPR:
+          {
             if (is_intrinsic (obj))
             {
               dump_intrinsic (obj, args);
@@ -735,31 +776,38 @@ parse_argument_list (argument_list_type alt, T_IDX obj)
               DUMP_OPCODE_3 (call_1, lhs, obj, args[0]);
             }
             break;
-
+          }
           default:
+          {
             JERRY_UNREACHABLE ();
           }
         }
+      }
       else if (current_arg == 1)
       {
         switch (alt)
         {
           case AL_FUNC_DECL:
+          {
             DUMP_OPCODE_3 (func_decl_2, obj, args[0], args[1]);
             break;
-
+          }
           case AL_ARRAY_LIT:
+          {
             DUMP_OPCODE_3 (array_2, lhs, args[0], args[1]);
             break;
-
+          }
           case AL_OBJECT_LIT:
+          {
             DUMP_OPCODE_3 (obj_2, lhs, args[0], args[1]);
             break;
-
+          }
           default:
+          {
             JERRY_UNREACHABLE ();
           }
         }
+      }
       else
       {
         JERRY_UNREACHABLE ();
@@ -775,33 +823,41 @@ parse_argument_list (argument_list_type alt, T_IDX obj)
     switch (alt)
     {
       case AL_FUNC_DECL:
+      {
         DUMP_OPCODE_1 (func_decl_0, obj);
         break;
-
+      }
       case AL_FUNC_EXPR:
+      {
         DUMP_OPCODE_2 (func_expr_0, lhs, obj);
         break;
-
+      }
       case AL_ARRAY_LIT:
+      {
         DUMP_OPCODE_1 (array_0, lhs);
         break;
-
+      }
       case AL_OBJECT_LIT:
+      {
         DUMP_OPCODE_1 (obj_0, lhs);
         break;
-
+      }
       case AL_CONSTRUCT_EXPR:
+      {
         DUMP_OPCODE_2 (construct_0, lhs, obj);
         break;
-
+      }
       case AL_CALL_EXPR:
+      {
         DUMP_OPCODE_2 (call_0, lhs, obj);
         break;
-
+      }
       default:
+      {
         JERRY_UNREACHABLE ();
       }
     }
+  }
 
   return lhs;
 }
@@ -913,35 +969,42 @@ parse_literal (void)
   switch (tok.type)
   {
     case TOK_NULL:
+    {
       lhs = next_temp_name ();
       DUMP_OPCODE_3 (assignment, lhs, OPCODE_ARG_TYPE_SIMPLE, ECMA_SIMPLE_VALUE_NULL);
       return lhs;
-
+    }
     case TOK_BOOL:
+    {
       lhs = next_temp_name ();
       DUMP_OPCODE_3 (assignment, lhs, OPCODE_ARG_TYPE_SIMPLE,
                      tok.data.uid ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
       return lhs;
-
+    }
     case TOK_NUMBER:
+    {
       lhs = next_temp_name ();
       DUMP_OPCODE_3 (assignment, lhs, OPCODE_ARG_TYPE_NUMBER, tok.data.uid);
       return lhs;
-
+    }
     case TOK_SMALL_INT:
+    {
       lhs = next_temp_name ();
       DUMP_OPCODE_3 (assignment, lhs, OPCODE_ARG_TYPE_SMALLINT, tok.data.uid);
       return lhs;
-
+    }
     case TOK_STRING:
+    {
       lhs = next_temp_name ();
       DUMP_OPCODE_3 (assignment, lhs, OPCODE_ARG_TYPE_STRING, tok.data.uid);
       return lhs;
-
+    }
     default:
+    {
       JERRY_UNREACHABLE ();
     }
   }
+}
 
 /* primary_expression
   : 'this'
@@ -966,22 +1029,27 @@ parse_primary_expression (void)
   switch (tok.type)
   {
     case TOK_NAME:
+    {
       return tok.data.uid;
-
+    }
     case TOK_NULL:
     case TOK_BOOL:
     case TOK_SMALL_INT:
     case TOK_NUMBER:
     case TOK_STRING:
+    {
       return parse_literal ();
-
+    }
     case TOK_OPEN_SQUARE:
+    {
       return parse_array_literal ();
-
+    }
     case TOK_OPEN_BRACE:
+    {
       return parse_object_literal ();
-
+    }
     case TOK_OPEN_PAREN:
+    {
       skip_newlines ();
       if (tok.type != TOK_CLOSE_PAREN)
       {
@@ -990,11 +1058,13 @@ parse_primary_expression (void)
         return lhs;
       }
       // FALLTHRU
-
+    }
     default:
+    {
       JERRY_UNREACHABLE ();
     }
   }
+}
 
 /* member_expression
   : (primary_expression | function_expression | 'new' LT!* member_expression (LT!* '(' LT!* arguments? LT!* ')')
@@ -1109,11 +1179,13 @@ parse_call_expression (void)
     switch (tok.type)
     {
       case TOK_OPEN_PAREN:
+      {
         lhs = parse_argument_list (AL_CALL_EXPR, obj);
         skip_newlines ();
         break;
-
+      }
       case TOK_OPEN_SQUARE:
+      {
         NEXT (prop, expression);
         next_token_must_be (TOK_CLOSE_SQUARE);
 
@@ -1121,8 +1193,9 @@ parse_call_expression (void)
         obj = lhs;
         skip_newlines ();
         break;
-
+      }
       case TOK_DOT:
+      {
         token_after_newlines_must_be (TOK_NAME);
         prop = tok.data.uid;
 
@@ -1130,11 +1203,13 @@ parse_call_expression (void)
         obj = lhs;
         skip_newlines ();
         break;
-
+      }
       default:
+      {
         JERRY_UNREACHABLE ();
       }
     }
+  }
   lexer_save_token (tok);
 
   return obj;
@@ -1189,42 +1264,49 @@ parse_unary_expression (void)
   switch (tok.type)
   {
     case TOK_DOUBLE_PLUS:
+    {
       lhs = next_temp_name ();
       NEXT (expr, unary_expression);
       DUMP_OPCODE_2 (pre_incr, lhs, expr);
       return expr;
-
+    }
     case TOK_DOUBLE_MINUS:
+    {
       lhs = next_temp_name ();
       NEXT (expr, unary_expression);
       DUMP_OPCODE_2 (pre_decr, lhs, expr);
       return expr;
-
+    }
     case TOK_PLUS:
+    {
       lhs = next_temp_name ();
       NEXT (expr, unary_expression);
       DUMP_OPCODE_3 (addition, lhs, integer_zero (), expr);
       return lhs;
-
+    }
     case TOK_MINUS:
+    {
       lhs = next_temp_name ();
       NEXT (expr, unary_expression);
       DUMP_OPCODE_3 (substraction, lhs, integer_zero (), expr);
       return lhs;
-
+    }
     case TOK_COMPL:
+    {
       lhs = next_temp_name ();
       NEXT (expr, unary_expression);
       DUMP_OPCODE_2 (b_not, lhs, expr);
       return lhs;
-
+    }
     case TOK_NOT:
+    {
       lhs = next_temp_name ();
       NEXT (expr, unary_expression);
       DUMP_OPCODE_2 (logical_not, lhs, expr);
       return lhs;
-
+    }
     case TOK_KEYWORD:
+    {
       if (is_keyword (KW_DELETE))
       {
         lhs = next_temp_name ();
@@ -1244,11 +1326,13 @@ parse_unary_expression (void)
         return lhs;
       }
       /* FALLTHRU.  */
-
+    }
     default:
+    {
       return parse_postfix_expression ();
     }
   }
+}
 
 #define DUMP_OF(GETOP, EXPR) \
     lhs = next_temp_name (); \
@@ -1273,16 +1357,23 @@ parse_multiplicative_expression (void)
     switch (tok.type)
     {
       case TOK_MULT:
+      {
         DUMP_OF (multiplication, unary_expression)
+      }
       case TOK_DIV:
+      {
         DUMP_OF (division, unary_expression)
+      }
       case TOK_MOD:
+      {
         DUMP_OF (remainder, unary_expression)
-
+      }
       default:
+      {
         lexer_save_token (tok);
         return expr1;
       }
+    }
 
     skip_newlines ();
   }
@@ -1304,14 +1395,19 @@ parse_additive_expression (void)
     switch (tok.type)
     {
       case TOK_PLUS:
+      {
         DUMP_OF (addition, multiplicative_expression);
+      }
       case TOK_MINUS:
+      {
         DUMP_OF (substraction, multiplicative_expression);
-
+      }
       default:
+      {
         lexer_save_token (tok);
         return expr1;
       }
+    }
 
     skip_newlines ();
   }
@@ -1333,16 +1429,23 @@ parse_shift_expression (void)
     switch (tok.type)
     {
       case TOK_LSHIFT:
+      {
         DUMP_OF (b_shift_left, additive_expression)
+      }
       case TOK_RSHIFT:
+      {
         DUMP_OF (b_shift_right, additive_expression)
+      }
       case TOK_RSHIFT_EX:
+      {
         DUMP_OF (b_shift_uright, additive_expression)
-
+      }
       default:
+      {
         lexer_save_token (tok);
         return expr1;
       }
+    }
 
     skip_newlines ();
   }
@@ -1364,14 +1467,23 @@ parse_relational_expression (void)
     switch (tok.type)
     {
       case TOK_LESS:
+      {
         DUMP_OF (less_than, shift_expression)
+      }
       case TOK_GREATER:
+      {
         DUMP_OF (greater_than, shift_expression)
+      }
       case TOK_LESS_EQ:
+      {
         DUMP_OF (less_or_equal_than, shift_expression)
+      }
       case TOK_GREATER_EQ:
+      {
         DUMP_OF (greater_or_equal_than, shift_expression)
+      }
       case TOK_KEYWORD:
+      {
         if (is_keyword (KW_INSTANCEOF))
         {
           DUMP_OF (instanceof, shift_expression)
@@ -1380,12 +1492,14 @@ parse_relational_expression (void)
         {
           DUMP_OF (in, shift_expression)
         }
-        // FALLTHRU
+        /* FALLTHROUGH */
-
+      }
       default:
+      {
         lexer_save_token (tok);
         return expr1;
       }
+    }
 
     skip_newlines ();
   }
@@ -1407,18 +1521,27 @@ parse_equality_expression (void)
     switch (tok.type)
     {
       case TOK_DOUBLE_EQ:
+      {
         DUMP_OF (equal_value, relational_expression)
+      }
       case TOK_NOT_EQ:
+      {
         DUMP_OF (not_equal_value, relational_expression)
+      }
       case TOK_TRIPLE_EQ:
+      {
         DUMP_OF (equal_value_type, relational_expression)
+      }
       case TOK_NOT_DOUBLE_EQ:
+      {
         DUMP_OF (not_equal_value_type, relational_expression)
-
+      }
       default:
+      {
         lexer_save_token (tok);
         return expr1;
       }
+    }
 
     skip_newlines ();
   }
@@ -1525,68 +1648,82 @@ parse_assignment_expression (void)
   switch (tok.type)
   {
     case TOK_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (assignment, lhs, OPCODE_ARG_TYPE_VARIABLE, rhs);
       break;
-
+    }
     case TOK_MULT_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (multiplication, lhs, lhs, rhs);
       break;
-
+    }
     case TOK_DIV_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (division, lhs, lhs, rhs);
       break;
-
+    }
     case TOK_MOD_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (remainder, lhs, lhs, rhs);
       break;
-
+    }
     case TOK_PLUS_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (addition, lhs, lhs, rhs);
       break;
-
+    }
     case TOK_MINUS_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (substraction, lhs, lhs, rhs);
       break;
-
+    }
     case TOK_LSHIFT_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (b_shift_left, lhs, lhs, rhs);
       break;
-
+    }
     case TOK_RSHIFT_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (b_shift_right, lhs, lhs, rhs);
       break;
-
+    }
     case TOK_RSHIFT_EX_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (b_shift_uright, lhs, lhs, rhs);
       break;
-
+    }
     case TOK_AND_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (b_and, lhs, lhs, rhs);
       break;
-
+    }
     case TOK_XOR_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (b_xor, lhs, lhs, rhs);
       break;
-
+    }
     case TOK_OR_EQ:
+    {
       NEXT (rhs, assignment_expression);
       DUMP_OPCODE_3 (b_or, lhs, lhs, rhs);
       break;
-
+    }
     default:
+    {
       lexer_save_token (tok);
     }
+  }
 
   return lhs;
 }
@@ -1821,7 +1958,6 @@ plain_for:
 
 for_in:
   JERRY_UNIMPLEMENTED ();
-
 }
 
 static T_IDX
@@ -2101,6 +2237,7 @@ parse_statement (void)
   }
   if (is_keyword (KW_CONTINUE))
   {
+
     must_be_inside_but_not_in ((uint8_t[])
     {
                                NESTING_ITERATIONAL, NESTING_SWITCH
@@ -2112,6 +2249,7 @@ parse_statement (void)
   }
   if (is_keyword (KW_BREAK))
   {
+
     must_be_inside_but_not_in ((uint8_t[])
     {
                                NESTING_ITERATIONAL, NESTING_SWITCH