#define PRISM_UNLIKELY(x) (x)

#endif

#endif

case '-':

parser->current.end++;

allow_multiple = false;

default: {

size_t width;

escape_write_byte_encoded(parser, buffer, escape_byte('\n', flags));

return;

}

}

default: {

if ((flags & (PM_ESCAPE_FLAG_CONTROL | PM_ESCAPE_FLAG_META)) && !char_is_ascii_printable(peeked)) {

size_t width = parser->encoding->char_width(parser->current.end, parser->end - parser->current.end);

lexed_comment = true;

}

case '\r':

case '\n': {

parser->semantic_token_seen = semantic_token_seen & 0x1;

parser->current.type = PM_TOKEN_NEWLINE;

return;

}

case PM_IGNORED_NEWLINE_ALL:

if (!lexed_comment) parser_lex_ignored_newline(parser);

lexed_comment = false;

PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE, "escaped carriage return");

break;

}

default:

PM_PARSER_ERR_TOKEN_FORMAT(parser, parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE, "backslash");

break;

pm_token_buffer_push_byte(&token_buffer, '\r');

break;

}

case '\n':

pm_token_buffer_push_byte(&token_buffer, '\n');

pm_regexp_token_buffer_escape(parser, &token_buffer);

token_buffer.base.cursor = breakpoint;

case '\n':

// If we've hit a newline, then we need to track that in

// the list of newlines.

pm_token_buffer_push_byte(&token_buffer.base, '\r');

break;

}

case '\n':

if (parser->heredoc_end) {

// ... if we are on the same line as a heredoc,

pm_token_buffer_escape(parser, &token_buffer);

token_buffer.cursor = breakpoint;

case '\n':

// When we hit a newline, we need to flush any potential

// heredocs. Note that this has to happen after we check

pm_token_buffer_push_byte(&token_buffer, '\r');

break;

}

case '\n':

if (!lex_mode->as.string.interpolation) {

pm_token_buffer_push_byte(&token_buffer, '\\');

pm_token_buffer_escape(parser, &token_buffer);

token_buffer.cursor = breakpoint;

case '\n': {

if (parser->heredoc_end != NULL && (parser->heredoc_end > breakpoint)) {

parser_flush_heredoc_end(parser);

pm_token_buffer_push_byte(&token_buffer, '\r');

break;

}

case '\n':

pm_token_buffer_push_byte(&token_buffer, '\\');

pm_token_buffer_push_byte(&token_buffer, '\n');

pm_token_buffer_push_byte(&token_buffer, '\r');

break;

}

case '\n':

// If we are in a tilde here, we should

// break out of the loop and return the

return (pm_node_t *) pm_index_target_node_create(parser, call);

}

}

default:

// In this case we have a node that we don't know how to convert

// into a target. We need to treat it as an error. For now, we'll

case PM_BACK_REFERENCE_READ_NODE:

case PM_NUMBERED_REFERENCE_READ_NODE:

PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, target, PM_ERR_WRITE_TARGET_READONLY);

case PM_GLOBAL_VARIABLE_READ_NODE: {

pm_global_variable_write_node_t *node = pm_global_variable_write_node_create(parser, target, operator, value);

pm_node_destroy(parser, target);

// is no way for us to attach it to the tree at this point.

pm_node_destroy(parser, value);

}

default:

// In this case we have a node that we don't know how to convert into a

// target. We need to treat it as an error. For now, we'll mark it as an

}

}

}

default: {

if (argument == NULL) {

argument = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, !parsed_first_argument, true, PM_ERR_EXPECT_ARGUMENT, (uint16_t) (depth + 1));

case PM_TOKEN_TILDE:

case PM_TOKEN_BANG:

if (name->end[-1] == '@') return name->end - 1;

default:

return name->end;

}

break;

}

}

default: {

// If we get anything else, then this is an error. For this we'll

// create a missing node for the value and create an assoc node for

break;

}

}

default:

node = parse_pattern_primitives(parser, captures, NULL, diag_id, (uint16_t) (depth + 1));

break;

pm_parser_err_node(parser, old_name, PM_ERR_ALIAS_ARGUMENT);

}

}

default:

return (pm_node_t *) pm_alias_method_node_create(parser, &keyword, new_name, old_name);

}

case PM_TOKEN_CLASS_VARIABLE:

case PM_TOKEN_GLOBAL_VARIABLE:

valid_name = false;

case PM_TOKEN_CONSTANT:

case PM_TOKEN_KEYWORD_NIL:

case PM_TOKEN_KEYWORD_SELF:

pm_parser_local_add_location(parser, call_node->message_loc.start, call_node->message_loc.end, 0);

}

}

case PM_CASE_WRITABLE: {

parser_lex(parser);

pm_node_t *value = parse_assignment_values(parser, previous_binding_power, PM_NODE_TYPE_P(node, PM_MULTI_TARGET_NODE) ? PM_BINDING_POWER_MULTI_ASSIGNMENT + 1 : binding_power, accepts_command_call, PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL, (uint16_t) (depth + 1));

case PM_BACK_REFERENCE_READ_NODE:

case PM_NUMBERED_REFERENCE_READ_NODE:

PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, node, PM_ERR_WRITE_TARGET_READONLY);

case PM_GLOBAL_VARIABLE_READ_NODE: {

parser_lex(parser);

case PM_BACK_REFERENCE_READ_NODE:

case PM_NUMBERED_REFERENCE_READ_NODE:

PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, node, PM_ERR_WRITE_TARGET_READONLY);

case PM_GLOBAL_VARIABLE_READ_NODE: {

parser_lex(parser);

case PM_BACK_REFERENCE_READ_NODE:

case PM_NUMBERED_REFERENCE_READ_NODE:

PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, node, PM_ERR_WRITE_TARGET_READONLY);

case PM_GLOBAL_VARIABLE_READ_NODE: {

parser_lex(parser);

if (pm_symbol_node_label_p(node)) {

return node;

}

default:

break;

}

// If we hit a -, then we're done parsing options.

if (*parser->cursor != '-') break;

case '-':

parser->cursor++;

while (!pm_regexp_char_is_eof(parser) && *parser->cursor != ':' && *parser->cursor != ')') {

if (!pm_regexp_char_find(parser, '\n')) parser->cursor = parser->end;

return true;

}

default: {

size_t width;

if (!parser->encoding_changed) {