herb 0.9.3-arm-linux-gnu → 0.9.5-arm-linux-gnu

data/src/analyze/action_view/tag_helpers.c

@@ -639,7 +639,15 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
         id_is_ruby_expression ? create_html_attribute_with_ruby_literal("id", id_value, id_start, id_end, allocator)
                               : create_html_attribute_node("id", id_value, id_start, id_end, allocator);
 
-      if (id_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) id_attribute, allocator); }
+      if (id_attribute) {
+        AST_NODE_T* src_node = remove_attribute_by_name(attributes, "src");
+        AST_NODE_T* target_node = remove_attribute_by_name(attributes, "target");
+
+        hb_array_append(attributes, (AST_NODE_T*) id_attribute);
+
+        if (src_node) { hb_array_append(attributes, src_node); }
+        if (target_node) { hb_array_append(attributes, target_node); }
+      }
 
       hb_allocator_dealloc(allocator, id_value);
     }
@@ -679,7 +687,7 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
           ? create_html_attribute_node("src", source_attribute_value, source_start, source_end, allocator)
           : create_html_attribute_with_ruby_literal("src", source_attribute_value, source_start, source_end, allocator);
 
-      if (source_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) source_attribute, allocator); }
+      if (source_attribute) { hb_array_append(attributes, (AST_NODE_T*) source_attribute); }
 
       if (source_attribute_value != source_value) { hb_allocator_dealloc(allocator, source_attribute_value); }
       hb_allocator_dealloc(allocator, source_value);
@@ -723,7 +731,7 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
           ? create_html_attribute_node("src", source_attribute_value, source_start, source_end, allocator)
           : create_html_attribute_with_ruby_literal("src", source_attribute_value, source_start, source_end, allocator);
 
-      if (source_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) source_attribute, allocator); }
+      if (source_attribute) { hb_array_append(attributes, (AST_NODE_T*) source_attribute); }
       if (source_attribute_value != source_value) { hb_allocator_dealloc(allocator, source_attribute_value); }
 
       hb_allocator_dealloc(allocator, source_value);
@@ -798,14 +806,37 @@ static AST_NODE_T* transform_tag_helper_with_attributes(
       );
     }
 
-    append_body_content_node(
-      body,
-      helper_content,
-      content_is_ruby_expression,
-      erb_node->base.location.start,
-      erb_node->base.location.end,
-      allocator
-    );
+    if (string_equals(handler->name, "javascript_tag")) {
+      hb_array_T* cdata_children = hb_array_init(1, allocator);
+
+      append_body_content_node(
+        cdata_children,
+        helper_content,
+        content_is_ruby_expression,
+        erb_node->base.location.start,
+        erb_node->base.location.end,
+        allocator
+      );
+
+      AST_CDATA_NODE_T* cdata_node = create_javascript_cdata_node(
+        cdata_children,
+        erb_node->base.location.start,
+        erb_node->base.location.end,
+        allocator
+      );
+
+      if (cdata_node) { hb_array_append(body, (AST_NODE_T*) cdata_node); }
+    } else {
+      append_body_content_node(
+        body,
+        helper_content,
+        content_is_ruby_expression,
+        erb_node->base.location.start,
+        erb_node->base.location.end,
+        allocator
+      );
+    }
+
     hb_allocator_dealloc(allocator, helper_content);
   }
 
@@ -1117,7 +1148,7 @@ static AST_NODE_T* transform_erb_block_to_tag_helper(
       AST_HTML_ATTRIBUTE_NODE_T* href_attribute =
         create_href_attribute(href, href_is_ruby_expression, href_start, href_end, allocator);
 
-      if (href_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) href_attribute, allocator); }
+      if (href_attribute) { hb_array_append(attributes, (AST_NODE_T*) href_attribute); }
 
       hb_allocator_dealloc(allocator, href);
     }
@@ -1138,7 +1169,15 @@ static AST_NODE_T* transform_erb_block_to_tag_helper(
         id_is_ruby_expression ? create_html_attribute_with_ruby_literal("id", id_value, id_start, id_end, allocator)
                               : create_html_attribute_node("id", id_value, id_start, id_end, allocator);
 
-      if (id_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) id_attribute, allocator); }
+      if (id_attribute) {
+        AST_NODE_T* src_node = remove_attribute_by_name(attributes, "src");
+        AST_NODE_T* target_node = remove_attribute_by_name(attributes, "target");
+
+        hb_array_append(attributes, (AST_NODE_T*) id_attribute);
+
+        if (src_node) { hb_array_append(attributes, src_node); }
+        if (target_node) { hb_array_append(attributes, target_node); }
+      }
 
       hb_allocator_dealloc(allocator, id_value);
     }
@@ -1395,7 +1434,7 @@ static AST_NODE_T* transform_link_to_helper(
     AST_HTML_ATTRIBUTE_NODE_T* href_attribute =
       create_href_attribute(href, href_is_ruby_expression, href_start, href_end, allocator);
 
-    if (href_attribute) { attributes = prepend_attribute(attributes, (AST_NODE_T*) href_attribute, allocator); }
+    if (href_attribute) { hb_array_append(attributes, (AST_NODE_T*) href_attribute); }
     if (!info->content) {
       href_for_body = hb_allocator_strdup(allocator, href);
       href_for_body_is_ruby_expression = href_is_ruby_expression;

data/src/analyze/analyze.c

@@ -75,8 +75,7 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
 
     hb_string_T opening = erb_content_node->tag_opening->value;
 
-    if (!hb_string_equals(opening, hb_string("<%%")) && !hb_string_equals(opening, hb_string("<%%="))
-        && !hb_string_equals(opening, hb_string("<%#")) && !hb_string_equals(opening, hb_string("<%graphql"))) {
+    if (!hb_string_equals(opening, hb_string("<%#")) && !hb_string_equals(opening, hb_string("<%graphql"))) {
       analyzed_ruby_T* analyzed = herb_analyze_ruby(erb_content_node->content->value);
 
       erb_content_node->parsed = true;
@@ -737,12 +736,32 @@ static size_t process_block_structure(
   hb_array_T* block_errors = erb_node->base.errors;
   erb_node->base.errors = NULL;
 
+  // Filter out "incomplete block" Prism errors since we've matched the block with its end tag.
+  if (block_errors) {
+    for (size_t error_index = hb_array_size(block_errors); error_index > 0; error_index--) {
+      ERROR_T* error = hb_array_get(block_errors, error_index - 1);
+      if (!error || error->type != RUBY_PARSE_ERROR) { continue; }
+
+      RUBY_PARSE_ERROR_T* parse_error = (RUBY_PARSE_ERROR_T*) error;
+
+      if (string_equals(parse_error->diagnostic_id.data, "block_term_end")
+          || string_equals(parse_error->diagnostic_id.data, "block_term_brace")
+          || string_equals(parse_error->diagnostic_id.data, "unexpected_token_close_context")) {
+        hb_array_remove(block_errors, error_index - 1);
+      }
+    }
+  }
+
+  hb_array_T* block_arguments =
+    extract_block_arguments_from_erb_node(erb_node, context->source, block_errors, allocator);
+
   AST_ERB_BLOCK_NODE_T* block_node = ast_erb_block_node_init(
     erb_node->tag_opening,
     erb_node->content,
     erb_node->tag_closing,
     HERB_PRISM_NODE_EMPTY,
     children,
+    block_arguments,
     rescue_clause,
     else_clause,
     ensure_clause,
@@ -943,6 +962,7 @@ hb_array_T* get_node_children_array(const AST_NODE_T* node) {
     case AST_ERB_ENSURE_NODE: return ((AST_ERB_ENSURE_NODE_T*) node)->statements;
     case AST_ERB_CASE_NODE: return ((AST_ERB_CASE_NODE_T*) node)->children;
     case AST_ERB_WHEN_NODE: return ((AST_ERB_WHEN_NODE_T*) node)->statements;
+    case AST_ERB_RENDER_NODE: return ((AST_ERB_RENDER_NODE_T*) node)->body;
     default: return NULL;
   }
 }
@@ -1032,7 +1052,7 @@ void herb_analyze_parse_tree(
 
   herb_visit_node((AST_NODE_T*) document, detect_invalid_erb_structures, &invalid_context);
 
-  herb_analyze_parse_errors(document, source, allocator);
+  herb_analyze_parse_errors(document, source, options, allocator);
 
   herb_parser_match_html_tags_post_analyze(document, options, allocator);
 

data/src/analyze/analyze_helpers.c

@@ -2,8 +2,14 @@
 #include <stdbool.h>
 #include <string.h>
 
+#include "../include/analyze/action_view/tag_helper_node_builders.h"
+#include "../include/analyze/action_view/tag_helpers.h"
 #include "../include/analyze/analyzed_ruby.h"
+#include "../include/analyze/helpers.h"
+#include "../include/ast/ast_nodes.h"
+#include "../include/lib/hb_array.h"
 #include "../include/lib/string.h"
+#include "../include/prism/prism_helpers.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed) {
   return analyzed && analyzed->if_node_count > 0;
@@ -526,3 +532,403 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
 
   return false;
 }
+
+static pm_block_node_t* find_first_block_node(pm_node_t* node) {
+  if (!node) { return NULL; }
+
+  if (node->type == PM_CALL_NODE) {
+    pm_call_node_t* call = (pm_call_node_t*) node;
+
+    if (call->block && call->block->type == PM_BLOCK_NODE) { return (pm_block_node_t*) call->block; }
+  }
+
+  if (node->type == PM_PROGRAM_NODE) {
+    pm_program_node_t* program = (pm_program_node_t*) node;
+
+    if (program->statements && program->statements->body.size > 0) {
+      return find_first_block_node(program->statements->body.nodes[0]);
+    }
+  }
+
+  if (node->type == PM_STATEMENTS_NODE) {
+    pm_statements_node_t* statements = (pm_statements_node_t*) node;
+
+    if (statements->body.size > 0) { return find_first_block_node(statements->body.nodes[0]); }
+  }
+
+  return NULL;
+}
+
+static position_T prism_to_source_position(
+  const uint8_t* prism_pointer,
+  const uint8_t* prism_source_start,
+  size_t source_base_offset,
+  const char* source
+) {
+  if (!source || !prism_source_start) { return (position_T) { .line = 1, .column = 0 }; }
+
+  size_t prism_offset = (size_t) (prism_pointer - prism_source_start);
+  return byte_offset_to_position(source, source_base_offset + prism_offset);
+}
+
+static token_T* create_parameter_name_token(
+  pm_location_t location,
+  const char* name,
+  const uint8_t* prism_source_start,
+  size_t source_base_offset,
+  const char* source,
+  hb_allocator_T* allocator
+) {
+  position_T start = prism_to_source_position(location.start, prism_source_start, source_base_offset, source);
+  position_T end = prism_to_source_position(location.end, prism_source_start, source_base_offset, source);
+
+  return create_synthetic_token(allocator, name, TOKEN_IDENTIFIER, start, end);
+}
+
+static void append_parameter(
+  hb_array_T* result,
+  token_T* name_token,
+  AST_RUBY_LITERAL_NODE_T* default_value,
+  const char* kind,
+  bool required,
+  position_T start,
+  position_T end,
+  hb_allocator_T* allocator
+) {
+  hb_array_append(
+    result,
+    ast_ruby_parameter_node_init(
+      name_token,
+      default_value,
+      hb_string(kind),
+      required,
+      start,
+      end,
+      hb_array_init(0, allocator),
+      allocator
+    )
+  );
+}
+
+hb_array_T* extract_parameters_from_prism(
+  pm_parameters_node_t* parameters,
+  pm_parser_t* parser,
+  const char* source,
+  size_t source_base_offset,
+  const uint8_t* prism_source_start,
+  hb_allocator_T* allocator
+) {
+  if (!parameters) { return hb_array_init(0, allocator); }
+
+  size_t count = parameters->requireds.size + parameters->optionals.size + parameters->keywords.size;
+  if (parameters->rest) { count++; }
+  if (parameters->keyword_rest) { count++; }
+  if (parameters->block) { count++; }
+
+  hb_array_T* result = hb_array_init(count, allocator);
+
+  // Required positional: |item|
+  for (size_t index = 0; index < parameters->requireds.size; index++) {
+    pm_node_t* node = parameters->requireds.nodes[index];
+    if (node->type != PM_REQUIRED_PARAMETER_NODE) { continue; }
+
+    pm_required_parameter_node_t* required = (pm_required_parameter_node_t*) node;
+    pm_constant_t* constant = pm_constant_pool_id_to_constant(&parser->constant_pool, required->name);
+    if (!constant) { continue; }
+
+    char* name = hb_allocator_strndup(allocator, (const char*) constant->start, constant->length);
+    position_T start = prism_to_source_position(node->location.start, prism_source_start, source_base_offset, source);
+    position_T end = prism_to_source_position(node->location.end, prism_source_start, source_base_offset, source);
+
+    append_parameter(
+      result,
+      create_parameter_name_token(node->location, name, prism_source_start, source_base_offset, source, allocator),
+      NULL,
+      "positional",
+      true,
+      start,
+      end,
+      allocator
+    );
+
+    hb_allocator_dealloc(allocator, name);
+  }
+
+  // Optional positional: |item = nil|
+  for (size_t index = 0; index < parameters->optionals.size; index++) {
+    pm_node_t* node = parameters->optionals.nodes[index];
+    if (node->type != PM_OPTIONAL_PARAMETER_NODE) { continue; }
+
+    pm_optional_parameter_node_t* optional = (pm_optional_parameter_node_t*) node;
+    size_t name_length = (size_t) (optional->name_loc.end - optional->name_loc.start);
+    char* name = hb_allocator_strndup(allocator, (const char*) optional->name_loc.start, name_length);
+
+    position_T start = prism_to_source_position(node->location.start, prism_source_start, source_base_offset, source);
+    position_T end = prism_to_source_position(node->location.end, prism_source_start, source_base_offset, source);
+
+    AST_RUBY_LITERAL_NODE_T* default_value = NULL;
+
+    if (optional->value) {
+      size_t value_length = (size_t) (optional->value->location.end - optional->value->location.start);
+      char* value_string = hb_allocator_strndup(allocator, (const char*) optional->value->location.start, value_length);
+      position_T value_start =
+        prism_to_source_position(optional->value->location.start, prism_source_start, source_base_offset, source);
+      position_T value_end =
+        prism_to_source_position(optional->value->location.end, prism_source_start, source_base_offset, source);
+
+      default_value = ast_ruby_literal_node_init(
+        hb_string_from_c_string(value_string),
+        value_start,
+        value_end,
+        hb_array_init(0, allocator),
+        allocator
+      );
+      hb_allocator_dealloc(allocator, value_string);
+    }
+
+    append_parameter(
+      result,
+      create_parameter_name_token(optional->name_loc, name, prism_source_start, source_base_offset, source, allocator),
+      default_value,
+      "positional",
+      false,
+      start,
+      end,
+      allocator
+    );
+
+    hb_allocator_dealloc(allocator, name);
+  }
+
+  // Rest: |*items|
+  if (parameters->rest && parameters->rest->type == PM_REST_PARAMETER_NODE) {
+    pm_rest_parameter_node_t* rest = (pm_rest_parameter_node_t*) parameters->rest;
+
+    if (rest->name) {
+      size_t name_length = (size_t) (rest->name_loc.end - rest->name_loc.start);
+      char* name = hb_allocator_strndup(allocator, (const char*) rest->name_loc.start, name_length);
+
+      position_T start =
+        prism_to_source_position(parameters->rest->location.start, prism_source_start, source_base_offset, source);
+      position_T end =
+        prism_to_source_position(parameters->rest->location.end, prism_source_start, source_base_offset, source);
+
+      append_parameter(
+        result,
+        create_parameter_name_token(rest->name_loc, name, prism_source_start, source_base_offset, source, allocator),
+        NULL,
+        "rest",
+        false,
+        start,
+        end,
+        allocator
+      );
+
+      hb_allocator_dealloc(allocator, name);
+    }
+  }
+
+  // Keywords: |name:| or |title: "default"|
+  for (size_t index = 0; index < parameters->keywords.size; index++) {
+    pm_node_t* keyword = parameters->keywords.nodes[index];
+
+    pm_location_t name_location;
+    bool is_required = false;
+    AST_RUBY_LITERAL_NODE_T* default_value = NULL;
+
+    if (keyword->type == PM_REQUIRED_KEYWORD_PARAMETER_NODE) {
+      name_location = ((pm_required_keyword_parameter_node_t*) keyword)->name_loc;
+      is_required = true;
+    } else if (keyword->type == PM_OPTIONAL_KEYWORD_PARAMETER_NODE) {
+      pm_optional_keyword_parameter_node_t* optional_keyword = (pm_optional_keyword_parameter_node_t*) keyword;
+      name_location = optional_keyword->name_loc;
+
+      if (optional_keyword->value) {
+        size_t value_length =
+          (size_t) (optional_keyword->value->location.end - optional_keyword->value->location.start);
+        char* value_string =
+          hb_allocator_strndup(allocator, (const char*) optional_keyword->value->location.start, value_length);
+
+        position_T value_start = prism_to_source_position(
+          optional_keyword->value->location.start,
+          prism_source_start,
+          source_base_offset,
+          source
+        );
+
+        position_T value_end = prism_to_source_position(
+          optional_keyword->value->location.end,
+          prism_source_start,
+          source_base_offset,
+          source
+        );
+
+        default_value = ast_ruby_literal_node_init(
+          hb_string_from_c_string(value_string),
+          value_start,
+          value_end,
+          hb_array_init(0, allocator),
+          allocator
+        );
+
+        hb_allocator_dealloc(allocator, value_string);
+      }
+    } else {
+      continue;
+    }
+
+    size_t name_length = (size_t) (name_location.end - name_location.start);
+    if (name_length > 0 && name_location.start[name_length - 1] == ':') { name_length--; }
+    char* name = hb_allocator_strndup(allocator, (const char*) name_location.start, name_length);
+
+    position_T start =
+      prism_to_source_position(keyword->location.start, prism_source_start, source_base_offset, source);
+    position_T end = prism_to_source_position(keyword->location.end, prism_source_start, source_base_offset, source);
+
+    append_parameter(
+      result,
+      create_parameter_name_token(name_location, name, prism_source_start, source_base_offset, source, allocator),
+      default_value,
+      "keyword",
+      is_required,
+      start,
+      end,
+      allocator
+    );
+
+    hb_allocator_dealloc(allocator, name);
+  }
+
+  // Keyword rest: |**opts| or |**|
+  if (parameters->keyword_rest && parameters->keyword_rest->type == PM_KEYWORD_REST_PARAMETER_NODE) {
+    pm_keyword_rest_parameter_node_t* keyword_rest = (pm_keyword_rest_parameter_node_t*) parameters->keyword_rest;
+
+    position_T start = prism_to_source_position(
+      parameters->keyword_rest->location.start,
+      prism_source_start,
+      source_base_offset,
+      source
+    );
+
+    position_T end =
+      prism_to_source_position(parameters->keyword_rest->location.end, prism_source_start, source_base_offset, source);
+
+    if (keyword_rest->name) {
+      size_t name_length = (size_t) (keyword_rest->name_loc.end - keyword_rest->name_loc.start);
+      char* name = hb_allocator_strndup(allocator, (const char*) keyword_rest->name_loc.start, name_length);
+
+      append_parameter(
+        result,
+        create_parameter_name_token(
+          keyword_rest->name_loc,
+          name,
+          prism_source_start,
+          source_base_offset,
+          source,
+          allocator
+        ),
+        NULL,
+        "keyword_rest",
+        false,
+        start,
+        end,
+        allocator
+      );
+
+      hb_allocator_dealloc(allocator, name);
+    } else {
+      // Anonymous **
+      append_parameter(result, NULL, NULL, "keyword_rest", false, start, end, allocator);
+    }
+  }
+
+  // Block: |&blk|
+  if (parameters->block) {
+    pm_block_parameter_node_t* block_param = parameters->block;
+
+    if (block_param->name) {
+      size_t name_length = (size_t) (block_param->name_loc.end - block_param->name_loc.start);
+      char* name = hb_allocator_strndup(allocator, (const char*) block_param->name_loc.start, name_length);
+
+      position_T start =
+        prism_to_source_position(block_param->base.location.start, prism_source_start, source_base_offset, source);
+      position_T end =
+        prism_to_source_position(block_param->base.location.end, prism_source_start, source_base_offset, source);
+
+      append_parameter(
+        result,
+        create_parameter_name_token(
+          block_param->name_loc,
+          name,
+          prism_source_start,
+          source_base_offset,
+          source,
+          allocator
+        ),
+        NULL,
+        "block",
+        false,
+        start,
+        end,
+        allocator
+      );
+
+      hb_allocator_dealloc(allocator, name);
+    }
+  }
+
+  return result;
+}
+
+hb_array_T* extract_block_arguments_from_erb_node(
+  const AST_ERB_CONTENT_NODE_T* erb_node,
+  const char* source,
+  hb_array_T* errors,
+  hb_allocator_T* allocator
+) {
+  if (!erb_node || !erb_node->analyzed_ruby || !erb_node->analyzed_ruby->parsed) { return hb_array_init(0, allocator); }
+
+  pm_parser_t* parser = &erb_node->analyzed_ruby->parser;
+  pm_block_node_t* block_node = find_first_block_node(erb_node->analyzed_ruby->root);
+
+  if (!block_node || !block_node->parameters) { return hb_array_init(0, allocator); }
+  if (block_node->parameters->type != PM_BLOCK_PARAMETERS_NODE) { return hb_array_init(0, allocator); }
+
+  pm_block_parameters_node_t* block_parameters = (pm_block_parameters_node_t*) block_node->parameters;
+  size_t erb_content_offset = 0;
+
+  if (source && erb_node->content) {
+    erb_content_offset = calculate_byte_offset_from_position(source, erb_node->content->location.start);
+  }
+
+  const uint8_t* prism_source_start = (const uint8_t*) parser->start;
+
+  if (errors) {
+    for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) parser->error_list.head; error != NULL;
+         error = (const pm_diagnostic_t*) error->node.next) {
+      if (error->diag_id == PM_ERR_BLOCK_TERM_END) { continue; }
+      if (error->diag_id == PM_ERR_BLOCK_TERM_BRACE) { continue; }
+      if (error->diag_id == PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT) { continue; }
+
+      size_t error_start_offset = (size_t) (error->location.start - prism_source_start);
+      size_t error_end_offset = (size_t) (error->location.end - prism_source_start);
+
+      position_T error_start = byte_offset_to_position(source, erb_content_offset + error_start_offset);
+      position_T error_end = byte_offset_to_position(source, erb_content_offset + error_end_offset);
+
+      RUBY_PARSE_ERROR_T* parse_error =
+        ruby_parse_error_from_prism_error_with_positions(error, error_start, error_end, allocator);
+
+      hb_array_append(errors, parse_error);
+    }
+  }
+
+  return extract_parameters_from_prism(
+    block_parameters->parameters,
+    parser,
+    source,
+    erb_content_offset,
+    prism_source_start,
+    allocator
+  );
+}

data/src/analyze/builders.c

@@ -322,6 +322,7 @@ static AST_NODE_T* build_block_node(control_builder_context_T* context) {
     context->tag_closing,
     HERB_PRISM_NODE_EMPTY,
     context->children,
+    hb_array_init(0, context->allocator),
     NULL,
     NULL,
     NULL,

data/src/analyze/missing_end.c

@@ -153,6 +153,22 @@ void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allo
       break;
     }
 
+    case AST_ERB_RENDER_NODE: {
+      const AST_ERB_RENDER_NODE_T* erb_render_node = (const AST_ERB_RENDER_NODE_T*) node;
+
+      if (erb_render_node->end_node == NULL) {
+        append_missing_erb_end_tag_error(
+          hb_string("`<" "%" " render " "%" ">`"),
+          erb_render_node->tag_opening->location.start,
+          erb_render_node->tag_closing->location.end,
+          allocator,
+          node->errors
+        );
+      }
+
+      break;
+    }
+
     default: break;
   }
 }