diff --git a/src/libcoreint/opcodes.c b/src/libcoreint/opcodes.c
index 0f8981593..6659035e0 100644
--- a/src/libcoreint/opcodes.c
+++ b/src/libcoreint/opcodes.c
@@ -816,8 +816,6 @@ opfunc_assignment (OPCODE opdata, /**< operation data */
                                                          ECMA_TARGET_ID_RESERVED);
       break;
     }
-
-    JERRY_UNIMPLEMENTED ();
   }
 
   if (unlikely (ecma_is_completion_value_throw (get_value_completion)))
diff --git a/src/libecmaobjects/ecma-helpers-value.c b/src/libecmaobjects/ecma-helpers-value.c
index 6d361e29a..fd2b4964c 100644
--- a/src/libecmaobjects/ecma-helpers-value.c
+++ b/src/libecmaobjects/ecma-helpers-value.c
@@ -383,13 +383,17 @@ ecma_free_completion_value (ecma_completion_value_t completion_value) /**< compl
     case ECMA_COMPLETION_TYPE_NORMAL:
     case ECMA_COMPLETION_TYPE_THROW:
     case ECMA_COMPLETION_TYPE_RETURN:
-    ecma_free_value (completion_value.value, true);
-    break;
+    {
+      ecma_free_value (completion_value.value, true);
+      break;
+    }
     case ECMA_COMPLETION_TYPE_CONTINUE:
     case ECMA_COMPLETION_TYPE_BREAK:
     case ECMA_COMPLETION_TYPE_EXIT:
-    JERRY_ASSERT(completion_value.value.value_type == ECMA_TYPE_SIMPLE);
-    break;
+    {
+      JERRY_ASSERT(completion_value.value.value_type == ECMA_TYPE_SIMPLE);
+      break;
+    }
   }
 } /* ecma_free_completion_value */
 
diff --git a/src/libjsparser/lexer.c b/src/libjsparser/lexer.c
index 46be4ae08..b55a4aa77 100644
--- a/src/libjsparser/lexer.c
+++ b/src/libjsparser/lexer.c
@@ -1299,37 +1299,38 @@ lexer_next_token_private (void)
 
   switch (c)
   {
-    case '{': RETURN_PUNC (TOK_OPEN_BRACE);
-    case '}': RETURN_PUNC (TOK_CLOSE_BRACE);
-    case '(': RETURN_PUNC (TOK_OPEN_PAREN);
-    case ')': RETURN_PUNC (TOK_CLOSE_PAREN);
-    case '[': RETURN_PUNC (TOK_OPEN_SQUARE);
-    case ']': RETURN_PUNC (TOK_CLOSE_SQUARE);
-    case '.': RETURN_PUNC (TOK_DOT);
-    case ';': RETURN_PUNC (TOK_SEMICOLON);
-    case ',': RETURN_PUNC (TOK_COMMA);
-    case '~': RETURN_PUNC (TOK_COMPL);
-    case ':': RETURN_PUNC (TOK_COLON);
-    case '?': RETURN_PUNC (TOK_QUERY);
+    case '{': RETURN_PUNC (TOK_OPEN_BRACE); break;
+    case '}': RETURN_PUNC (TOK_CLOSE_BRACE); break;
+    case '(': RETURN_PUNC (TOK_OPEN_PAREN); break;
+    case ')': RETURN_PUNC (TOK_CLOSE_PAREN); break;
+    case '[': RETURN_PUNC (TOK_OPEN_SQUARE); break;
+    case ']': RETURN_PUNC (TOK_CLOSE_SQUARE); break;
+    case '.': RETURN_PUNC (TOK_DOT); break;
+    case ';': RETURN_PUNC (TOK_SEMICOLON); break;
+    case ',': RETURN_PUNC (TOK_COMMA); break;
+    case '~': RETURN_PUNC (TOK_COMPL); break;
+    case ':': RETURN_PUNC (TOK_COLON); break;
+    case '?': RETURN_PUNC (TOK_QUERY); break;
 
-    case '*': IF_LA_IS ('=', TOK_MULT_EQ, TOK_MULT);
-    case '/': IF_LA_IS ('=', TOK_DIV_EQ, TOK_DIV);
-    case '^': IF_LA_IS ('=', TOK_XOR_EQ, TOK_XOR);
-    case '%': IF_LA_IS ('=', TOK_MOD_EQ, TOK_MOD);
+    case '*': IF_LA_IS ('=', TOK_MULT_EQ, TOK_MULT); break;
+    case '/': IF_LA_IS ('=', TOK_DIV_EQ, TOK_DIV); break;
+    case '^': IF_LA_IS ('=', TOK_XOR_EQ, TOK_XOR); break;
+    case '%': IF_LA_IS ('=', TOK_MOD_EQ, TOK_MOD); break;
 
-    case '+': IF_LA_IS_OR ('+', TOK_DOUBLE_PLUS, '=', TOK_PLUS_EQ, TOK_PLUS);
-    case '-': IF_LA_IS_OR ('-', TOK_DOUBLE_MINUS, '=', TOK_MINUS_EQ, TOK_MINUS);
-    case '&': IF_LA_IS_OR ('&', TOK_DOUBLE_AND, '=', TOK_AND_EQ, TOK_AND);
-    case '|': IF_LA_IS_OR ('|', TOK_DOUBLE_OR, '=', TOK_OR_EQ, TOK_OR);
+    case '+': IF_LA_IS_OR ('+', TOK_DOUBLE_PLUS, '=', TOK_PLUS_EQ, TOK_PLUS); break;
+    case '-': IF_LA_IS_OR ('-', TOK_DOUBLE_MINUS, '=', TOK_MINUS_EQ, TOK_MINUS); break;
+    case '&': IF_LA_IS_OR ('&', TOK_DOUBLE_AND, '=', TOK_AND_EQ, TOK_AND); break;
+    case '|': IF_LA_IS_OR ('|', TOK_DOUBLE_OR, '=', TOK_OR_EQ, TOK_OR); break;
 
     case '<':
     {
       switch (LA (1))
       {
-        case '<': IF_LA_N_IS ('=', TOK_LSHIFT_EQ, TOK_LSHIFT, 2);
-        case '=': RETURN_PUNC_EX (TOK_LESS_EQ, 2);
+        case '<': IF_LA_N_IS ('=', TOK_LSHIFT_EQ, TOK_LSHIFT, 2); break;
+        case '=': RETURN_PUNC_EX (TOK_LESS_EQ, 2); break;
         default: RETURN_PUNC (TOK_LESS);
       }
+      break;
     }
     case '>':
     {
@@ -1339,14 +1340,16 @@ lexer_next_token_private (void)
         {
           switch (LA (2))
           {
-            case '>': IF_LA_N_IS ('=', TOK_RSHIFT_EX_EQ, TOK_RSHIFT_EX, 3);
-            case '=': RETURN_PUNC_EX (TOK_RSHIFT_EQ, 3);
+            case '>': IF_LA_N_IS ('=', TOK_RSHIFT_EX_EQ, TOK_RSHIFT_EX, 3); break;
+            case '=': RETURN_PUNC_EX (TOK_RSHIFT_EQ, 3); break;
             default: RETURN_PUNC_EX (TOK_RSHIFT, 2);
           }
+          break;
         }
-        case '=': RETURN_PUNC_EX (TOK_GREATER_EQ, 2);
+        case '=': RETURN_PUNC_EX (TOK_GREATER_EQ, 2); break;
         default: RETURN_PUNC (TOK_GREATER);
       }
+      break;
     }
     case '=':
     {
@@ -1358,6 +1361,7 @@ lexer_next_token_private (void)
       {
         RETURN_PUNC (TOK_EQ);
       }
+      break;
     }
     case '!':
     {
@@ -1369,6 +1373,7 @@ lexer_next_token_private (void)
       {
         RETURN_PUNC (TOK_NOT);
       }
+      break;
     }
     default: JERRY_UNREACHABLE ();
   }
diff --git a/src/libjsparser/parser.c b/src/libjsparser/parser.c
index 686724b85..13497806d 100644
--- a/src/libjsparser/parser.c
+++ b/src/libjsparser/parser.c
@@ -1058,7 +1058,7 @@ parse_primary_expression (void)
         token_after_newlines_must_be (TOK_CLOSE_PAREN);
         return lhs;
       }
-      // FALLTHRU
+      /* FALLTHRU */
     }
     default:
     {
@@ -1339,8 +1339,7 @@ parse_unary_expression (void)
     lhs = next_temp_name (); \
     NEXT (expr2, EXPR);\
     DUMP_OPCODE_3 (GETOP, lhs, expr1, expr2); \
-    expr1 = lhs; \
-    break;
+    expr1 = lhs
 
 /* multiplicative_expression
   : unary_expression (LT!* ('*' | '/' | '%') LT!* unary_expression)*
@@ -1357,18 +1356,9 @@ 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)
-      }
+      case TOK_MULT: DUMP_OF (multiplication, unary_expression); break;
+      case TOK_DIV: DUMP_OF (division, unary_expression); break;
+      case TOK_MOD: DUMP_OF (remainder, unary_expression); break;
       default:
       {
         lexer_save_token (tok);
@@ -1395,14 +1385,8 @@ parse_additive_expression (void)
   {
     switch (tok.type)
     {
-      case TOK_PLUS:
-      {
-        DUMP_OF (addition, multiplicative_expression);
-      }
-      case TOK_MINUS:
-      {
-        DUMP_OF (substraction, multiplicative_expression);
-      }
+      case TOK_PLUS: DUMP_OF (addition, multiplicative_expression); break;
+      case TOK_MINUS: DUMP_OF (substraction, multiplicative_expression); break;
       default:
       {
         lexer_save_token (tok);
@@ -1429,18 +1413,9 @@ 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)
-      }
+      case TOK_LSHIFT: DUMP_OF (b_shift_left, additive_expression); break;
+      case TOK_RSHIFT: DUMP_OF (b_shift_right, additive_expression); break;
+      case TOK_RSHIFT_EX: DUMP_OF (b_shift_uright, additive_expression); break;
       default:
       {
         lexer_save_token (tok);
@@ -1467,31 +1442,21 @@ 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_LESS: DUMP_OF (less_than, shift_expression); break;
+      case TOK_GREATER: DUMP_OF (greater_than, shift_expression); break;
+      case TOK_LESS_EQ: DUMP_OF (less_or_equal_than, shift_expression); break;
+      case TOK_GREATER_EQ: DUMP_OF (greater_or_equal_than, shift_expression); break;
       case TOK_KEYWORD:
       {
         if (is_keyword (KW_INSTANCEOF))
         {
-          DUMP_OF (instanceof, shift_expression)
+          DUMP_OF (instanceof, shift_expression);
+          break;
         }
         else if (is_keyword (KW_IN))
         {
-          DUMP_OF (in, shift_expression)
+          DUMP_OF (in, shift_expression);
+          break;
         }
         /* FALLTHROUGH */
       }
@@ -1521,22 +1486,10 @@ 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)
-      }
+      case TOK_DOUBLE_EQ: DUMP_OF (equal_value, relational_expression); break;
+      case TOK_NOT_EQ: DUMP_OF (not_equal_value, relational_expression); break;
+      case TOK_TRIPLE_EQ: DUMP_OF (equal_value_type, relational_expression); break;
+      case TOK_NOT_DOUBLE_EQ: DUMP_OF (not_equal_value_type, relational_expression); break;
       default:
       {
         lexer_save_token (tok);
@@ -1557,7 +1510,7 @@ static T_IDX parse_##FUNC (void) { \
   { \
     switch (tok.type) \
     { \
-      case TOK_##TOK_TYPE: DUMP_OF (GETOP, EXPR) \
+      case TOK_##TOK_TYPE: DUMP_OF (GETOP, EXPR); break; \
       default: lexer_save_token (tok); return expr1; \
     } \
     skip_newlines (); \