6#include "prism/internal/allocator.h"
7#include "prism/internal/arena.h"
8#include "prism/internal/assert.h"
9#include "prism/internal/bit.h"
10#include "prism/internal/buffer.h"
11#include "prism/internal/char.h"
12#include "prism/internal/comments.h"
13#include "prism/internal/constant_pool.h"
14#include "prism/internal/diagnostic.h"
15#include "prism/internal/double.h"
16#include "prism/internal/encoding.h"
17#include "prism/internal/integer.h"
18#include "prism/internal/line_offset_list.h"
19#include "prism/internal/list.h"
20#include "prism/internal/magic_comments.h"
21#include "prism/internal/memchr.h"
22#include "prism/internal/node.h"
23#include "prism/internal/oom.h"
24#include "prism/internal/options.h"
25#include "prism/internal/parser.h"
26#include "prism/internal/regexp.h"
27#include "prism/internal/serialize.h"
28#include "prism/internal/source.h"
29#include "prism/internal/static_literals.h"
30#include "prism/internal/stringy.h"
31#include "prism/internal/strncasecmp.h"
32#include "prism/internal/strpbrk.h"
33#include "prism/internal/tokens.h"
49#ifndef PRISM_DEPTH_MAXIMUM
50 #define PRISM_DEPTH_MAXIMUM 10000
57#define PM_CONCATENATE(left, right) left ## right
64#if defined(_Static_assert)
65# define PM_STATIC_ASSERT(line, condition, message) _Static_assert(condition, message)
67# define PM_STATIC_ASSERT(line, condition, message) typedef char PM_CONCATENATE(static_assert_, line)[(condition) ? 1 : -1]
82#define PM_TAB_WHITESPACE_SIZE 8
85#define MIN(a,b) (((a)<(b))?(a):(b))
86#define MAX(a,b) (((a)>(b))?(a):(b))
92#define U32(value_) ((uint32_t) (value_))
94#define FL PM_NODE_FLAGS
95#define UP PM_NODE_UPCAST
97#define PM_TOKEN_START(parser_, token_) U32((token_)->start - (parser_)->start)
98#define PM_TOKEN_END(parser_, token_) U32((token_)->end - (parser_)->start)
99#define PM_TOKEN_LENGTH(token_) U32((token_)->end - (token_)->start)
100#define PM_TOKENS_LENGTH(left_, right_) U32((right_)->end - (left_)->start)
102#define PM_NODE_START(node_) (UP(node_)->location.start)
103#define PM_NODE_LENGTH(node_) (UP(node_)->location.length)
104#define PM_NODE_END(node_) (UP(node_)->location.start + UP(node_)->location.length)
105#define PM_NODES_LENGTH(left_, right_) (PM_NODE_END(right_) - PM_NODE_START(left_))
107#define PM_TOKEN_NODE_LENGTH(parser_, token_, node_) (PM_NODE_END(node_) - PM_TOKEN_START(parser_, token_))
108#define PM_NODE_TOKEN_LENGTH(parser_, node_, token_) (PM_TOKEN_END(parser_, token_) - PM_NODE_START(node_))
110#define PM_NODE_START_SET_NODE(left_, right_) (PM_NODE_START(left_) = PM_NODE_START(right_))
111#define PM_NODE_START_SET_TOKEN(parser_, node_, token_) (PM_NODE_START(node_) = PM_TOKEN_START(parser_, token_))
112#define PM_NODE_LENGTH_SET_NODE(left_, right_) (PM_NODE_LENGTH(left_) = PM_NODE_END(right_) - PM_NODE_START(left_))
113#define PM_NODE_LENGTH_SET_TOKEN(parser_, node_, token_) (PM_NODE_LENGTH(node_) = PM_TOKEN_END(parser_, token_) - PM_NODE_START(node_))
114#define PM_NODE_LENGTH_SET_LOCATION(node_, location_) (PM_NODE_LENGTH(node_) = PM_LOCATION_END(location_) - PM_NODE_START(node_))
124pm_location_init(uint32_t start, uint32_t length) {
125 pm_location_t location = { .start = start, .length = length };
129#define PM_LOCATION_INIT(start_, length_) pm_location_init((start_), (length_))
130#define PM_LOCATION_INIT_BOUNDS(start_, end_) PM_LOCATION_INIT((start_), U32((end_) - (start_)))
131#define PM_LOCATION_INIT_UNSET PM_LOCATION_INIT(0, 0)
132#define PM_LOCATION_INIT_TOKEN(parser_, token_) PM_LOCATION_INIT(PM_TOKEN_START(parser_, token_), PM_TOKEN_LENGTH(token_))
133#define PM_LOCATION_INIT_NODE(node_) UP(node_)->location
135#define PM_LOCATION_INIT_TOKENS(parser_, left_, right_) PM_LOCATION_INIT(PM_TOKEN_START(parser_, left_), PM_TOKENS_LENGTH(left_, right_))
136#define PM_LOCATION_INIT_NODES(left_, right_) PM_LOCATION_INIT(PM_NODE_START(left_), PM_NODES_LENGTH(left_, right_))
137#define PM_LOCATION_INIT_TOKEN_NODE(parser_, token_, node_) PM_LOCATION_INIT(PM_TOKEN_START(parser_, token_), PM_TOKEN_NODE_LENGTH(parser_, token_, node_))
138#define PM_LOCATION_INIT_NODE_TOKEN(parser_, node_, token_) PM_LOCATION_INIT(PM_NODE_START(node_), PM_NODE_TOKEN_LENGTH(parser_, node_, token_))
140#define TOK2LOC(parser_, token_) PM_LOCATION_INIT_TOKEN(parser_, token_)
141#define NTOK2LOC(parser_, token_) ((token_) == NULL ? PM_LOCATION_INIT_UNSET : TOK2LOC(parser_, token_))
142#define NTOK2PTR(token_) ((token_).start == NULL ? NULL : &(token_))
153lex_mode_incrementor(
const uint8_t start) {
170lex_mode_terminator(
const uint8_t start) {
190lex_mode_push(
pm_parser_t *parser, pm_lex_mode_t lex_mode) {
191 pm_lex_mode_t *next = parser->lex_modes.free;
194 parser->lex_modes.free = next->prev;
196 next = PM_ARENA_ALLOC(&parser->scratch_arena, pm_lex_mode_t);
199 lex_mode.prev = parser->lex_modes.current;
201 parser->lex_modes.current = next;
208lex_mode_push_list(
pm_parser_t *parser,
bool interpolation, uint8_t delimiter) {
209 uint8_t incrementor = lex_mode_incrementor(delimiter);
210 uint8_t terminator = lex_mode_terminator(delimiter);
212 pm_lex_mode_t lex_mode = {
216 .interpolation = interpolation,
219 .incrementor = incrementor,
220 .terminator = terminator
226 uint8_t *breakpoints = lex_mode.as.list.breakpoints;
227 memset(breakpoints, 0, PM_STRPBRK_CACHE_SIZE);
228 memcpy(breakpoints,
"\\ \t\f\r\v\n",
sizeof(
"\\ \t\f\r\v\n") - 1);
233 if (terminator !=
'\0') {
234 breakpoints[index++] = terminator;
240 breakpoints[index++] =
'#';
244 if (incrementor !=
'\0') {
245 breakpoints[index++] = incrementor;
248 parser->explicit_encoding = NULL;
249 lex_mode_push(parser, lex_mode);
259 lex_mode_push_list(parser,
false,
'\0');
266lex_mode_push_regexp(
pm_parser_t *parser, uint8_t incrementor, uint8_t terminator) {
267 pm_lex_mode_t lex_mode = {
268 .mode = PM_LEX_REGEXP,
271 .incrementor = incrementor,
272 .terminator = terminator
279 uint8_t *breakpoints = lex_mode.as.regexp.breakpoints;
280 memset(breakpoints, 0, PM_STRPBRK_CACHE_SIZE);
281 memcpy(breakpoints,
"\r\n\\#",
sizeof(
"\r\n\\#") - 1);
285 if (terminator !=
'\0') {
286 breakpoints[index++] = terminator;
290 if (incrementor !=
'\0') {
291 breakpoints[index++] = incrementor;
294 parser->explicit_encoding = NULL;
295 lex_mode_push(parser, lex_mode);
302lex_mode_push_string(
pm_parser_t *parser,
bool interpolation,
bool label_allowed, uint8_t incrementor, uint8_t terminator) {
303 pm_lex_mode_t lex_mode = {
304 .mode = PM_LEX_STRING,
307 .interpolation = interpolation,
308 .label_allowed = label_allowed,
309 .incrementor = incrementor,
310 .terminator = terminator
316 uint8_t *breakpoints = lex_mode.as.string.breakpoints;
317 memset(breakpoints, 0, PM_STRPBRK_CACHE_SIZE);
318 memcpy(breakpoints,
"\r\n\\",
sizeof(
"\r\n\\") - 1);
323 if (terminator !=
'\0') {
324 breakpoints[index++] = terminator;
330 breakpoints[index++] =
'#';
335 if (incrementor !=
'\0') {
336 breakpoints[index++] = incrementor;
339 parser->explicit_encoding = NULL;
340 lex_mode_push(parser, lex_mode);
350 lex_mode_push_string(parser,
false,
false,
'\0',
'\0');
360 pm_lex_mode_t *popped = parser->lex_modes.current;
362 if (popped == &parser->lex_modes.base) {
363 popped->mode = PM_LEX_DEFAULT;
365 parser->lex_modes.current = popped->prev;
366 popped->prev = parser->lex_modes.free;
367 parser->lex_modes.free = popped;
375lex_state_p(
const pm_parser_t *parser, pm_lex_state_t state) {
376 return parser->lex_state & state;
380 PM_IGNORED_NEWLINE_NONE = 0,
381 PM_IGNORED_NEWLINE_ALL,
382 PM_IGNORED_NEWLINE_PATTERN
383} pm_ignored_newline_type_t;
387 bool ignored = lex_state_p(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_CLASS | PM_LEX_STATE_FNAME | PM_LEX_STATE_DOT) && !lex_state_p(parser, PM_LEX_STATE_LABELED);
390 return PM_IGNORED_NEWLINE_ALL;
391 }
else if ((parser->lex_state & ~((
unsigned int) PM_LEX_STATE_LABEL)) == (PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED)) {
392 return PM_IGNORED_NEWLINE_PATTERN;
394 return PM_IGNORED_NEWLINE_NONE;
400 return lex_state_p(parser, PM_LEX_STATE_BEG_ANY) || ((parser->lex_state & (PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED)) == (PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED));
405 return lex_state_p(parser, PM_LEX_STATE_ARG_ANY);
409lex_state_spcarg_p(
pm_parser_t *parser,
bool space_seen) {
410 if (parser->current.end >= parser->end) {
413 return lex_state_arg_p(parser) && space_seen && !pm_char_is_whitespace(*parser->current.end);
418 return lex_state_p(parser, PM_LEX_STATE_END_ANY);
426 return lex_state_p(parser, PM_LEX_STATE_FNAME | PM_LEX_STATE_DOT);
434lex_state_set(
pm_parser_t *parser, pm_lex_state_t state) {
435 parser->lex_state = state;
438#ifndef PM_DEBUG_LOGGING
443#define PM_DEBUG_LOGGING 0
449 fprintf(stderr,
"STATE: ");
452 if (parser->lex_state == PM_LEX_STATE_NONE) {
453 fprintf(stderr,
"NONE\n");
457#define CHECK_STATE(state) \
458 if (parser->lex_state & state) { \
459 if (!first) fprintf(stderr, "|"); \
460 fprintf(stderr, "%s", #state); \
464 CHECK_STATE(PM_LEX_STATE_BEG)
465 CHECK_STATE(PM_LEX_STATE_END)
466 CHECK_STATE(PM_LEX_STATE_ENDARG)
467 CHECK_STATE(PM_LEX_STATE_ENDFN)
468 CHECK_STATE(PM_LEX_STATE_ARG)
469 CHECK_STATE(PM_LEX_STATE_CMDARG)
470 CHECK_STATE(PM_LEX_STATE_MID)
471 CHECK_STATE(PM_LEX_STATE_FNAME)
472 CHECK_STATE(PM_LEX_STATE_DOT)
473 CHECK_STATE(PM_LEX_STATE_CLASS)
474 CHECK_STATE(PM_LEX_STATE_LABEL)
475 CHECK_STATE(PM_LEX_STATE_LABELED)
476 CHECK_STATE(PM_LEX_STATE_FITEM)
480 fprintf(stderr,
"\n");
484debug_lex_state_set(
pm_parser_t *parser, pm_lex_state_t state,
char const * caller_name,
int line_number) {
485 fprintf(stderr,
"Caller: %s:%d\nPrevious: ", caller_name, line_number);
487 lex_state_set(parser, state);
488 fprintf(stderr,
"Now: ");
490 fprintf(stderr,
"\n");
493#define lex_state_set(parser, state) debug_lex_state_set(parser, state, __func__, __LINE__)
501#define PM_PARSER_COMMAND_LINE_OPTION(parser, option) ((parser)->command_line & (option))
504#define PM_PARSER_COMMAND_LINE_OPTION_A(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_A)
507#define PM_PARSER_COMMAND_LINE_OPTION_E(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_E)
510#define PM_PARSER_COMMAND_LINE_OPTION_L(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_L)
513#define PM_PARSER_COMMAND_LINE_OPTION_N(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_N)
516#define PM_PARSER_COMMAND_LINE_OPTION_P(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_P)
519#define PM_PARSER_COMMAND_LINE_OPTION_X(parser) PM_PARSER_COMMAND_LINE_OPTION(parser, PM_OPTIONS_COMMAND_LINE_X)
529pm_parser_err(
pm_parser_t *parser, uint32_t start, uint32_t length, pm_diagnostic_id_t diag_id) {
530 pm_diagnostic_list_append(&parser->metadata_arena, &parser->error_list, start, length, diag_id);
539 pm_parser_err(parser, PM_TOKEN_START(parser, token), PM_TOKEN_LENGTH(token), diag_id);
547pm_parser_err_current(
pm_parser_t *parser, pm_diagnostic_id_t diag_id) {
548 pm_parser_err_token(parser, &parser->current, diag_id);
555pm_parser_err_stack_exhausted(
pm_parser_t *parser, uint32_t start, uint32_t length) {
556 if (parser->stack_exhausted_reported)
return;
557 parser->stack_exhausted_reported =
true;
558 pm_parser_err(parser, start, length, PM_ERR_STACK_EXHAUSTED);
566pm_parser_err_previous(
pm_parser_t *parser, pm_diagnostic_id_t diag_id) {
567 pm_parser_err_token(parser, &parser->previous, diag_id);
575pm_parser_err_node(
pm_parser_t *parser,
const pm_node_t *node, pm_diagnostic_id_t diag_id) {
576 pm_parser_err(parser, PM_NODE_START(node), PM_NODE_LENGTH(node), diag_id);
582#define PM_PARSER_ERR_FORMAT(parser_, start_, length_, diag_id_, ...) \
583 pm_diagnostic_list_append_format(&(parser_)->metadata_arena, &(parser_)->error_list, start_, length_, diag_id_, __VA_ARGS__)
589#define PM_PARSER_ERR_NODE_FORMAT(parser_, node_, diag_id_, ...) \
590 PM_PARSER_ERR_FORMAT(parser_, PM_NODE_START(node_), PM_NODE_LENGTH(node_), diag_id_, __VA_ARGS__)
596#define PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser_, node_, diag_id_) \
597 PM_PARSER_ERR_NODE_FORMAT(parser_, node_, diag_id_, (int) PM_NODE_LENGTH(node_), (const char *) (parser_->start + PM_NODE_START(node_)))
603#define PM_PARSER_ERR_TOKEN_FORMAT(parser_, token_, diag_id, ...) \
604 PM_PARSER_ERR_FORMAT(parser_, PM_TOKEN_START(parser_, token_), PM_TOKEN_LENGTH(token_), diag_id, __VA_ARGS__)
610#define PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser_, token_, diag_id_) \
611 PM_PARSER_ERR_TOKEN_FORMAT(parser_, token_, diag_id_, (int) PM_TOKEN_LENGTH(token_), (const char *) (token_)->start)
617pm_parser_warn(
pm_parser_t *parser, uint32_t start, uint32_t length, pm_diagnostic_id_t diag_id) {
618 pm_diagnostic_list_append(&parser->metadata_arena, &parser->warning_list, start, length, diag_id);
627 pm_parser_warn(parser, PM_TOKEN_START(parser, token), PM_TOKEN_LENGTH(token), diag_id);
635pm_parser_warn_node(
pm_parser_t *parser,
const pm_node_t *node, pm_diagnostic_id_t diag_id) {
636 pm_parser_warn(parser, PM_NODE_START(node), PM_NODE_LENGTH(node), diag_id);
643#define PM_PARSER_WARN_FORMAT(parser_, start_, length_, diag_id_, ...) \
644 pm_diagnostic_list_append_format(&(parser_)->metadata_arena, &(parser_)->warning_list, start_, length_, diag_id_, __VA_ARGS__)
650#define PM_PARSER_WARN_TOKEN_FORMAT(parser_, token_, diag_id_, ...) \
651 PM_PARSER_WARN_FORMAT(parser_, PM_TOKEN_START(parser_, token_), PM_TOKEN_LENGTH(token_), diag_id_, __VA_ARGS__)
657#define PM_PARSER_WARN_TOKEN_FORMAT_CONTENT(parser_, token_, diag_id_) \
658 PM_PARSER_WARN_TOKEN_FORMAT(parser_, token_, diag_id_, (int) PM_TOKEN_LENGTH(token_), (const char *) (token_)->start)
664#define PM_PARSER_WARN_NODE_FORMAT(parser_, node_, diag_id_, ...) \
665 PM_PARSER_WARN_FORMAT(parser_, PM_NODE_START(node_), PM_NODE_LENGTH(node_), diag_id_, __VA_ARGS__)
673pm_parser_err_heredoc_term(
pm_parser_t *parser,
const uint8_t *ident_start,
size_t ident_length) {
674 PM_PARSER_ERR_FORMAT(
676 U32(ident_start - parser->start),
680 (
const char *) ident_start
692pm_parser_scope_push(
pm_parser_t *parser,
bool closed) {
693 pm_scope_t *previous = parser->current_scope;
694 pm_scope_t *scope = parser->free_scopes;
697 parser->free_scopes = scope->previous;
699 scope = PM_ARENA_ALLOC(&parser->scratch_arena, pm_scope_t);
702 uint32_t locals_start = parser->locals_size;
704 *scope = (pm_scope_t) {
705 .previous = previous,
706 .locals_start = locals_start,
707 .level = previous == NULL ? 1 : previous->level + 1,
708 .floor = (closed || previous == NULL) ? locals_start : previous->floor,
709 .parameters = PM_SCOPE_PARAMETERS_NONE,
710 .implicit_parameters = { 0 },
711 .shareable_constant = previous == NULL ? PM_SCOPE_SHAREABLE_CONSTANT_NONE : previous->shareable_constant,
715 parser->current_scope = scope;
724 pm_scope_t *scope = parser->current_scope;
727 if (scope->previous == NULL)
return true;
728 if (scope->closed)
return false;
729 }
while ((scope = scope->previous) != NULL);
731 PRISM_ASSERT(
false &&
"unreachable");
739pm_parser_scope_find(
pm_parser_t *parser, uint32_t depth) {
740 pm_scope_t *scope = parser->current_scope;
742 while (depth-- > 0) {
743 PRISM_ASSERT(scope != NULL);
744 scope = scope->previous;
751 PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS,
752 PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT,
753 PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL
754} pm_scope_forwarding_param_check_result_t;
756static pm_scope_forwarding_param_check_result_t
757pm_parser_scope_forwarding_param_check(
pm_parser_t *parser,
const uint8_t mask) {
758 pm_scope_t *scope = parser->current_scope;
759 bool conflict =
false;
761 while (scope != NULL) {
762 if (scope->parameters & mask) {
765 return PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT;
767 return PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS;
774 if (scope->closed)
break;
775 scope = scope->previous;
778 return PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL;
783 switch (pm_parser_scope_forwarding_param_check(parser, PM_SCOPE_PARAMETERS_FORWARDING_BLOCK)) {
784 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS:
787 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT:
788 pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_CONFLICT_AMPERSAND);
790 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL:
791 pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_NO_FORWARDING_AMPERSAND);
798 switch (pm_parser_scope_forwarding_param_check(parser, PM_SCOPE_PARAMETERS_FORWARDING_POSITIONALS)) {
799 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS:
802 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT:
803 pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_CONFLICT_STAR);
805 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL:
806 pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_NO_FORWARDING_STAR);
813 switch (pm_parser_scope_forwarding_param_check(parser, PM_SCOPE_PARAMETERS_FORWARDING_ALL)) {
814 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS:
817 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT:
822 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL:
823 pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES);
830 switch (pm_parser_scope_forwarding_param_check(parser, PM_SCOPE_PARAMETERS_FORWARDING_KEYWORDS)) {
831 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_PASS:
834 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_CONFLICT:
835 pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_CONFLICT_STAR_STAR);
837 case PM_SCOPE_FORWARDING_PARAM_CHECK_RESULT_FAIL:
838 pm_parser_err_token(parser, token, PM_ERR_ARGUMENT_NO_FORWARDING_STAR_STAR);
847pm_parser_scope_shareable_constant_get(
pm_parser_t *parser) {
848 return parser->current_scope->shareable_constant;
856pm_parser_scope_shareable_constant_set(
pm_parser_t *parser, pm_shareable_constant_value_t shareable_constant) {
857 pm_scope_t *scope = parser->current_scope;
860 scope->shareable_constant = shareable_constant;
861 }
while (!scope->closed && (scope = scope->previous) != NULL);
874 if (name >= parser->bindings_capacity)
return 0;
875 return parser->bindings[name];
886 uint32_t index = pm_parser_binding(parser, constant_id);
887 const pm_scope_t *scope = parser->current_scope;
892 if (index < scope->floor)
return -1;
893 return (
int) (scope->level - parser->locals[index].level);
907 uint32_t capacity = parser->constant_pool.capacity;
908 uint32_t *bindings = PM_ARENA_ZALLOC_ARRAY(&parser->scratch_arena, uint32_t, capacity);
910 if (parser->bindings_capacity > 0) {
911 memcpy(bindings, parser->bindings, parser->bindings_capacity *
sizeof(uint32_t));
914 parser->bindings = bindings;
915 parser->bindings_capacity = capacity;
925 uint32_t capacity = parser->locals_capacity == 0 ? 16 : parser->locals_capacity * 2;
928 if (parser->locals_capacity > 0) {
929 memcpy(locals, parser->locals, parser->locals_size *
sizeof(
pm_local_t));
932 parser->locals = locals;
933 parser->locals_capacity = capacity;
953 const pm_scope_t *scope = parser->current_scope;
954 uint32_t shadowed = pm_parser_binding(parser, name);
958 if (shadowed >= scope->locals_start)
return;
960 if (name >= parser->bindings_capacity) pm_parser_bindings_grow(parser);
961 PRISM_ASSERT(name < parser->bindings_capacity);
963 if (parser->locals_size >= parser->locals_capacity) pm_parser_locals_grow(parser);
965 uint32_t index = parser->locals_size++;
969 .location = { .start = start, .length = length },
971 .level = scope->level,
975 parser->bindings[name] = index;
986 uint32_t index = pm_parser_binding(parser, name);
987 PRISM_ASSERT(index >= parser->current_scope->floor);
989 return &parser->locals[index];
998 pm_local_t *local = pm_locals_get(parser, name);
999 PRISM_ASSERT(local->reads < UINT32_MAX);
1010 pm_local_t *local = pm_locals_get(parser, name);
1011 PRISM_ASSERT(local->reads > 0);
1021 return pm_locals_get(parser, name)->reads;
1035 uint32_t start = parser->current_scope->locals_start;
1036 pm_constant_id_list_init(parser->arena, list, parser->locals_size - start);
1040 bool warn_unused = !toplevel || (!parser->parsing_eval && !PM_PARSER_COMMAND_LINE_OPTION_E(parser));
1042 for (uint32_t index = start; index < parser->locals_size; index++) {
1044 pm_constant_id_list_insert(list, index - start, local->name);
1046 if (warn_unused && local->reads == 0 && ((parser->start_line >= 0) || (pm_line_offset_list_line(&parser->line_offsets, local->location.
start, parser->start_line) >= 0))) {
1050 PM_PARSER_WARN_FORMAT(
1052 local->location.
start,
1054 PM_WARN_UNUSED_LOCAL_VARIABLE,
1071pm_parser_constant_id_raw(
pm_parser_t *parser,
const uint8_t *start,
const uint8_t *end) {
1074 if (start == parser->constant_cache.start && end == parser->constant_cache.end) {
1075 return parser->constant_cache.id;
1078 pm_constant_id_t id = pm_constant_pool_insert_shared(&parser->metadata_arena, &parser->constant_pool, start, (
size_t) (end - start));
1080 parser->constant_cache.start = start;
1081 parser->constant_cache.end = end;
1082 parser->constant_cache.id = id;
1091pm_parser_constant_id_owned(
pm_parser_t *parser, uint8_t *start,
size_t length) {
1092 return pm_constant_pool_insert_owned(&parser->metadata_arena, &parser->constant_pool, start, length);
1099pm_parser_constant_id_constant(
pm_parser_t *parser,
const char *start,
size_t length) {
1100 return pm_constant_pool_insert_constant(&parser->metadata_arena, &parser->constant_pool, (
const uint8_t *) start, length);
1108 return pm_parser_constant_id_raw(parser, token->start, token->end);
1115#define PM_CASE_VOID_VALUE PM_RETURN_NODE: case PM_BREAK_NODE: case PM_NEXT_NODE: \
1116 case PM_REDO_NODE: case PM_RETRY_NODE: case PM_MATCH_REQUIRED_NODE
1124pm_check_value_expression(
pm_parser_t *parser, pm_node_t *node) {
1125 pm_node_t *void_node = NULL;
1127 while (node != NULL) {
1128 switch (PM_NODE_TYPE(node)) {
1129 case PM_CASE_VOID_VALUE:
1130 return void_node != NULL ? void_node : node;
1131 case PM_MATCH_PREDICATE_NODE:
1133 case PM_BEGIN_NODE: {
1134 pm_begin_node_t *
cast = (pm_begin_node_t *) node;
1136 if (
cast->rescue_clause != NULL) {
1138 node = UP(
cast->ensure_clause);
1139 pm_node_t *rescue_void = NULL;
1142 if (
cast->else_clause == NULL || parser->version < PM_OPTIONS_VERSION_CRUBY_4_1) {
1143 rescue_void = pm_check_value_expression(parser, UP(
cast->statements));
1144 if (rescue_void == NULL)
break;
1147 bool rescue_has_value =
false;
1148 for (pm_rescue_node_t *rescue_clause =
cast->rescue_clause; rescue_clause != NULL; rescue_clause = rescue_clause->subsequent) {
1149 pm_node_t *vn = pm_check_value_expression(parser, UP(rescue_clause->statements));
1152 rescue_has_value =
true;
1157 if (rescue_has_value && parser->version >= PM_OPTIONS_VERSION_CRUBY_4_1)
break;
1159 if (
cast->else_clause != NULL) {
1160 pm_node_t *vn = pm_check_value_expression(parser, UP(
cast->else_clause));
1162 if (parser->version < PM_OPTIONS_VERSION_CRUBY_4_1 && !rescue_has_value) {
1163 if (void_node != NULL)
return void_node;
1164 if (rescue_void != NULL)
return rescue_void;
1168 }
else if (!rescue_has_value && rescue_void != NULL) {
1169 return void_node != NULL ? void_node : rescue_void;
1171 }
else if (
cast->ensure_clause != NULL) {
1172 pm_node_t *vn = pm_check_value_expression(parser, UP(
cast->statements));
1173 if (vn != NULL)
return vn;
1174 node = UP(
cast->ensure_clause);
1176 node = UP(
cast->statements);
1181 case PM_CASE_NODE: {
1183 if (parser->version < PM_OPTIONS_VERSION_CRUBY_4_1) {
1187 pm_case_node_t *
cast = (pm_case_node_t *) node;
1188 if (
cast->else_clause == NULL)
return NULL;
1190 pm_node_t *condition;
1192 PRISM_ASSERT(PM_NODE_TYPE_P(condition, PM_WHEN_NODE));
1194 pm_when_node_t *
cast = (pm_when_node_t *) condition;
1195 pm_node_t *vn = pm_check_value_expression(parser, UP(
cast->statements));
1196 if (vn == NULL)
return NULL;
1197 if (void_node == NULL) void_node = vn;
1200 node = UP(
cast->else_clause);
1203 case PM_CASE_MATCH_NODE: {
1205 if (parser->version < PM_OPTIONS_VERSION_CRUBY_4_1) {
1209 pm_case_match_node_t *
cast = (pm_case_match_node_t *) node;
1210 if (
cast->else_clause == NULL)
return NULL;
1212 pm_node_t *condition;
1214 PRISM_ASSERT(PM_NODE_TYPE_P(condition, PM_IN_NODE));
1216 pm_in_node_t *
cast = (pm_in_node_t *) condition;
1217 pm_node_t *vn = pm_check_value_expression(parser, UP(
cast->statements));
1218 if (vn == NULL)
return NULL;
1219 if (void_node == NULL) void_node = vn;
1222 node = UP(
cast->else_clause);
1225 case PM_ENSURE_NODE: {
1226 pm_ensure_node_t *
cast = (pm_ensure_node_t *) node;
1227 node = UP(
cast->statements);
1230 case PM_PARENTHESES_NODE: {
1231 pm_parentheses_node_t *
cast = (pm_parentheses_node_t *) node;
1232 node = UP(
cast->body);
1235 case PM_STATEMENTS_NODE: {
1236 pm_statements_node_t *
cast = (pm_statements_node_t *) node;
1239 if (parser->version >= PM_OPTIONS_VERSION_CRUBY_4_1) {
1240 pm_node_t *body_part;
1242 switch (PM_NODE_TYPE(body_part)) {
1243 case PM_CASE_VOID_VALUE:
1244 if (void_node == NULL) {
1245 void_node = body_part;
1253 node =
cast->body.nodes[
cast->body.size - 1];
1257 pm_if_node_t *
cast = (pm_if_node_t *) node;
1258 if (
cast->statements == NULL ||
cast->subsequent == NULL) {
1261 pm_node_t *vn = pm_check_value_expression(parser, UP(
cast->statements));
1265 if (void_node == NULL) {
1268 node =
cast->subsequent;
1271 case PM_UNLESS_NODE: {
1272 pm_unless_node_t *
cast = (pm_unless_node_t *) node;
1273 if (
cast->statements == NULL ||
cast->else_clause == NULL) {
1276 pm_node_t *vn = pm_check_value_expression(parser, UP(
cast->statements));
1280 if (void_node == NULL) {
1283 node = UP(
cast->else_clause);
1286 case PM_ELSE_NODE: {
1287 pm_else_node_t *
cast = (pm_else_node_t *) node;
1288 node = UP(
cast->statements);
1299 case PM_LOCAL_VARIABLE_WRITE_NODE: {
1300 pm_local_variable_write_node_t *
cast = (pm_local_variable_write_node_t *) node;
1302 PRISM_ASSERT(pm_parser_local_depth_constant_id(parser,
cast->name) == (
int)
cast->depth);
1303 pm_locals_read(parser,
cast->name);
1315pm_assert_value_expression(
pm_parser_t *parser, pm_node_t *node) {
1316 pm_node_t *void_node = pm_check_value_expression(parser, node);
1317 if (void_node != NULL) {
1318 pm_parser_err_node(parser, void_node, PM_ERR_VOID_EXPRESSION);
1326pm_void_statement_check(
pm_parser_t *parser,
const pm_node_t *node) {
1327 const char *
type = NULL;
1330 switch (PM_NODE_TYPE(node)) {
1331 case PM_BACK_REFERENCE_READ_NODE:
1332 case PM_CLASS_VARIABLE_READ_NODE:
1333 case PM_GLOBAL_VARIABLE_READ_NODE:
1334 case PM_INSTANCE_VARIABLE_READ_NODE:
1335 case PM_IT_LOCAL_VARIABLE_READ_NODE:
1336 case PM_LOCAL_VARIABLE_READ_NODE:
1337 case PM_NUMBERED_REFERENCE_READ_NODE:
1338 type =
"a variable";
1341 case PM_CALL_NODE: {
1342 const pm_call_node_t *
cast = (
const pm_call_node_t *) node;
1343 if (
cast->call_operator_loc.length > 0 ||
cast->message_loc.length == 0)
break;
1345 const pm_constant_t *message = pm_constant_pool_id_to_constant(&parser->constant_pool,
cast->name);
1346 switch (message->length) {
1348 switch (message->start[0]) {
1359 type = (
const char *) message->start;
1365 switch (message->start[1]) {
1367 if (message->start[0] ==
'<' || message->start[0] ==
'>' || message->start[0] ==
'!' || message->start[0] ==
'=') {
1368 type = (
const char *) message->start;
1373 if (message->start[0] ==
'+' || message->start[0] ==
'-') {
1374 type = (
const char *) message->start;
1379 if (message->start[0] ==
'*') {
1380 type = (
const char *) message->start;
1387 if (memcmp(message->start,
"<=>", 3) == 0) {
1396 case PM_CONSTANT_PATH_NODE:
1400 case PM_CONSTANT_READ_NODE:
1401 type =
"a constant";
1404 case PM_DEFINED_NODE:
1413 case PM_IMAGINARY_NODE:
1414 case PM_INTEGER_NODE:
1415 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
1416 case PM_INTERPOLATED_STRING_NODE:
1417 case PM_RATIONAL_NODE:
1418 case PM_REGULAR_EXPRESSION_NODE:
1419 case PM_SOURCE_ENCODING_NODE:
1420 case PM_SOURCE_FILE_NODE:
1421 case PM_SOURCE_LINE_NODE:
1422 case PM_STRING_NODE:
1423 case PM_SYMBOL_NODE:
1431 case PM_RANGE_NODE: {
1432 const pm_range_node_t *
cast = (
const pm_range_node_t *) node;
1434 if (PM_NODE_FLAG_P(cast, PM_RANGE_FLAGS_EXCLUDE_END)) {
1457 PM_PARSER_WARN_NODE_FORMAT(parser, node, PM_WARN_VOID_STATEMENT, length, type);
1466pm_void_statement_check_unwrap(
pm_parser_t *parser,
const pm_node_t *node) {
1467 switch (PM_NODE_TYPE(node)) {
1468 case PM_BEGIN_NODE: {
1469 const pm_begin_node_t *
cast = (
const pm_begin_node_t *) node;
1470 if (
cast->statements == NULL ||
cast->rescue_clause != NULL ||
cast->else_clause != NULL ||
cast->ensure_clause != NULL)
break;
1473 const pm_node_list_t *body = &
cast->statements->body;
1474 pm_void_statement_check_unwrap(parser, body->
nodes[body->
size - 1]);
1477 case PM_PARENTHESES_NODE: {
1478 const pm_parentheses_node_t *
cast = (
const pm_parentheses_node_t *) node;
1479 if (
cast->body == NULL || !PM_NODE_TYPE_P(
cast->body, PM_STATEMENTS_NODE))
break;
1483 const pm_statements_node_t *statements = (
const pm_statements_node_t *)
cast->body;
1484 if (statements->body.size == 1) pm_void_statement_check(parser, statements->body.nodes[0]);
1488 pm_void_statement_check(parser, node);
1498pm_void_statements_check(
pm_parser_t *parser,
const pm_statements_node_t *node,
bool last_value) {
1500 const size_t size = node->
body.
size - (last_value ? 1 : 0);
1501 for (
size_t index = 0; index < size; index++) {
1502 pm_void_statement_check_unwrap(parser, node->
body.
nodes[index]);
1512 PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL,
1513 PM_CONDITIONAL_PREDICATE_TYPE_FLIP_FLOP,
1514 PM_CONDITIONAL_PREDICATE_TYPE_NOT
1515} pm_conditional_predicate_type_t;
1521pm_parser_warn_conditional_predicate_literal(
pm_parser_t *parser, pm_node_t *node, pm_conditional_predicate_type_t type, pm_diagnostic_id_t diag_id,
const char *prefix) {
1523 case PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL:
1524 PM_PARSER_WARN_NODE_FORMAT(parser, node, diag_id, prefix,
"condition");
1526 case PM_CONDITIONAL_PREDICATE_TYPE_FLIP_FLOP:
1527 PM_PARSER_WARN_NODE_FORMAT(parser, node, diag_id, prefix,
"flip-flop");
1529 case PM_CONDITIONAL_PREDICATE_TYPE_NOT:
1539pm_conditional_predicate_warn_write_literal_p(
const pm_node_t *node) {
1540 switch (PM_NODE_TYPE(node)) {
1541 case PM_ARRAY_NODE: {
1542 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL))
return true;
1544 const pm_array_node_t *
cast = (
const pm_array_node_t *) node;
1545 for (
size_t index = 0; index <
cast->elements.size; index++) {
1546 if (!pm_conditional_predicate_warn_write_literal_p(
cast->elements.nodes[index]))
return false;
1551 case PM_HASH_NODE: {
1552 if (PM_NODE_FLAG_P(node, PM_NODE_FLAG_STATIC_LITERAL))
return true;
1554 const pm_hash_node_t *
cast = (
const pm_hash_node_t *) node;
1555 for (
size_t index = 0; index <
cast->elements.size; index++) {
1556 const pm_node_t *element =
cast->elements.nodes[index];
1557 if (!PM_NODE_TYPE_P(element, PM_ASSOC_NODE))
return false;
1559 const pm_assoc_node_t *assoc = (
const pm_assoc_node_t *) element;
1560 if (!pm_conditional_predicate_warn_write_literal_p(assoc->
key) || !pm_conditional_predicate_warn_write_literal_p(assoc->
value))
return false;
1567 case PM_IMAGINARY_NODE:
1568 case PM_INTEGER_NODE:
1570 case PM_RATIONAL_NODE:
1571 case PM_REGULAR_EXPRESSION_NODE:
1572 case PM_SOURCE_ENCODING_NODE:
1573 case PM_SOURCE_FILE_NODE:
1574 case PM_SOURCE_LINE_NODE:
1575 case PM_STRING_NODE:
1576 case PM_SYMBOL_NODE:
1589pm_conditional_predicate_warn_write_literal(
pm_parser_t *parser,
const pm_node_t *node) {
1590 if (pm_conditional_predicate_warn_write_literal_p(node)) {
1591 pm_parser_warn_node(parser, node, parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 ? PM_WARN_EQUAL_IN_CONDITIONAL_3_3 : PM_WARN_EQUAL_IN_CONDITIONAL);
1608pm_conditional_predicate(
pm_parser_t *parser, pm_node_t *node, pm_conditional_predicate_type_t type) {
1609 switch (PM_NODE_TYPE(node)) {
1611 pm_and_node_t *
cast = (pm_and_node_t *) node;
1612 pm_conditional_predicate(parser,
cast->left, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
1613 pm_conditional_predicate(parser,
cast->right, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
1617 pm_or_node_t *
cast = (pm_or_node_t *) node;
1618 pm_conditional_predicate(parser,
cast->left, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
1619 pm_conditional_predicate(parser,
cast->right, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
1622 case PM_PARENTHESES_NODE: {
1623 pm_parentheses_node_t *
cast = (pm_parentheses_node_t *) node;
1625 if ((
cast->body != NULL) && PM_NODE_TYPE_P(
cast->body, PM_STATEMENTS_NODE)) {
1626 pm_statements_node_t *statements = (pm_statements_node_t *)
cast->body;
1627 if (statements->body.size == 1) pm_conditional_predicate(parser, statements->body.nodes[0], type);
1632 case PM_BEGIN_NODE: {
1633 pm_begin_node_t *
cast = (pm_begin_node_t *) node;
1634 if (
cast->statements != NULL) {
1635 pm_statements_node_t *statements =
cast->statements;
1636 if (statements->
body.
size == 1) pm_conditional_predicate(parser, statements->
body.
nodes[0], type);
1640 case PM_RANGE_NODE: {
1641 pm_range_node_t *
cast = (pm_range_node_t *) node;
1643 if (
cast->left != NULL) pm_conditional_predicate(parser,
cast->left, PM_CONDITIONAL_PREDICATE_TYPE_FLIP_FLOP);
1644 if (
cast->right != NULL) pm_conditional_predicate(parser,
cast->right, PM_CONDITIONAL_PREDICATE_TYPE_FLIP_FLOP);
1651 PRISM_ASSERT(
sizeof(pm_range_node_t) ==
sizeof(pm_flip_flop_node_t));
1652 node->
type = PM_FLIP_FLOP_NODE;
1656 case PM_REGULAR_EXPRESSION_NODE:
1660 PRISM_ASSERT(
sizeof(pm_regular_expression_node_t) ==
sizeof(pm_match_last_line_node_t));
1661 node->
type = PM_MATCH_LAST_LINE_NODE;
1663 if (!PM_PARSER_COMMAND_LINE_OPTION_E(parser)) {
1664 pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_DEFAULT,
"regex ");
1668 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
1672 PRISM_ASSERT(
sizeof(pm_interpolated_regular_expression_node_t) ==
sizeof(pm_interpolated_match_last_line_node_t));
1673 node->
type = PM_INTERPOLATED_MATCH_LAST_LINE_NODE;
1675 if (!PM_PARSER_COMMAND_LINE_OPTION_E(parser)) {
1676 pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_VERBOSE,
"regex ");
1680 case PM_INTEGER_NODE:
1681 if (type == PM_CONDITIONAL_PREDICATE_TYPE_FLIP_FLOP) {
1682 if (!PM_PARSER_COMMAND_LINE_OPTION_E(parser)) {
1683 pm_parser_warn_node(parser, node, PM_WARN_INTEGER_IN_FLIP_FLOP);
1686 pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_VERBOSE,
"");
1689 case PM_STRING_NODE:
1690 case PM_SOURCE_FILE_NODE:
1691 case PM_INTERPOLATED_STRING_NODE:
1692 pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_DEFAULT,
"string ");
1694 case PM_SYMBOL_NODE:
1695 case PM_INTERPOLATED_SYMBOL_NODE:
1696 pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_VERBOSE,
"symbol ");
1698 case PM_SOURCE_LINE_NODE:
1699 case PM_SOURCE_ENCODING_NODE:
1701 case PM_RATIONAL_NODE:
1702 case PM_IMAGINARY_NODE:
1703 pm_parser_warn_conditional_predicate_literal(parser, node, type, PM_WARN_LITERAL_IN_CONDITION_VERBOSE,
"");
1705 case PM_CLASS_VARIABLE_WRITE_NODE:
1706 pm_conditional_predicate_warn_write_literal(parser, ((pm_class_variable_write_node_t *) node)->value);
1708 case PM_CONSTANT_WRITE_NODE:
1709 pm_conditional_predicate_warn_write_literal(parser, ((pm_constant_write_node_t *) node)->value);
1711 case PM_GLOBAL_VARIABLE_WRITE_NODE:
1712 pm_conditional_predicate_warn_write_literal(parser, ((pm_global_variable_write_node_t *) node)->value);
1714 case PM_INSTANCE_VARIABLE_WRITE_NODE:
1715 pm_conditional_predicate_warn_write_literal(parser, ((pm_instance_variable_write_node_t *) node)->value);
1717 case PM_LOCAL_VARIABLE_WRITE_NODE:
1718 pm_conditional_predicate_warn_write_literal(parser, ((pm_local_variable_write_node_t *) node)->value);
1720 case PM_MULTI_WRITE_NODE:
1721 pm_conditional_predicate_warn_write_literal(parser, ((pm_multi_write_node_t *) node)->value);
1762 if (arguments->
block != NULL) {
1763 uint32_t end = PM_NODE_END(arguments->
block);
1766 uint32_t arguments_end = PM_LOCATION_END(&arguments->
closing_loc);
1767 if (arguments_end > end) {
1804 if (arguments->
list.
size == 1 && PM_NODE_TYPE_P(pm_node_list_open_last(&arguments->
list), PM_PARENTHESES_NODE)) {
1810 pm_parser_err_node(parser, UP(block), PM_ERR_ARGUMENT_UNEXPECTED_BLOCK);
1826char_is_identifier_start(
const pm_parser_t *parser,
const uint8_t *b, ptrdiff_t n) {
1827 if (n <= 0)
return 0;
1829 if (parser->encoding_changed && *b >= 0x80) {
1830 return pm_encoding_char_width(parser->encoding, b, n);
1831 }
else if (*b < 0x80) {
1832 return pm_encoding_ascii_alpha_p(*b) || (*b ==
'_');
1834 return pm_encoding_utf_8_char_width(b, n);
1844char_is_identifier_utf8(
const uint8_t *b, ptrdiff_t n) {
1847 }
else if (*b < 0x80) {
1848 return (*b ==
'_') || pm_encoding_ascii_alnum_p(*b);
1850 return pm_encoding_utf_8_char_width(b, n);
1867#if defined(PRISM_HAS_NEON)
1868#include <arm_neon.h>
1871scan_identifier_ascii(
const uint8_t *start,
const uint8_t *end) {
1872 const uint8_t *cursor = start;
1879 static const uint8_t low_lut_data[16] = {
1880 0x15, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F,
1881 0x1F, 0x1F, 0x1E, 0x0A, 0x0A, 0x0A, 0x0A, 0x0E
1883 static const uint8_t high_lut_data[16] = {
1884 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x10,
1885 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1887 const uint8x16_t low_lut = vld1q_u8(low_lut_data);
1888 const uint8x16_t high_lut = vld1q_u8(high_lut_data);
1889 const uint8x16_t mask_0f = vdupq_n_u8(0x0F);
1891 while (cursor + 16 <= end) {
1892 uint8x16_t v = vld1q_u8(cursor);
1894 uint8x16_t lo_class = vqtbl1q_u8(low_lut, vandq_u8(v, mask_0f));
1895 uint8x16_t hi_class = vqtbl1q_u8(high_lut, vshrq_n_u8(v, 4));
1896 uint8x16_t ident = vandq_u8(lo_class, hi_class);
1899 if (vminvq_u8(ident) != 0) {
1905 uint8x16_t is_zero = vceqq_u8(ident, vdupq_n_u8(0));
1906 uint64_t lo = vgetq_lane_u64(vreinterpretq_u64_u8(is_zero), 0);
1909 cursor += pm_ctzll(lo) / 8;
1911 uint64_t hi = vgetq_lane_u64(vreinterpretq_u64_u8(is_zero), 1);
1912 cursor += 8 + pm_ctzll(hi) / 8;
1915 return (
size_t) (cursor - start);
1918 return (
size_t) (cursor - start);
1921#elif defined(PRISM_HAS_SSE2)
1922#include <emmintrin.h>
1925scan_identifier_ascii(
const uint8_t *start,
const uint8_t *end) {
1926 const uint8_t *cursor = start;
1928 while (cursor + 16 <= end) {
1929 __m128i v = _mm_loadu_si128((
const __m128i *) cursor);
1930 __m128i zero = _mm_setzero_si128();
1937 __m128i lowered = _mm_or_si128(v, _mm_set1_epi8(0x20));
1938 __m128i letter = _mm_and_si128(
1939 _mm_cmpeq_epi8(_mm_subs_epu8(_mm_set1_epi8(0x61), lowered), zero),
1940 _mm_cmpeq_epi8(_mm_subs_epu8(lowered, _mm_set1_epi8(0x7A)), zero));
1942 __m128i digit = _mm_and_si128(
1943 _mm_cmpeq_epi8(_mm_subs_epu8(_mm_set1_epi8(0x30), v), zero),
1944 _mm_cmpeq_epi8(_mm_subs_epu8(v, _mm_set1_epi8(0x39)), zero));
1946 __m128i underscore = _mm_cmpeq_epi8(v, _mm_set1_epi8(0x5F));
1948 __m128i ident = _mm_or_si128(_mm_or_si128(letter, digit), underscore);
1949 int mask = _mm_movemask_epi8(ident);
1951 if (mask == 0xFFFF) {
1956 cursor += pm_ctzll((uint64_t) (~mask & 0xFFFF));
1957 return (
size_t) (cursor - start);
1960 return (
size_t) (cursor - start);
1967#elif defined(PRISM_HAS_SWAR)
1979scan_identifier_ascii(
const uint8_t *start,
const uint8_t *end) {
1980 static const uint64_t ones = 0x0101010101010101ULL;
1981 static const uint64_t highs = 0x8080808080808080ULL;
1982 const uint8_t *cursor = start;
1984 while (cursor + 8 <= end) {
1986 memcpy(&word, cursor, 8);
1989 if (word & highs)
break;
1991 uint64_t digit = ((word | highs) - ones * 0x30) & ((ones * 0x39 | highs) - word) & highs;
1998 uint64_t lowered = word | (ones * 0x20);
1999 uint64_t letter = ((lowered | highs) - ones * 0x61) & ((ones * 0x7A | highs) - lowered) & highs;
2004 uint64_t xor_us = word ^ (ones * 0x5F);
2005 uint64_t underscore = (xor_us - ones) & ~xor_us & highs;
2007 uint64_t ident = digit | letter | underscore;
2009 if (ident == highs) {
2016 uint64_t not_ident = ~ident & highs;
2017 cursor += pm_ctzll(not_ident) / 8;
2018 return (
size_t) (cursor - start);
2021 return (
size_t) (cursor - start);
2028#define scan_identifier_ascii(start, end) ((size_t) 0)
2038char_is_identifier(
const pm_parser_t *parser,
const uint8_t *b, ptrdiff_t n) {
2041 }
else if (parser->encoding_changed && *b >= 0x80) {
2042 return pm_encoding_char_width(parser->encoding, b, n);
2044 return char_is_identifier_utf8(b, n);
2051#define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
2052#define PUNCT(idx) ( \
2053 BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
2054 BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
2055 BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
2056 BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
2057 BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
2060const unsigned int pm_global_name_punctuation_hash[(0x7e - 0x20 + 31) / 32] = { PUNCT(0), PUNCT(1), PUNCT(2) };
2065static PRISM_INLINE bool
2066char_is_global_name_punctuation(const uint8_t b) {
2067 const unsigned int i = (const unsigned int) b;
2068 if (i <= 0x20 || 0x7e < i) return false;
2070 return (pm_global_name_punctuation_hash[(i - 0x20) / 32] >> (i % 32)) & 1;
2073static PRISM_INLINE bool
2074token_is_setter_name(pm_token_t *token) {
2076 (token->type == PM_TOKEN_BRACKET_LEFT_RIGHT_EQUAL) ||
2077 ((token->type == PM_TOKEN_IDENTIFIER) &&
2078 (token->end - token->start >= 2) &&
2079 (token->end[-1] == '='))
2087pm_local_is_keyword(const char *source, size_t length) {
2088#define KEYWORD(name) if (memcmp(source, name, length) == 0) return true
2092 switch (source[0]) {
2093 case 'd': KEYWORD("do"); return false;
2094 case 'i': KEYWORD("if"); KEYWORD("in"); return false;
2095 case 'o': KEYWORD("or"); return false;
2096 default: return false;
2099 switch (source[0]) {
2100 case 'a': KEYWORD("and"); return false;
2101 case 'd': KEYWORD("def"); return false;
2102 case 'e': KEYWORD("end"); return false;
2103 case 'f': KEYWORD("for"); return false;
2104 case 'n': KEYWORD("nil"); KEYWORD("not"); return false;
2105 default: return false;
2108 switch (source[0]) {
2109 case 'c': KEYWORD("case"); return false;
2110 case 'e': KEYWORD("else"); return false;
2111 case 'n': KEYWORD("next"); return false;
2112 case 'r': KEYWORD("redo"); return false;
2113 case 's': KEYWORD("self"); return false;
2114 case 't': KEYWORD("then"); KEYWORD("true"); return false;
2115 case 'w': KEYWORD("when"); return false;
2116 default: return false;
2119 switch (source[0]) {
2120 case 'a': KEYWORD("alias"); return false;
2121 case 'b': KEYWORD("begin"); KEYWORD("break"); return false;
2122 case 'c': KEYWORD("class"); return false;
2123 case 'e': KEYWORD("elsif"); return false;
2124 case 'f': KEYWORD("false"); return false;
2125 case 'r': KEYWORD("retry"); return false;
2126 case 's': KEYWORD("super"); return false;
2127 case 'u': KEYWORD("undef"); KEYWORD("until"); return false;
2128 case 'w': KEYWORD("while"); return false;
2129 case 'y': KEYWORD("yield"); return false;
2130 default: return false;
2133 switch (source[0]) {
2134 case 'e': KEYWORD("ensure"); return false;
2135 case 'm': KEYWORD("module"); return false;
2136 case 'r': KEYWORD("rescue"); KEYWORD("return"); return false;
2137 case 'u': KEYWORD("unless"); return false;
2138 default: return false;
2141 KEYWORD("__LINE__");
2142 KEYWORD("__FILE__");
2145 KEYWORD("__ENCODING__");
2154/******************************************************************************/
2155/* Node flag handling functions */
2156/******************************************************************************/
2161static PRISM_INLINE void
2162pm_node_flag_set(pm_node_t *node, pm_node_flags_t flag) {
2163 node->flags |= flag;
2169static PRISM_INLINE void
2170pm_node_flag_unset(pm_node_t *node, pm_node_flags_t flag) {
2171 node->flags &= (pm_node_flags_t) ~flag;
2177static PRISM_INLINE void
2178pm_node_flag_set_repeated_parameter(pm_node_t *node) {
2179 PRISM_ASSERT(PM_NODE_TYPE(node) == PM_BLOCK_LOCAL_VARIABLE_NODE ||
2180 PM_NODE_TYPE(node) == PM_BLOCK_PARAMETER_NODE ||
2181 PM_NODE_TYPE(node) == PM_KEYWORD_REST_PARAMETER_NODE ||
2182 PM_NODE_TYPE(node) == PM_OPTIONAL_KEYWORD_PARAMETER_NODE ||
2183 PM_NODE_TYPE(node) == PM_OPTIONAL_PARAMETER_NODE ||
2184 PM_NODE_TYPE(node) == PM_REQUIRED_KEYWORD_PARAMETER_NODE ||
2185 PM_NODE_TYPE(node) == PM_REQUIRED_PARAMETER_NODE ||
2186 PM_NODE_TYPE(node) == PM_REST_PARAMETER_NODE);
2188 pm_node_flag_set(node, PM_PARAMETER_FLAGS_REPEATED_PARAMETER);
2191/******************************************************************************/
2192/* Node creation functions */
2193/******************************************************************************/
2200#define PM_REGULAR_EXPRESSION_ENCODING_MASK ~(PM_REGULAR_EXPRESSION_FLAGS_EUC_JP | PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT | PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J | PM_REGULAR_EXPRESSION_FLAGS_UTF_8)
2205static PRISM_INLINE pm_node_flags_t
2206pm_regular_expression_flags_create(pm_parser_t *parser, const pm_token_t *closing) {
2207 pm_node_flags_t flags = 0;
2209 if (closing->type == PM_TOKEN_REGEXP_END) {
2210 pm_buffer_t unknown_flags = { 0 };
2212 // The closing delimiter is normally a single byte, so the options
2213 // follow it. A `\r\n` newline delimiter is two bytes, however, so we
2214 // skip past it to avoid misreading the trailing `\n` as an option.
2215 const uint8_t *flag = closing->start + 1;
2216 if ((closing->end - closing->start) >= 2 && closing->start[0] == '\r' && closing->start[1] == '\n') {
2220 for (; flag < closing->end; flag++) {
2222 case 'i': flags |= PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE; break;
2223 case 'm': flags |= PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE; break;
2224 case 'x': flags |= PM_REGULAR_EXPRESSION_FLAGS_EXTENDED; break;
2225 case 'o': flags |= PM_REGULAR_EXPRESSION_FLAGS_ONCE; break;
2227 case 'e': flags = (pm_node_flags_t) (((pm_node_flags_t) (flags & PM_REGULAR_EXPRESSION_ENCODING_MASK)) | PM_REGULAR_EXPRESSION_FLAGS_EUC_JP); break;
2228 case 'n': flags = (pm_node_flags_t) (((pm_node_flags_t) (flags & PM_REGULAR_EXPRESSION_ENCODING_MASK)) | PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT); break;
2229 case 's': flags = (pm_node_flags_t) (((pm_node_flags_t) (flags & PM_REGULAR_EXPRESSION_ENCODING_MASK)) | PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J); break;
2230 case 'u': flags = (pm_node_flags_t) (((pm_node_flags_t) (flags & PM_REGULAR_EXPRESSION_ENCODING_MASK)) | PM_REGULAR_EXPRESSION_FLAGS_UTF_8); break;
2232 default: pm_buffer_append_byte(&unknown_flags, *flag);
2236 size_t unknown_flags_length = pm_buffer_length(&unknown_flags);
2237 if (unknown_flags_length != 0) {
2238 const char *word = unknown_flags_length >= 2 ? "options" : "option";
2239 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->previous, PM_ERR_REGEXP_UNKNOWN_OPTIONS, word, unknown_flags_length, pm_buffer_value(&unknown_flags));
2241 pm_buffer_cleanup(&unknown_flags);
2247#undef PM_REGULAR_EXPRESSION_ENCODING_MASK
2249static pm_statements_node_t *
2250pm_statements_node_single_create(pm_parser_t *parser, pm_node_t *statement, bool newline);
2253pm_statements_node_body_length(pm_statements_node_t *node);
2258static pm_error_recovery_node_t *
2259pm_error_recovery_node_create(pm_parser_t *parser, uint32_t start, uint32_t length) {
2260 return pm_error_recovery_node_new(
2264 ((pm_location_t) { .start = start, .length = length }),
2272static pm_error_recovery_node_t *
2273pm_error_recovery_node_create_unexpected(pm_parser_t *parser, pm_node_t *unexpected) {
2274 return pm_error_recovery_node_new(
2278 unexpected->location,
2286static pm_alias_global_variable_node_t *
2287pm_alias_global_variable_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *new_name, pm_node_t *old_name) {
2288 PRISM_ASSERT(keyword->type == PM_TOKEN_KEYWORD_ALIAS);
2290 return pm_alias_global_variable_node_new(
2294 PM_LOCATION_INIT_TOKEN_NODE(parser, keyword, old_name),
2297 TOK2LOC(parser, keyword)
2304static pm_alias_method_node_t *
2305pm_alias_method_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *new_name, pm_node_t *old_name) {
2306 PRISM_ASSERT(keyword->type == PM_TOKEN_KEYWORD_ALIAS);
2308 return pm_alias_method_node_new(
2312 PM_LOCATION_INIT_TOKEN_NODE(parser, keyword, old_name),
2315 TOK2LOC(parser, keyword)
2322static pm_alternation_pattern_node_t *
2323pm_alternation_pattern_node_create(pm_parser_t *parser, pm_node_t *left, pm_node_t *right, const pm_token_t *operator) {
2324 return pm_alternation_pattern_node_new(
2328 PM_LOCATION_INIT_NODES(left, right),
2331 TOK2LOC(parser, operator)
2338static pm_and_node_t *
2339pm_and_node_create(pm_parser_t *parser, pm_node_t *left, const pm_token_t *operator, pm_node_t *right) {
2340 pm_assert_value_expression(parser, left);
2342 return pm_and_node_new(
2346 PM_LOCATION_INIT_NODES(left, right),
2349 TOK2LOC(parser, operator)
2358static pm_arguments_node_t *
2359pm_arguments_node_create(pm_parser_t *parser, pm_arguments_t *arguments) {
2360 if (arguments->list.size == 0) return NULL;
2361 pm_node_list_finalize(&parser->node_chunks, parser->arena, &arguments->list);
2363 return pm_arguments_node_new(
2366 arguments->list_flags,
2367 arguments->list_loc,
2376pm_arguments_flags_update(pm_node_flags_t *flags, const pm_node_t *argument) {
2377 if (PM_NODE_TYPE_P(argument, PM_SPLAT_NODE)) {
2378 if (*flags & PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT) {
2379 *flags |= PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS;
2381 *flags |= PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT;
2389static pm_arguments_node_t *
2390pm_arguments_node_single_create(pm_parser_t *parser, pm_node_t *argument) {
2391 pm_node_flags_t flags = 0;
2392 pm_arguments_flags_update(&flags, argument);
2394 return pm_arguments_node_new(
2398 PM_LOCATION_INIT_NODE(argument),
2399 pm_node_list_single(parser->arena, argument)
2407static pm_arguments_node_t *
2408pm_arguments_node_extend(pm_parser_t *parser, pm_arguments_node_t *node, pm_node_t *argument) {
2409 if (node == NULL) return pm_arguments_node_single_create(parser, argument);
2411 if (PM_NODE_END(node) < PM_NODE_END(argument)) {
2412 PM_NODE_LENGTH_SET_NODE(node, argument);
2415 pm_arguments_flags_update(&node->base.flags, argument);
2416 pm_node_list_append(parser->arena, &node->arguments, argument);
2427 pm_node_list_t nodes;
2436 bool contains_splat;
2437} pm_array_elements_t;
2443static PRISM_INLINE void
2444pm_array_elements_append(pm_parser_t *parser, pm_array_elements_t *elements, pm_node_t *element) {
2445 if (PM_NODE_TYPE_P(element, PM_ARRAY_NODE) || PM_NODE_TYPE_P(element, PM_HASH_NODE) || PM_NODE_TYPE_P(element, PM_RANGE_NODE) || !PM_NODE_FLAG_P(element, PM_NODE_FLAG_STATIC_LITERAL)) {
2446 elements->dynamic = true;
2449 if (PM_NODE_TYPE_P(element, PM_SPLAT_NODE)) {
2450 elements->contains_splat = true;
2453 pm_node_list_open_append(&parser->node_chunks, &elements->nodes, element);
2459static pm_array_node_t *
2460pm_array_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_array_elements_t *elements, const pm_token_t *closing) {
2461 PRISM_ASSERT(closing == NULL || closing->type == PM_TOKEN_BRACKET_RIGHT || closing->type == PM_TOKEN_STRING_END || closing->type == 0);
2463 pm_node_list_t *nodes = &elements->nodes;
2464 pm_node_list_finalize(&parser->node_chunks, parser->arena, nodes);
2466 pm_node_flags_t flags = (pm_node_flags_t) ((elements->dynamic ? 0 : PM_NODE_FLAG_STATIC_LITERAL) | (elements->contains_splat ? PM_ARRAY_NODE_FLAGS_CONTAINS_SPLAT : 0));
2471 if (opening != NULL) {
2472 start = PM_TOKEN_START(parser, opening);
2473 end = PM_TOKEN_END(parser, opening);
2474 } else if (nodes->size > 0) {
2475 start = PM_NODE_START(nodes->nodes[0]);
2478 if (nodes->size > 0) end = PM_NODE_END(nodes->nodes[nodes->size - 1]);
2479 if (closing != NULL) end = PM_TOKEN_END(parser, closing);
2481 return pm_array_node_new(
2485 PM_LOCATION_INIT_BOUNDS(start, end),
2487 NTOK2LOC(parser, opening),
2488 NTOK2LOC(parser, closing)
2497static pm_array_pattern_node_t *
2498pm_array_pattern_node_node_list_create(pm_parser_t *parser, const pm_node_list_t *nodes) {
2499 uint32_t rest_index = nodes->size;
2500 for (uint32_t idx = 0; idx < nodes->size; ++idx) {
2501 if (PM_NODE_TYPE_P(nodes->nodes[idx], PM_SPLAT_NODE) || PM_NODE_TYPE_P(nodes->nodes[idx], PM_IMPLICIT_REST_NODE)) {
2507 pm_node_t *rest = NULL;
2508 pm_node_list_t posts = { 0 };
2510 if (rest_index < nodes->size) {
2511 rest = nodes->nodes[rest_index];
2512 posts = pm_node_list_slice(nodes, rest_index + 1, nodes->size - rest_index - 1);
2515 return pm_array_pattern_node_new(
2519 PM_LOCATION_INIT_NODES(nodes->nodes[0], nodes->nodes[nodes->size - 1]),
2521 pm_node_list_slice(nodes, 0, rest_index),
2524 ((pm_location_t) { 0 }),
2525 ((pm_location_t) { 0 })
2532static pm_array_pattern_node_t *
2533pm_array_pattern_node_rest_create(pm_parser_t *parser, pm_node_t *rest) {
2534 return pm_array_pattern_node_new(
2538 PM_LOCATION_INIT_NODE(rest),
2540 ((pm_node_list_t) { 0 }),
2542 ((pm_node_list_t) { 0 }),
2543 ((pm_location_t) { 0 }),
2544 ((pm_location_t) { 0 })
2552static pm_array_pattern_node_t *
2553pm_array_pattern_node_constant_create(pm_parser_t *parser, pm_node_t *constant, const pm_token_t *opening, pm_node_t *inner, const pm_token_t *closing) {
2554 return pm_array_pattern_node_new(
2558 PM_LOCATION_INIT_NODE_TOKEN(parser, constant, closing),
2560 inner == NULL ? ((pm_node_list_t) { 0 }) : pm_node_list_single(parser->arena, inner),
2562 ((pm_node_list_t) { 0 }),
2563 TOK2LOC(parser, opening),
2564 TOK2LOC(parser, closing)
2572static pm_array_pattern_node_t *
2573pm_array_pattern_node_bracket_create(pm_parser_t *parser, const pm_token_t *opening, pm_node_t *inner, const pm_token_t *closing) {
2574 return pm_array_pattern_node_new(
2578 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
2580 inner == NULL ? ((pm_node_list_t) { 0 }) : pm_node_list_single(parser->arena, inner),
2582 ((pm_node_list_t) { 0 }),
2583 TOK2LOC(parser, opening),
2584 TOK2LOC(parser, closing)
2591static pm_assoc_node_t *
2592pm_assoc_node_create(pm_parser_t *parser, pm_node_t *key, const pm_token_t *operator, pm_node_t *value) {
2595 if (value != NULL && PM_NODE_END(value) > PM_NODE_END(key)) {
2596 end = PM_NODE_END(value);
2597 } else if (operator != NULL) {
2598 end = PM_TOKEN_END(parser, operator);
2600 end = PM_NODE_END(key);
2603 // Hash string keys will be frozen, so we can mark them as frozen here so
2604 // that the compiler picks them up and also when we check for static literal
2605 // on the keys it gets factored in.
2606 if (PM_NODE_TYPE_P(key, PM_STRING_NODE)) {
2607 key->flags |= PM_STRING_FLAGS_FROZEN | PM_NODE_FLAG_STATIC_LITERAL;
2610 // If the key and value of this assoc node are both static literals, then
2611 // we can mark this node as a static literal.
2612 pm_node_flags_t flags = 0;
2614 !PM_NODE_TYPE_P(key, PM_ARRAY_NODE) && !PM_NODE_TYPE_P(key, PM_HASH_NODE) && !PM_NODE_TYPE_P(key, PM_RANGE_NODE) &&
2615 value && !PM_NODE_TYPE_P(value, PM_ARRAY_NODE) && !PM_NODE_TYPE_P(value, PM_HASH_NODE) && !PM_NODE_TYPE_P(value, PM_RANGE_NODE)
2617 flags = key->flags & value->flags & PM_NODE_FLAG_STATIC_LITERAL;
2620 return pm_assoc_node_new(
2624 ((pm_location_t) { .start = PM_NODE_START(key), .length = U32(end - PM_NODE_START(key)) }),
2627 NTOK2LOC(parser, operator)
2634static pm_assoc_splat_node_t *
2635pm_assoc_splat_node_create(pm_parser_t *parser, pm_node_t *value, const pm_token_t *operator) {
2636 PRISM_ASSERT(operator->type == PM_TOKEN_USTAR_STAR);
2638 return pm_assoc_splat_node_new(
2642 (value == NULL) ? PM_LOCATION_INIT_TOKEN(parser, operator) : PM_LOCATION_INIT_TOKEN_NODE(parser, operator, value),
2644 TOK2LOC(parser, operator)
2651static pm_back_reference_read_node_t *
2652pm_back_reference_read_node_create(pm_parser_t *parser, const pm_token_t *name) {
2653 PRISM_ASSERT(name->type == PM_TOKEN_BACK_REFERENCE);
2655 return pm_back_reference_read_node_new(
2659 PM_LOCATION_INIT_TOKEN(parser, name),
2660 pm_parser_constant_id_token(parser, name)
2667static pm_begin_node_t *
2668pm_begin_node_create(pm_parser_t *parser, const pm_token_t *begin_keyword, pm_statements_node_t *statements) {
2669 uint32_t start = begin_keyword == NULL ? 0 : PM_TOKEN_START(parser, begin_keyword);
2670 uint32_t end = statements == NULL ? (begin_keyword == NULL ? 0 : PM_TOKEN_END(parser, begin_keyword)) : PM_NODE_END(statements);
2672 return pm_begin_node_new(
2676 ((pm_location_t) { .start = start, .length = U32(end - start) }),
2677 NTOK2LOC(parser, begin_keyword),
2682 ((pm_location_t) { 0 })
2690pm_begin_node_rescue_clause_set(pm_begin_node_t *node, pm_rescue_node_t *rescue_clause) {
2691 if (node->begin_keyword_loc.length == 0) {
2692 PM_NODE_START_SET_NODE(node, rescue_clause);
2694 PM_NODE_LENGTH_SET_NODE(node, rescue_clause);
2695 node->rescue_clause = rescue_clause;
2702pm_begin_node_else_clause_set(pm_begin_node_t *node, pm_else_node_t *else_clause) {
2703 if ((node->begin_keyword_loc.length == 0) && PM_NODE_START(node) == 0) {
2704 PM_NODE_START_SET_NODE(node, else_clause);
2706 PM_NODE_LENGTH_SET_NODE(node, else_clause);
2707 node->else_clause = else_clause;
2714pm_begin_node_ensure_clause_set(pm_begin_node_t *node, pm_ensure_node_t *ensure_clause) {
2715 if ((node->begin_keyword_loc.length == 0) && PM_NODE_START(node) == 0) {
2716 PM_NODE_START_SET_NODE(node, ensure_clause);
2718 PM_NODE_LENGTH_SET_NODE(node, ensure_clause);
2719 node->ensure_clause = ensure_clause;
2726pm_begin_node_end_keyword_set(const pm_parser_t *parser, pm_begin_node_t *node, const pm_token_t *end_keyword) {
2727 PRISM_ASSERT(end_keyword->type == PM_TOKEN_KEYWORD_END || end_keyword->type == 0);
2728 PM_NODE_LENGTH_SET_TOKEN(parser, node, end_keyword);
2729 node->end_keyword_loc = TOK2LOC(parser, end_keyword);
2735static pm_block_argument_node_t *
2736pm_block_argument_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *expression) {
2737 PRISM_ASSERT(operator->type == PM_TOKEN_UAMPERSAND);
2739 return pm_block_argument_node_new(
2743 (expression == NULL) ? PM_LOCATION_INIT_TOKEN(parser, operator) : PM_LOCATION_INIT_TOKEN_NODE(parser, operator, expression),
2745 TOK2LOC(parser, operator)
2752static pm_block_node_t *
2753pm_block_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *opening, pm_node_t *parameters, pm_node_t *body, const pm_token_t *closing) {
2754 return pm_block_node_new(
2758 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
2762 TOK2LOC(parser, opening),
2763 TOK2LOC(parser, closing)
2770static pm_block_parameter_node_t *
2771pm_block_parameter_node_create(pm_parser_t *parser, const pm_token_t *name, const pm_token_t *operator) {
2772 PRISM_ASSERT(operator->type == PM_TOKEN_UAMPERSAND || operator->type == PM_TOKEN_AMPERSAND);
2774 return pm_block_parameter_node_new(
2778 (name == NULL) ? PM_LOCATION_INIT_TOKEN(parser, operator) : PM_LOCATION_INIT_TOKENS(parser, operator, name),
2779 name == NULL ? 0 : pm_parser_constant_id_token(parser, name),
2780 NTOK2LOC(parser, name),
2781 TOK2LOC(parser, operator)
2788static pm_block_parameters_node_t *
2789pm_block_parameters_node_create(pm_parser_t *parser, pm_parameters_node_t *parameters, const pm_token_t *opening, pm_node_list_t *locals) {
2790 pm_node_list_finalize(&parser->node_chunks, parser->arena, locals);
2793 if (opening != NULL) {
2794 start = PM_TOKEN_START(parser, opening);
2795 } else if (parameters != NULL) {
2796 start = PM_NODE_START(parameters);
2802 if (parameters != NULL) {
2803 end = PM_NODE_END(parameters);
2804 } else if (opening != NULL) {
2805 end = PM_TOKEN_END(parser, opening);
2810 /* Locals only follow an opening token, so they always extend the end of
2811 * a node that has already started. */
2812 if (locals->size > 0) {
2813 PRISM_ASSERT(opening != NULL);
2814 end = PM_NODE_END(locals->nodes[locals->size - 1]);
2817 return pm_block_parameters_node_new(
2821 ((pm_location_t) { .start = start, .length = U32(end - start) }),
2824 NTOK2LOC(parser, opening),
2825 ((pm_location_t) { 0 })
2833pm_block_parameters_node_closing_set(const pm_parser_t *parser, pm_block_parameters_node_t *node, const pm_token_t *closing) {
2834 PRISM_ASSERT(closing->type == PM_TOKEN_PIPE || closing->type == PM_TOKEN_PARENTHESIS_RIGHT || closing->type == 0);
2835 PM_NODE_LENGTH_SET_TOKEN(parser, node, closing);
2836 node->closing_loc = TOK2LOC(parser, closing);
2842static pm_block_local_variable_node_t *
2843pm_block_local_variable_node_create(pm_parser_t *parser, const pm_token_t *name) {
2844 return pm_block_local_variable_node_new(
2848 PM_LOCATION_INIT_TOKEN(parser, name),
2849 pm_parser_constant_id_token(parser, name)
2856static pm_break_node_t *
2857pm_break_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_node_t *arguments) {
2858 PRISM_ASSERT(keyword->type == PM_TOKEN_KEYWORD_BREAK);
2860 return pm_break_node_new(
2864 (arguments == NULL) ? PM_LOCATION_INIT_TOKEN(parser, keyword) : PM_LOCATION_INIT_TOKEN_NODE(parser, keyword, arguments),
2866 TOK2LOC(parser, keyword)
2870// There are certain flags that we want to use internally but don't want to
2871// expose because they are not relevant beyond parsing. Therefore we'll define
2872// them here and not define them in config.yml/a header file.
2873static const pm_node_flags_t PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY = (1 << 2);
2875static const pm_node_flags_t PM_CALL_NODE_FLAGS_IMPLICIT_ARRAY = ((PM_CALL_NODE_FLAGS_LAST - 1) << 1);
2876static const pm_node_flags_t PM_CALL_NODE_FLAGS_COMPARISON = ((PM_CALL_NODE_FLAGS_LAST - 1) << 2);
2877static const pm_node_flags_t PM_CALL_NODE_FLAGS_INDEX = ((PM_CALL_NODE_FLAGS_LAST - 1) << 3);
2884static pm_call_node_t *
2885pm_call_node_create(pm_parser_t *parser, pm_node_flags_t flags) {
2886 return pm_call_node_new(
2890 PM_LOCATION_INIT_UNSET,
2892 ((pm_location_t) { 0 }),
2894 ((pm_location_t) { 0 }),
2895 ((pm_location_t) { 0 }),
2897 ((pm_location_t) { 0 }),
2898 ((pm_location_t) { 0 }),
2907static PRISM_INLINE pm_node_flags_t
2908pm_call_node_ignore_visibility_flag(const pm_node_t *receiver) {
2909 return PM_NODE_TYPE_P(receiver, PM_SELF_NODE) ? PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY : 0;
2916static pm_call_node_t *
2917pm_call_node_aref_create(pm_parser_t *parser, pm_node_t *receiver, pm_arguments_t *arguments) {
2918 pm_assert_value_expression(parser, receiver);
2920 pm_node_flags_t flags = pm_call_node_ignore_visibility_flag(receiver);
2921 if (arguments->block == NULL || PM_NODE_TYPE_P(arguments->block, PM_BLOCK_ARGUMENT_NODE)) {
2922 flags |= PM_CALL_NODE_FLAGS_INDEX;
2925 pm_call_node_t *node = pm_call_node_create(parser, flags);
2927 PM_NODE_START_SET_NODE(node, receiver);
2929 const pm_location_t *end = pm_arguments_end(arguments);
2930 PRISM_ASSERT(end != NULL && "unreachable");
2931 PM_NODE_LENGTH_SET_LOCATION(node, end);
2933 node->receiver = receiver;
2934 node->message_loc.start = arguments->opening_loc.start;
2935 node->message_loc.length = (arguments->closing_loc.start + arguments->closing_loc.length) - arguments->opening_loc.start;
2937 node->opening_loc = arguments->opening_loc;
2938 node->arguments = pm_arguments_node_create(parser, arguments);
2939 node->closing_loc = arguments->closing_loc;
2940 node->block = arguments->block;
2942 node->name = pm_parser_constant_id_constant(parser, "[]", 2);
2949static pm_call_node_t *
2950pm_call_node_binary_create(pm_parser_t *parser, pm_node_t *receiver, pm_token_t *operator, pm_node_t *argument, pm_node_flags_t flags) {
2951 pm_assert_value_expression(parser, receiver);
2952 pm_assert_value_expression(parser, argument);
2954 pm_call_node_t *node = pm_call_node_create(parser, pm_call_node_ignore_visibility_flag(receiver) | flags);
2956 PM_NODE_START_SET_NODE(node, PM_NODE_START(receiver) < PM_NODE_START(argument) ? receiver : argument);
2957 PM_NODE_LENGTH_SET_NODE(node, PM_NODE_END(receiver) > PM_NODE_END(argument) ? receiver : argument);
2959 node->receiver = receiver;
2960 node->message_loc = TOK2LOC(parser, operator);
2962 node->arguments = pm_arguments_node_single_create(parser, argument);
2964 node->name = pm_parser_constant_id_token(parser, operator);
2968static const uint8_t * parse_operator_symbol_name(const pm_token_t *);
2973static pm_call_node_t *
2974pm_call_node_call_create(pm_parser_t *parser, pm_node_t *receiver, pm_token_t *operator, pm_token_t *message, pm_arguments_t *arguments) {
2975 pm_assert_value_expression(parser, receiver);
2977 pm_call_node_t *node = pm_call_node_create(parser, pm_call_node_ignore_visibility_flag(receiver));
2979 PM_NODE_START_SET_NODE(node, receiver);
2980 const pm_location_t *end = pm_arguments_end(arguments);
2982 PM_NODE_LENGTH_SET_TOKEN(parser, node, message);
2984 PM_NODE_LENGTH_SET_LOCATION(node, end);
2987 node->receiver = receiver;
2988 node->call_operator_loc = TOK2LOC(parser, operator);
2989 node->message_loc = TOK2LOC(parser, message);
2990 node->opening_loc = arguments->opening_loc;
2991 node->arguments = pm_arguments_node_create(parser, arguments);
2992 node->closing_loc = arguments->closing_loc;
2993 node->block = arguments->block;
2995 if (operator->type == PM_TOKEN_AMPERSAND_DOT) {
2996 pm_node_flag_set(UP(node), PM_CALL_NODE_FLAGS_SAFE_NAVIGATION);
3003 node->name = pm_parser_constant_id_raw(parser, message->start, parse_operator_symbol_name(message));
3010static pm_call_node_t *
3011pm_call_node_call_synthesized_create(pm_parser_t *parser, pm_node_t *receiver, const char *message, pm_arguments_node_t *arguments, pm_location_t location) {
3012 pm_call_node_t *node = pm_call_node_create(parser, 0);
3013 node->base.location = location;
3015 node->receiver = receiver;
3016 node->arguments = arguments;
3018 node->name = pm_parser_constant_id_constant(parser, message, strlen(message));
3026static pm_call_node_t *
3027pm_call_node_fcall_create(pm_parser_t *parser, pm_token_t *message, pm_arguments_t *arguments) {
3028 pm_call_node_t *node = pm_call_node_create(parser, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY);
3030 PM_NODE_START_SET_TOKEN(parser, node, message);
3031 const pm_location_t *end = pm_arguments_end(arguments);
3032 PRISM_ASSERT(end != NULL && "unreachable");
3033 PM_NODE_LENGTH_SET_LOCATION(node, end);
3035 node->message_loc = TOK2LOC(parser, message);
3036 node->opening_loc = arguments->opening_loc;
3037 node->arguments = pm_arguments_node_create(parser, arguments);
3038 node->closing_loc = arguments->closing_loc;
3039 node->block = arguments->block;
3041 node->name = pm_parser_constant_id_token(parser, message);
3049static pm_call_node_t *
3050pm_call_node_fcall_synthesized_create(pm_parser_t *parser, pm_arguments_node_t *arguments, pm_constant_id_t name) {
3051 pm_call_node_t *node = pm_call_node_create(parser, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY);
3053 node->base.location = (pm_location_t) { 0 };
3054 node->arguments = arguments;
3063static pm_call_node_t *
3064pm_call_node_not_create(pm_parser_t *parser, pm_node_t *receiver, pm_token_t *message, pm_arguments_t *arguments) {
3065 pm_assert_value_expression(parser, receiver);
3066 if (receiver != NULL) pm_conditional_predicate(parser, receiver, PM_CONDITIONAL_PREDICATE_TYPE_NOT);
3068 pm_call_node_t *node = pm_call_node_create(parser, receiver == NULL ? 0 : pm_call_node_ignore_visibility_flag(receiver));
3070 PM_NODE_START_SET_TOKEN(parser, node, message);
3071 if (arguments->closing_loc.length > 0) {
3072 PM_NODE_LENGTH_SET_LOCATION(node, &arguments->closing_loc);
3074 PRISM_ASSERT(receiver != NULL);
3075 PM_NODE_LENGTH_SET_NODE(node, receiver);
3078 node->receiver = receiver;
3079 node->message_loc = TOK2LOC(parser, message);
3080 node->opening_loc = arguments->opening_loc;
3081 node->arguments = pm_arguments_node_create(parser, arguments);
3082 node->closing_loc = arguments->closing_loc;
3084 node->name = pm_parser_constant_id_constant(parser, "!", 1);
3091static pm_call_node_t *
3092pm_call_node_shorthand_create(pm_parser_t *parser, pm_node_t *receiver, pm_token_t *operator, pm_arguments_t *arguments) {
3093 pm_assert_value_expression(parser, receiver);
3095 pm_call_node_t *node = pm_call_node_create(parser, pm_call_node_ignore_visibility_flag(receiver));
3097 PM_NODE_START_SET_NODE(node, receiver);
3098 const pm_location_t *end = pm_arguments_end(arguments);
3099 PRISM_ASSERT(end != NULL && "unreachable");
3100 PM_NODE_LENGTH_SET_LOCATION(node, end);
3102 node->receiver = receiver;
3103 node->call_operator_loc = TOK2LOC(parser, operator);
3104 node->opening_loc = arguments->opening_loc;
3105 node->arguments = pm_arguments_node_create(parser, arguments);
3106 node->closing_loc = arguments->closing_loc;
3107 node->block = arguments->block;
3109 if (operator->type == PM_TOKEN_AMPERSAND_DOT) {
3110 pm_node_flag_set(UP(node), PM_CALL_NODE_FLAGS_SAFE_NAVIGATION);
3113 node->name = pm_parser_constant_id_constant(parser, "call", 4);
3120static pm_call_node_t *
3121pm_call_node_unary_create(pm_parser_t *parser, pm_token_t *operator, pm_node_t *receiver, const char *name) {
3122 pm_assert_value_expression(parser, receiver);
3124 pm_call_node_t *node = pm_call_node_create(parser, pm_call_node_ignore_visibility_flag(receiver));
3126 PM_NODE_START_SET_TOKEN(parser, node, operator);
3127 PM_NODE_LENGTH_SET_NODE(node, receiver);
3129 node->receiver = receiver;
3130 node->message_loc = TOK2LOC(parser, operator);
3132 node->name = pm_parser_constant_id_constant(parser, name, strlen(name));
3140static pm_call_node_t *
3141pm_call_node_variable_call_create(pm_parser_t *parser, pm_token_t *message) {
3142 pm_call_node_t *node = pm_call_node_create(parser, PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY);
3144 node->base.location = TOK2LOC(parser, message);
3145 node->message_loc = TOK2LOC(parser, message);
3147 node->name = pm_parser_constant_id_token(parser, message);
3155static PRISM_INLINE bool
3156pm_call_node_writable_p(const pm_parser_t *parser, const pm_call_node_t *node) {
3158 (node->message_loc.length > 0) &&
3159 (parser->start[node->message_loc.start + node->message_loc.length - 1] != '!') &&
3160 (parser->start[node->message_loc.start + node->message_loc.length - 1] != '?') &&
3161 (node->receiver == NULL || node->call_operator_loc.length > 0) &&
3162 char_is_identifier_start(parser, parser->start + node->message_loc.start, (ptrdiff_t) node->message_loc.length) &&
3163 (node->opening_loc.length == 0) &&
3164 (node->arguments == NULL) &&
3165 (node->block == NULL)
3173pm_call_write_read_name_init(pm_parser_t *parser, pm_constant_id_t *read_name, pm_constant_id_t *write_name) {
3174 pm_constant_t *write_constant = pm_constant_pool_id_to_constant(&parser->constant_pool, *write_name);
3176 if (write_constant->length > 0) {
3177 size_t length = write_constant->length - 1;
3179 uint8_t *memory = PM_ARENA_ALLOC_ARRAY(parser->arena, uint8_t, length);
3180 memcpy(memory, write_constant->start, length);
3182 *read_name = pm_constant_pool_insert_owned(&parser->metadata_arena, &parser->constant_pool, memory, length);
3184 // We can get here if the message was missing because of a syntax error.
3185 *read_name = pm_parser_constant_id_constant(parser, "", 0);
3192static pm_call_and_write_node_t *
3193pm_call_and_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3194 PRISM_ASSERT(target->block == NULL);
3195 PRISM_ASSERT(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
3197 pm_call_and_write_node_t *node = pm_call_and_write_node_new(
3201 PM_LOCATION_INIT_NODES(target, value),
3203 target->call_operator_loc,
3204 target->message_loc,
3207 TOK2LOC(parser, operator),
3211 pm_call_write_read_name_init(parser, &node->read_name, &node->write_name);
3213 // The target is no longer necessary because we've reused its children.
3214 // It is arena-allocated so no explicit free is needed.
3224pm_index_arguments_check(pm_parser_t *parser, const pm_arguments_node_t *arguments, const pm_node_t *block) {
3225 if (parser->version >= PM_OPTIONS_VERSION_CRUBY_3_4) {
3226 if (arguments != NULL && PM_NODE_FLAG_P(arguments, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS)) {
3228 PM_NODE_LIST_FOREACH(&arguments->arguments, index, node) {
3229 if (PM_NODE_TYPE_P(node, PM_KEYWORD_HASH_NODE)) {
3230 pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_INDEX_KEYWORDS);
3236 if (block != NULL) {
3237 pm_parser_err_node(parser, block, PM_ERR_UNEXPECTED_INDEX_BLOCK);
3245static pm_index_and_write_node_t *
3246pm_index_and_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3247 PRISM_ASSERT(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
3249 pm_index_arguments_check(parser, target->arguments, target->block);
3251 PRISM_ASSERT(!target->block || PM_NODE_TYPE_P(target->block, PM_BLOCK_ARGUMENT_NODE));
3253 pm_index_and_write_node_t *node = pm_index_and_write_node_new(
3257 PM_LOCATION_INIT_NODES(target, value),
3259 target->call_operator_loc,
3260 target->opening_loc,
3262 target->closing_loc,
3263 (pm_block_argument_node_t *) target->block,
3264 TOK2LOC(parser, operator),
3268 // The target is no longer necessary because we've reused its children.
3269 // It is arena-allocated so no explicit free is needed.
3277static pm_call_operator_write_node_t *
3278pm_call_operator_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3279 PRISM_ASSERT(target->block == NULL);
3281 pm_call_operator_write_node_t *node = pm_call_operator_write_node_new(
3285 PM_LOCATION_INIT_NODES(target, value),
3287 target->call_operator_loc,
3288 target->message_loc,
3291 pm_parser_constant_id_raw(parser, operator->start, operator->end - 1),
3292 TOK2LOC(parser, operator),
3296 pm_call_write_read_name_init(parser, &node->read_name, &node->write_name);
3298 // The target is no longer necessary because we've reused its children.
3299 // It is arena-allocated so no explicit free is needed.
3307static pm_index_operator_write_node_t *
3308pm_index_operator_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3309 pm_index_arguments_check(parser, target->arguments, target->block);
3311 PRISM_ASSERT(!target->block || PM_NODE_TYPE_P(target->block, PM_BLOCK_ARGUMENT_NODE));
3313 pm_index_operator_write_node_t *node = pm_index_operator_write_node_new(
3317 PM_LOCATION_INIT_NODES(target, value),
3319 target->call_operator_loc,
3320 target->opening_loc,
3322 target->closing_loc,
3323 (pm_block_argument_node_t *) target->block,
3324 pm_parser_constant_id_raw(parser, operator->start, operator->end - 1),
3325 TOK2LOC(parser, operator),
3329 // The target is no longer necessary because we've reused its children.
3330 // It is arena-allocated so no explicit free is needed.
3338static pm_call_or_write_node_t *
3339pm_call_or_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3340 PRISM_ASSERT(target->block == NULL);
3341 PRISM_ASSERT(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
3343 pm_call_or_write_node_t *node = pm_call_or_write_node_new(
3347 PM_LOCATION_INIT_NODES(target, value),
3349 target->call_operator_loc,
3350 target->message_loc,
3353 TOK2LOC(parser, operator),
3357 pm_call_write_read_name_init(parser, &node->read_name, &node->write_name);
3359 // The target is no longer necessary because we've reused its children.
3360 // It is arena-allocated so no explicit free is needed.
3368static pm_index_or_write_node_t *
3369pm_index_or_write_node_create(pm_parser_t *parser, pm_call_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3370 PRISM_ASSERT(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
3372 pm_index_arguments_check(parser, target->arguments, target->block);
3374 PRISM_ASSERT(!target->block || PM_NODE_TYPE_P(target->block, PM_BLOCK_ARGUMENT_NODE));
3376 pm_index_or_write_node_t *node = pm_index_or_write_node_new(
3380 PM_LOCATION_INIT_NODES(target, value),
3382 target->call_operator_loc,
3383 target->opening_loc,
3385 target->closing_loc,
3386 (pm_block_argument_node_t *) target->block,
3387 TOK2LOC(parser, operator),
3391 // The target is no longer necessary because we've reused its children.
3392 // It is arena-allocated so no explicit free is needed.
3401static pm_call_target_node_t *
3402pm_call_target_node_create(pm_parser_t *parser, pm_call_node_t *target) {
3403 pm_call_target_node_t *node = pm_call_target_node_new(
3407 PM_LOCATION_INIT_NODE(target),
3409 target->call_operator_loc,
3414 /* It is possible to get here where we have parsed an invalid syntax tree
3415 * where the call operator was not present. In that case we will have a
3416 * problem because it is a required location. In this case we need to fill
3417 * it in with a fake location so that the syntax tree remains valid. */
3418 if (node->call_operator_loc.length == 0) {
3419 node->call_operator_loc = target->base.location;
3422 // The target is no longer necessary because we've reused its children.
3423 // It is arena-allocated so no explicit free is needed.
3432static pm_index_target_node_t *
3433pm_index_target_node_create(pm_parser_t *parser, pm_call_node_t *target) {
3434 pm_index_arguments_check(parser, target->arguments, target->block);
3435 PRISM_ASSERT(!target->block || PM_NODE_TYPE_P(target->block, PM_BLOCK_ARGUMENT_NODE));
3437 pm_index_target_node_t *node = pm_index_target_node_new(
3440 FL(target) | PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE,
3441 PM_LOCATION_INIT_NODE(target),
3443 target->opening_loc,
3445 target->closing_loc,
3446 (pm_block_argument_node_t *) target->block
3449 // The target is no longer necessary because we've reused its children.
3450 // It is arena-allocated so no explicit free is needed.
3458static pm_capture_pattern_node_t *
3459pm_capture_pattern_node_create(pm_parser_t *parser, pm_node_t *value, pm_local_variable_target_node_t *target, const pm_token_t *operator) {
3460 return pm_capture_pattern_node_new(
3464 PM_LOCATION_INIT_NODES(value, target),
3467 TOK2LOC(parser, operator)
3474static pm_case_node_t *
3475pm_case_node_create(pm_parser_t *parser, const pm_token_t *case_keyword, pm_node_t *predicate, pm_node_list_t *conditions, pm_else_node_t *else_clause, const pm_token_t *end_keyword) {
3476 pm_node_list_finalize(&parser->node_chunks, parser->arena, conditions);
3478 return pm_case_node_new(
3482 PM_LOCATION_INIT_TOKENS(parser, case_keyword, end_keyword),
3486 TOK2LOC(parser, case_keyword),
3487 TOK2LOC(parser, end_keyword)
3494static pm_case_match_node_t *
3495pm_case_match_node_create(pm_parser_t *parser, const pm_token_t *case_keyword, pm_node_t *predicate, pm_node_list_t *conditions, pm_else_node_t *else_clause, const pm_token_t *end_keyword) {
3496 pm_node_list_finalize(&parser->node_chunks, parser->arena, conditions);
3498 return pm_case_match_node_new(
3502 PM_LOCATION_INIT_TOKENS(parser, case_keyword, end_keyword),
3506 TOK2LOC(parser, case_keyword),
3507 TOK2LOC(parser, end_keyword)
3514static pm_class_node_t *
3515pm_class_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *class_keyword, pm_node_t *constant_path, const pm_token_t *name, const pm_token_t *inheritance_operator, pm_node_t *superclass, pm_node_t *body, const pm_token_t *end_keyword) {
3516 return pm_class_node_new(
3520 PM_LOCATION_INIT_TOKENS(parser, class_keyword, end_keyword),
3522 TOK2LOC(parser, class_keyword),
3524 NTOK2LOC(parser, inheritance_operator),
3527 TOK2LOC(parser, end_keyword),
3528 pm_parser_constant_id_token(parser, name)
3535static pm_class_variable_and_write_node_t *
3536pm_class_variable_and_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3537 PRISM_ASSERT(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
3539 return pm_class_variable_and_write_node_new(
3543 PM_LOCATION_INIT_NODES(target, value),
3545 target->base.location,
3546 TOK2LOC(parser, operator),
3554static pm_class_variable_operator_write_node_t *
3555pm_class_variable_operator_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3556 return pm_class_variable_operator_write_node_new(
3560 PM_LOCATION_INIT_NODES(target, value),
3562 target->base.location,
3563 TOK2LOC(parser, operator),
3565 pm_parser_constant_id_raw(parser, operator->start, operator->end - 1)
3572static pm_class_variable_or_write_node_t *
3573pm_class_variable_or_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3574 PRISM_ASSERT(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
3576 return pm_class_variable_or_write_node_new(
3580 PM_LOCATION_INIT_NODES(target, value),
3582 target->base.location,
3583 TOK2LOC(parser, operator),
3591static pm_class_variable_read_node_t *
3592pm_class_variable_read_node_create(pm_parser_t *parser, const pm_token_t *token) {
3593 PRISM_ASSERT(token->type == PM_TOKEN_CLASS_VARIABLE);
3595 return pm_class_variable_read_node_new(
3599 PM_LOCATION_INIT_TOKEN(parser, token),
3600 pm_parser_constant_id_token(parser, token)
3610static PRISM_INLINE pm_node_flags_t
3611pm_implicit_array_write_flags(const pm_node_t *node, pm_node_flags_t flags) {
3612 if (PM_NODE_TYPE_P(node, PM_ARRAY_NODE) && ((const pm_array_node_t *) node)->opening_loc.length == 0) {
3621static pm_class_variable_write_node_t *
3622pm_class_variable_write_node_create(pm_parser_t *parser, pm_class_variable_read_node_t *read_node, pm_token_t *operator, pm_node_t *value) {
3623 return pm_class_variable_write_node_new(
3626 pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
3627 PM_LOCATION_INIT_NODES(read_node, value),
3629 read_node->base.location,
3631 TOK2LOC(parser, operator)
3638static pm_constant_path_and_write_node_t *
3639pm_constant_path_and_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3640 PRISM_ASSERT(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
3642 return pm_constant_path_and_write_node_new(
3646 PM_LOCATION_INIT_NODES(target, value),
3648 TOK2LOC(parser, operator),
3656static pm_constant_path_operator_write_node_t *
3657pm_constant_path_operator_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3658 return pm_constant_path_operator_write_node_new(
3662 PM_LOCATION_INIT_NODES(target, value),
3664 TOK2LOC(parser, operator),
3666 pm_parser_constant_id_raw(parser, operator->start, operator->end - 1)
3673static pm_constant_path_or_write_node_t *
3674pm_constant_path_or_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3675 PRISM_ASSERT(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
3677 return pm_constant_path_or_write_node_new(
3681 PM_LOCATION_INIT_NODES(target, value),
3683 TOK2LOC(parser, operator),
3691static pm_constant_path_node_t *
3692pm_constant_path_node_create(pm_parser_t *parser, pm_node_t *parent, const pm_token_t *delimiter, const pm_token_t *name_token) {
3693 pm_assert_value_expression(parser, parent);
3695 pm_constant_id_t name = PM_CONSTANT_ID_UNSET;
3696 if (name_token->type == PM_TOKEN_CONSTANT) {
3697 name = pm_parser_constant_id_token(parser, name_token);
3700 return pm_constant_path_node_new(
3704 (parent == NULL) ? PM_LOCATION_INIT_TOKENS(parser, delimiter, name_token) : PM_LOCATION_INIT_NODE_TOKEN(parser, parent, name_token),
3707 TOK2LOC(parser, delimiter),
3708 TOK2LOC(parser, name_token)
3715static pm_constant_path_write_node_t *
3716pm_constant_path_write_node_create(pm_parser_t *parser, pm_constant_path_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3717 return pm_constant_path_write_node_new(
3720 pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
3721 PM_LOCATION_INIT_NODES(target, value),
3723 TOK2LOC(parser, operator),
3731static pm_constant_and_write_node_t *
3732pm_constant_and_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3733 PRISM_ASSERT(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
3735 return pm_constant_and_write_node_new(
3739 PM_LOCATION_INIT_NODES(target, value),
3741 target->base.location,
3742 TOK2LOC(parser, operator),
3750static pm_constant_operator_write_node_t *
3751pm_constant_operator_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3752 return pm_constant_operator_write_node_new(
3756 PM_LOCATION_INIT_NODES(target, value),
3758 target->base.location,
3759 TOK2LOC(parser, operator),
3761 pm_parser_constant_id_raw(parser, operator->start, operator->end - 1)
3768static pm_constant_or_write_node_t *
3769pm_constant_or_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3770 PRISM_ASSERT(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
3772 return pm_constant_or_write_node_new(
3776 PM_LOCATION_INIT_NODES(target, value),
3778 target->base.location,
3779 TOK2LOC(parser, operator),
3787static pm_constant_read_node_t *
3788pm_constant_read_node_create(pm_parser_t *parser, const pm_token_t *name) {
3789 PRISM_ASSERT(name->type == PM_TOKEN_CONSTANT || name->type == 0);
3791 return pm_constant_read_node_new(
3795 PM_LOCATION_INIT_TOKEN(parser, name),
3796 pm_parser_constant_id_token(parser, name)
3803static pm_constant_write_node_t *
3804pm_constant_write_node_create(pm_parser_t *parser, pm_constant_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
3805 return pm_constant_write_node_new(
3808 pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
3809 PM_LOCATION_INIT_NODES(target, value),
3811 target->base.location,
3813 TOK2LOC(parser, operator)
3821pm_def_node_receiver_check(pm_parser_t *parser, const pm_node_t *node) {
3822 switch (PM_NODE_TYPE(node)) {
3823 case PM_BEGIN_NODE: {
3824 const pm_begin_node_t *cast = (pm_begin_node_t *) node;
3825 if (cast->statements != NULL) pm_def_node_receiver_check(parser, UP(cast->statements));
3828 case PM_PARENTHESES_NODE: {
3829 const pm_parentheses_node_t *cast = (const pm_parentheses_node_t *) node;
3830 if (cast->body != NULL) pm_def_node_receiver_check(parser, cast->body);
3833 case PM_STATEMENTS_NODE: {
3834 const pm_statements_node_t *cast = (const pm_statements_node_t *) node;
3835 pm_def_node_receiver_check(parser, cast->body.nodes[cast->body.size - 1]);
3840 case PM_IMAGINARY_NODE:
3841 case PM_INTEGER_NODE:
3842 case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE:
3843 case PM_INTERPOLATED_STRING_NODE:
3844 case PM_INTERPOLATED_SYMBOL_NODE:
3845 case PM_INTERPOLATED_X_STRING_NODE:
3846 case PM_RATIONAL_NODE:
3847 case PM_REGULAR_EXPRESSION_NODE:
3848 case PM_SOURCE_ENCODING_NODE:
3849 case PM_SOURCE_FILE_NODE:
3850 case PM_SOURCE_LINE_NODE:
3851 case PM_STRING_NODE:
3852 case PM_SYMBOL_NODE:
3853 case PM_X_STRING_NODE:
3854 pm_parser_err_node(parser, node, PM_ERR_SINGLETON_FOR_LITERALS);
3864static pm_def_node_t *
3866 pm_parser_t *parser,
3867 pm_constant_id_t name,
3868 const pm_token_t *name_loc,
3869 pm_node_t *receiver,
3870 pm_parameters_node_t *parameters,
3872 pm_constant_id_list_t *locals,
3873 const pm_token_t *def_keyword,
3874 const pm_token_t *operator,
3875 const pm_token_t *lparen,
3876 const pm_token_t *rparen,
3877 const pm_token_t *equal,
3878 const pm_token_t *end_keyword
3880 if (receiver != NULL) {
3881 pm_def_node_receiver_check(parser, receiver);
3884 return pm_def_node_new(
3888 (end_keyword == NULL) ? PM_LOCATION_INIT_TOKEN_NODE(parser, def_keyword, body) : PM_LOCATION_INIT_TOKENS(parser, def_keyword, end_keyword),
3890 TOK2LOC(parser, name_loc),
3895 TOK2LOC(parser, def_keyword),
3896 NTOK2LOC(parser, operator),
3897 NTOK2LOC(parser, lparen),
3898 NTOK2LOC(parser, rparen),
3899 NTOK2LOC(parser, equal),
3900 NTOK2LOC(parser, end_keyword)
3907static pm_defined_node_t *
3908pm_defined_node_create(pm_parser_t *parser, const pm_token_t *lparen, pm_node_t *value, const pm_token_t *rparen, const pm_token_t *keyword) {
3909 return pm_defined_node_new(
3913 (rparen == NULL) ? PM_LOCATION_INIT_TOKEN_NODE(parser, keyword, value) : PM_LOCATION_INIT_TOKENS(parser, keyword, rparen),
3914 NTOK2LOC(parser, lparen),
3916 NTOK2LOC(parser, rparen),
3917 TOK2LOC(parser, keyword)
3924static pm_else_node_t *
3925pm_else_node_create(pm_parser_t *parser, const pm_token_t *else_keyword, pm_statements_node_t *statements, const pm_token_t *end_keyword) {
3926 return pm_else_node_new(
3930 (end_keyword == NULL) ? PM_LOCATION_INIT_TOKEN_NODE(parser, else_keyword, statements) : PM_LOCATION_INIT_TOKENS(parser, else_keyword, end_keyword),
3931 TOK2LOC(parser, else_keyword),
3933 NTOK2LOC(parser, end_keyword)
3940static pm_embedded_statements_node_t *
3941pm_embedded_statements_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_statements_node_t *statements, const pm_token_t *closing) {
3942 return pm_embedded_statements_node_new(
3946 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
3947 TOK2LOC(parser, opening),
3949 TOK2LOC(parser, closing)
3956static pm_embedded_variable_node_t *
3957pm_embedded_variable_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *variable) {
3958 return pm_embedded_variable_node_new(
3962 PM_LOCATION_INIT_TOKEN_NODE(parser, operator, variable),
3963 TOK2LOC(parser, operator),
3971static pm_ensure_node_t *
3972pm_ensure_node_create(pm_parser_t *parser, const pm_token_t *ensure_keyword, pm_statements_node_t *statements, const pm_token_t *end_keyword) {
3973 return pm_ensure_node_new(
3977 PM_LOCATION_INIT_TOKENS(parser, ensure_keyword, end_keyword),
3978 TOK2LOC(parser, ensure_keyword),
3980 TOK2LOC(parser, end_keyword)
3987static pm_false_node_t *
3988pm_false_node_create(pm_parser_t *parser, const pm_token_t *token) {
3989 PRISM_ASSERT(token->type == PM_TOKEN_KEYWORD_FALSE);
3991 return pm_false_node_new(
3994 PM_NODE_FLAG_STATIC_LITERAL,
3995 PM_LOCATION_INIT_TOKEN(parser, token)
4003static pm_find_pattern_node_t *
4004pm_find_pattern_node_create(pm_parser_t *parser, const pm_node_list_t *nodes) {
4005 PRISM_ASSERT(nodes->size >= 2);
4006 pm_node_t *left = nodes->nodes[0];
4007 pm_node_t *right = nodes->nodes[nodes->size - 1];
4009 PRISM_ASSERT(PM_NODE_TYPE_P(left, PM_SPLAT_NODE));
4010 PRISM_ASSERT(PM_NODE_TYPE_P(right, PM_SPLAT_NODE));
4012 return pm_find_pattern_node_new(
4016 PM_LOCATION_INIT_NODES(left, right),
4018 (pm_splat_node_t *) left,
4019 pm_node_list_slice(nodes, 1, nodes->size - 2),
4020 (pm_splat_node_t *) right,
4021 ((pm_location_t) { 0 }),
4022 ((pm_location_t) { 0 })
4031pm_float_node_value(pm_parser_t *parser, const pm_token_t *token) {
4033 double value = pm_double_parse(token->start, token->end, &out_of_range);
4036 size_t length = PM_TOKEN_LENGTH(token);
4038 const char *ellipsis;
4044 warn_width = (int) length;
4048 pm_diagnostic_list_append_format(&parser->metadata_arena, &parser->warning_list, PM_TOKEN_START(parser, token), PM_TOKEN_LENGTH(token), PM_WARN_FLOAT_OUT_OF_RANGE, warn_width, (const char *) token->start, ellipsis);
4057static pm_float_node_t *
4058pm_float_node_create(pm_parser_t *parser, const pm_token_t *token) {
4059 PRISM_ASSERT(token->type == PM_TOKEN_FLOAT);
4061 return pm_float_node_new(
4064 PM_NODE_FLAG_STATIC_LITERAL,
4065 PM_LOCATION_INIT_TOKEN(parser, token),
4066 pm_float_node_value(parser, token)
4073static pm_imaginary_node_t *
4074pm_float_node_imaginary_create(pm_parser_t *parser, const pm_token_t *token) {
4075 PRISM_ASSERT(token->type == PM_TOKEN_FLOAT_IMAGINARY);
4077 return pm_imaginary_node_new(
4080 PM_NODE_FLAG_STATIC_LITERAL,
4081 PM_LOCATION_INIT_TOKEN(parser, token),
4082 UP(pm_float_node_create(parser, &((pm_token_t) {
4083 .type = PM_TOKEN_FLOAT,
4084 .start = token->start,
4085 .end = token->end - 1
4093static pm_rational_node_t *
4094pm_float_node_rational_create(pm_parser_t *parser, const pm_token_t *token) {
4095 PRISM_ASSERT(token->type == PM_TOKEN_FLOAT_RATIONAL);
4097 pm_rational_node_t *node = pm_rational_node_new(
4100 PM_INTEGER_BASE_FLAGS_DECIMAL | PM_NODE_FLAG_STATIC_LITERAL,
4101 PM_LOCATION_INIT_TOKEN(parser, token),
4102 ((pm_integer_t) { 0 }),
4103 ((pm_integer_t) { 0 })
4106 pm_integer_parse_rational(parser->arena, &node->numerator, &node->denominator, token->start, token->end - 1);
4114static pm_imaginary_node_t *
4115pm_float_node_rational_imaginary_create(pm_parser_t *parser, const pm_token_t *token) {
4116 PRISM_ASSERT(token->type == PM_TOKEN_FLOAT_RATIONAL_IMAGINARY);
4118 return pm_imaginary_node_new(
4121 PM_NODE_FLAG_STATIC_LITERAL,
4122 PM_LOCATION_INIT_TOKEN(parser, token),
4123 UP(pm_float_node_rational_create(parser, &((pm_token_t) {
4124 .type = PM_TOKEN_FLOAT_RATIONAL,
4125 .start = token->start,
4126 .end = token->end - 1
4134static pm_for_node_t *
4136 pm_parser_t *parser,
4138 pm_node_t *collection,
4139 pm_statements_node_t *statements,
4140 const pm_token_t *for_keyword,
4141 const pm_token_t *in_keyword,
4142 const pm_token_t *do_keyword,
4143 const pm_token_t *end_keyword
4145 return pm_for_node_new(
4149 PM_LOCATION_INIT_TOKENS(parser, for_keyword, end_keyword),
4153 TOK2LOC(parser, for_keyword),
4154 TOK2LOC(parser, in_keyword),
4155 NTOK2LOC(parser, do_keyword),
4156 TOK2LOC(parser, end_keyword)
4163static pm_forwarding_arguments_node_t *
4164pm_forwarding_arguments_node_create(pm_parser_t *parser, const pm_token_t *token) {
4165 PRISM_ASSERT(token->type == PM_TOKEN_UDOT_DOT_DOT);
4167 return pm_forwarding_arguments_node_new(
4171 PM_LOCATION_INIT_TOKEN(parser, token)
4178static pm_forwarding_parameter_node_t *
4179pm_forwarding_parameter_node_create(pm_parser_t *parser, const pm_token_t *token) {
4180 PRISM_ASSERT(token->type == PM_TOKEN_UDOT_DOT_DOT);
4182 return pm_forwarding_parameter_node_new(
4186 PM_LOCATION_INIT_TOKEN(parser, token)
4193static pm_forwarding_super_node_t *
4194pm_forwarding_super_node_create(pm_parser_t *parser, const pm_token_t *token, pm_arguments_t *arguments) {
4195 PRISM_ASSERT(arguments->block == NULL || PM_NODE_TYPE_P(arguments->block, PM_BLOCK_NODE));
4196 PRISM_ASSERT(token->type == PM_TOKEN_KEYWORD_SUPER);
4198 pm_block_node_t *block = NULL;
4199 if (arguments->block != NULL) {
4200 block = (pm_block_node_t *) arguments->block;
4203 return pm_forwarding_super_node_new(
4207 (block == NULL) ? PM_LOCATION_INIT_TOKEN(parser, token) : PM_LOCATION_INIT_TOKEN_NODE(parser, token, block),
4208 PM_LOCATION_INIT_TOKEN(parser, token),
4217static pm_hash_pattern_node_t *
4218pm_hash_pattern_node_empty_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *closing) {
4219 return pm_hash_pattern_node_new(
4223 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
4225 ((pm_node_list_t) { 0 }),
4227 TOK2LOC(parser, opening),
4228 TOK2LOC(parser, closing)
4236static pm_hash_pattern_node_t *
4237pm_hash_pattern_node_node_list_create(pm_parser_t *parser, pm_node_list_t *elements, pm_node_t *rest) {
4238 pm_node_list_finalize(&parser->node_chunks, parser->arena, elements);
4243 if (elements->size > 0) {
4245 start = MIN(PM_NODE_START(rest), PM_NODE_START(elements->nodes[0]));
4246 end = MAX(PM_NODE_END(rest), PM_NODE_END(elements->nodes[elements->size - 1]));
4248 start = PM_NODE_START(elements->nodes[0]);
4249 end = PM_NODE_END(elements->nodes[elements->size - 1]);
4252 PRISM_ASSERT(rest != NULL);
4253 start = PM_NODE_START(rest);
4254 end = PM_NODE_END(rest);
4257 return pm_hash_pattern_node_new(
4261 PM_LOCATION_INIT_BOUNDS(start, end),
4265 ((pm_location_t) { 0 }),
4266 ((pm_location_t) { 0 })
4273static pm_constant_id_t
4274pm_global_variable_write_name(pm_parser_t *parser, const pm_node_t *target) {
4275 switch (PM_NODE_TYPE(target)) {
4276 case PM_GLOBAL_VARIABLE_READ_NODE:
4277 return ((pm_global_variable_read_node_t *) target)->name;
4278 case PM_BACK_REFERENCE_READ_NODE:
4279 return ((pm_back_reference_read_node_t *) target)->name;
4280 case PM_NUMBERED_REFERENCE_READ_NODE:
4281 // This will only ever happen in the event of a syntax error, but we
4282 // still need to provide something for the node.
4283 return pm_parser_constant_id_raw(parser, parser->start + PM_NODE_START(target), parser->start + PM_NODE_END(target));
4285 PRISM_ASSERT(false && "unreachable");
4286 return (pm_constant_id_t) -1;
4293static pm_global_variable_and_write_node_t *
4294pm_global_variable_and_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {
4295 PRISM_ASSERT(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
4297 return pm_global_variable_and_write_node_new(
4301 PM_LOCATION_INIT_NODES(target, value),
4302 pm_global_variable_write_name(parser, target),
4304 TOK2LOC(parser, operator),
4312static pm_global_variable_operator_write_node_t *
4313pm_global_variable_operator_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {
4314 return pm_global_variable_operator_write_node_new(
4318 PM_LOCATION_INIT_NODES(target, value),
4319 pm_global_variable_write_name(parser, target),
4321 TOK2LOC(parser, operator),
4323 pm_parser_constant_id_raw(parser, operator->start, operator->end - 1)
4330static pm_global_variable_or_write_node_t *
4331pm_global_variable_or_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {
4332 PRISM_ASSERT(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
4334 return pm_global_variable_or_write_node_new(
4338 PM_LOCATION_INIT_NODES(target, value),
4339 pm_global_variable_write_name(parser, target),
4341 TOK2LOC(parser, operator),
4349static pm_global_variable_read_node_t *
4350pm_global_variable_read_node_create(pm_parser_t *parser, const pm_token_t *name) {
4351 return pm_global_variable_read_node_new(
4355 PM_LOCATION_INIT_TOKEN(parser, name),
4356 pm_parser_constant_id_token(parser, name)
4363static pm_global_variable_read_node_t *
4364pm_global_variable_read_node_synthesized_create(pm_parser_t *parser, pm_constant_id_t name) {
4365 return pm_global_variable_read_node_new(
4369 PM_LOCATION_INIT_UNSET,
4377static pm_global_variable_write_node_t *
4378pm_global_variable_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value) {
4379 return pm_global_variable_write_node_new(
4382 pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
4383 PM_LOCATION_INIT_NODES(target, value),
4384 pm_global_variable_write_name(parser, target),
4387 TOK2LOC(parser, operator)
4394static pm_global_variable_write_node_t *
4395pm_global_variable_write_node_synthesized_create(pm_parser_t *parser, pm_constant_id_t name, pm_node_t *value) {
4396 return pm_global_variable_write_node_new(
4400 PM_LOCATION_INIT_UNSET,
4402 ((pm_location_t) { 0 }),
4404 ((pm_location_t) { 0 })
4416 pm_node_list_t nodes;
4426 bool non_symbol_keys;
4427} pm_hash_elements_t;
4433static PRISM_INLINE void
4434pm_hash_elements_append(pm_parser_t *parser, pm_hash_elements_t *elements, pm_node_t *element) {
4435 if (!PM_NODE_FLAG_P(element, PM_NODE_FLAG_STATIC_LITERAL)) {
4436 elements->dynamic = true;
4439 if (!PM_NODE_TYPE_P(element, PM_ASSOC_NODE) || !PM_NODE_TYPE_P(((const pm_assoc_node_t *) element)->key, PM_SYMBOL_NODE)) {
4440 elements->non_symbol_keys = true;
4443 pm_node_list_open_append(&parser->node_chunks, &elements->nodes, element);
4449static pm_hash_node_t *
4450pm_hash_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_hash_elements_t *elements, const pm_token_t *closing) {
4451 pm_node_list_finalize(&parser->node_chunks, parser->arena, &elements->nodes);
4453 return pm_hash_node_new(
4456 elements->dynamic ? 0 : PM_NODE_FLAG_STATIC_LITERAL,
4457 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
4458 TOK2LOC(parser, opening),
4460 TOK2LOC(parser, closing)
4467static pm_if_node_t *
4468pm_if_node_create(pm_parser_t *parser,
4469 const pm_token_t *if_keyword,
4470 pm_node_t *predicate,
4471 const pm_token_t *then_keyword,
4472 pm_statements_node_t *statements,
4473 pm_node_t *subsequent,
4474 const pm_token_t *end_keyword
4476 pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
4478 uint32_t start = PM_TOKEN_START(parser, if_keyword);
4481 if (end_keyword != NULL) {
4482 end = PM_TOKEN_END(parser, end_keyword);
4483 } else if (subsequent != NULL) {
4484 end = PM_NODE_END(subsequent);
4485 } else if (pm_statements_node_body_length(statements) != 0) {
4486 end = PM_NODE_END(statements);
4488 end = PM_NODE_END(predicate);
4491 return pm_if_node_new(
4494 PM_NODE_FLAG_NEWLINE,
4495 ((pm_location_t) { .start = start, .length = U32(end - start) }),
4496 TOK2LOC(parser, if_keyword),
4498 NTOK2LOC(parser, then_keyword),
4501 NTOK2LOC(parser, end_keyword)
4508static pm_if_node_t *
4509pm_if_node_modifier_create(pm_parser_t *parser, pm_node_t *statement, const pm_token_t *if_keyword, pm_node_t *predicate) {
4510 pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
4512 pm_statements_node_t *statements = pm_statements_node_single_create(parser, statement, true);
4514 return pm_if_node_new(
4517 PM_NODE_FLAG_NEWLINE,
4518 PM_LOCATION_INIT_NODES(statement, predicate),
4519 TOK2LOC(parser, if_keyword),
4521 ((pm_location_t) { 0 }),
4524 ((pm_location_t) { 0 })
4531static pm_if_node_t *
4532pm_if_node_ternary_create(pm_parser_t *parser, pm_node_t *predicate, const pm_token_t *qmark, pm_node_t *true_expression, const pm_token_t *colon, pm_node_t *false_expression) {
4533 pm_assert_value_expression(parser, predicate);
4534 pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
4536 pm_statements_node_t *if_statements = pm_statements_node_single_create(parser, true_expression, true);
4537 pm_statements_node_t *else_statements = pm_statements_node_single_create(parser, false_expression, true);
4539 pm_else_node_t *else_node = pm_else_node_create(parser, colon, else_statements, NULL);
4540 return pm_if_node_new(
4543 PM_NODE_FLAG_NEWLINE,
4544 PM_LOCATION_INIT_NODES(predicate, false_expression),
4545 ((pm_location_t) { 0 }),
4547 TOK2LOC(parser, qmark),
4550 ((pm_location_t) { 0 })
4554static PRISM_INLINE void
4555pm_if_node_end_keyword_loc_set(const pm_parser_t *parser, pm_if_node_t *node, const pm_token_t *keyword) {
4556 PM_NODE_LENGTH_SET_TOKEN(parser, node, keyword);
4557 node->end_keyword_loc = TOK2LOC(parser, keyword);
4560static PRISM_INLINE void
4561pm_else_node_end_keyword_loc_set(const pm_parser_t *parser, pm_else_node_t *node, const pm_token_t *keyword) {
4562 PM_NODE_LENGTH_SET_TOKEN(parser, node, keyword);
4563 node->end_keyword_loc = TOK2LOC(parser, keyword);
4569static pm_implicit_node_t *
4570pm_implicit_node_create(pm_parser_t *parser, pm_node_t *value) {
4571 return pm_implicit_node_new(
4575 PM_LOCATION_INIT_NODE(value),
4583static pm_implicit_rest_node_t *
4584pm_implicit_rest_node_create(pm_parser_t *parser, const pm_token_t *token) {
4585 PRISM_ASSERT(token->type == PM_TOKEN_COMMA);
4587 return pm_implicit_rest_node_new(
4591 PM_LOCATION_INIT_TOKEN(parser, token)
4598static pm_integer_node_t *
4599pm_integer_node_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {
4600 PRISM_ASSERT(token->type == PM_TOKEN_INTEGER);
4602 pm_integer_node_t *node = pm_integer_node_new(
4605 base | PM_NODE_FLAG_STATIC_LITERAL,
4606 PM_LOCATION_INIT_TOKEN(parser, token),
4607 ((pm_integer_t) { 0 })
4610 if (parser->integer.start == token->start) {
4611 // The value was already computed during lexing.
4612 node->value = pm_integer_uint64(parser->integer.value);
4614 pm_integer_base_t integer_base = PM_INTEGER_BASE_DECIMAL;
4616 case PM_INTEGER_BASE_FLAGS_BINARY: integer_base = PM_INTEGER_BASE_BINARY; break;
4617 case PM_INTEGER_BASE_FLAGS_OCTAL: integer_base = PM_INTEGER_BASE_OCTAL; break;
4618 case PM_INTEGER_BASE_FLAGS_DECIMAL: break;
4619 case PM_INTEGER_BASE_FLAGS_HEXADECIMAL: integer_base = PM_INTEGER_BASE_HEXADECIMAL; break;
4620 default: PRISM_ASSERT(false && "unreachable"); break;
4623 pm_integer_parse(parser->arena, &node->value, integer_base, token->start, token->end);
4633static pm_imaginary_node_t *
4634pm_integer_node_imaginary_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {
4635 PRISM_ASSERT(token->type == PM_TOKEN_INTEGER_IMAGINARY);
4637 return pm_imaginary_node_new(
4640 PM_NODE_FLAG_STATIC_LITERAL,
4641 PM_LOCATION_INIT_TOKEN(parser, token),
4642 UP(pm_integer_node_create(parser, base, &((pm_token_t) {
4643 .type = PM_TOKEN_INTEGER,
4644 .start = token->start,
4645 .end = token->end - 1
4654static pm_rational_node_t *
4655pm_integer_node_rational_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {
4656 PRISM_ASSERT(token->type == PM_TOKEN_INTEGER_RATIONAL);
4658 pm_rational_node_t *node = pm_rational_node_new(
4661 base | PM_NODE_FLAG_STATIC_LITERAL,
4662 PM_LOCATION_INIT_TOKEN(parser, token),
4663 ((pm_integer_t) { 0 }),
4664 pm_integer_uint64(1)
4667 pm_integer_base_t integer_base = PM_INTEGER_BASE_DECIMAL;
4669 case PM_INTEGER_BASE_FLAGS_BINARY: integer_base = PM_INTEGER_BASE_BINARY; break;
4670 case PM_INTEGER_BASE_FLAGS_OCTAL: integer_base = PM_INTEGER_BASE_OCTAL; break;
4671 case PM_INTEGER_BASE_FLAGS_DECIMAL: break;
4672 case PM_INTEGER_BASE_FLAGS_HEXADECIMAL: integer_base = PM_INTEGER_BASE_HEXADECIMAL; break;
4673 default: PRISM_ASSERT(false && "unreachable"); break;
4676 pm_integer_parse(parser->arena, &node->numerator, integer_base, token->start, token->end - 1);
4685static pm_imaginary_node_t *
4686pm_integer_node_rational_imaginary_create(pm_parser_t *parser, pm_node_flags_t base, const pm_token_t *token) {
4687 PRISM_ASSERT(token->type == PM_TOKEN_INTEGER_RATIONAL_IMAGINARY);
4689 return pm_imaginary_node_new(
4692 PM_NODE_FLAG_STATIC_LITERAL,
4693 PM_LOCATION_INIT_TOKEN(parser, token),
4694 UP(pm_integer_node_rational_create(parser, base, &((pm_token_t) {
4695 .type = PM_TOKEN_INTEGER_RATIONAL,
4696 .start = token->start,
4697 .end = token->end - 1
4705static pm_in_node_t *
4706pm_in_node_create(pm_parser_t *parser, pm_node_t *pattern, pm_statements_node_t *statements, const pm_token_t *in_keyword, const pm_token_t *then_keyword) {
4707 uint32_t start = PM_TOKEN_START(parser, in_keyword);
4710 if (statements != NULL) {
4711 end = PM_NODE_END(statements);
4712 } else if (then_keyword != NULL) {
4713 end = PM_TOKEN_END(parser, then_keyword);
4715 end = PM_NODE_END(pattern);
4718 return pm_in_node_new(
4722 PM_LOCATION_INIT_BOUNDS(start, end),
4725 TOK2LOC(parser, in_keyword),
4726 NTOK2LOC(parser, then_keyword)
4733static pm_instance_variable_and_write_node_t *
4734pm_instance_variable_and_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
4735 PRISM_ASSERT(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
4737 return pm_instance_variable_and_write_node_new(
4741 PM_LOCATION_INIT_NODES(target, value),
4743 target->base.location,
4744 TOK2LOC(parser, operator),
4752static pm_instance_variable_operator_write_node_t *
4753pm_instance_variable_operator_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
4754 return pm_instance_variable_operator_write_node_new(
4758 PM_LOCATION_INIT_NODES(target, value),
4760 target->base.location,
4761 TOK2LOC(parser, operator),
4763 pm_parser_constant_id_raw(parser, operator->start, operator->end - 1)
4770static pm_instance_variable_or_write_node_t *
4771pm_instance_variable_or_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *target, const pm_token_t *operator, pm_node_t *value) {
4772 PRISM_ASSERT(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
4774 return pm_instance_variable_or_write_node_new(
4778 PM_LOCATION_INIT_NODES(target, value),
4780 target->base.location,
4781 TOK2LOC(parser, operator),
4789static pm_instance_variable_read_node_t *
4790pm_instance_variable_read_node_create(pm_parser_t *parser, const pm_token_t *token) {
4791 PRISM_ASSERT(token->type == PM_TOKEN_INSTANCE_VARIABLE);
4793 return pm_instance_variable_read_node_new(
4797 PM_LOCATION_INIT_TOKEN(parser, token),
4798 pm_parser_constant_id_token(parser, token)
4806static pm_instance_variable_write_node_t *
4807pm_instance_variable_write_node_create(pm_parser_t *parser, pm_instance_variable_read_node_t *read_node, pm_token_t *operator, pm_node_t *value) {
4808 return pm_instance_variable_write_node_new(
4811 pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
4812 PM_LOCATION_INIT_NODES(read_node, value),
4814 read_node->base.location,
4816 TOK2LOC(parser, operator)
4826pm_interpolated_part_flags(pm_node_flags_t *flags, pm_node_t *part) {
4827 switch (PM_NODE_TYPE(part)) {
4828 case PM_STRING_NODE:
4829 pm_node_flag_set(part, PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN);
4831 case PM_EMBEDDED_STATEMENTS_NODE: {
4832 pm_embedded_statements_node_t *cast = (pm_embedded_statements_node_t *) part;
4833 pm_node_t *embedded = (cast->statements != NULL && cast->statements->body.size == 1) ? cast->statements->body.nodes[0] : NULL;
4835 if (embedded == NULL) {
4836 // If there are no statements or more than one statement, then
4837 // we lose the static literal flag.
4838 *flags &= (pm_node_flags_t) ~PM_NODE_FLAG_STATIC_LITERAL;
4839 } else if (PM_NODE_TYPE_P(embedded, PM_STRING_NODE)) {
4840 // If the embedded statement is a string, then we can keep the
4841 // static literal flag and mark the string as frozen.
4842 pm_node_flag_set(embedded, PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN);
4843 } else if (PM_NODE_TYPE_P(embedded, PM_INTERPOLATED_STRING_NODE) && PM_NODE_FLAG_P(embedded, PM_INTERPOLATED_STRING_NODE_FLAGS_STATIC_VALUE)) {
4844 /* An interpolated string whose value is known while parsing
4845 * keeps the static literal flag, frozen or not, since only its
4846 * value is interpolated. */
4848 // Otherwise we lose the static literal flag.
4849 *flags &= (pm_node_flags_t) ~PM_NODE_FLAG_STATIC_LITERAL;
4854 case PM_EMBEDDED_VARIABLE_NODE:
4855 *flags &= (pm_node_flags_t) ~PM_NODE_FLAG_STATIC_LITERAL;
4858 PRISM_ASSERT(false && "unexpected node type");
4869pm_interpolated_location(const pm_parser_t *parser, const pm_token_t *opening, const pm_node_list_t *parts, const pm_token_t *closing) {
4871 uint32_t end = closing == NULL ? 0 : PM_TOKEN_END(parser, closing);
4873 if (opening != NULL) {
4874 start = PM_TOKEN_START(parser, opening);
4875 if (closing == NULL) end = PM_TOKEN_END(parser, opening);
4876 } else if (parts->size > 0) {
4877 start = PM_NODE_START(parts->nodes[0]);
4880 if (parts->size > 0 && PM_NODE_END(parts->nodes[parts->size - 1]) > end) {
4881 end = PM_NODE_END(parts->nodes[parts->size - 1]);
4884 return PM_LOCATION_INIT_BOUNDS(start, end);
4891static pm_interpolated_regular_expression_node_t *
4892pm_interpolated_regular_expression_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_node_list_t *parts, const pm_token_t *closing) {
4893 pm_node_list_finalize(&parser->node_chunks, parser->arena, parts);
4895 pm_node_flags_t flags = PM_NODE_FLAG_STATIC_LITERAL;
4896 for (size_t idx = 0; idx < parts->size; ++idx) {
4897 pm_interpolated_part_flags(&flags, parts->nodes[idx]);
4899 flags |= pm_regular_expression_flags_create(parser, closing);
4901 return pm_interpolated_regular_expression_node_new(
4905 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
4906 TOK2LOC(parser, opening),
4908 TOK2LOC(parser, closing)
4940static pm_interpolated_string_node_t *
4941pm_interpolated_string_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_node_list_t *parts, const pm_token_t *closing) {
4942#define CLEAR_FLAGS() \
4943 flags = (pm_node_flags_t) (flags & ~(PM_NODE_FLAG_STATIC_LITERAL | PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN | PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE))
4945#define MUTABLE_FLAGS() \
4946 flags = (pm_node_flags_t) ((flags | PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE) & ~PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN)
4948 pm_node_list_finalize(&parser->node_chunks, parser->arena, parts);
4949 pm_location_t location = pm_interpolated_location(parser, opening, parts, closing);
4951 pm_node_flags_t flags = PM_NODE_FLAG_STATIC_LITERAL | PM_INTERPOLATED_STRING_NODE_FLAGS_STATIC_VALUE;
4953 switch (parser->frozen_string_literal) {
4954 case PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED:
4955 flags |= PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE;
4957 case PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED:
4958 flags |= PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN;
4962 for (size_t idx = 0; idx < parts->size; ++idx) {
4963 pm_node_t *part = parts->nodes[idx];
4965 switch (PM_NODE_TYPE(part)) {
4966 case PM_STRING_NODE:
4967 // If inner string is not frozen, it stops being a static literal. We should *not* clear other flags,
4968 // because concatenating two frozen strings (`'foo' 'bar'`) is still frozen. This holds true for
4969 // as long as this interpolation only consists of other string literals.
4970 if (!PM_NODE_FLAG_P(part, PM_STRING_FLAGS_FROZEN)) {
4971 flags &= (pm_node_flags_t) ~PM_NODE_FLAG_STATIC_LITERAL;
4973 part->flags = (pm_node_flags_t) ((part->flags | PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN) & ~PM_STRING_FLAGS_MUTABLE);
4975 case PM_INTERPOLATED_STRING_NODE:
4976 if (PM_NODE_FLAG_P(part, PM_NODE_FLAG_STATIC_LITERAL)) {
4977 // If the string that we're concatenating is a static literal,
4978 // then we can keep the static literal flag for this string.
4980 // Otherwise, we lose the static literal flag here and we should
4981 // also clear the mutability flags.
4985 if (!PM_NODE_FLAG_P(part, PM_INTERPOLATED_STRING_NODE_FLAGS_STATIC_VALUE)) {
4986 flags &= (pm_node_flags_t) ~PM_INTERPOLATED_STRING_NODE_FLAGS_STATIC_VALUE;
4989 case PM_EMBEDDED_STATEMENTS_NODE: {
4990 pm_embedded_statements_node_t *cast = (pm_embedded_statements_node_t *) part;
4991 pm_node_t *embedded = (cast->statements != NULL && cast->statements->body.size == 1) ? cast->statements->body.nodes[0] : NULL;
4993 if (embedded == NULL) {
4994 // If we're embedding multiple statements or no statements, then
4995 // the string is not longer a static literal.
4997 } else if (PM_NODE_TYPE_P(embedded, PM_STRING_NODE)) {
4998 // If the embedded statement is a string, then we can make that
4999 // string as frozen and static literal, and not touch the static
5000 // literal status of this string.
5001 embedded->flags = (pm_node_flags_t) ((embedded->flags | PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN) & ~PM_STRING_FLAGS_MUTABLE);
5003 if (flags & PM_NODE_FLAG_STATIC_LITERAL) {
5006 } else if (PM_NODE_TYPE_P(embedded, PM_INTERPOLATED_STRING_NODE) && PM_NODE_FLAG_P(embedded, PM_NODE_FLAG_STATIC_LITERAL)) {
5007 // If the embedded statement is an interpolated string, but that
5008 // string is marked as static literal, then we can keep our
5009 // static literal status for this string.
5010 if (flags & PM_NODE_FLAG_STATIC_LITERAL) {
5014 // In all other cases, we lose the static literal flag here and
5019 if (embedded == NULL || !(PM_NODE_TYPE_P(embedded, PM_STRING_NODE) || (PM_NODE_TYPE_P(embedded, PM_INTERPOLATED_STRING_NODE) && PM_NODE_FLAG_P(embedded, PM_INTERPOLATED_STRING_NODE_FLAGS_STATIC_VALUE)))) {
5020 flags &= (pm_node_flags_t) ~PM_INTERPOLATED_STRING_NODE_FLAGS_STATIC_VALUE;
5025 case PM_EMBEDDED_VARIABLE_NODE:
5026 // Embedded variables clear static literal, which means we also
5027 // should clear the mutability flags.
5029 flags &= (pm_node_flags_t) ~PM_INTERPOLATED_STRING_NODE_FLAGS_STATIC_VALUE;
5031 case PM_X_STRING_NODE:
5032 case PM_INTERPOLATED_X_STRING_NODE:
5033 case PM_SYMBOL_NODE:
5034 case PM_INTERPOLATED_SYMBOL_NODE:
5035 // These will only happen in error cases. But we want to handle it
5036 // here so that we don't fail the assertion.
5038 flags &= (pm_node_flags_t) ~PM_INTERPOLATED_STRING_NODE_FLAGS_STATIC_VALUE;
5039 parts->nodes[idx] = UP(pm_error_recovery_node_create_unexpected(parser, part));
5041 case PM_ERROR_RECOVERY_NODE:
5043 flags &= (pm_node_flags_t) ~PM_INTERPOLATED_STRING_NODE_FLAGS_STATIC_VALUE;
5046 PRISM_ASSERT(false && "unexpected node type");
5051 return pm_interpolated_string_node_new(
5056 NTOK2LOC(parser, opening),
5058 NTOK2LOC(parser, closing)
5069static pm_interpolated_symbol_node_t *
5070pm_interpolated_symbol_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_node_list_t *parts, const pm_token_t *closing) {
5071 pm_node_list_finalize(&parser->node_chunks, parser->arena, parts);
5073 pm_node_flags_t flags = PM_NODE_FLAG_STATIC_LITERAL;
5074 for (size_t idx = 0; idx < parts->size; ++idx) {
5075 pm_interpolated_part_flags(&flags, parts->nodes[idx]);
5078 return pm_interpolated_symbol_node_new(
5082 pm_interpolated_location(parser, opening, parts, closing),
5083 NTOK2LOC(parser, opening),
5085 NTOK2LOC(parser, closing)
5094static pm_interpolated_x_string_node_t *
5095pm_interpolated_xstring_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_node_list_t *parts, const pm_token_t *closing) {
5096 pm_node_list_finalize(&parser->node_chunks, parser->arena, parts);
5098 pm_node_flags_t flags = 0;
5099 for (size_t idx = 0; idx < parts->size; ++idx) {
5100 pm_interpolated_part_flags(&flags, parts->nodes[idx]);
5103 return pm_interpolated_x_string_node_new(
5107 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
5108 TOK2LOC(parser, opening),
5110 TOK2LOC(parser, closing)
5117static pm_it_local_variable_read_node_t *
5118pm_it_local_variable_read_node_create(pm_parser_t *parser, const pm_token_t *name) {
5119 return pm_it_local_variable_read_node_new(
5123 PM_LOCATION_INIT_TOKEN(parser, name)
5130static pm_it_parameters_node_t *
5131pm_it_parameters_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *closing) {
5132 return pm_it_parameters_node_new(
5136 PM_LOCATION_INIT_TOKENS(parser, opening, closing)
5143static pm_keyword_hash_node_t *
5144pm_keyword_hash_node_create(pm_parser_t *parser, pm_hash_elements_t *elements) {
5145 pm_node_list_t *nodes = &elements->nodes;
5146 pm_node_list_finalize(&parser->node_chunks, parser->arena, nodes);
5151 if (nodes->size > 0) {
5152 start = PM_NODE_START(nodes->nodes[0]);
5153 end = PM_NODE_END(nodes->nodes[nodes->size - 1]);
5156 return pm_keyword_hash_node_new(
5159 elements->non_symbol_keys ? 0 : PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS,
5160 PM_LOCATION_INIT_BOUNDS(start, end),
5168static pm_required_keyword_parameter_node_t *
5169pm_required_keyword_parameter_node_create(pm_parser_t *parser, const pm_token_t *name) {
5170 return pm_required_keyword_parameter_node_new(
5174 PM_LOCATION_INIT_TOKEN(parser, name),
5175 pm_parser_constant_id_raw(parser, name->start, name->end - 1),
5176 TOK2LOC(parser, name)
5183static pm_optional_keyword_parameter_node_t *
5184pm_optional_keyword_parameter_node_create(pm_parser_t *parser, const pm_token_t *name, pm_node_t *value) {
5185 return pm_optional_keyword_parameter_node_new(
5189 PM_LOCATION_INIT_TOKEN_NODE(parser, name, value),
5190 pm_parser_constant_id_raw(parser, name->start, name->end - 1),
5191 TOK2LOC(parser, name),
5199static pm_keyword_rest_parameter_node_t *
5200pm_keyword_rest_parameter_node_create(pm_parser_t *parser, const pm_token_t *operator, const pm_token_t *name) {
5201 return pm_keyword_rest_parameter_node_new(
5205 (name == NULL) ? PM_LOCATION_INIT_TOKEN(parser, operator) : PM_LOCATION_INIT_TOKENS(parser, operator, name),
5206 name == NULL ? 0 : pm_parser_constant_id_token(parser, name),
5207 NTOK2LOC(parser, name),
5208 TOK2LOC(parser, operator)
5215static pm_lambda_node_t *
5216pm_lambda_node_create(
5217 pm_parser_t *parser,
5218 pm_constant_id_list_t *locals,
5219 const pm_token_t *operator,
5220 const pm_token_t *opening,
5221 const pm_token_t *closing,
5222 pm_node_t *parameters,
5225 return pm_lambda_node_new(
5229 PM_LOCATION_INIT_TOKENS(parser, operator, closing),
5231 TOK2LOC(parser, operator),
5232 TOK2LOC(parser, opening),
5233 TOK2LOC(parser, closing),
5242static pm_local_variable_and_write_node_t *
5243pm_local_variable_and_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value, pm_constant_id_t name, uint32_t depth) {
5244 PRISM_ASSERT(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_READ_NODE) || PM_NODE_TYPE_P(target, PM_IT_LOCAL_VARIABLE_READ_NODE) || PM_NODE_TYPE_P(target, PM_CALL_NODE));
5245 PRISM_ASSERT(operator->type == PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
5247 return pm_local_variable_and_write_node_new(
5251 PM_LOCATION_INIT_NODES(target, value),
5253 TOK2LOC(parser, operator),
5263static pm_local_variable_operator_write_node_t *
5264pm_local_variable_operator_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value, pm_constant_id_t name, uint32_t depth) {
5265 return pm_local_variable_operator_write_node_new(
5269 PM_LOCATION_INIT_NODES(target, value),
5271 TOK2LOC(parser, operator),
5274 pm_parser_constant_id_raw(parser, operator->start, operator->end - 1),
5282static pm_local_variable_or_write_node_t *
5283pm_local_variable_or_write_node_create(pm_parser_t *parser, pm_node_t *target, const pm_token_t *operator, pm_node_t *value, pm_constant_id_t name, uint32_t depth) {
5284 PRISM_ASSERT(PM_NODE_TYPE_P(target, PM_LOCAL_VARIABLE_READ_NODE) || PM_NODE_TYPE_P(target, PM_IT_LOCAL_VARIABLE_READ_NODE) || PM_NODE_TYPE_P(target, PM_CALL_NODE));
5285 PRISM_ASSERT(operator->type == PM_TOKEN_PIPE_PIPE_EQUAL);
5287 return pm_local_variable_or_write_node_new(
5291 PM_LOCATION_INIT_NODES(target, value),
5293 TOK2LOC(parser, operator),
5303static pm_local_variable_read_node_t *
5304pm_local_variable_read_node_create_constant_id(pm_parser_t *parser, const pm_token_t *name, pm_constant_id_t name_id, uint32_t depth, bool missing) {
5306 PRISM_ASSERT(pm_parser_local_depth_constant_id(parser, name_id) == (int) depth);
5307 pm_locals_read(parser, name_id);
5310 return pm_local_variable_read_node_new(
5314 PM_LOCATION_INIT_TOKEN(parser, name),
5323static pm_local_variable_read_node_t *
5324pm_local_variable_read_node_create(pm_parser_t *parser, const pm_token_t *name, uint32_t depth) {
5325 pm_constant_id_t name_id = pm_parser_constant_id_token(parser, name);
5326 return pm_local_variable_read_node_create_constant_id(parser, name, name_id, depth, false);
5333static pm_local_variable_read_node_t *
5334pm_local_variable_read_node_missing_create(pm_parser_t *parser, const pm_token_t *name, uint32_t depth) {
5335 pm_constant_id_t name_id = pm_parser_constant_id_token(parser, name);
5336 return pm_local_variable_read_node_create_constant_id(parser, name, name_id, depth, true);
5342static pm_local_variable_write_node_t *
5343pm_local_variable_write_node_create(pm_parser_t *parser, pm_constant_id_t name, uint32_t depth, pm_node_t *value, const pm_location_t *name_loc, const pm_token_t *operator) {
5344 return pm_local_variable_write_node_new(
5347 pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
5348 ((pm_location_t) { .start = name_loc->start, .length = PM_NODE_END(value) - name_loc->start }),
5353 TOK2LOC(parser, operator)
5360static PRISM_INLINE bool
5361pm_token_is_it(const uint8_t *start, const uint8_t *end) {
5362 return (end - start == 2) && (start[0] == 'i') && (start[1] == 't');
5369static PRISM_INLINE bool
5370pm_token_is_numbered_parameter(const pm_parser_t *parser, uint32_t start, uint32_t length) {
5373 (parser->start[start] == '_') &&
5374 (parser->start[start + 1] != '0') &&
5375 pm_char_is_decimal_digit(parser->start[start + 1])
5383static PRISM_INLINE void
5384pm_refute_numbered_parameter(pm_parser_t *parser, uint32_t start, uint32_t length) {
5385 if (pm_token_is_numbered_parameter(parser, start, length)) {
5386 PM_PARSER_ERR_FORMAT(parser, start, length, PM_ERR_PARAMETER_NUMBERED_RESERVED, parser->start + start);
5394static pm_local_variable_target_node_t *
5395pm_local_variable_target_node_create(pm_parser_t *parser, const pm_location_t *location, pm_constant_id_t name, uint32_t depth) {
5396 pm_refute_numbered_parameter(parser, location->start, location->length);
5398 return pm_local_variable_target_node_new(
5402 ((pm_location_t) { .start = location->start, .length = location->length }),
5411static pm_match_predicate_node_t *
5412pm_match_predicate_node_create(pm_parser_t *parser, pm_node_t *value, pm_node_t *pattern, const pm_token_t *operator) {
5413 pm_assert_value_expression(parser, value);
5415 return pm_match_predicate_node_new(
5419 PM_LOCATION_INIT_NODES(value, pattern),
5422 TOK2LOC(parser, operator)
5429static pm_match_required_node_t *
5430pm_match_required_node_create(pm_parser_t *parser, pm_node_t *value, pm_node_t *pattern, const pm_token_t *operator) {
5431 pm_assert_value_expression(parser, value);
5433 return pm_match_required_node_new(
5437 PM_LOCATION_INIT_NODES(value, pattern),
5440 TOK2LOC(parser, operator)
5447static pm_match_write_node_t *
5448pm_match_write_node_create(pm_parser_t *parser, pm_call_node_t *call, pm_node_list_t *targets) {
5449 pm_node_list_finalize(&parser->node_chunks, parser->arena, targets);
5451 return pm_match_write_node_new(
5455 PM_LOCATION_INIT_NODE(call),
5464static pm_module_node_t *
5465pm_module_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *module_keyword, pm_node_t *constant_path, const pm_token_t *name, pm_node_t *body, const pm_token_t *end_keyword) {
5466 pm_constant_id_list_t module_locals = { .ids = NULL, .size = 0 };
5467 if (locals != NULL) module_locals = *locals;
5469 return pm_module_node_new(
5473 PM_LOCATION_INIT_TOKENS(parser, module_keyword, end_keyword),
5475 TOK2LOC(parser, module_keyword),
5478 TOK2LOC(parser, end_keyword),
5479 pm_parser_constant_id_token(parser, name)
5488 /* The open list of every target, including the rests. */
5489 pm_node_list_t nodes;
5491 /* The first splat or implicit rest, or NULL if there has not been one. */
5494 /* The index of the first rest in nodes, which is only set with rest. */
5495 uint32_t rest_index;
5496} pm_multi_targets_t;
5503pm_multi_targets_append(pm_parser_t *parser, pm_multi_targets_t *targets, pm_node_t *target) {
5504 if (PM_NODE_TYPE_P(target, PM_SPLAT_NODE) || PM_NODE_TYPE_P(target, PM_IMPLICIT_REST_NODE)) {
5505 if (targets->rest == NULL) {
5506 targets->rest = target;
5507 targets->rest_index = targets->nodes.size;
5508 } else if (PM_NODE_TYPE_P(target, PM_SPLAT_NODE)) {
5509 pm_parser_err_node(parser, target, PM_ERR_MULTI_ASSIGN_MULTI_SPLATS);
5511 PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, &parser->current, PM_ERR_MULTI_ASSIGN_UNEXPECTED_REST);
5515 pm_node_list_open_append(&parser->node_chunks, &targets->nodes, target);
5523static pm_multi_target_node_t *
5524pm_multi_target_node_create(pm_parser_t *parser, pm_multi_targets_t *targets, const pm_token_t *lparen, const pm_token_t *rparen) {
5525 pm_node_list_t *nodes = &targets->nodes;
5526 pm_node_list_finalize(&parser->node_chunks, parser->arena, nodes);
5527 PRISM_ASSERT(nodes->size > 0);
5529 pm_node_list_t lefts = *nodes;
5530 pm_node_list_t rights = { 0 };
5532 if (targets->rest != NULL) {
5533 lefts = pm_node_list_slice(nodes, 0, targets->rest_index);
5534 rights = pm_node_list_slice(nodes, targets->rest_index + 1, nodes->size - targets->rest_index - 1);
5537 pm_location_t location;
5538 if (lparen != NULL) {
5539 PRISM_ASSERT(rparen != NULL);
5540 location = PM_LOCATION_INIT_TOKENS(parser, lparen, rparen);
5542 location = PM_LOCATION_INIT_NODES(nodes->nodes[0], nodes->nodes[nodes->size - 1]);
5545 return pm_multi_target_node_new(
5553 NTOK2LOC(parser, lparen),
5554 NTOK2LOC(parser, rparen)
5561static pm_multi_write_node_t *
5562pm_multi_write_node_create(pm_parser_t *parser, pm_multi_target_node_t *target, const pm_token_t *operator, pm_node_t *value) {
5563 /* The target is no longer necessary because we have reused its children. It
5564 * is arena-allocated so no explicit free is needed. */
5565 return pm_multi_write_node_new(
5568 pm_implicit_array_write_flags(value, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY),
5569 PM_LOCATION_INIT_NODES(target, value),
5575 TOK2LOC(parser, operator),
5583static pm_next_node_t *
5584pm_next_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_node_t *arguments) {
5585 PRISM_ASSERT(keyword->type == PM_TOKEN_KEYWORD_NEXT);
5587 return pm_next_node_new(
5591 (arguments == NULL) ? PM_LOCATION_INIT_TOKEN(parser, keyword) : PM_LOCATION_INIT_TOKEN_NODE(parser, keyword, arguments),
5593 TOK2LOC(parser, keyword)
5600static pm_nil_node_t *
5601pm_nil_node_create(pm_parser_t *parser, const pm_token_t *token) {
5602 PRISM_ASSERT(token->type == PM_TOKEN_KEYWORD_NIL);
5604 return pm_nil_node_new(
5607 PM_NODE_FLAG_STATIC_LITERAL,
5608 PM_LOCATION_INIT_TOKEN(parser, token)
5615static pm_no_block_parameter_node_t *
5616pm_no_block_parameter_node_create(pm_parser_t *parser, const pm_token_t *operator, const pm_token_t *keyword) {
5617 PRISM_ASSERT(operator->type == PM_TOKEN_AMPERSAND || operator->type == PM_TOKEN_UAMPERSAND);
5618 PRISM_ASSERT(keyword->type == PM_TOKEN_KEYWORD_NIL);
5620 return pm_no_block_parameter_node_new(
5624 PM_LOCATION_INIT_TOKENS(parser, operator, keyword),
5625 TOK2LOC(parser, operator),
5626 TOK2LOC(parser, keyword)
5633static pm_no_keywords_parameter_node_t *
5634pm_no_keywords_parameter_node_create(pm_parser_t *parser, const pm_token_t *operator, const pm_token_t *keyword) {
5635 PRISM_ASSERT(operator->type == PM_TOKEN_USTAR_STAR || operator->type == PM_TOKEN_STAR_STAR);
5636 PRISM_ASSERT(keyword->type == PM_TOKEN_KEYWORD_NIL);
5638 return pm_no_keywords_parameter_node_new(
5642 PM_LOCATION_INIT_TOKENS(parser, operator, keyword),
5643 TOK2LOC(parser, operator),
5644 TOK2LOC(parser, keyword)
5651static pm_numbered_parameters_node_t *
5652pm_numbered_parameters_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *closing, uint8_t maximum) {
5653 return pm_numbered_parameters_node_new(
5657 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
5669pm_numbered_reference_read_node_number(pm_parser_t *parser, const pm_token_t *token) {
5674#define NTH_REF_MAX ((uint64_t) (uint32_t) (INT_MAX >> 1))
5676 const uint8_t *start = token->start + 1;
5677 ptrdiff_t diff = token->end - start;
5678 PRISM_ASSERT(diff > 0);
5680 size_t length = (size_t) diff;
5683 for (size_t idx = 0; idx < length; ++idx) {
5684 value = value * 10 + (uint64_t) (start[idx] - '0');
5686 if (value > NTH_REF_MAX) {
5687 PM_PARSER_WARN_FORMAT(parser, U32(start - parser->start), U32(length), PM_WARN_INVALID_NUMBERED_REFERENCE, (int) (length + 1), (const char *) token->start);
5693 return (uint32_t) value;
5701static pm_numbered_reference_read_node_t *
5702pm_numbered_reference_read_node_create(pm_parser_t *parser, const pm_token_t *name) {
5703 PRISM_ASSERT(name->type == PM_TOKEN_NUMBERED_REFERENCE);
5705 return pm_numbered_reference_read_node_new(
5709 PM_LOCATION_INIT_TOKEN(parser, name),
5710 pm_numbered_reference_read_node_number(parser, name)
5717static pm_optional_parameter_node_t *
5718pm_optional_parameter_node_create(pm_parser_t *parser, const pm_token_t *name, const pm_token_t *operator, pm_node_t *value) {
5719 return pm_optional_parameter_node_new(
5723 PM_LOCATION_INIT_TOKEN_NODE(parser, name, value),
5724 pm_parser_constant_id_token(parser, name),
5725 TOK2LOC(parser, name),
5726 TOK2LOC(parser, operator),
5734static pm_or_node_t *
5735pm_or_node_create(pm_parser_t *parser, pm_node_t *left, const pm_token_t *operator, pm_node_t *right) {
5736 pm_assert_value_expression(parser, left);
5738 return pm_or_node_new(
5742 PM_LOCATION_INIT_NODES(left, right),
5745 TOK2LOC(parser, operator)
5754 /* The location covering every parameter added so far. */
5755 pm_location_t location;
5757 /* The required parameters before any optional or rest parameter. */
5758 pm_node_list_t requireds;
5760 /* The optional parameters. */
5761 pm_node_list_t optionals;
5763 /* The rest parameter, or NULL if there is not one. */
5766 /* The required parameters after an optional or rest parameter. */
5767 pm_node_list_t posts;
5769 /* The keyword parameters. */
5770 pm_node_list_t keywords;
5772 /* The keyword rest parameter, or NULL if there is not one. */
5773 pm_node_t *keyword_rest;
5775 /* The block parameter, or NULL if there is not one. */
5785pm_parameters_location_extend(pm_parameters_t *params, const pm_node_t *param) {
5786 params->location = params->location.length == 0
5788 : pm_location_join(params->location, param->location);
5795pm_parameters_requireds_append(pm_parser_t *parser, pm_parameters_t *params, pm_node_t *param) {
5796 pm_parameters_location_extend(params, param);
5797 pm_node_list_open_append(&parser->node_chunks, ¶ms->requireds, param);
5804pm_parameters_optionals_append(pm_parser_t *parser, pm_parameters_t *params, pm_optional_parameter_node_t *param) {
5805 pm_parameters_location_extend(params, UP(param));
5806 pm_node_list_open_append(&parser->node_chunks, ¶ms->optionals, UP(param));
5813pm_parameters_posts_append(pm_parser_t *parser, pm_parameters_t *params, pm_node_t *param) {
5814 pm_parameters_location_extend(params, param);
5815 pm_node_list_open_append(&parser->node_chunks, ¶ms->posts, param);
5822pm_parameters_rest_set(pm_parameters_t *params, pm_node_t *param) {
5823 pm_parameters_location_extend(params, param);
5824 params->rest = param;
5831pm_parameters_keywords_append(pm_parser_t *parser, pm_parameters_t *params, pm_node_t *param) {
5832 pm_parameters_location_extend(params, param);
5833 pm_node_list_open_append(&parser->node_chunks, ¶ms->keywords, param);
5840pm_parameters_keyword_rest_set(pm_parameters_t *params, pm_node_t *param) {
5841 PRISM_ASSERT(params->keyword_rest == NULL);
5842 pm_parameters_location_extend(params, param);
5843 params->keyword_rest = param;
5850pm_parameters_block_set(pm_parameters_t *params, pm_node_t *param) {
5851 PRISM_ASSERT(params->block == NULL);
5852 pm_parameters_location_extend(params, param);
5853 params->block = param;
5859static pm_parameters_node_t *
5860pm_parameters_node_create(pm_parser_t *parser, pm_parameters_t *params) {
5861 pm_node_list_finalize(&parser->node_chunks, parser->arena, ¶ms->requireds);
5862 pm_node_list_finalize(&parser->node_chunks, parser->arena, ¶ms->optionals);
5863 pm_node_list_finalize(&parser->node_chunks, parser->arena, ¶ms->posts);
5864 pm_node_list_finalize(&parser->node_chunks, parser->arena, ¶ms->keywords);
5866 return pm_parameters_node_new(
5876 params->keyword_rest,
5884static pm_program_node_t *
5885pm_program_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, pm_statements_node_t *statements) {
5886 return pm_program_node_new(
5890 PM_LOCATION_INIT_NODE(statements),
5899static pm_parentheses_node_t *
5900pm_parentheses_node_create(pm_parser_t *parser, const pm_token_t *opening, pm_node_t *body, const pm_token_t *closing, pm_node_flags_t flags) {
5901 return pm_parentheses_node_new(
5905 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
5907 TOK2LOC(parser, opening),
5908 TOK2LOC(parser, closing)
5915static pm_pinned_expression_node_t *
5916pm_pinned_expression_node_create(pm_parser_t *parser, pm_node_t *expression, const pm_token_t *operator, const pm_token_t *lparen, const pm_token_t *rparen) {
5917 return pm_pinned_expression_node_new(
5921 PM_LOCATION_INIT_TOKENS(parser, operator, rparen),
5923 TOK2LOC(parser, operator),
5924 TOK2LOC(parser, lparen),
5925 TOK2LOC(parser, rparen)
5932static pm_pinned_variable_node_t *
5933pm_pinned_variable_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *variable) {
5934 return pm_pinned_variable_node_new(
5938 PM_LOCATION_INIT_TOKEN_NODE(parser, operator, variable),
5940 TOK2LOC(parser, operator)
5947static pm_post_execution_node_t *
5948pm_post_execution_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *opening, pm_statements_node_t *statements, const pm_token_t *closing) {
5949 return pm_post_execution_node_new(
5953 PM_LOCATION_INIT_TOKENS(parser, keyword, closing),
5955 TOK2LOC(parser, keyword),
5956 TOK2LOC(parser, opening),
5957 TOK2LOC(parser, closing)
5964static pm_pre_execution_node_t *
5965pm_pre_execution_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *opening, pm_statements_node_t *statements, const pm_token_t *closing) {
5966 return pm_pre_execution_node_new(
5970 PM_LOCATION_INIT_TOKENS(parser, keyword, closing),
5972 TOK2LOC(parser, keyword),
5973 TOK2LOC(parser, opening),
5974 TOK2LOC(parser, closing)
5981static pm_range_node_t *
5982pm_range_node_create(pm_parser_t *parser, pm_node_t *left, const pm_token_t *operator, pm_node_t *right) {
5983 pm_assert_value_expression(parser, left);
5984 pm_assert_value_expression(parser, right);
5985 pm_node_flags_t flags = 0;
5987 // Indicate that this node is an exclusive range if the operator is `...`.
5988 if (operator->type == PM_TOKEN_DOT_DOT_DOT || operator->type == PM_TOKEN_UDOT_DOT_DOT) {
5989 flags |= PM_RANGE_FLAGS_EXCLUDE_END;
5992 // Indicate that this node is a static literal (i.e., can be compiled with
5993 // a putobject in CRuby) if the left and right are implicit nil, explicit
5994 // nil, or integers.
5996 (left == NULL || PM_NODE_TYPE_P(left, PM_NIL_NODE) || PM_NODE_TYPE_P(left, PM_INTEGER_NODE)) &&
5997 (right == NULL || PM_NODE_TYPE_P(right, PM_NIL_NODE) || PM_NODE_TYPE_P(right, PM_INTEGER_NODE))
5999 flags |= PM_NODE_FLAG_STATIC_LITERAL;
6002 uint32_t start = left == NULL ? PM_TOKEN_START(parser, operator) : PM_NODE_START(left);
6003 uint32_t end = right == NULL ? PM_TOKEN_END(parser, operator) : PM_NODE_END(right);
6005 return pm_range_node_new(
6009 ((pm_location_t) { .start = start, .length = U32(end - start) }),
6012 TOK2LOC(parser, operator)
6019static pm_redo_node_t *
6020pm_redo_node_create(pm_parser_t *parser, const pm_token_t *token) {
6021 PRISM_ASSERT(token->type == PM_TOKEN_KEYWORD_REDO);
6023 return pm_redo_node_new(
6027 PM_LOCATION_INIT_TOKEN(parser, token)
6035static pm_regular_expression_node_t *
6036pm_regular_expression_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing, const pm_string_t *unescaped) {
6037 return pm_regular_expression_node_new(
6040 pm_regular_expression_flags_create(parser, closing) | PM_NODE_FLAG_STATIC_LITERAL,
6041 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
6042 TOK2LOC(parser, opening),
6043 TOK2LOC(parser, content),
6044 TOK2LOC(parser, closing),
6052static PRISM_INLINE pm_regular_expression_node_t *
6053pm_regular_expression_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing) {
6054 return pm_regular_expression_node_create_unescaped(parser, opening, content, closing, &PM_STRING_EMPTY);
6060static pm_required_parameter_node_t *
6061pm_required_parameter_node_create(pm_parser_t *parser, const pm_token_t *token) {
6062 return pm_required_parameter_node_new(
6066 PM_LOCATION_INIT_TOKEN(parser, token),
6067 pm_parser_constant_id_token(parser, token)
6074static pm_rescue_modifier_node_t *
6075pm_rescue_modifier_node_create(pm_parser_t *parser, pm_node_t *expression, const pm_token_t *keyword, pm_node_t *rescue_expression) {
6076 return pm_rescue_modifier_node_new(
6080 PM_LOCATION_INIT_NODES(expression, rescue_expression),
6082 TOK2LOC(parser, keyword),
6090static pm_rescue_node_t *
6091pm_rescue_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_list_t *exceptions, const pm_token_t *operator, pm_node_t *reference, const pm_token_t *then_keyword, pm_statements_node_t *statements) {
6092 pm_node_list_finalize(&parser->node_chunks, parser->arena, exceptions);
6094 uint32_t start = PM_TOKEN_START(parser, keyword);
6095 uint32_t end = PM_TOKEN_END(parser, keyword);
6097 if (exceptions->size > 0) end = PM_NODE_END(exceptions->nodes[exceptions->size - 1]);
6098 if (reference != NULL) end = PM_NODE_END(reference);
6099 if (statements != NULL && pm_statements_node_body_length(statements) > 0) end = PM_NODE_END(statements);
6101 return pm_rescue_node_new(
6105 PM_LOCATION_INIT_BOUNDS(start, end),
6106 TOK2LOC(parser, keyword),
6108 NTOK2LOC(parser, operator),
6110 NTOK2LOC(parser, then_keyword),
6120pm_rescue_node_subsequent_set(pm_rescue_node_t *node, pm_rescue_node_t *subsequent) {
6121 node->subsequent = subsequent;
6122 PM_NODE_LENGTH_SET_NODE(node, subsequent);
6128static pm_rest_parameter_node_t *
6129pm_rest_parameter_node_create(pm_parser_t *parser, const pm_token_t *operator, const pm_token_t *name) {
6130 return pm_rest_parameter_node_new(
6134 (name == NULL) ? PM_LOCATION_INIT_TOKEN(parser, operator) : PM_LOCATION_INIT_TOKENS(parser, operator, name),
6135 name == NULL ? 0 : pm_parser_constant_id_token(parser, name),
6136 NTOK2LOC(parser, name),
6137 TOK2LOC(parser, operator)
6144static pm_retry_node_t *
6145pm_retry_node_create(pm_parser_t *parser, const pm_token_t *token) {
6146 PRISM_ASSERT(token->type == PM_TOKEN_KEYWORD_RETRY);
6148 return pm_retry_node_new(
6152 PM_LOCATION_INIT_TOKEN(parser, token)
6159static pm_return_node_t *
6160pm_return_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_node_t *arguments) {
6161 return pm_return_node_new(
6165 (arguments == NULL) ? PM_LOCATION_INIT_TOKEN(parser, keyword) : PM_LOCATION_INIT_TOKEN_NODE(parser, keyword, arguments),
6166 TOK2LOC(parser, keyword),
6174static pm_self_node_t *
6175pm_self_node_create(pm_parser_t *parser, const pm_token_t *token) {
6176 PRISM_ASSERT(token->type == PM_TOKEN_KEYWORD_SELF);
6178 return pm_self_node_new(
6182 PM_LOCATION_INIT_TOKEN(parser, token)
6189static pm_shareable_constant_node_t *
6190pm_shareable_constant_node_create(pm_parser_t *parser, pm_node_t *write, pm_shareable_constant_value_t value) {
6191 return pm_shareable_constant_node_new(
6194 (pm_node_flags_t) value,
6195 PM_LOCATION_INIT_NODE(write),
6203static pm_singleton_class_node_t *
6204pm_singleton_class_node_create(pm_parser_t *parser, pm_constant_id_list_t *locals, const pm_token_t *class_keyword, const pm_token_t *operator, pm_node_t *expression, pm_node_t *body, const pm_token_t *end_keyword) {
6205 return pm_singleton_class_node_new(
6209 PM_LOCATION_INIT_TOKENS(parser, class_keyword, end_keyword),
6211 TOK2LOC(parser, class_keyword),
6212 TOK2LOC(parser, operator),
6215 TOK2LOC(parser, end_keyword)
6222static pm_source_encoding_node_t *
6223pm_source_encoding_node_create(pm_parser_t *parser, const pm_token_t *token) {
6224 PRISM_ASSERT(token->type == PM_TOKEN_KEYWORD___ENCODING__);
6226 return pm_source_encoding_node_new(
6229 PM_NODE_FLAG_STATIC_LITERAL,
6230 PM_LOCATION_INIT_TOKEN(parser, token)
6237static pm_source_file_node_t*
6238pm_source_file_node_create(pm_parser_t *parser, const pm_token_t *file_keyword) {
6239 PRISM_ASSERT(file_keyword->type == PM_TOKEN_KEYWORD___FILE__);
6241 pm_node_flags_t flags = 0;
6243 switch (parser->frozen_string_literal) {
6244 case PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED:
6245 flags |= PM_STRING_FLAGS_MUTABLE;
6247 case PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED:
6248 flags |= PM_STRING_FLAGS_FROZEN;
6249 if (parser->version < PM_OPTIONS_VERSION_CRUBY_4_1) {
6250 flags |= PM_NODE_FLAG_STATIC_LITERAL;
6255 return pm_source_file_node_new(
6259 PM_LOCATION_INIT_TOKEN(parser, file_keyword),
6267static pm_source_line_node_t *
6268pm_source_line_node_create(pm_parser_t *parser, const pm_token_t *token) {
6269 PRISM_ASSERT(token->type == PM_TOKEN_KEYWORD___LINE__);
6271 return pm_source_line_node_new(
6274 PM_NODE_FLAG_STATIC_LITERAL,
6275 PM_LOCATION_INIT_TOKEN(parser, token)
6282static pm_splat_node_t *
6283pm_splat_node_create(pm_parser_t *parser, const pm_token_t *operator, pm_node_t *expression) {
6284 return pm_splat_node_new(
6288 (expression == NULL) ? PM_LOCATION_INIT_TOKEN(parser, operator) : PM_LOCATION_INIT_TOKEN_NODE(parser, operator, expression),
6289 TOK2LOC(parser, operator),
6298pm_statements_unreachable_check(pm_parser_t *parser, const pm_node_t *previous, pm_node_t *statement) {
6299 switch (PM_NODE_TYPE(previous)) {
6304 case PM_RETURN_NODE:
6305 pm_parser_warn_node(parser, statement, PM_WARN_UNREACHABLE_STATEMENT);
6317 pm_node_list_t nodes;
6324 pm_location_t location;
6327 pm_node_flags_t flags;
6335pm_statements_body_append(pm_parser_t *parser, pm_statements_t *body, pm_node_t *statement, bool newline) {
6336 body->location = body->nodes.size == 0
6337 ? statement->location
6338 : pm_location_join(body->location, statement->location);
6340 if (body->nodes.size > 0) pm_statements_unreachable_check(parser, pm_node_list_open_last(&body->nodes), statement);
6341 pm_node_list_open_append(&parser->node_chunks, &body->nodes, statement);
6342 if (PM_NODE_TYPE_P(statement, PM_PRE_EXECUTION_NODE)) body->flags |= PM_STATEMENTS_FLAGS_CONTAINS_PRE_EXECUTION;
6343 if (newline) pm_node_flag_set(statement, PM_NODE_FLAG_NEWLINE);
6349static pm_statements_node_t *
6350pm_statements_node_create(pm_parser_t *parser, pm_statements_t *body) {
6351 pm_node_list_finalize(&parser->node_chunks, parser->arena, &body->nodes);
6353 return pm_statements_node_new(
6365static pm_statements_node_t *
6366pm_statements_node_single_create(pm_parser_t *parser, pm_node_t *statement, bool newline) {
6367 if (newline) pm_node_flag_set(statement, PM_NODE_FLAG_NEWLINE);
6369 return pm_statements_node_new(
6372 PM_NODE_TYPE_P(statement, PM_PRE_EXECUTION_NODE) ? PM_STATEMENTS_FLAGS_CONTAINS_PRE_EXECUTION : 0,
6373 PM_LOCATION_INIT_NODE(statement),
6374 pm_node_list_single(parser->arena, statement)
6382pm_statements_node_body_length(pm_statements_node_t *node) {
6383 return node && node->body.size;
6390static PRISM_INLINE void
6391pm_statements_node_body_update(pm_statements_node_t *node, pm_node_t *statement) {
6392 node->base.location = pm_statements_node_body_length(node) == 0
6393 ? statement->location
6394 : pm_location_join(node->base.location, statement->location);
6395 if (PM_NODE_TYPE_P(statement, PM_PRE_EXECUTION_NODE)) pm_node_flag_set(UP(node), PM_STATEMENTS_FLAGS_CONTAINS_PRE_EXECUTION);
6402pm_statements_node_body_append(pm_parser_t *parser, pm_statements_node_t *node, pm_node_t *statement) {
6403 pm_statements_node_body_update(node, statement);
6404 if (node->body.size > 0) pm_statements_unreachable_check(parser, node->body.nodes[node->body.size - 1], statement);
6406 pm_node_list_append(parser->arena, &node->body, statement);
6407 pm_node_flag_set(statement, PM_NODE_FLAG_NEWLINE);
6414pm_statements_node_body_prepend(pm_arena_t *arena, pm_statements_node_t *node, pm_node_t *statement) {
6415 pm_statements_node_body_update(node, statement);
6416 pm_node_list_prepend_finalized(arena, &node->body, statement);
6417 pm_node_flag_set(statement, PM_NODE_FLAG_NEWLINE);
6423static PRISM_INLINE pm_string_node_t *
6424pm_string_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing, const pm_string_t *string) {
6425 pm_node_flags_t flags = 0;
6427 switch (parser->frozen_string_literal) {
6428 case PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED:
6429 flags = PM_STRING_FLAGS_MUTABLE;
6431 case PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED:
6432 flags = PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN;
6436 uint32_t start = PM_TOKEN_START(parser, opening == NULL ? content : opening);
6437 uint32_t end = PM_TOKEN_END(parser, closing == NULL ? content : closing);
6439 return pm_string_node_new(
6443 ((pm_location_t) { .start = start, .length = U32(end - start) }),
6444 NTOK2LOC(parser, opening),
6445 TOK2LOC(parser, content),
6446 NTOK2LOC(parser, closing),
6454static pm_string_node_t *
6455pm_string_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing) {
6456 return pm_string_node_create_unescaped(parser, opening, content, closing, &PM_STRING_EMPTY);
6463static pm_string_node_t *
6464pm_string_node_create_current_string(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing) {
6465 pm_string_node_t *node = pm_string_node_create_unescaped(parser, opening, content, closing, &parser->current_string);
6466 parser->current_string = PM_STRING_EMPTY;
6473static pm_super_node_t *
6474pm_super_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_arguments_t *arguments) {
6475 PRISM_ASSERT(keyword->type == PM_TOKEN_KEYWORD_SUPER);
6477 const pm_location_t *end = pm_arguments_end(arguments);
6478 PRISM_ASSERT(end != NULL && "unreachable");
6480 return pm_super_node_new(
6484 ((pm_location_t) { .start = PM_TOKEN_START(parser, keyword), .length = PM_LOCATION_END(end) - PM_TOKEN_START(parser, keyword) }),
6485 TOK2LOC(parser, keyword),
6486 arguments->opening_loc,
6487 pm_arguments_node_create(parser, arguments),
6488 arguments->closing_loc,
6497parse_symbol_encoding_validate_utf8(pm_parser_t *parser, const pm_token_t *location, const pm_string_t *contents) {
6498 for (const uint8_t *cursor = pm_string_source(contents), *end = cursor + pm_string_length(contents); cursor < end;) {
6499 size_t width = pm_encoding_utf_8_char_width(cursor, end - cursor);
6502 pm_parser_err(parser, PM_TOKEN_START(parser, location), PM_TOKEN_LENGTH(location), PM_ERR_INVALID_SYMBOL);
6515parse_symbol_encoding_validate_other(pm_parser_t *parser, const pm_token_t *location, const pm_string_t *contents) {
6516 const pm_encoding_t *encoding = parser->encoding;
6518 for (const uint8_t *cursor = pm_string_source(contents), *end = cursor + pm_string_length(contents); cursor < end;) {
6519 size_t width = pm_encoding_char_width(encoding, cursor, end - cursor);
6522 pm_parser_err(parser, PM_TOKEN_START(parser, location), PM_TOKEN_LENGTH(location), PM_ERR_INVALID_SYMBOL);
6539static PRISM_INLINE pm_node_flags_t
6540parse_symbol_encoding(pm_parser_t *parser, const pm_encoding_t *explicit_encoding, const pm_token_t *location, const pm_string_t *contents, bool validate) {
6541 if (explicit_encoding != NULL) {
6542 // A Symbol may optionally have its encoding explicitly set. This will
6543 // happen if an escape sequence results in a non-ASCII code point.
6544 if (explicit_encoding == PM_ENCODING_UTF_8_ENTRY) {
6545 if (validate) parse_symbol_encoding_validate_utf8(parser, location, contents);
6546 return PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING;
6547 } else if (parser->encoding == PM_ENCODING_US_ASCII_ENTRY) {
6548 return PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING;
6549 } else if (validate) {
6550 parse_symbol_encoding_validate_other(parser, location, contents);
6552 } else if (pm_string_ascii_only_p(contents)) {
6553 // Ruby stipulates that all source files must use an ASCII-compatible
6554 // encoding. Thus, all symbols appearing in source are eligible for
6555 // "downgrading" to US-ASCII.
6556 return PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING;
6557 } else if (validate) {
6558 parse_symbol_encoding_validate_other(parser, location, contents);
6568static pm_symbol_node_t *
6569pm_symbol_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *value, const pm_token_t *closing, const pm_string_t *unescaped, pm_node_flags_t flags) {
6570 uint32_t start = opening == NULL ? PM_TOKEN_START(parser, value) : PM_TOKEN_START(parser, opening);
6571 uint32_t end = closing == NULL ? PM_TOKEN_END(parser, value) : PM_TOKEN_END(parser, closing);
6573 return pm_symbol_node_new(
6576 PM_NODE_FLAG_STATIC_LITERAL | flags,
6577 ((pm_location_t) { .start = start, .length = U32(end - start) }),
6578 NTOK2LOC(parser, opening),
6579 NTOK2LOC(parser, value),
6580 NTOK2LOC(parser, closing),
6588static PRISM_INLINE pm_symbol_node_t *
6589pm_symbol_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *value, const pm_token_t *closing) {
6590 return pm_symbol_node_create_unescaped(parser, opening, value, closing, &PM_STRING_EMPTY, 0);
6596static pm_symbol_node_t *
6597pm_symbol_node_create_current_string(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *value, const pm_token_t *closing) {
6598 pm_symbol_node_t *node = pm_symbol_node_create_unescaped(parser, opening, value, closing, &parser->current_string, parse_symbol_encoding(parser, parser->explicit_encoding, value, &parser->current_string, false));
6599 parser->current_string = PM_STRING_EMPTY;
6606static pm_symbol_node_t *
6607pm_symbol_node_label_create(pm_parser_t *parser, const pm_token_t *token) {
6608 PRISM_ASSERT(token->type == PM_TOKEN_LABEL);
6610 pm_token_t closing = { .type = PM_TOKEN_LABEL_END, .start = token->end - 1, .end = token->end };
6611 pm_token_t label = { .type = PM_TOKEN_LABEL, .start = token->start, .end = token->end - 1 };
6612 pm_symbol_node_t *node = pm_symbol_node_create(parser, NULL, &label, &closing);
6614 PRISM_ASSERT((label.end - label.start) >= 0);
6615 pm_string_shared_init(&node->unescaped, label.start, label.end);
6616 pm_node_flag_set(UP(node), parse_symbol_encoding(parser, parser->explicit_encoding, &label, &node->unescaped, false));
6624static pm_symbol_node_t *
6625pm_symbol_node_synthesized_create(pm_parser_t *parser, const char *content) {
6626 pm_symbol_node_t *node = pm_symbol_node_new(
6629 PM_NODE_FLAG_STATIC_LITERAL | PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING,
6630 PM_LOCATION_INIT_UNSET,
6631 ((pm_location_t) { 0 }),
6632 ((pm_location_t) { 0 }),
6633 ((pm_location_t) { 0 }),
6634 ((pm_string_t) { 0 })
6637 pm_string_init(&node->unescaped, (const uint8_t *) content, strlen(content));
6645pm_symbol_node_label_p(const pm_parser_t *parser, const pm_node_t *node) {
6646 const pm_location_t *closing;
6647 uint32_t expected_length;
6649 switch (PM_NODE_TYPE(node)) {
6650 case PM_SYMBOL_NODE: {
6651 const pm_symbol_node_t *cast = (pm_symbol_node_t *) node;
6652 closing = &cast->closing_loc;
6653 expected_length = cast->opening_loc.length == 0 ? 1 : 2;
6656 case PM_INTERPOLATED_SYMBOL_NODE: {
6657 const pm_interpolated_symbol_node_t *cast = (pm_interpolated_symbol_node_t *) node;
6658 closing = &cast->closing_loc;
6659 expected_length = 2;
6666 /* An unquoted label ends with a colon alone. A quoted label ends with
6667 * its closing quote followed by a colon. */
6668 return closing->length == expected_length && parser->start[PM_LOCATION_END(closing) - 1] == ':';
6674static pm_symbol_node_t *
6675pm_string_node_to_symbol_node(pm_parser_t *parser, pm_string_node_t *node, const pm_token_t *opening, const pm_token_t *closing) {
6676 pm_symbol_node_t *new_node = pm_symbol_node_new(
6679 PM_NODE_FLAG_STATIC_LITERAL,
6680 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
6681 TOK2LOC(parser, opening),
6683 TOK2LOC(parser, closing),
6687 pm_token_t content = {
6688 .type = PM_TOKEN_IDENTIFIER,
6689 .start = parser->start + node->content_loc.start,
6690 .end = parser->start + node->content_loc.start + node->content_loc.length
6693 pm_node_flag_set(UP(new_node), parse_symbol_encoding(parser, parser->explicit_encoding, &content, &node->unescaped, true));
6695 /* The old node is arena-allocated so no explicit free is needed. */
6702static pm_string_node_t *
6703pm_symbol_node_to_string_node(pm_parser_t *parser, pm_symbol_node_t *node) {
6704 pm_node_flags_t flags = 0;
6706 switch (parser->frozen_string_literal) {
6707 case PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED:
6708 flags = PM_STRING_FLAGS_MUTABLE;
6710 case PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED:
6711 flags = PM_NODE_FLAG_STATIC_LITERAL | PM_STRING_FLAGS_FROZEN;
6715 pm_string_node_t *new_node = pm_string_node_new(
6719 PM_LOCATION_INIT_NODE(node),
6726 /* The old node is arena-allocated so no explicit free is needed. */
6733static pm_true_node_t *
6734pm_true_node_create(pm_parser_t *parser, const pm_token_t *token) {
6735 PRISM_ASSERT(token->type == PM_TOKEN_KEYWORD_TRUE);
6737 return pm_true_node_new(
6740 PM_NODE_FLAG_STATIC_LITERAL,
6741 PM_LOCATION_INIT_TOKEN(parser, token)
6748static pm_true_node_t *
6749pm_true_node_synthesized_create(pm_parser_t *parser) {
6750 return pm_true_node_new(
6753 PM_NODE_FLAG_STATIC_LITERAL,
6754 PM_LOCATION_INIT_UNSET
6761static pm_undef_node_t *
6762pm_undef_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_list_t *names) {
6763 PRISM_ASSERT(keyword->type == PM_TOKEN_KEYWORD_UNDEF);
6764 pm_node_list_finalize(&parser->node_chunks, parser->arena, names);
6766 return pm_undef_node_new(
6770 names->size == 0 ? PM_LOCATION_INIT_TOKEN(parser, keyword) : PM_LOCATION_INIT_TOKEN_NODE(parser, keyword, names->nodes[names->size - 1]),
6772 TOK2LOC(parser, keyword)
6779static pm_unless_node_t *
6780pm_unless_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *predicate, const pm_token_t *then_keyword, pm_statements_node_t *statements) {
6781 pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
6782 pm_node_t *end = statements == NULL ? predicate : UP(statements);
6784 return pm_unless_node_new(
6787 PM_NODE_FLAG_NEWLINE,
6788 PM_LOCATION_INIT_TOKEN_NODE(parser, keyword, end),
6789 TOK2LOC(parser, keyword),
6791 NTOK2LOC(parser, then_keyword),
6794 ((pm_location_t) { 0 })
6801static pm_unless_node_t *
6802pm_unless_node_modifier_create(pm_parser_t *parser, pm_node_t *statement, const pm_token_t *unless_keyword, pm_node_t *predicate) {
6803 pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
6805 pm_statements_node_t *statements = pm_statements_node_single_create(parser, statement, true);
6807 return pm_unless_node_new(
6810 PM_NODE_FLAG_NEWLINE,
6811 PM_LOCATION_INIT_NODES(statement, predicate),
6812 TOK2LOC(parser, unless_keyword),
6814 ((pm_location_t) { 0 }),
6817 ((pm_location_t) { 0 })
6821static PRISM_INLINE void
6822pm_unless_node_end_keyword_loc_set(const pm_parser_t *parser, pm_unless_node_t *node, const pm_token_t *end_keyword) {
6823 node->end_keyword_loc = TOK2LOC(parser, end_keyword);
6824 PM_NODE_LENGTH_SET_TOKEN(parser, node, end_keyword);
6833pm_loop_modifier_block_exits(pm_parser_t *parser, pm_statements_node_t *statements) {
6834 PRISM_ASSERT(parser->current_block_exits != NULL);
6836 // All of the block exits that we want to remove should be within the
6837 // statements, and since we are modifying the statements, we shouldn't have
6838 // to check the end location.
6839 uint32_t start = statements->base.location.start;
6841 for (size_t index = parser->current_block_exits->size; index > 0; index--) {
6842 pm_node_t *block_exit = parser->current_block_exits->nodes[index - 1];
6843 if (block_exit->location.start < start) break;
6845 // Implicitly remove from the list by lowering the size.
6846 parser->current_block_exits->size--;
6853static pm_until_node_t *
6854pm_until_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *do_keyword, const pm_token_t *closing, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {
6855 pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
6857 return pm_until_node_new(
6861 PM_LOCATION_INIT_TOKENS(parser, keyword, closing),
6862 TOK2LOC(parser, keyword),
6863 NTOK2LOC(parser, do_keyword),
6864 TOK2LOC(parser, closing),
6873static pm_until_node_t *
6874pm_until_node_modifier_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {
6875 pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
6876 pm_loop_modifier_block_exits(parser, statements);
6878 return pm_until_node_new(
6882 PM_LOCATION_INIT_NODES(statements, predicate),
6883 TOK2LOC(parser, keyword),
6884 ((pm_location_t) { 0 }),
6885 ((pm_location_t) { 0 }),
6894static pm_when_node_t *
6895pm_when_node_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_list_t *conditions, const pm_token_t *then_keyword, pm_statements_node_t *statements) {
6896 PRISM_ASSERT(conditions->size > 0);
6897 pm_node_list_finalize(&parser->node_chunks, parser->arena, conditions);
6899 uint32_t start = PM_TOKEN_START(parser, keyword);
6900 uint32_t end = PM_NODE_END(conditions->nodes[conditions->size - 1]);
6902 if (then_keyword != NULL) end = PM_TOKEN_END(parser, then_keyword);
6903 if (statements != NULL && PM_NODE_END(statements) > end) end = PM_NODE_END(statements);
6905 return pm_when_node_new(
6909 PM_LOCATION_INIT_BOUNDS(start, end),
6910 TOK2LOC(parser, keyword),
6912 NTOK2LOC(parser, then_keyword),
6920static pm_while_node_t *
6921pm_while_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_token_t *do_keyword, const pm_token_t *closing, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {
6922 pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
6924 return pm_while_node_new(
6928 PM_LOCATION_INIT_TOKENS(parser, keyword, closing),
6929 TOK2LOC(parser, keyword),
6930 NTOK2LOC(parser, do_keyword),
6931 TOK2LOC(parser, closing),
6940static pm_while_node_t *
6941pm_while_node_modifier_create(pm_parser_t *parser, const pm_token_t *keyword, pm_node_t *predicate, pm_statements_node_t *statements, pm_node_flags_t flags) {
6942 pm_conditional_predicate(parser, predicate, PM_CONDITIONAL_PREDICATE_TYPE_CONDITIONAL);
6943 pm_loop_modifier_block_exits(parser, statements);
6945 return pm_while_node_new(
6949 PM_LOCATION_INIT_NODES(statements, predicate),
6950 TOK2LOC(parser, keyword),
6951 ((pm_location_t) { 0 }),
6952 ((pm_location_t) { 0 }),
6961static pm_while_node_t *
6962pm_while_node_synthesized_create(pm_parser_t *parser, pm_node_t *predicate, pm_statements_node_t *statements) {
6963 return pm_while_node_new(
6967 PM_LOCATION_INIT_UNSET,
6968 ((pm_location_t) { 0 }),
6969 ((pm_location_t) { 0 }),
6970 ((pm_location_t) { 0 }),
6980static pm_x_string_node_t *
6981pm_xstring_node_create_unescaped(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing, const pm_string_t *unescaped) {
6982 return pm_x_string_node_new(
6985 PM_STRING_FLAGS_FROZEN,
6986 PM_LOCATION_INIT_TOKENS(parser, opening, closing),
6987 TOK2LOC(parser, opening),
6988 TOK2LOC(parser, content),
6989 TOK2LOC(parser, closing),
6997static PRISM_INLINE pm_x_string_node_t *
6998pm_xstring_node_create(pm_parser_t *parser, const pm_token_t *opening, const pm_token_t *content, const pm_token_t *closing) {
6999 return pm_xstring_node_create_unescaped(parser, opening, content, closing, &PM_STRING_EMPTY);
7005static pm_yield_node_t *
7006pm_yield_node_create(pm_parser_t *parser, const pm_token_t *keyword, const pm_location_t *lparen_loc, pm_arguments_node_t *arguments, const pm_location_t *rparen_loc) {
7007 uint32_t start = PM_TOKEN_START(parser, keyword);
7010 if (rparen_loc->length > 0) {
7011 end = PM_LOCATION_END(rparen_loc);
7012 } else if (arguments != NULL) {
7013 end = PM_NODE_END(arguments);
7014 } else if (lparen_loc->length > 0) {
7015 end = PM_LOCATION_END(lparen_loc);
7017 end = PM_TOKEN_END(parser, keyword);
7020 return pm_yield_node_new(
7024 ((pm_location_t) { .start = start, .length = U32(end - start) }),
7025 TOK2LOC(parser, keyword),
7037static PRISM_INLINE int
7038pm_parser_local_depth(pm_parser_t *parser, pm_token_t *token) {
7039 return pm_parser_local_depth_constant_id(parser, pm_parser_constant_id_token(parser, token));
7045static PRISM_INLINE void
7046pm_parser_local_add(pm_parser_t *parser, pm_constant_id_t constant_id, const uint8_t *start, const uint8_t *end, uint32_t reads) {
7047 pm_locals_write(parser, constant_id, U32(start - parser->start), U32(end - start), reads);
7053static pm_constant_id_t
7054pm_parser_local_add_raw(pm_parser_t *parser, const uint8_t *start, const uint8_t *end, uint32_t reads) {
7055 pm_constant_id_t constant_id = pm_parser_constant_id_raw(parser, start, end);
7056 if (constant_id != 0) pm_parser_local_add(parser, constant_id, start, end, reads);
7063static PRISM_INLINE pm_constant_id_t
7064pm_parser_local_add_location(pm_parser_t *parser, pm_location_t *location, uint32_t reads) {
7065 return pm_parser_local_add_raw(parser, parser->start + location->start, parser->start + location->start + location->length, reads);
7071static PRISM_INLINE pm_constant_id_t
7072pm_parser_local_add_token(pm_parser_t *parser, pm_token_t *token, uint32_t reads) {
7073 return pm_parser_local_add_raw(parser, token->start, token->end, reads);
7079static pm_constant_id_t
7080pm_parser_local_add_owned(pm_parser_t *parser, uint8_t *start, size_t length) {
7081 pm_constant_id_t constant_id = pm_parser_constant_id_owned(parser, start, length);
7082 if (constant_id != 0) pm_parser_local_add(parser, constant_id, parser->start, parser->start, 1);
7089static pm_constant_id_t
7090pm_parser_local_add_constant(pm_parser_t *parser, const char *start, size_t length) {
7091 pm_constant_id_t constant_id = pm_parser_constant_id_constant(parser, start, length);
7092 if (constant_id != 0) pm_parser_local_add(parser, constant_id, parser->start, parser->start, 1);
7104pm_parser_parameter_name_check(pm_parser_t *parser, const pm_token_t *name) {
7105 // We want to check whether the parameter name is a numbered parameter or
7107 pm_refute_numbered_parameter(parser, PM_TOKEN_START(parser, name), PM_TOKEN_LENGTH(name));
7109 // Otherwise we'll fetch the constant id for the parameter name and check
7110 // whether it's already in the current scope.
7111 pm_constant_id_t constant_id = pm_parser_constant_id_token(parser, name);
7113 if (pm_parser_binding(parser, constant_id) >= parser->current_scope->locals_start) {
7114 // Add an error if the parameter doesn't start with _ and has been seen before
7115 if ((name->start < name->end) && (*name->start != '_')) {
7116 pm_parser_err_token(parser, name, PM_ERR_PARAMETER_NAME_DUPLICATED);
7127pm_parser_scope_pop(pm_parser_t *parser) {
7128 pm_scope_t *scope = parser->current_scope;
7130 /* Restore the bindings that the locals of this scope hid, in the reverse of
7131 * the order they were declared, then discard the locals. */
7132 for (uint32_t index = parser->locals_size; index > scope->locals_start; index--) {
7133 const pm_local_t *local = &parser->locals[index - 1];
7134 parser->bindings[local->name] = local->shadowed;
7137 parser->locals_size = scope->locals_start;
7139 parser->current_scope = scope->previous;
7140 scope->previous = parser->free_scopes;
7141 parser->free_scopes = scope;
7144/******************************************************************************/
7146/******************************************************************************/
7153pm_state_stack_spill(pm_arena_t *arena, pm_state_stack_t *stack) {
7154 uint32_t size = (stack->depth >> 6) - 1;
7156 if (size == stack->capacity) {
7157 uint32_t capacity = stack->capacity == 0 ? 2 : stack->capacity * 2;
7158 stack->spill = PM_ARENA_REALLOC(arena, stack->spill, capacity * sizeof(uint64_t), stack->capacity * sizeof(uint64_t), uint64_t);
7159 stack->capacity = capacity;
7162 stack->spill[size] = stack->top;
7170static PRISM_INLINE void
7171pm_state_stack_push(pm_arena_t *arena, pm_state_stack_t *stack, bool value) {
7172 if (PRISM_UNLIKELY(stack->depth && !(stack->depth & 63))) {
7173 pm_state_stack_spill(arena, stack);
7176 stack->top = (stack->top << 1) | value;
7185static PRISM_INLINE void
7186pm_state_stack_pop(pm_state_stack_t *stack) {
7187 /* A closing delimiter without a matching opening one is a syntax error that
7188 * the parser reports and recovers from, but the lexer still pops for it, so
7189 * popping an empty stack has to leave it empty. */
7190 if (PRISM_UNLIKELY(stack->depth == 0)) return;
7195 if (PRISM_UNLIKELY(stack->depth && !(stack->depth & 63))) {
7196 stack->top = stack->spill[(stack->depth >> 6) - 1];
7204static PRISM_INLINE bool
7205pm_state_stack_p(const pm_state_stack_t *stack) {
7206 return stack->top & 1;
7213static PRISM_INLINE void
7214pm_accepts_block_stack_push(pm_parser_t *parser, bool value) {
7215 pm_state_stack_push(&parser->scratch_arena, &parser->accepts_block_stack, !value);
7218static PRISM_INLINE void
7219pm_accepts_block_stack_pop(pm_parser_t *parser) {
7220 pm_state_stack_pop(&parser->accepts_block_stack);
7223static PRISM_INLINE bool
7224pm_accepts_block_stack_p(pm_parser_t *parser) {
7225 return !pm_state_stack_p(&parser->accepts_block_stack);
7228static PRISM_INLINE void
7229pm_do_loop_stack_push(pm_parser_t *parser, bool value) {
7230 pm_state_stack_push(&parser->scratch_arena, &parser->do_loop_stack, value);
7233static PRISM_INLINE void
7234pm_do_loop_stack_pop(pm_parser_t *parser) {
7235 pm_state_stack_pop(&parser->do_loop_stack);
7238static PRISM_INLINE bool
7239pm_do_loop_stack_p(pm_parser_t *parser) {
7240 return pm_state_stack_p(&parser->do_loop_stack);
7272static PRISM_INLINE void
7273pm_enclosure_frame_push(pm_parser_t *parser) {
7274 pm_do_loop_stack_push(parser, false);
7275 pm_accepts_block_stack_push(parser, true);
7278static PRISM_INLINE void
7279pm_enclosure_frame_pop(pm_parser_t *parser) {
7280 pm_do_loop_stack_pop(parser);
7281 pm_accepts_block_stack_pop(parser);
7284/******************************************************************************/
7285/* Lexer check helpers */
7286/******************************************************************************/
7292static PRISM_INLINE uint8_t
7293peek_at(const pm_parser_t *parser, const uint8_t *cursor) {
7294 if (cursor < parser->end) {
7306static PRISM_INLINE uint8_t
7307peek_offset(pm_parser_t *parser, ptrdiff_t offset) {
7308 return peek_at(parser, parser->current.end + offset);
7315static PRISM_INLINE uint8_t
7316peek(const pm_parser_t *parser) {
7317 return peek_at(parser, parser->current.end);
7324static PRISM_INLINE bool
7325match(pm_parser_t *parser, uint8_t value) {
7326 if (peek(parser) == value) {
7327 parser->current.end++;
7337static PRISM_INLINE size_t
7338match_eol_at(pm_parser_t *parser, const uint8_t *cursor) {
7339 if (peek_at(parser, cursor) == '\n') {
7342 if (peek_at(parser, cursor) == '\r' && peek_at(parser, cursor + 1) == '\n') {
7353static PRISM_INLINE size_t
7354match_eol_offset(pm_parser_t *parser, ptrdiff_t offset) {
7355 return match_eol_at(parser, parser->current.end + offset);
7363static PRISM_INLINE size_t
7364match_eol(pm_parser_t *parser) {
7365 return match_eol_at(parser, parser->current.end);
7371static PRISM_INLINE const uint8_t *
7372next_newline(const uint8_t *cursor, ptrdiff_t length) {
7373 PRISM_ASSERT(length >= 0);
7375 // Note that it's okay for us to use memchr here to look for \n because none
7376 // of the encodings that we support have \n as a component of a multi-byte
7378 return memchr(cursor, '\n', (size_t) length);
7384static PRISM_INLINE bool
7385ambiguous_operator_p(const pm_parser_t *parser, bool space_seen) {
7386 return !lex_state_p(parser, PM_LEX_STATE_CLASS | PM_LEX_STATE_DOT | PM_LEX_STATE_FNAME | PM_LEX_STATE_ENDFN) && space_seen && !pm_char_is_whitespace(peek(parser));
7394parser_lex_magic_comment_encoding_value(pm_parser_t *parser, const uint8_t *start, const uint8_t *end) {
7395 const pm_encoding_t *encoding = pm_encoding_find(start, end);
7397 if (encoding != NULL) {
7398 if (parser->encoding != encoding) {
7399 parser->encoding = encoding;
7400 if (parser->encoding_changed_callback != NULL) parser->encoding_changed_callback(parser);
7403 parser->encoding_changed = (encoding != PM_ENCODING_UTF_8_ENTRY);
7415parser_lex_magic_comment_encoding(pm_parser_t *parser) {
7416 const uint8_t *cursor = parser->current.start + 1;
7417 const uint8_t *end = parser->current.end;
7419 bool separator = false;
7421 if (end - cursor <= 6) return;
7422 switch (cursor[6]) {
7423 case 'C': case 'c': cursor += 6; continue;
7424 case 'O': case 'o': cursor += 5; continue;
7425 case 'D': case 'd': cursor += 4; continue;
7426 case 'I': case 'i': cursor += 3; continue;
7427 case 'N': case 'n': cursor += 2; continue;
7428 case 'G': case 'g': cursor += 1; continue;
7435 if (pm_char_is_whitespace(*cursor)) break;
7438 if (pm_strncasecmp(cursor - 6, (const uint8_t *) "coding", 6) == 0) break;
7444 if (++cursor >= end) return;
7445 } while (pm_char_is_whitespace(*cursor));
7447 if (separator) break;
7448 if (*cursor != '=' && *cursor != ':') return;
7454 /* The name of an encoding is made of ASCII letters, digits, - and _. */
7455 const uint8_t *value_start = cursor;
7456 while ((*cursor == '-' || *cursor == '_' || pm_encoding_ascii_alnum_p(*cursor)) && ++cursor < end);
7458 if (!parser_lex_magic_comment_encoding_value(parser, value_start, cursor)) {
7459 // If we were unable to parse the encoding value, then we've got an
7460 // issue because we didn't understand the encoding that the user was
7461 // trying to use. In this case we'll keep using the default encoding but
7462 // add an error to the parser to indicate an unsuccessful parse.
7463 pm_parser_err(parser, U32(value_start - parser->start), U32(cursor - value_start), PM_ERR_INVALID_ENCODING_MAGIC_COMMENT);
7468 PM_MAGIC_COMMENT_BOOLEAN_VALUE_TRUE,
7469 PM_MAGIC_COMMENT_BOOLEAN_VALUE_FALSE,
7470 PM_MAGIC_COMMENT_BOOLEAN_VALUE_INVALID
7471} pm_magic_comment_boolean_value_t;
7477static pm_magic_comment_boolean_value_t
7478parser_lex_magic_comment_boolean_value(const uint8_t *value_start, uint32_t value_length) {
7479 if (value_length == 4 && pm_strncasecmp(value_start, (const uint8_t *) "true", 4) == 0) {
7480 return PM_MAGIC_COMMENT_BOOLEAN_VALUE_TRUE;
7481 } else if (value_length == 5 && pm_strncasecmp(value_start, (const uint8_t *) "false", 5) == 0) {
7482 return PM_MAGIC_COMMENT_BOOLEAN_VALUE_FALSE;
7484 return PM_MAGIC_COMMENT_BOOLEAN_VALUE_INVALID;
7488static PRISM_INLINE bool
7489pm_char_is_magic_comment_key_delimiter(const uint8_t b) {
7490 return b == '\'' || b == '"' || b == ':' || b == ';';
7499parser_lex_magic_comment_emacs_marker(
pm_parser_t *parser,
const uint8_t *cursor,
const uint8_t *end) {
7503 while ((cursor + 3 <= end) && (cursor = pm_memchr(cursor + 1,
'*', (
size_t) (end - cursor - 1), parser->encoding_changed, parser->encoding)) != NULL) {
7504 if (cursor[-1] ==
'-' && cursor + 1 < end && cursor[1] ==
'-') {
7519parser_magic_comment_key_p(
const uint8_t *key,
size_t key_length,
const char *name) {
7520 PRISM_ASSERT(name[key_length] ==
'\0');
7522 for (
size_t index = 0; index < key_length; index++) {
7523 uint8_t
byte = key[index];
7524 if (
byte ==
'-')
byte =
'_';
7525 if (
'A' <=
byte &&
byte <=
'Z')
byte |= 0x20;
7526 if (
byte != (uint8_t) name[index])
return false;
7543parser_lex_magic_comment(
pm_parser_t *parser,
bool semantic_token_seen) {
7544 const uint8_t *start = parser->current.start + 1;
7545 const uint8_t *end = parser->current.end;
7546 if (end - start <= 7)
return false;
7548 const uint8_t *cursor;
7549 bool indicator =
false;
7551 if ((cursor = parser_lex_magic_comment_emacs_marker(parser, start, end)) != NULL) {
7554 if ((cursor = parser_lex_magic_comment_emacs_marker(parser, start, end)) != NULL) {
7568 if ((parser->current.start != parser->encoding_comment_start || parser->encoding_locked) &&
7569 pm_memchr(start,
':', (
size_t) (end - start), parser->encoding_changed, parser->encoding) == NULL) {
7573 start += pm_strspn_whitespace(start, end - start);
7577 while (cursor < end) {
7578 while (cursor < end && (pm_char_is_magic_comment_key_delimiter(*cursor) || pm_char_is_whitespace(*cursor))) cursor++;
7580 const uint8_t *key_start = cursor;
7581 while (cursor < end && (!pm_char_is_magic_comment_key_delimiter(*cursor) && !pm_char_is_whitespace(*cursor))) cursor++;
7583 const uint8_t *key_end = cursor;
7584 while (cursor < end && pm_char_is_whitespace(*cursor)) cursor++;
7585 if (cursor == end)
break;
7587 if (*cursor ==
':') {
7590 if (!indicator)
return false;
7594 while (cursor < end && pm_char_is_whitespace(*cursor)) cursor++;
7595 if (cursor == end)
break;
7597 const uint8_t *value_start;
7598 const uint8_t *value_end;
7600 if (*cursor ==
'"') {
7601 value_start = ++cursor;
7602 for (; cursor < end && *cursor !=
'"'; cursor++) {
7603 if (*cursor ==
'\\' && (cursor + 1 < end)) cursor++;
7606 if (cursor < end && *cursor ==
'"') cursor++;
7608 value_start = cursor;
7609 while (cursor < end && *cursor !=
'"' && *cursor !=
';' && !pm_char_is_whitespace(*cursor)) cursor++;
7614 while (cursor < end && (*cursor ==
';' || pm_char_is_whitespace(*cursor))) cursor++;
7616 while (cursor < end && pm_char_is_whitespace(*cursor)) cursor++;
7617 if (cursor != end)
return false;
7622 const size_t key_length = (size_t) (key_end - key_start);
7623 uint32_t value_length = (uint32_t) (value_end - value_start);
7625 switch (key_length) {
7631 if (parser->current.start == parser->encoding_comment_start && !parser->encoding_locked) {
7632 if (parser_magic_comment_key_p(key_start, key_length, key_length == 6 ?
"coding" :
"encoding")) {
7633 if (!parser_lex_magic_comment_encoding_value(parser, value_start, value_end)) {
7634 pm_parser_err(parser, U32(value_start - parser->start), value_length, PM_ERR_INVALID_ENCODING_MAGIC_COMMENT);
7640 if (parser_magic_comment_key_p(key_start, key_length,
"warn_indent")) {
7641 switch (parser_lex_magic_comment_boolean_value(value_start, value_length)) {
7642 case PM_MAGIC_COMMENT_BOOLEAN_VALUE_INVALID:
7643 PM_PARSER_WARN_TOKEN_FORMAT(
7646 PM_WARN_INVALID_MAGIC_COMMENT_VALUE,
7650 (
const char *) value_start
7653 case PM_MAGIC_COMMENT_BOOLEAN_VALUE_FALSE:
7654 parser->warn_mismatched_indentation =
false;
7656 case PM_MAGIC_COMMENT_BOOLEAN_VALUE_TRUE:
7657 parser->warn_mismatched_indentation =
true;
7663 if (parser_magic_comment_key_p(key_start, key_length,
"frozen_string_literal")) {
7666 if (semantic_token_seen) {
7667 pm_parser_warn_token(parser, &parser->current, PM_WARN_IGNORED_FROZEN_STRING_LITERAL);
7669 switch (parser_lex_magic_comment_boolean_value(value_start, value_length)) {
7670 case PM_MAGIC_COMMENT_BOOLEAN_VALUE_INVALID:
7671 PM_PARSER_WARN_TOKEN_FORMAT(
7674 PM_WARN_INVALID_MAGIC_COMMENT_VALUE,
7676 "frozen_string_literal",
7678 (
const char *) value_start
7681 case PM_MAGIC_COMMENT_BOOLEAN_VALUE_FALSE:
7684 case PM_MAGIC_COMMENT_BOOLEAN_VALUE_TRUE:
7692 if (parser_magic_comment_key_p(key_start, key_length,
"shareable_constant_value")) {
7693 const uint8_t *cursor = parser->current.start;
7694 while ((cursor > parser->start) && ((cursor[-1] ==
' ') || (cursor[-1] ==
'\t'))) cursor--;
7696 if (!((cursor == parser->start) || (cursor[-1] ==
'\n'))) {
7697 pm_parser_warn_token(parser, &parser->current, PM_WARN_SHAREABLE_CONSTANT_VALUE_LINE);
7698 }
else if (value_length == 4 && pm_strncasecmp(value_start, (
const uint8_t *)
"none", 4) == 0) {
7699 pm_parser_scope_shareable_constant_set(parser, PM_SCOPE_SHAREABLE_CONSTANT_NONE);
7700 }
else if (value_length == 7 && pm_strncasecmp(value_start, (
const uint8_t *)
"literal", 7) == 0) {
7701 pm_parser_scope_shareable_constant_set(parser, PM_SCOPE_SHAREABLE_CONSTANT_LITERAL);
7702 }
else if (value_length == 23 && pm_strncasecmp(value_start, (
const uint8_t *)
"experimental_everything", 23) == 0) {
7703 pm_parser_scope_shareable_constant_set(parser, PM_SCOPE_SHAREABLE_CONSTANT_EXPERIMENTAL_EVERYTHING);
7704 }
else if (value_length == 17 && pm_strncasecmp(value_start, (
const uint8_t *)
"experimental_copy", 17) == 0) {
7705 pm_parser_scope_shareable_constant_set(parser, PM_SCOPE_SHAREABLE_CONSTANT_EXPERIMENTAL_COPY);
7707 PM_PARSER_WARN_TOKEN_FORMAT(
7710 PM_WARN_INVALID_MAGIC_COMMENT_VALUE,
7712 "shareable_constant_value",
7714 (
const char *) value_start
7726 pm_list_append(&parser->magic_comment_list, (pm_list_node_t *)
magic_comment);
7736static const uint32_t context_terminators[] = {
7737 [PM_CONTEXT_NONE] = 0,
7738 [PM_CONTEXT_BEGIN] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ELSE) | (1U << PM_TOKEN_KEYWORD_END),
7739 [PM_CONTEXT_BEGIN_ENSURE] = (1U << PM_TOKEN_KEYWORD_END),
7740 [PM_CONTEXT_BEGIN_ELSE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_END),
7741 [PM_CONTEXT_BEGIN_RESCUE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ELSE) | (1U << PM_TOKEN_KEYWORD_END),
7742 [PM_CONTEXT_BLOCK_BRACES] = (1U << PM_TOKEN_BRACE_RIGHT),
7743 [PM_CONTEXT_BLOCK_KEYWORDS] = (1U << PM_TOKEN_KEYWORD_END) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ENSURE),
7744 [PM_CONTEXT_BLOCK_ENSURE] = (1U << PM_TOKEN_KEYWORD_END),
7745 [PM_CONTEXT_BLOCK_ELSE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_END),
7746 [PM_CONTEXT_BLOCK_PARAMETERS] = (1U << PM_TOKEN_PIPE),
7747 [PM_CONTEXT_BLOCK_RESCUE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ELSE) | (1U << PM_TOKEN_KEYWORD_END),
7748 [PM_CONTEXT_CASE_WHEN] = (1U << PM_TOKEN_KEYWORD_WHEN) | (1U << PM_TOKEN_KEYWORD_END) | (1U << PM_TOKEN_KEYWORD_ELSE),
7749 [PM_CONTEXT_CASE_IN] = (1U << PM_TOKEN_KEYWORD_IN) | (1U << PM_TOKEN_KEYWORD_END) | (1U << PM_TOKEN_KEYWORD_ELSE),
7750 [PM_CONTEXT_CLASS] = (1U << PM_TOKEN_KEYWORD_END) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ENSURE),
7751 [PM_CONTEXT_CLASS_ENSURE] = (1U << PM_TOKEN_KEYWORD_END),
7752 [PM_CONTEXT_CLASS_ELSE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_END),
7753 [PM_CONTEXT_CLASS_RESCUE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ELSE) | (1U << PM_TOKEN_KEYWORD_END),
7754 [PM_CONTEXT_DEF] = (1U << PM_TOKEN_KEYWORD_END) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ENSURE),
7755 [PM_CONTEXT_DEF_ENSURE] = (1U << PM_TOKEN_KEYWORD_END),
7756 [PM_CONTEXT_DEF_ELSE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_END),
7757 [PM_CONTEXT_DEF_RESCUE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ELSE) | (1U << PM_TOKEN_KEYWORD_END),
7758 [PM_CONTEXT_DEF_PARAMS] = (1U << PM_TOKEN_EOF),
7759 [PM_CONTEXT_DEFINED] = (1U << PM_TOKEN_EOF),
7760 [PM_CONTEXT_DEFAULT_PARAMS] = (1U << PM_TOKEN_COMMA) | (1U << PM_TOKEN_PARENTHESIS_RIGHT),
7761 [PM_CONTEXT_ELSE] = (1U << PM_TOKEN_KEYWORD_END),
7762 [PM_CONTEXT_ELSIF] = (1U << PM_TOKEN_KEYWORD_ELSE) | (1U << PM_TOKEN_KEYWORD_ELSIF) | (1U << PM_TOKEN_KEYWORD_END),
7763 [PM_CONTEXT_EMBEXPR] = (1U << PM_TOKEN_EMBEXPR_END) | (1U << PM_TOKEN_HEREDOC_END),
7764 [PM_CONTEXT_FOR] = (1U << PM_TOKEN_KEYWORD_END),
7765 [PM_CONTEXT_FOR_INDEX] = (1U << PM_TOKEN_KEYWORD_IN),
7766 [PM_CONTEXT_IF] = (1U << PM_TOKEN_KEYWORD_ELSE) | (1U << PM_TOKEN_KEYWORD_ELSIF) | (1U << PM_TOKEN_KEYWORD_END),
7767 [PM_CONTEXT_LAMBDA_BRACES] = (1U << PM_TOKEN_BRACE_RIGHT),
7768 [PM_CONTEXT_LAMBDA_DO_END] = (1U << PM_TOKEN_KEYWORD_END) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ENSURE),
7769 [PM_CONTEXT_LAMBDA_ENSURE] = (1U << PM_TOKEN_KEYWORD_END),
7770 [PM_CONTEXT_LAMBDA_ELSE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_END),
7771 [PM_CONTEXT_LAMBDA_RESCUE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ELSE) | (1U << PM_TOKEN_KEYWORD_END),
7772 [PM_CONTEXT_LOOP_PREDICATE] = (1U << PM_TOKEN_KEYWORD_DO) | (1U << PM_TOKEN_KEYWORD_THEN),
7773 [PM_CONTEXT_MAIN] = (1U << PM_TOKEN_EOF),
7774 [PM_CONTEXT_MODULE] = (1U << PM_TOKEN_KEYWORD_END) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ENSURE),
7775 [PM_CONTEXT_MODULE_ENSURE] = (1U << PM_TOKEN_KEYWORD_END),
7776 [PM_CONTEXT_MODULE_ELSE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_END),
7777 [PM_CONTEXT_MODULE_RESCUE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ELSE) | (1U << PM_TOKEN_KEYWORD_END),
7778 [PM_CONTEXT_MULTI_TARGET] = (1U << PM_TOKEN_EOF),
7779 [PM_CONTEXT_PARENS] = (1U << PM_TOKEN_PARENTHESIS_RIGHT),
7780 [PM_CONTEXT_POSTEXE] = (1U << PM_TOKEN_BRACE_RIGHT),
7781 [PM_CONTEXT_PREDICATE] = (1U << PM_TOKEN_KEYWORD_THEN) | (1U << PM_TOKEN_NEWLINE) | (1U << PM_TOKEN_SEMICOLON),
7782 [PM_CONTEXT_PREEXE] = (1U << PM_TOKEN_BRACE_RIGHT),
7783 [PM_CONTEXT_RESCUE_MODIFIER] = (1U << PM_TOKEN_EOF),
7784 [PM_CONTEXT_SCLASS] = (1U << PM_TOKEN_KEYWORD_END) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ENSURE),
7785 [PM_CONTEXT_SCLASS_ENSURE] = (1U << PM_TOKEN_KEYWORD_END),
7786 [PM_CONTEXT_SCLASS_ELSE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_END),
7787 [PM_CONTEXT_SCLASS_RESCUE] = (1U << PM_TOKEN_KEYWORD_ENSURE) | (1U << PM_TOKEN_KEYWORD_RESCUE) | (1U << PM_TOKEN_KEYWORD_ELSE) | (1U << PM_TOKEN_KEYWORD_END),
7788 [PM_CONTEXT_TERNARY] = (1U << PM_TOKEN_EOF),
7789 [PM_CONTEXT_UNLESS] = (1U << PM_TOKEN_KEYWORD_ELSE) | (1U << PM_TOKEN_KEYWORD_END),
7790 [PM_CONTEXT_UNTIL] = (1U << PM_TOKEN_KEYWORD_END),
7791 [PM_CONTEXT_WHILE] = (1U << PM_TOKEN_KEYWORD_END),
7795context_terminator(pm_context_t context,
pm_token_t *token) {
7796 return token->type < 32 && (context_terminators[context] & (1U << token->type));
7805 pm_context_node_t *context_node = parser->current_context;
7807 while (context_node != NULL) {
7808 if (context_terminator(context_node->context, token))
return context_node->context;
7809 context_node = context_node->prev;
7812 return PM_CONTEXT_NONE;
7815PM_STATIC_ASSERT(__LINE__, PM_CONTEXT_MAXIMUM <= 64,
"Expected every context to fit in the context mask.");
7818context_push(
pm_parser_t *parser, pm_context_t context) {
7819 pm_context_node_t *context_node = parser->free_contexts;
7820 if (context_node != NULL) {
7821 parser->free_contexts = context_node->prev;
7823 context_node = PM_ARENA_ALLOC(&parser->scratch_arena, pm_context_node_t);
7826 pm_context_node_t *previous = parser->current_context;
7827 *context_node = (pm_context_node_t) {
7830 .mask = (previous == NULL ? 0 : previous->mask) | ((uint64_t) 1 << context)
7833 parser->current_context = context_node;
7839 pm_context_node_t *context_node = parser->current_context;
7840 parser->current_context = context_node->prev;
7841 context_node->prev = parser->free_contexts;
7842 parser->free_contexts = context_node;
7846context_p(
const pm_parser_t *parser, pm_context_t context) {
7847 return parser->current_context != NULL && (parser->current_context->mask & ((uint64_t) 1 << context)) != 0;
7852 pm_context_node_t *context_node = parser->current_context;
7854 while (context_node != NULL) {
7855 switch (context_node->context) {
7856 case PM_CONTEXT_DEF:
7857 case PM_CONTEXT_DEF_PARAMS:
7858 case PM_CONTEXT_DEF_ENSURE:
7859 case PM_CONTEXT_DEF_RESCUE:
7860 case PM_CONTEXT_DEF_ELSE:
7862 case PM_CONTEXT_CLASS:
7863 case PM_CONTEXT_CLASS_ENSURE:
7864 case PM_CONTEXT_CLASS_RESCUE:
7865 case PM_CONTEXT_CLASS_ELSE:
7866 case PM_CONTEXT_MODULE:
7867 case PM_CONTEXT_MODULE_ENSURE:
7868 case PM_CONTEXT_MODULE_RESCUE:
7869 case PM_CONTEXT_MODULE_ELSE:
7870 case PM_CONTEXT_SCLASS:
7871 case PM_CONTEXT_SCLASS_ENSURE:
7872 case PM_CONTEXT_SCLASS_RESCUE:
7873 case PM_CONTEXT_SCLASS_ELSE:
7876 context_node = context_node->prev;
7888context_human(pm_context_t context) {
7890 case PM_CONTEXT_NONE:
7891 case PM_CONTEXT_MAXIMUM:
7892 PRISM_ASSERT(
false &&
"unreachable");
7894 case PM_CONTEXT_BEGIN:
return "begin statement";
7895 case PM_CONTEXT_BLOCK_BRACES:
return "'{'..'}' block";
7896 case PM_CONTEXT_BLOCK_KEYWORDS:
return "'do'..'end' block";
7897 case PM_CONTEXT_BLOCK_PARAMETERS:
return "'|'..'|' block parameter";
7898 case PM_CONTEXT_CASE_WHEN:
return "'when' clause";
7899 case PM_CONTEXT_CASE_IN:
return "'in' clause";
7900 case PM_CONTEXT_CLASS:
return "class definition";
7901 case PM_CONTEXT_DEF:
return "method definition";
7902 case PM_CONTEXT_DEF_PARAMS:
return "method parameters";
7903 case PM_CONTEXT_DEFAULT_PARAMS:
return "parameter default value";
7904 case PM_CONTEXT_DEFINED:
return "'defined?' expression";
7905 case PM_CONTEXT_ELSE:
7906 case PM_CONTEXT_BEGIN_ELSE:
7907 case PM_CONTEXT_BLOCK_ELSE:
7908 case PM_CONTEXT_CLASS_ELSE:
7909 case PM_CONTEXT_DEF_ELSE:
7910 case PM_CONTEXT_LAMBDA_ELSE:
7911 case PM_CONTEXT_MODULE_ELSE:
7912 case PM_CONTEXT_SCLASS_ELSE:
return "'else' clause";
7913 case PM_CONTEXT_ELSIF:
return "'elsif' clause";
7914 case PM_CONTEXT_EMBEXPR:
return "embedded expression";
7915 case PM_CONTEXT_BEGIN_ENSURE:
7916 case PM_CONTEXT_BLOCK_ENSURE:
7917 case PM_CONTEXT_CLASS_ENSURE:
7918 case PM_CONTEXT_DEF_ENSURE:
7919 case PM_CONTEXT_LAMBDA_ENSURE:
7920 case PM_CONTEXT_MODULE_ENSURE:
7921 case PM_CONTEXT_SCLASS_ENSURE:
return "'ensure' clause";
7922 case PM_CONTEXT_FOR:
return "for loop";
7923 case PM_CONTEXT_FOR_INDEX:
return "for loop index";
7924 case PM_CONTEXT_IF:
return "if statement";
7925 case PM_CONTEXT_LAMBDA_BRACES:
return "'{'..'}' lambda block";
7926 case PM_CONTEXT_LAMBDA_DO_END:
return "'do'..'end' lambda block";
7927 case PM_CONTEXT_LOOP_PREDICATE:
return "loop predicate";
7928 case PM_CONTEXT_MAIN:
return "top level context";
7929 case PM_CONTEXT_MODULE:
return "module definition";
7930 case PM_CONTEXT_MULTI_TARGET:
return "multiple targets";
7931 case PM_CONTEXT_PARENS:
return "parentheses";
7932 case PM_CONTEXT_POSTEXE:
return "'END' block";
7933 case PM_CONTEXT_PREDICATE:
return "predicate";
7934 case PM_CONTEXT_PREEXE:
return "'BEGIN' block";
7935 case PM_CONTEXT_BEGIN_RESCUE:
7936 case PM_CONTEXT_BLOCK_RESCUE:
7937 case PM_CONTEXT_CLASS_RESCUE:
7938 case PM_CONTEXT_DEF_RESCUE:
7939 case PM_CONTEXT_LAMBDA_RESCUE:
7940 case PM_CONTEXT_MODULE_RESCUE:
7941 case PM_CONTEXT_RESCUE_MODIFIER:
7942 case PM_CONTEXT_SCLASS_RESCUE:
return "'rescue' clause";
7943 case PM_CONTEXT_SCLASS:
return "singleton class definition";
7944 case PM_CONTEXT_TERNARY:
return "ternary expression";
7945 case PM_CONTEXT_UNLESS:
return "unless statement";
7946 case PM_CONTEXT_UNTIL:
return "until statement";
7947 case PM_CONTEXT_WHILE:
return "while statement";
7950 PRISM_ASSERT(
false &&
"unreachable");
7959pm_strspn_number_validate(
pm_parser_t *parser,
const uint8_t *
string,
size_t length,
const uint8_t *invalid) {
7960 if (invalid != NULL) {
7961 pm_diagnostic_id_t diag_id = (invalid == (
string + length - 1)) ? PM_ERR_INVALID_NUMBER_UNDERSCORE_TRAILING : PM_ERR_INVALID_NUMBER_UNDERSCORE_INNER;
7962 pm_parser_err(parser, U32(invalid - parser->start), 1, diag_id);
7967pm_strspn_binary_number_validate(
pm_parser_t *parser,
const uint8_t *
string) {
7968 const uint8_t *invalid = NULL;
7969 size_t length = pm_strspn_binary_number(
string, parser->end -
string, &invalid);
7970 pm_strspn_number_validate(parser,
string, length, invalid);
7975pm_strspn_octal_number_validate(
pm_parser_t *parser,
const uint8_t *
string) {
7976 const uint8_t *invalid = NULL;
7977 size_t length = pm_strspn_octal_number(
string, parser->end -
string, &invalid);
7978 pm_strspn_number_validate(parser,
string, length, invalid);
7983pm_strspn_decimal_number_validate(
pm_parser_t *parser,
const uint8_t *
string) {
7984 const uint8_t *invalid = NULL;
7985 size_t length = pm_strspn_decimal_number(
string, parser->end -
string, &invalid);
7986 pm_strspn_number_validate(parser,
string, length, invalid);
7991pm_strspn_hexadecimal_number_validate(
pm_parser_t *parser,
const uint8_t *
string) {
7992 const uint8_t *invalid = NULL;
7993 size_t length = pm_strspn_hexadecimal_number(
string, parser->end -
string, &invalid);
7994 pm_strspn_number_validate(parser,
string, length, invalid);
7998static pm_token_type_t
7999lex_optional_float_suffix(
pm_parser_t *parser,
bool* seen_e) {
8000 pm_token_type_t
type = PM_TOKEN_INTEGER;
8004 if (peek(parser) ==
'.') {
8005 if (pm_char_is_decimal_digit(peek_offset(parser, 1))) {
8006 parser->current.end += 2;
8007 parser->current.end += pm_strspn_decimal_number_validate(parser, parser->current.end);
8008 type = PM_TOKEN_FLOAT;
8018 if ((peek(parser) ==
'e') || (peek(parser) ==
'E')) {
8019 if ((peek_offset(parser, 1) ==
'+') || (peek_offset(parser, 1) ==
'-')) {
8020 parser->current.end += 2;
8022 if (pm_char_is_decimal_digit(peek(parser))) {
8023 parser->current.end++;
8024 parser->current.end += pm_strspn_decimal_number_validate(parser, parser->current.end);
8026 pm_parser_err_current(parser, PM_ERR_INVALID_FLOAT_EXPONENT);
8028 }
else if (pm_char_is_decimal_digit(peek_offset(parser, 1))) {
8029 parser->current.end++;
8030 parser->current.end += pm_strspn_decimal_number_validate(parser, parser->current.end);
8036 type = PM_TOKEN_FLOAT;
8042static pm_token_type_t
8043lex_numeric_prefix(
pm_parser_t *parser,
bool* seen_e) {
8044 pm_token_type_t
type = PM_TOKEN_INTEGER;
8047 if (peek_offset(parser, -1) ==
'0') {
8048 switch (*parser->current.end) {
8052 parser->current.end++;
8053 if (pm_char_is_decimal_digit(peek(parser))) {
8054 parser->current.end += pm_strspn_decimal_number_validate(parser, parser->current.end);
8057 pm_parser_err_current(parser, PM_ERR_INVALID_NUMBER_DECIMAL);
8065 parser->current.end++;
8066 if (pm_char_is_binary_digit(peek(parser))) {
8067 parser->current.end += pm_strspn_binary_number_validate(parser, parser->current.end);
8070 pm_parser_err_current(parser, PM_ERR_INVALID_NUMBER_BINARY);
8073 parser->integer.base = PM_INTEGER_BASE_FLAGS_BINARY;
8079 parser->current.end++;
8080 if (pm_char_is_octal_digit(peek(parser))) {
8081 parser->current.end += pm_strspn_octal_number_validate(parser, parser->current.end);
8084 pm_parser_err_current(parser, PM_ERR_INVALID_NUMBER_OCTAL);
8087 parser->integer.base = PM_INTEGER_BASE_FLAGS_OCTAL;
8100 parser->current.end += pm_strspn_octal_number_validate(parser, parser->current.end);
8101 parser->integer.base = PM_INTEGER_BASE_FLAGS_OCTAL;
8107 parser->current.end++;
8108 if (pm_char_is_hexadecimal_digit(peek(parser))) {
8109 parser->current.end += pm_strspn_hexadecimal_number_validate(parser, parser->current.end);
8112 pm_parser_err_current(parser, PM_ERR_INVALID_NUMBER_HEXADECIMAL);
8115 parser->integer.base = PM_INTEGER_BASE_FLAGS_HEXADECIMAL;
8120 type = lex_optional_float_suffix(parser, seen_e);
8127 type = lex_optional_float_suffix(parser, seen_e);
8133 parser->integer.value = 0;
8134 parser->integer.start = parser->current.start;
8142 const uint8_t *cursor = parser->current.end;
8143 const uint8_t *end = parser->end;
8144 uint64_t value = (uint64_t) (cursor[-1] -
'0');
8146 size_t underscores = 0;
8147 bool prev_underscore =
false;
8148 const uint8_t *invalid = NULL;
8150 while (cursor < end) {
8151 uint8_t c = *cursor;
8152 if (c >=
'0' && c <=
'9') {
8153 value = value * 10 + (uint64_t) (c -
'0');
8154 prev_underscore =
false;
8156 }
else if (c ==
'_') {
8158 if (prev_underscore && invalid == NULL) invalid = cursor;
8159 prev_underscore =
true;
8166 if (underscores > 0) {
8167 if (prev_underscore && invalid == NULL) invalid = cursor - 1;
8168 pm_strspn_number_validate(parser, parser->current.end, (
size_t) (cursor - parser->current.end), invalid);
8173 size_t digits = (size_t) (cursor - parser->current.end) + 1 - underscores;
8175 parser->integer.value = value;
8176 parser->integer.start = parser->current.start;
8179 parser->current.end = cursor;
8187 uint8_t next = peek(parser);
8188 if (next ==
'.' || next ==
'e' || next ==
'E') {
8189 type = lex_optional_float_suffix(parser, seen_e);
8197 if (peek_offset(parser, 0) ==
'.' && pm_char_is_decimal_digit(peek_offset(parser, 1))) {
8198 const uint8_t *fraction_start = parser->current.end;
8199 const uint8_t *fraction_end = parser->current.end + 2;
8200 fraction_end += pm_strspn_decimal_digit(fraction_end, parser->end - fraction_end);
8201 pm_parser_err(parser, U32(fraction_start - parser->start), U32(fraction_end - fraction_start), PM_ERR_INVALID_NUMBER_FRACTION);
8207static pm_token_type_t
8209 pm_token_type_t
type = PM_TOKEN_INTEGER;
8210 parser->integer.base = PM_INTEGER_BASE_FLAGS_DECIMAL;
8212 if (parser->current.end < parser->end) {
8213 bool seen_e =
false;
8214 type = lex_numeric_prefix(parser, &seen_e);
8216 const uint8_t *end = parser->current.end;
8217 pm_token_type_t suffix_type =
type;
8219 if (type == PM_TOKEN_INTEGER) {
8220 if (match(parser,
'r')) {
8221 suffix_type = PM_TOKEN_INTEGER_RATIONAL;
8223 if (match(parser,
'i')) {
8224 suffix_type = PM_TOKEN_INTEGER_RATIONAL_IMAGINARY;
8226 }
else if (match(parser,
'i')) {
8227 suffix_type = PM_TOKEN_INTEGER_IMAGINARY;
8230 if (!seen_e && match(parser,
'r')) {
8231 suffix_type = PM_TOKEN_FLOAT_RATIONAL;
8233 if (match(parser,
'i')) {
8234 suffix_type = PM_TOKEN_FLOAT_RATIONAL_IMAGINARY;
8236 }
else if (match(parser,
'i')) {
8237 suffix_type = PM_TOKEN_FLOAT_IMAGINARY;
8241 const uint8_t b = peek(parser);
8242 if (b !=
'\0' && (b >= 0x80 || ((b >=
'a' && b <=
'z') || (b >=
'A' && b <=
'Z')) || b ==
'_')) {
8243 parser->current.end = end;
8252static pm_token_type_t
8254 if (parser->current.end >= parser->end) {
8255 pm_parser_err_token(parser, &parser->current, PM_ERR_GLOBAL_VARIABLE_BARE);
8256 return PM_TOKEN_GLOBAL_VARIABLE;
8261 bool allow_multiple =
true;
8263 switch (*parser->current.end) {
8280 parser->current.end++;
8281 return PM_TOKEN_GLOBAL_VARIABLE;
8287 parser->current.end++;
8288 return lex_state_p(parser, PM_LEX_STATE_FNAME) ? PM_TOKEN_GLOBAL_VARIABLE : PM_TOKEN_BACK_REFERENCE;
8291 parser->current.end++;
8294 if ((width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end)) > 0) {
8296 parser->current.end += width;
8297 }
while ((width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end)) > 0);
8300 pm_diagnostic_id_t diag_id = parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 ? PM_ERR_INVALID_VARIABLE_GLOBAL_3_3 : PM_ERR_INVALID_VARIABLE_GLOBAL;
8301 PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, &parser->current, diag_id);
8304 return PM_TOKEN_GLOBAL_VARIABLE;
8316 parser->current.end += pm_strspn_decimal_digit(parser->current.end, parser->end - parser->current.end);
8317 return lex_state_p(parser, PM_LEX_STATE_FNAME) ? PM_TOKEN_GLOBAL_VARIABLE : PM_TOKEN_NUMBERED_REFERENCE;
8320 parser->current.end++;
8321 allow_multiple =
false;
8326 if ((width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end)) > 0) {
8328 parser->current.end += width;
8329 }
while (allow_multiple && (width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end)) > 0);
8330 }
else if (pm_char_is_whitespace(peek(parser))) {
8333 pm_parser_err_token(parser, &parser->current, PM_ERR_GLOBAL_VARIABLE_BARE);
8337 pm_diagnostic_id_t diag_id = parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 ? PM_ERR_INVALID_VARIABLE_GLOBAL_3_3 : PM_ERR_INVALID_VARIABLE_GLOBAL;
8338 size_t width = pm_encoding_char_width(parser->encoding, parser->current.end, parser->end - parser->current.end);
8339 PM_PARSER_ERR_FORMAT(parser, PM_TOKEN_START(parser, &parser->current), PM_TOKEN_LENGTH(&parser->current) + U32(width), diag_id, (
int) (PM_TOKEN_LENGTH(&parser->current) + U32(width)), (
const char *) parser->current.start);
8342 return PM_TOKEN_GLOBAL_VARIABLE;
8360 pm_lex_state_t state;
8363 pm_token_type_t type;
8367 pm_token_type_t modifier_type;
8373#define PM_KEYWORD_LENGTH_MAXIMUM 12
8379#define PM_KEYWORD_PACK(first, middle, last, length) \
8380 ((uint32_t) (first) | ((uint32_t) (middle) << 8) | ((uint32_t) (last) << 16) | ((uint32_t) (length) << 24))
8386#define PM_KEYWORD_SLOT_BITS 6
8401#define PM_KEYWORD_SLOT(packed) ((uint32_t) ((uint32_t) (packed) * 0x75f796ddU) >> (32 - PM_KEYWORD_SLOT_BITS))
8407#define PM_KEYWORD(name, first, middle, last, state, type, modifier_type) \
8408 [PM_KEYWORD_SLOT(PM_KEYWORD_PACK(first, middle, last, sizeof(name) - 1))] = { name, PM_KEYWORD_PACK(first, middle, last, sizeof(name) - 1), state, type, modifier_type }
8415static const pm_keyword_t pm_keywords[1 << PM_KEYWORD_SLOT_BITS] = {
8416 PM_KEYWORD(
"do",
'd',
'o',
'o', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_DO, PM_TOKEN_EOF),
8417 PM_KEYWORD(
"if",
'i',
'f',
'f', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_IF, PM_TOKEN_KEYWORD_IF_MODIFIER),
8418 PM_KEYWORD(
"in",
'i',
'n',
'n', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_IN, PM_TOKEN_EOF),
8419 PM_KEYWORD(
"or",
'o',
'r',
'r', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_OR, PM_TOKEN_EOF),
8420 PM_KEYWORD(
"and",
'a',
'n',
'd', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_AND, PM_TOKEN_EOF),
8421 PM_KEYWORD(
"def",
'd',
'e',
'f', PM_LEX_STATE_FNAME, PM_TOKEN_KEYWORD_DEF, PM_TOKEN_EOF),
8422 PM_KEYWORD(
"end",
'e',
'n',
'd', PM_LEX_STATE_END, PM_TOKEN_KEYWORD_END, PM_TOKEN_EOF),
8423 PM_KEYWORD(
"END",
'E',
'N',
'D', PM_LEX_STATE_END, PM_TOKEN_KEYWORD_END_UPCASE, PM_TOKEN_EOF),
8424 PM_KEYWORD(
"for",
'f',
'o',
'r', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_FOR, PM_TOKEN_EOF),
8425 PM_KEYWORD(
"nil",
'n',
'i',
'l', PM_LEX_STATE_END, PM_TOKEN_KEYWORD_NIL, PM_TOKEN_EOF),
8426 PM_KEYWORD(
"not",
'n',
'o',
't', PM_LEX_STATE_ARG, PM_TOKEN_KEYWORD_NOT, PM_TOKEN_EOF),
8427 PM_KEYWORD(
"case",
'c',
's',
'e', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_CASE, PM_TOKEN_EOF),
8428 PM_KEYWORD(
"else",
'e',
's',
'e', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_EOF),
8429 PM_KEYWORD(
"next",
'n',
'x',
't', PM_LEX_STATE_MID, PM_TOKEN_KEYWORD_NEXT, PM_TOKEN_EOF),
8430 PM_KEYWORD(
"redo",
'r',
'd',
'o', PM_LEX_STATE_END, PM_TOKEN_KEYWORD_REDO, PM_TOKEN_EOF),
8431 PM_KEYWORD(
"self",
's',
'l',
'f', PM_LEX_STATE_END, PM_TOKEN_KEYWORD_SELF, PM_TOKEN_EOF),
8432 PM_KEYWORD(
"then",
't',
'e',
'n', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_THEN, PM_TOKEN_EOF),
8433 PM_KEYWORD(
"true",
't',
'u',
'e', PM_LEX_STATE_END, PM_TOKEN_KEYWORD_TRUE, PM_TOKEN_EOF),
8434 PM_KEYWORD(
"when",
'w',
'e',
'n', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_WHEN, PM_TOKEN_EOF),
8435 PM_KEYWORD(
"alias",
'a',
'i',
's', PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM, PM_TOKEN_KEYWORD_ALIAS, PM_TOKEN_EOF),
8436 PM_KEYWORD(
"begin",
'b',
'g',
'n', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_BEGIN, PM_TOKEN_EOF),
8437 PM_KEYWORD(
"BEGIN",
'B',
'G',
'N', PM_LEX_STATE_END, PM_TOKEN_KEYWORD_BEGIN_UPCASE, PM_TOKEN_EOF),
8438 PM_KEYWORD(
"break",
'b',
'e',
'k', PM_LEX_STATE_MID, PM_TOKEN_KEYWORD_BREAK, PM_TOKEN_EOF),
8439 PM_KEYWORD(
"class",
'c',
'a',
's', PM_LEX_STATE_CLASS, PM_TOKEN_KEYWORD_CLASS, PM_TOKEN_EOF),
8440 PM_KEYWORD(
"elsif",
'e',
's',
'f', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_ELSIF, PM_TOKEN_EOF),
8441 PM_KEYWORD(
"false",
'f',
'l',
'e', PM_LEX_STATE_END, PM_TOKEN_KEYWORD_FALSE, PM_TOKEN_EOF),
8442 PM_KEYWORD(
"retry",
'r',
't',
'y', PM_LEX_STATE_END, PM_TOKEN_KEYWORD_RETRY, PM_TOKEN_EOF),
8443 PM_KEYWORD(
"super",
's',
'p',
'r', PM_LEX_STATE_ARG, PM_TOKEN_KEYWORD_SUPER, PM_TOKEN_EOF),
8444 PM_KEYWORD(
"undef",
'u',
'd',
'f', PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM, PM_TOKEN_KEYWORD_UNDEF, PM_TOKEN_EOF),
8445 PM_KEYWORD(
"until",
'u',
't',
'l', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_UNTIL, PM_TOKEN_KEYWORD_UNTIL_MODIFIER),
8446 PM_KEYWORD(
"while",
'w',
'i',
'e', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_WHILE, PM_TOKEN_KEYWORD_WHILE_MODIFIER),
8447 PM_KEYWORD(
"yield",
'y',
'e',
'd', PM_LEX_STATE_ARG, PM_TOKEN_KEYWORD_YIELD, PM_TOKEN_EOF),
8448 PM_KEYWORD(
"ensure",
'e',
'u',
'e', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_EOF),
8449 PM_KEYWORD(
"module",
'm',
'u',
'e', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_MODULE, PM_TOKEN_EOF),
8450 PM_KEYWORD(
"rescue",
'r',
'c',
'e', PM_LEX_STATE_MID, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_RESCUE_MODIFIER),
8451 PM_KEYWORD(
"return",
'r',
'u',
'n', PM_LEX_STATE_MID, PM_TOKEN_KEYWORD_RETURN, PM_TOKEN_EOF),
8452 PM_KEYWORD(
"unless",
'u',
'e',
's', PM_LEX_STATE_BEG, PM_TOKEN_KEYWORD_UNLESS, PM_TOKEN_KEYWORD_UNLESS_MODIFIER),
8453 PM_KEYWORD(
"defined?",
'd',
'n',
'?', PM_LEX_STATE_ARG, PM_TOKEN_KEYWORD_DEFINED, PM_TOKEN_EOF),
8454 PM_KEYWORD(
"__LINE__",
'_',
'N',
'_', PM_LEX_STATE_END, PM_TOKEN_KEYWORD___LINE__, PM_TOKEN_EOF),
8455 PM_KEYWORD(
"__FILE__",
'_',
'L',
'_', PM_LEX_STATE_END, PM_TOKEN_KEYWORD___FILE__, PM_TOKEN_EOF),
8456 PM_KEYWORD(
"__ENCODING__",
'_',
'D',
'_', PM_LEX_STATE_END, PM_TOKEN_KEYWORD___ENCODING__, PM_TOKEN_EOF)
8466pm_keyword_find(
const uint8_t *start,
const uint8_t *end) {
8467 ptrdiff_t width = end - start;
8468 if (width < 2 || width > PM_KEYWORD_LENGTH_MAXIMUM)
return NULL;
8470 size_t uwidth = (size_t) width;
8471 uint32_t packed = PM_KEYWORD_PACK(start[0], start[uwidth >> 1], start[uwidth - 1], uwidth);
8473 const pm_keyword_t *keyword = &pm_keywords[PM_KEYWORD_SLOT(packed)];
8474 return (keyword->packed == packed && memcmp(start + 1, keyword->name + 1, uwidth - 2) == 0) ? keyword : NULL;
8482pm_keyword_p(
const uint8_t *start,
const uint8_t *end) {
8483 return pm_keyword_find(start, end) != NULL;
8486static pm_token_type_t
8487lex_identifier(
pm_parser_t *parser,
bool previous_command_start) {
8489 const uint8_t *end = parser->end;
8490 const uint8_t *current_start = parser->current.start;
8491 const uint8_t *current_end = parser->current.end;
8492 bool encoding_changed = parser->encoding_changed;
8497 current_end += scan_identifier_ascii(current_end, end);
8501 if (encoding_changed) {
8502 while ((width = char_is_identifier(parser, current_end, end - current_end)) > 0) {
8503 current_end += width;
8506 while ((width = char_is_identifier_utf8(current_end, end - current_end)) > 0) {
8507 current_end += width;
8511 parser->current.end = current_end;
8515 bool method_name =
false;
8517 if (current_end < end) {
8518 if (((current_end + 1 >= end) || (current_end[1] !=
'=')) && (match(parser,
'!') || match(parser,
'?'))) {
8524 ((lex_state_p(parser, PM_LEX_STATE_LABEL | PM_LEX_STATE_ENDFN) && !previous_command_start) || lex_state_arg_p(parser)) &&
8525 (peek(parser) ==
':') && (peek_offset(parser, 1) !=
':')
8529 lex_state_set(parser, PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED);
8530 (void) match(parser,
':');
8534 parser->explicit_encoding = NULL;
8535 return PM_TOKEN_LABEL;
8539 }
else if (lex_state_p(parser, PM_LEX_STATE_FNAME) && peek_offset(parser, 1) !=
'~' && peek_offset(parser, 1) !=
'>' && (peek_offset(parser, 1) !=
'=' || peek_offset(parser, 2) ==
'>') && match(parser,
'=')) {
8542 return PM_TOKEN_IDENTIFIER;
8544 ((lex_state_p(parser, PM_LEX_STATE_LABEL | PM_LEX_STATE_ENDFN) && !previous_command_start) || lex_state_arg_p(parser)) &&
8545 peek(parser) ==
':' && peek_offset(parser, 1) !=
':'
8549 lex_state_set(parser, PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED);
8550 (void) match(parser,
':');
8554 parser->explicit_encoding = NULL;
8555 return PM_TOKEN_LABEL;
8559 if (parser->lex_state != PM_LEX_STATE_DOT) {
8563 pm_lex_state_t previous_lex_state = parser->lex_state;
8564 const pm_keyword_t *keyword = pm_keyword_find(current_start, current_end);
8566 if (keyword != NULL) {
8567 if (previous_lex_state & PM_LEX_STATE_FNAME) {
8568 lex_state_set(parser, PM_LEX_STATE_ENDFN);
8570 lex_state_set(parser, keyword->state);
8571 if (keyword->state == PM_LEX_STATE_BEG) {
8572 parser->command_start =
true;
8575 if ((keyword->modifier_type != PM_TOKEN_EOF) && !(previous_lex_state & (PM_LEX_STATE_BEG | PM_LEX_STATE_LABELED | PM_LEX_STATE_CLASS))) {
8576 lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
8577 return keyword->modifier_type;
8581 if (keyword->type == PM_TOKEN_KEYWORD_DO) {
8586 if (previous_lex_state & PM_LEX_STATE_FNAME) {
8587 return PM_TOKEN_KEYWORD_DO;
8589 if (parser->enclosure_nesting == parser->lambda_enclosure_nesting) {
8600 parser->lambda_enclosure_nesting = -1;
8601 return PM_TOKEN_KEYWORD_DO_LAMBDA;
8603 if (pm_do_loop_stack_p(parser)) {
8604 return PM_TOKEN_KEYWORD_DO_LOOP;
8606 if (!pm_accepts_block_stack_p(parser)) {
8607 return PM_TOKEN_KEYWORD_DO_BLOCK;
8609 return PM_TOKEN_KEYWORD_DO;
8612 return keyword->type;
8617 return PM_TOKEN_METHOD_NAME;
8620 if (encoding_changed) {
8621 return pm_encoding_isupper_char(parser->encoding, current_start, end - current_start, parser->version) ? PM_TOKEN_CONSTANT : PM_TOKEN_IDENTIFIER;
8627 if (*current_start < 0x80) {
8628 return (*current_start >=
'A' && *current_start <=
'Z') ? PM_TOKEN_CONSTANT : PM_TOKEN_IDENTIFIER;
8630 return pm_encoding_utf_8_isupper_char(current_start, end - current_start, parser->version) ? PM_TOKEN_CONSTANT : PM_TOKEN_IDENTIFIER;
8639 if (parser->current.start == parser->start)
return true;
8641 switch (parser->current.start[-1]) {
8645 return (parser->current.start - parser->start == 3 && parser->start[0] == 0xef && parser->start[1] == 0xbb);
8665static pm_token_type_t
8666lex_interpolation(
pm_parser_t *parser,
const uint8_t *pound) {
8669 if (pound + 1 >= parser->end) {
8670 parser->current.end = pound + 1;
8671 return PM_TOKEN_STRING_CONTENT;
8680 if (pound + 2 >= parser->end) {
8681 parser->current.end = pound + 1;
8682 return PM_TOKEN_STRING_CONTENT;
8687 const uint8_t *variable = pound + 2;
8688 if (*variable ==
'@' && pound + 3 < parser->end) variable++;
8690 if (char_is_identifier_start(parser, variable, parser->end - variable)) {
8694 if (pound > parser->current.start) {
8695 parser->current.end = pound;
8696 return PM_TOKEN_STRING_CONTENT;
8701 lex_mode_push(parser, (pm_lex_mode_t) { .mode = PM_LEX_EMBVAR });
8702 parser->current.end = pound + 1;
8703 return PM_TOKEN_EMBVAR;
8709 parser->current.end = pound + 1;
8715 if (pound + 2 >= parser->end) {
8716 parser->current.end = pound + 1;
8717 return PM_TOKEN_STRING_CONTENT;
8723 const uint8_t *check = pound + 2;
8725 if (pound[2] ==
'-') {
8726 if (pound + 3 >= parser->end) {
8727 parser->current.end = pound + 2;
8728 return PM_TOKEN_STRING_CONTENT;
8739 char_is_identifier_start(parser, check, parser->end - check) ||
8740 (pound[2] !=
'-' && (pm_char_is_decimal_digit(pound[2]) || char_is_global_name_punctuation(pound[2])))
8745 if (pound > parser->current.start) {
8746 parser->current.end = pound;
8747 return PM_TOKEN_STRING_CONTENT;
8752 lex_mode_push(parser, (pm_lex_mode_t) { .mode = PM_LEX_EMBVAR });
8753 parser->current.end = pound + 1;
8754 return PM_TOKEN_EMBVAR;
8759 parser->current.end = pound + 1;
8765 if (pound > parser->current.start) {
8766 parser->current.end = pound;
8767 return PM_TOKEN_STRING_CONTENT;
8770 parser->enclosure_nesting++;
8774 lex_mode_push(parser, (pm_lex_mode_t) { .mode = PM_LEX_EMBEXPR });
8775 parser->current.end = pound + 2;
8776 parser->command_start =
true;
8777 pm_enclosure_frame_push(parser);
8778 return PM_TOKEN_EMBEXPR_BEGIN;
8783 parser->current.end = pound + 1;
8788static const uint8_t PM_ESCAPE_FLAG_NONE = 0x0;
8789static const uint8_t PM_ESCAPE_FLAG_CONTROL = 0x1;
8790static const uint8_t PM_ESCAPE_FLAG_META = 0x2;
8791static const uint8_t PM_ESCAPE_FLAG_SINGLE = 0x4;
8792static const uint8_t PM_ESCAPE_FLAG_REGEXP = 0x8;
8797static const bool ascii_printable_chars[] = {
8798 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
8799 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
8800 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
8801 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
8802 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
8803 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,
8804 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
8805 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0
8809char_is_ascii_printable(
const uint8_t b) {
8810 return (b < 0x80) && ascii_printable_chars[b];
8818escape_hexadecimal_digit(
const uint8_t value) {
8819 return (uint8_t) ((value <=
'9') ? (value -
'0') : (value & 0x7) + 9);
8828escape_unicode(
pm_parser_t *parser,
const uint8_t *
string,
size_t length,
const pm_location_t *error_location,
const uint8_t flags) {
8830 for (
size_t index = 0; index < length; index++) {
8831 if (index != 0) value <<= 4;
8832 value |= escape_hexadecimal_digit(
string[index]);
8837 if (value >= 0xD800 && value <= 0xDFFF) {
8838 if (flags & PM_ESCAPE_FLAG_REGEXP) {
8841 }
else if (error_location != NULL) {
8842 pm_parser_err(parser, error_location->
start, error_location->
length, PM_ERR_ESCAPE_INVALID_UNICODE);
8844 pm_parser_err(parser, U32(
string - parser->start), U32(length), PM_ERR_ESCAPE_INVALID_UNICODE);
8856escape_byte(uint8_t value,
const uint8_t flags) {
8857 if (flags & PM_ESCAPE_FLAG_CONTROL) value &= 0x9f;
8858 if (flags & PM_ESCAPE_FLAG_META) value |= 0x80;
8866escape_write_unicode(
pm_parser_t *parser,
pm_buffer_t *buffer,
const uint8_t flags,
const uint8_t *start,
const uint8_t *end, uint32_t value) {
8870 if (value >= 0x80 || flags & PM_ESCAPE_FLAG_SINGLE) {
8871 if (parser->explicit_encoding != NULL && parser->explicit_encoding != PM_ENCODING_UTF_8_ENTRY) {
8872 if (flags & PM_ESCAPE_FLAG_REGEXP) {
8876 PM_PARSER_ERR_FORMAT(parser, U32(start - parser->start), U32(end - start), PM_ERR_MIXED_ENCODING, parser->explicit_encoding->name);
8880 parser->explicit_encoding = PM_ENCODING_UTF_8_ENTRY;
8883 if (!(flags & PM_ESCAPE_FLAG_REGEXP) && !pm_buffer_append_unicode_codepoint(buffer, value)) {
8884 pm_parser_err(parser, U32(start - parser->start), U32(end - start), PM_ERR_ESCAPE_INVALID_UNICODE);
8885 pm_buffer_append_byte(buffer, 0xEF);
8886 pm_buffer_append_byte(buffer, 0xBF);
8887 pm_buffer_append_byte(buffer, 0xBD);
8900 if (parser->explicit_encoding != NULL && parser->explicit_encoding == PM_ENCODING_UTF_8_ENTRY && parser->encoding != PM_ENCODING_UTF_8_ENTRY) {
8901 if (flags & PM_ESCAPE_FLAG_REGEXP) {
8905 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_MIXED_ENCODING, parser->encoding->name);
8909 parser->explicit_encoding = parser->encoding;
8912 if (!(flags & PM_ESCAPE_FLAG_REGEXP)) pm_buffer_append_byte(buffer,
byte);
8932 if (flags & PM_ESCAPE_FLAG_REGEXP) {
8933 pm_buffer_append_format(buffer,
"\\x%02X",
byte);
8936 escape_write_byte_encoded(parser, buffer, flags,
byte);
8950 PRISM_ASSERT(parser->heredoc_end <= parser->end);
8951 parser->next_start = parser->heredoc_end;
8952 parser->heredoc_end = NULL;
8965escape_consume_newline(
pm_parser_t *parser, uint32_t width) {
8966 if (parser->heredoc_end == NULL) {
8967 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, PM_TOKEN_END(parser, &parser->current) + width);
8969 parser_flush_heredoc_end(parser);
8979 escape_write_byte(parser, buffer, flags, escape_byte(0, flags));
8988 if (parser->current.end >= parser->end)
return;
8990 size_t eol_length = match_eol(parser);
8991 if (eol_length > 0) {
8992 escape_consume_newline(parser, U32(eol_length));
8993 parser->current.end += eol_length;
8997 size_t width = pm_encoding_char_width(parser->encoding, parser->current.end, parser->end - parser->current.end);
8998 parser->current.end += (width == 0 ? 1 : width);
9007 if (parser->encoding_changed) {
9008 width = pm_encoding_char_width(parser->encoding, parser->current.end, parser->end - parser->current.end);
9010 width = pm_encoding_utf_8_char_width(parser->current.end, parser->end - parser->current.end);
9014 if (*parser->current.end ==
'\n') escape_consume_newline(parser, 1);
9015 escape_write_byte(parser, buffer, flags, escape_byte(*parser->current.end++, flags));
9016 }
else if (width > 1) {
9018 pm_buffer_append_bytes(buffer, parser->current.end, width);
9019 parser->current.end += width;
9023 parser->current.end++;
9024 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL);
9034escape_read_warn(
pm_parser_t *parser, uint8_t flags, uint8_t flag,
const char *type) {
9035#define FLAG(value) ((value & PM_ESCAPE_FLAG_CONTROL) ? "\\C-" : (value & PM_ESCAPE_FLAG_META) ? "\\M-" : "")
9037 PM_PARSER_WARN_TOKEN_FORMAT(
9040 PM_WARN_INVALID_CHARACTER,
9056escape_consume_modified_byte(
pm_parser_t *parser, uint8_t
byte, uint8_t flags, uint8_t flag) {
9057 size_t eol_length = match_eol(parser);
9059 if (eol_length > 0) {
9060 escape_consume_newline(parser, U32(eol_length));
9061 parser->current.end += eol_length;
9064 parser->current.end++;
9068 case '\n': escape_read_warn(parser, flags, flag,
"\\n");
break;
9069 case '\t': escape_read_warn(parser, flags, flag,
"\\t");
break;
9070 case '\v': escape_read_warn(parser, flags, flag,
"\\v");
break;
9071 case '\f': escape_read_warn(parser, flags, flag,
"\\f");
break;
9072 case '\r': escape_read_warn(parser, flags, flag,
"\\r");
break;
9099 switch (peeked = peek(parser)) {
9101 parser->current.end++;
9102 escape_write_byte(parser, buffer, flags, escape_byte(
'\\', flags));
9106 parser->current.end++;
9107 escape_write_byte(parser, buffer, flags, escape_byte(
'\'', flags));
9111 parser->current.end++;
9112 escape_write_byte(parser, buffer, flags, escape_byte(
'\a', flags));
9116 parser->current.end++;
9117 escape_write_byte(parser, buffer, flags, escape_byte(
'\b', flags));
9121 parser->current.end++;
9122 escape_write_byte(parser, buffer, flags, escape_byte(
'\033', flags));
9126 parser->current.end++;
9127 escape_write_byte(parser, buffer, flags, escape_byte(
'\f', flags));
9131 parser->current.end++;
9132 escape_write_byte(parser, buffer, flags, escape_byte(
'\n', flags));
9136 parser->current.end++;
9137 escape_write_byte(parser, buffer, flags, escape_byte(
'\r', flags));
9141 parser->current.end++;
9142 escape_write_byte(parser, buffer, flags, escape_byte(
' ', flags));
9146 parser->current.end++;
9147 escape_write_byte(parser, buffer, flags, escape_byte(
'\t', flags));
9151 parser->current.end++;
9152 escape_write_byte(parser, buffer, flags, escape_byte(
'\v', flags));
9155 case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7': {
9156 uint8_t value = (uint8_t) (*parser->current.end -
'0');
9157 parser->current.end++;
9159 if (pm_char_is_octal_digit(peek(parser))) {
9160 value = ((uint8_t) (value << 3)) | ((uint8_t) (*parser->current.end -
'0'));
9161 parser->current.end++;
9163 if (pm_char_is_octal_digit(peek(parser))) {
9164 value = ((uint8_t) (value << 3)) | ((uint8_t) (*parser->current.end -
'0'));
9165 parser->current.end++;
9169 value = escape_byte(value, flags);
9170 escape_write_byte(parser, buffer, flags, value);
9174 const uint8_t *start = parser->current.end - 1;
9176 parser->current.end++;
9177 uint8_t
byte = peek(parser);
9179 if (pm_char_is_hexadecimal_digit(
byte)) {
9180 uint8_t value = escape_hexadecimal_digit(
byte);
9181 parser->current.end++;
9183 byte = peek(parser);
9184 if (pm_char_is_hexadecimal_digit(
byte)) {
9185 value = (uint8_t) ((value << 4) | escape_hexadecimal_digit(
byte));
9186 parser->current.end++;
9189 value = escape_byte(value, flags);
9190 if (flags & PM_ESCAPE_FLAG_REGEXP) {
9191 if (flags & (PM_ESCAPE_FLAG_CONTROL | PM_ESCAPE_FLAG_META)) {
9192 pm_buffer_append_format(buffer,
"\\x%02X", value);
9194 pm_buffer_append_bytes(buffer, start, (
size_t) (parser->current.end - start));
9198 escape_write_byte_encoded(parser, buffer, flags, value);
9200 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_HEXADECIMAL);
9204 if (!(flags & PM_ESCAPE_FLAG_REGEXP) || (flags & (PM_ESCAPE_FLAG_CONTROL | PM_ESCAPE_FLAG_META))) {
9205 escape_write_invalid(parser, buffer, flags);
9212 const uint8_t *start = parser->current.end - 1;
9213 parser->current.end++;
9215 if (parser->current.end == parser->end) {
9216 if (flags & PM_ESCAPE_FLAG_REGEXP) {
9219 pm_buffer_append_bytes(buffer, start, (
size_t) (parser->current.end - start));
9221 const uint8_t *start = parser->current.end - 2;
9222 PM_PARSER_ERR_FORMAT(parser, U32(start - parser->start), U32(parser->current.end - start), PM_ERR_ESCAPE_INVALID_UNICODE_SHORT, 2, start);
9224 }
else if (peek(parser) ==
'{') {
9225 const uint8_t *unicode_codepoints_start = parser->current.end - 2;
9226 parser->current.end++;
9230 if ((whitespace = pm_strspn_inline_whitespace(parser->current.end, parser->end - parser->current.end)) > 0) {
9231 parser->current.end += whitespace;
9232 }
else if (peek(parser) ==
'\\' && peek_offset(parser, 1) ==
'n') {
9237 parser->current.end += 2;
9243 const uint8_t *extra_codepoints_start = NULL;
9244 int codepoints_count = 0;
9246 while ((parser->current.end < parser->end) && (*parser->current.end !=
'}')) {
9247 const uint8_t *unicode_start = parser->current.end;
9248 size_t hexadecimal_length = pm_strspn_hexadecimal_digit(parser->current.end, parser->end - parser->current.end);
9250 if (hexadecimal_length > 6) {
9255 if (!(flags & PM_ESCAPE_FLAG_REGEXP)) {
9256 pm_parser_err(parser, U32(unicode_start - parser->start), U32(hexadecimal_length), PM_ERR_ESCAPE_INVALID_UNICODE_LONG);
9258 }
else if (hexadecimal_length == 0) {
9261 if (flags & PM_ESCAPE_FLAG_REGEXP) {
9266 pm_buffer_append_bytes(buffer, start, (
size_t) (parser->current.end - start));
9268 pm_parser_err(parser, PM_TOKEN_END(parser, &parser->current), 0, PM_ERR_ESCAPE_INVALID_UNICODE);
9269 pm_parser_err(parser, PM_TOKEN_END(parser, &parser->current), 0, PM_ERR_ESCAPE_INVALID_UNICODE_TERM);
9275 parser->current.end += hexadecimal_length;
9277 if (flags & PM_ESCAPE_FLAG_SINGLE && codepoints_count == 2) {
9278 extra_codepoints_start = unicode_start;
9281 uint32_t value = escape_unicode(parser, unicode_start, hexadecimal_length, NULL, flags);
9282 escape_write_unicode(parser, buffer, flags, unicode_start, parser->current.end, value);
9284 parser->current.end += pm_strspn_inline_whitespace(parser->current.end, parser->end - parser->current.end);
9289 if (flags & PM_ESCAPE_FLAG_SINGLE && codepoints_count > 1) {
9290 pm_parser_err(parser, U32(extra_codepoints_start - parser->start), U32(parser->current.end - extra_codepoints_start), PM_ERR_ESCAPE_INVALID_UNICODE_LITERAL);
9293 if (parser->current.end == parser->end) {
9296 if (!(flags & PM_ESCAPE_FLAG_REGEXP)) {
9297 PM_PARSER_ERR_FORMAT(parser, U32(start - parser->start), U32(parser->current.end - start), PM_ERR_ESCAPE_INVALID_UNICODE_LIST, (
int) (parser->current.end - start), start);
9299 }
else if (peek(parser) ==
'}') {
9300 parser->current.end++;
9302 if (flags & PM_ESCAPE_FLAG_REGEXP) {
9307 pm_buffer_append_bytes(buffer, start, (
size_t) (parser->current.end - start));
9309 pm_parser_err(parser, U32(unicode_codepoints_start - parser->start), U32(parser->current.end - unicode_codepoints_start), PM_ERR_ESCAPE_INVALID_UNICODE_TERM);
9313 if (flags & PM_ESCAPE_FLAG_REGEXP) {
9314 pm_buffer_append_bytes(buffer, unicode_codepoints_start, (
size_t) (parser->current.end - unicode_codepoints_start));
9317 size_t length = pm_strspn_hexadecimal_digit(parser->current.end, MIN(parser->end - parser->current.end, 4));
9320 if (flags & PM_ESCAPE_FLAG_REGEXP) {
9321 pm_buffer_append_bytes(buffer, start, (
size_t) (parser->current.end - start));
9323 const uint8_t *start = parser->current.end - 2;
9324 PM_PARSER_ERR_FORMAT(parser, U32(start - parser->start), U32(parser->current.end - start), PM_ERR_ESCAPE_INVALID_UNICODE_SHORT, 2, start);
9326 }
else if (length == 4) {
9327 uint32_t value = escape_unicode(parser, parser->current.end, 4, NULL, flags);
9329 if (flags & PM_ESCAPE_FLAG_REGEXP) {
9330 pm_buffer_append_bytes(buffer, start, (
size_t) (parser->current.end + 4 - start));
9333 escape_write_unicode(parser, buffer, flags, start, parser->current.end + 4, value);
9334 parser->current.end += 4;
9336 parser->current.end += length;
9338 if (flags & PM_ESCAPE_FLAG_REGEXP) {
9342 pm_buffer_append_bytes(buffer, start, (
size_t) (parser->current.end - start));
9344 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_UNICODE);
9352 parser->current.end++;
9354 if (peek(parser) !=
'-') {
9355 escape_skip_char(parser);
9356 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL);
9357 escape_write_invalid(parser, buffer, flags);
9366 parser->current.end++;
9368 if (flags & PM_ESCAPE_FLAG_CONTROL) {
9369 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL_REPEAT);
9370 escape_write_invalid(parser, buffer, flags);
9374 if (parser->current.end == parser->end) {
9375 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL);
9376 escape_write_invalid(parser, buffer, flags);
9380 uint8_t peeked = peek(parser);
9383 parser->current.end++;
9384 escape_write_byte(parser, buffer, flags, escape_byte(0x7f, flags));
9388 parser->current.end++;
9390 if (match(parser,
'u') || match(parser,
'U')) {
9391 pm_parser_err(parser, PM_TOKEN_START(parser, &parser->current), PM_TOKEN_LENGTH(&parser->current), PM_ERR_INVALID_ESCAPE_CHARACTER);
9392 escape_write_invalid(parser, buffer, flags);
9396 flags |= PM_ESCAPE_FLAG_CONTROL;
9397 goto escape_read_next;
9399 parser->current.end++;
9400 escape_read_warn(parser, flags, PM_ESCAPE_FLAG_CONTROL,
"\\s");
9401 escape_write_byte(parser, buffer, flags, escape_byte(peeked, flags | PM_ESCAPE_FLAG_CONTROL));
9404 if (!char_is_ascii_printable(peeked)) {
9405 escape_skip_char(parser);
9406 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_CONTROL);
9407 escape_write_invalid(parser, buffer, flags);
9411 escape_write_byte(parser, buffer, flags, escape_byte(escape_consume_modified_byte(parser, peeked, flags, 0), flags | PM_ESCAPE_FLAG_CONTROL));
9417 parser->current.end++;
9419 if (flags & PM_ESCAPE_FLAG_META) {
9420 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_META_REPEAT);
9421 escape_write_invalid(parser, buffer, flags);
9425 if (peek(parser) !=
'-') {
9426 escape_skip_char(parser);
9427 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_META);
9428 escape_write_invalid(parser, buffer, flags);
9432 parser->current.end++;
9433 if (parser->current.end == parser->end) {
9434 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_META);
9435 escape_write_invalid(parser, buffer, flags);
9439 uint8_t peeked = peek(parser);
9442 parser->current.end++;
9444 if (match(parser,
'u') || match(parser,
'U')) {
9445 pm_parser_err(parser, PM_TOKEN_START(parser, &parser->current), PM_TOKEN_LENGTH(&parser->current), PM_ERR_INVALID_ESCAPE_CHARACTER);
9446 escape_write_invalid(parser, buffer, flags);
9450 flags |= PM_ESCAPE_FLAG_META;
9451 goto escape_read_next;
9453 parser->current.end++;
9454 escape_read_warn(parser, flags, PM_ESCAPE_FLAG_META,
"\\s");
9455 escape_write_byte(parser, buffer, flags, escape_byte(peeked, flags | PM_ESCAPE_FLAG_META));
9458 if (!char_is_ascii_printable(peeked)) {
9459 escape_skip_char(parser);
9460 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_META);
9461 escape_write_invalid(parser, buffer, flags);
9465 escape_write_byte(parser, buffer, flags, escape_byte(escape_consume_modified_byte(parser, peeked, flags & ((uint8_t) ~PM_ESCAPE_FLAG_CONTROL), PM_ESCAPE_FLAG_META), flags | PM_ESCAPE_FLAG_META));
9470 if (peek_offset(parser, 1) ==
'\n') {
9471 escape_consume_newline(parser, 2);
9472 parser->current.end += 2;
9473 escape_write_byte(parser, buffer, flags, escape_byte(
'\n', flags));
9482 bool wrapped = (flags & (PM_ESCAPE_FLAG_CONTROL | PM_ESCAPE_FLAG_META)) != 0;
9484 if (wrapped && parser->current.end < parser->end && peeked >= 0x80) {
9485 escape_skip_char(parser);
9486 pm_parser_err_current(parser, PM_ERR_ESCAPE_INVALID_META);
9487 escape_write_invalid(parser, buffer, flags);
9491 if (parser->current.end < parser->end) {
9492 escape_write_escape_encoded(parser, buffer, flags);
9494 pm_parser_err_current(parser, PM_ERR_INVALID_ESCAPE_CHARACTER);
9495 if (wrapped) escape_write_invalid(parser, buffer, flags);
9527static pm_token_type_t
9529 if (lex_state_end_p(parser)) {
9530 lex_state_set(parser, PM_LEX_STATE_BEG);
9531 return PM_TOKEN_QUESTION_MARK;
9539 parser->explicit_encoding = NULL;
9541 if (parser->current.end >= parser->end) {
9542 pm_parser_err_current(parser, PM_ERR_INCOMPLETE_QUESTION_MARK);
9543 pm_string_shared_init(&parser->current_string, parser->current.start + 1, parser->current.end);
9544 return PM_TOKEN_CHARACTER_LITERAL;
9547 if (pm_char_is_whitespace(*parser->current.end)) {
9548 lex_state_set(parser, PM_LEX_STATE_BEG);
9549 return PM_TOKEN_QUESTION_MARK;
9552 lex_state_set(parser, PM_LEX_STATE_BEG);
9554 if (match(parser,
'\\')) {
9555 lex_state_set(parser, PM_LEX_STATE_END);
9558 pm_buffer_init(&buffer, 3);
9560 escape_read(parser, &buffer, PM_ESCAPE_FLAG_SINGLE);
9563 void *arena_data = pm_arena_memdup(parser->arena, buffer.value, buffer.length,
PRISM_ALIGNOF(uint8_t));
9564 pm_string_init(&parser->current_string, (
const uint8_t *) arena_data, buffer.length);
9565 pm_buffer_cleanup(&buffer);
9567 return PM_TOKEN_CHARACTER_LITERAL;
9569 size_t encoding_width = pm_encoding_char_width(parser->encoding, parser->current.end, parser->end - parser->current.end);
9575 !char_is_identifier(parser, parser->current.end, parser->end - parser->current.end) ||
9577 (parser->current.end + encoding_width >= parser->end) ||
9578 !char_is_identifier(parser, parser->current.end + encoding_width, parser->end - (parser->current.end + encoding_width))
9581 lex_state_set(parser, PM_LEX_STATE_END);
9582 parser->current.end += encoding_width;
9583 pm_string_shared_init(&parser->current_string, parser->current.start + 1, parser->current.end);
9584 return PM_TOKEN_CHARACTER_LITERAL;
9588 return PM_TOKEN_QUESTION_MARK;
9595static pm_token_type_t
9597 pm_token_type_t
type = match(parser,
'@') ? PM_TOKEN_CLASS_VARIABLE : PM_TOKEN_INSTANCE_VARIABLE;
9598 const uint8_t *end = parser->end;
9601 if ((width = char_is_identifier_start(parser, parser->current.end, end - parser->current.end)) > 0) {
9602 parser->current.end += width;
9604 while ((width = char_is_identifier(parser, parser->current.end, end - parser->current.end)) > 0) {
9605 parser->current.end += width;
9607 }
else if (parser->current.end < end && pm_char_is_decimal_digit(*parser->current.end)) {
9608 pm_diagnostic_id_t diag_id = (
type == PM_TOKEN_CLASS_VARIABLE) ? PM_ERR_INCOMPLETE_VARIABLE_CLASS : PM_ERR_INCOMPLETE_VARIABLE_INSTANCE;
9609 if (parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3) {
9610 diag_id = (
type == PM_TOKEN_CLASS_VARIABLE) ? PM_ERR_INCOMPLETE_VARIABLE_CLASS_3_3 : PM_ERR_INCOMPLETE_VARIABLE_INSTANCE_3_3;
9613 size_t width = pm_encoding_char_width(parser->encoding, parser->current.end, end - parser->current.end);
9614 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, diag_id, (
int) ((parser->current.end + width) - parser->current.start), (
const char *) parser->current.start);
9616 pm_diagnostic_id_t diag_id = (
type == PM_TOKEN_CLASS_VARIABLE) ? PM_ERR_CLASS_VARIABLE_BARE : PM_ERR_INSTANCE_VARIABLE_BARE;
9617 pm_parser_err_token(parser, &parser->current, diag_id);
9622 if (parser->lex_modes.current->mode == PM_LEX_EMBVAR) {
9623 lex_mode_pop(parser);
9634 if (parser->lex_callback.callback) {
9635 parser->lex_callback.callback(parser, &parser->current, parser->lex_callback.data);
9648 .location = TOK2LOC(parser, &parser->current)
9659static pm_token_type_t
9662 const uint8_t *newline = next_newline(parser->current.end, parser->end - parser->current.end);
9664 if (newline == NULL) {
9665 parser->current.end = parser->end;
9667 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, U32(newline - parser->start + 1));
9668 parser->current.end = newline + 1;
9671 parser->current.type = PM_TOKEN_EMBDOC_BEGIN;
9672 parser_lex_callback(parser);
9675 const uint8_t *comment_start = parser->current.start;
9676 pm_comment_t *comment = parser_comment(parser, PM_COMMENT_EMBDOC);
9680 while (parser->current.end < parser->end) {
9681 parser->current.start = parser->current.end;
9686 (parser->end - parser->current.end >= 4) &&
9687 (memcmp(parser->current.end,
"=end", 4) == 0) &&
9689 (parser->current.end + 4 == parser->end) ||
9690 pm_char_is_whitespace(parser->current.end[4]) ||
9691 (parser->current.end[4] ==
'\0') ||
9692 (parser->current.end[4] ==
'\004') ||
9693 (parser->current.end[4] ==
'\032')
9696 const uint8_t *newline = next_newline(parser->current.end, parser->end - parser->current.end);
9698 if (newline == NULL) {
9699 parser->current.end = parser->end;
9701 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, U32(newline - parser->start + 1));
9702 parser->current.end = newline + 1;
9705 parser->current.type = PM_TOKEN_EMBDOC_END;
9706 parser_lex_callback(parser);
9708 comment->location.
length = (uint32_t) (parser->current.end - comment_start);
9709 pm_list_append(&parser->comment_list, (pm_list_node_t *) comment);
9711 return PM_TOKEN_EMBDOC_END;
9716 const uint8_t *newline = next_newline(parser->current.end, parser->end - parser->current.end);
9718 if (newline == NULL) {
9719 parser->current.end = parser->end;
9721 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, U32(newline - parser->start + 1));
9722 parser->current.end = newline + 1;
9725 parser->current.type = PM_TOKEN_EMBDOC_LINE;
9726 parser_lex_callback(parser);
9729 pm_parser_err_current(parser, PM_ERR_EMBDOC_TERM);
9731 comment->location.
length = (uint32_t) (parser->current.end - comment_start);
9732 pm_list_append(&parser->comment_list, (pm_list_node_t *) comment);
9734 return PM_TOKEN_EOF;
9744 parser->current.type = PM_TOKEN_IGNORED_NEWLINE;
9745 parser_lex_callback(parser);
9753 const uint8_t *cursor = parser->current.end;
9755 while (cursor < parser->end && *cursor !=
'\n' && *cursor !=
'#') {
9756 if (!pm_char_is_inline_whitespace(*cursor++))
return false;
9799 pm_buffer_append_byte(&token_buffer->
buffer,
byte);
9808 if (parser->encoding_changed) {
9809 width = pm_encoding_char_width(parser->encoding, parser->current.end, parser->end - parser->current.end);
9811 width = pm_encoding_utf_8_char_width(parser->current.end, parser->end - parser->current.end);
9816 return (width == 0 ? 1 : width);
9824 size_t width = parser_char_width(parser);
9825 pm_buffer_append_bytes(&token_buffer->
buffer, parser->current.end, width);
9826 parser->current.end += width;
9838 size_t len = pm_buffer_length(&token_buffer->
buffer);
9839 void *arena_data = pm_arena_memdup(parser->arena, pm_buffer_value(&token_buffer->
buffer),
len,
PRISM_ALIGNOF(uint8_t));
9840 pm_string_init(&parser->current_string, (
const uint8_t *) arena_data,
len);
9841 pm_buffer_cleanup(&token_buffer->
buffer);
9855 if (token_buffer->
cursor == NULL) {
9856 pm_string_shared_init(&parser->current_string, parser->current.start, parser->current.end);
9858 pm_buffer_append_bytes(&token_buffer->
buffer, token_buffer->
cursor, (
size_t) (parser->current.end - token_buffer->
cursor));
9859 pm_token_buffer_copy(parser, token_buffer);
9863#define PM_TOKEN_BUFFER_DEFAULT_SIZE 16
9875 const uint8_t *start;
9876 if (token_buffer->
cursor == NULL) {
9877 pm_buffer_init(&token_buffer->
buffer, PM_TOKEN_BUFFER_DEFAULT_SIZE);
9878 start = parser->current.start;
9880 start = token_buffer->
cursor;
9883 const uint8_t *end = parser->current.end - 1;
9884 PRISM_ASSERT(end >= start);
9885 pm_buffer_append_bytes(&token_buffer->
buffer, start, (
size_t) (end - start));
9887 token_buffer->
cursor = end;
9890#undef PM_TOKEN_BUFFER_DEFAULT_SIZE
9921 uint32_t content = U32(pm_buffer_length(&token_buffer->
base.
buffer));
9922 uint32_t source = U32(cursor - parser->start);
9923 pm_regexp_offsets_record(parser, &token_buffer->
offsets, content, source, U32(parser->current.start - parser->start));
9935pm_regexp_escape_kept_p(
const pm_lex_mode_t *lex_mode, uint8_t peeked) {
9937 case '\r':
case '\n':
case 'c':
case 'C':
case 'M':
case 'u':
case 'x':
9939 case '$':
case ')':
case '*':
case '+':
case '.':
case '>':
9940 case '?':
case ']':
case '^':
case '|':
case '}':
9943 return peeked < 0x80 && peeked != lex_mode->as.regexp.terminator;
9955 const uint8_t *start = parser->current.end - 1;
9956 const uint8_t *cursor = parser->current.end + 2;
9957 const uint8_t breakpoints[PM_STRPBRK_CACHE_SIZE] = {
'}',
'\\',
'\n',
'\r', terminator,
'\0' };
9959 while (cursor < parser->end) {
9960 cursor = pm_strpbrk(parser, cursor, breakpoints, parser->end - cursor, PM_STRPBRK_REGEXP);
9961 if (cursor == NULL) {
9962 cursor = parser->end;
9966 uint8_t
byte = *cursor;
9967 if (
byte !=
'}' && (
byte == terminator ||
byte ==
'\n' || (
byte ==
'\r' && peek_at(parser, cursor + 1) ==
'\n')))
break;
9969 if (
byte ==
'}')
break;
9972 if (
byte ==
'\\' && cursor < parser->end && *cursor < 0x80 && *cursor !=
'\n' && *cursor !=
'\r') cursor++;
9975 parser->current.end = cursor;
9976 pm_buffer_append_bytes(buffer, start, (
size_t) (cursor - start));
9985 pm_token_buffer_copy(parser, &token_buffer->
base);
9986 parser->current_regexp_offsets = token_buffer->
offsets;
9995 pm_token_buffer_flush(parser, &token_buffer->
base);
9996 parser->current_regexp_offsets = token_buffer->
offsets;
10004pm_heredoc_strspn_inline_whitespace(
pm_parser_t *parser,
const uint8_t **cursor, pm_heredoc_indent_t indent) {
10005 size_t whitespace = 0;
10008 case PM_HEREDOC_INDENT_NONE:
10013 case PM_HEREDOC_INDENT_DASH:
10015 *cursor += pm_strspn_inline_whitespace(*cursor, parser->end - *cursor);
10017 case PM_HEREDOC_INDENT_TILDE:
10020 while (*cursor < parser->end && pm_char_is_inline_whitespace(**cursor)) {
10021 if (**cursor ==
'\t') {
10022 whitespace = (whitespace / PM_TAB_WHITESPACE_SIZE + 1) * PM_TAB_WHITESPACE_SIZE;
10041 size_t eol_length = match_eol(parser);
10044 if (parser->heredoc_end) {
10048 parser_flush_heredoc_end(parser);
10051 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, PM_TOKEN_END(parser, &parser->current) + U32(eol_length));
10054 uint8_t delimiter = *parser->current.end;
10058 if (eol_length == 2) {
10059 delimiter = *(parser->current.end + 1);
10062 parser->current.end += eol_length;
10066 return *parser->current.end++;
10073#define LEX(token_type) parser->current.type = token_type; parser_lex_callback(parser); return
10083 PRISM_ASSERT(parser->current.end <= parser->end);
10084 parser->previous = parser->current;
10087 bool previous_command_start = parser->command_start;
10088 parser->command_start =
false;
10092 bool lexed_comment =
false;
10096 unsigned int semantic_token_seen = parser->semantic_token_seen;
10097 parser->semantic_token_seen =
true;
10105 switch (parser->lex_modes.current->mode) {
10106 case PM_LEX_DEFAULT:
10107 case PM_LEX_EMBEXPR:
10108 case PM_LEX_EMBVAR:
10117 if (parser->next_start != NULL) {
10118 parser->current.end = parser->next_start;
10119 parser->next_start = NULL;
10124 bool space_seen =
false;
10129 bool chomping =
true;
10136 static const uint8_t inline_whitespace[256] = {
10137 [
' '] = 1, [
'\t'] = 1, [
'\f'] = 1, [
'\v'] = 1
10139 const uint8_t *scan = parser->current.end;
10140 while (scan < parser->end && inline_whitespace[*scan]) scan++;
10141 if (scan > parser->current.end) {
10142 parser->current.end = scan;
10145 if (scan >= parser->end)
break;
10148 switch (*parser->current.end) {
10150 if (match_eol_offset(parser, 1)) {
10153 pm_parser_warn(parser, PM_TOKEN_END(parser, &parser->current), 1, PM_WARN_UNEXPECTED_CARRIAGE_RETURN);
10154 parser->current.end++;
10159 size_t eol_length = match_eol_offset(parser, 1);
10161 if (parser->heredoc_end) {
10162 parser->current.end = parser->heredoc_end;
10163 parser->heredoc_end = NULL;
10165 parser->current.end += eol_length + 1;
10166 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, PM_TOKEN_END(parser, &parser->current));
10169 }
else if (pm_char_is_inline_whitespace(*parser->current.end)) {
10170 parser->current.end += 2;
10184 parser->current.start = parser->current.end;
10188 if (parser->current.end >= parser->end) {
10193 if (parser->lex_modes.current->mode != PM_LEX_DEFAULT) {
10194 lex_mode_pop(parser);
10195 goto switch_lex_modes;
10203 if (parser->current.start > parser->start && (*(parser->current.start - 1) ==
'\n')) {
10204 parser->current.start -= 1;
10211 switch (*parser->current.end++) {
10215 parser->current.end--;
10219 const uint8_t *ending = next_newline(parser->current.end, parser->end - parser->current.end);
10220 parser->current.end = ending == NULL ? parser->end : ending;
10225 pm_comment_t *comment = parser_comment(parser, PM_COMMENT_INLINE);
10226 pm_list_append(&parser->comment_list, (pm_list_node_t *) comment);
10228 parser->current.type = PM_TOKEN_COMMENT;
10229 parser_lex_callback(parser);
10233 if (!parser_lex_magic_comment(parser, semantic_token_seen) && (parser->current.start == parser->encoding_comment_start)) {
10234 ptrdiff_t length = parser->current.end - parser->current.start;
10240 if (length >= 10 && !parser->encoding_locked) {
10241 parser_lex_magic_comment_encoding(parser);
10249 if (ending == NULL) {
10250 lexed_comment =
true;
10252 parser->current.start = ending;
10253 parser->current.end = ending + 1;
10259 parser->semantic_token_seen = semantic_token_seen & 0x1;
10260 size_t eol_length = match_eol_at(parser, parser->current.end - 1);
10272 if (!lexed_comment) {
10273 parser->current.end += eol_length - 1;
10276 if (parser->heredoc_end == NULL) {
10277 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, PM_TOKEN_END(parser, &parser->current));
10281 if (parser->heredoc_end) {
10282 parser_flush_heredoc_end(parser);
10287 switch (lex_state_ignored_p(parser)) {
10288 case PM_IGNORED_NEWLINE_NONE:
10290 case PM_IGNORED_NEWLINE_PATTERN:
10291 if (parser->pattern_matching_newlines || parser->in_keyword_arg) {
10292 if (!lexed_comment) {
10293 parser->current.type = PM_TOKEN_NEWLINE_TERMINATOR;
10294 parser_lex_callback(parser);
10297 lex_state_set(parser, PM_LEX_STATE_BEG);
10298 parser->command_start =
true;
10299 parser->current.type = PM_TOKEN_NEWLINE;
10303 case PM_IGNORED_NEWLINE_ALL:
10304 if (!lexed_comment) parser_lex_ignored_newline(parser);
10305 lexed_comment =
false;
10306 goto lex_next_token;
10313 const uint8_t *next_content = parser->next_start == NULL ? parser->current.end : parser->next_start;
10314 next_content += pm_strspn_inline_whitespace(next_content, parser->end - next_content);
10316 if (next_content < parser->end) {
10322 if (next_content[0] ==
'#') {
10324 const uint8_t *following = next_newline(next_content, parser->end - next_content);
10326 while (following && (following + 1 < parser->end)) {
10328 following += pm_strspn_inline_whitespace(following, parser->end - following);
10332 if (peek_at(parser, following) !=
'#')
break;
10336 following = next_newline(following, parser->end - following);
10341 if (lex_state_ignored_p(parser)) {
10342 if (!lexed_comment) parser_lex_ignored_newline(parser);
10343 lexed_comment =
false;
10344 goto lex_next_token;
10350 (peek_at(parser, following) ==
'.') ||
10351 (peek_at(parser, following) ==
'&' && peek_at(parser, following + 1) ==
'.')
10353 if (!lexed_comment) parser_lex_ignored_newline(parser);
10354 lexed_comment =
false;
10355 goto lex_next_token;
10363 (parser->version >= PM_OPTIONS_VERSION_CRUBY_4_0) &&
10365 (peek_at(parser, following) ==
'&' && peek_at(parser, following + 1) ==
'&') ||
10366 (peek_at(parser, following) ==
'|' && peek_at(parser, following + 1) ==
'|') ||
10368 peek_at(parser, following) ==
'a' &&
10369 peek_at(parser, following + 1) ==
'n' &&
10370 peek_at(parser, following + 2) ==
'd' &&
10371 peek_at(parser, following + 3) !=
'!' &&
10372 peek_at(parser, following + 3) !=
'?' &&
10373 !char_is_identifier(parser, following + 3, parser->end - (following + 3))
10376 peek_at(parser, following) ==
'o' &&
10377 peek_at(parser, following + 1) ==
'r' &&
10378 peek_at(parser, following + 2) !=
'!' &&
10379 peek_at(parser, following + 2) !=
'?' &&
10380 !char_is_identifier(parser, following + 2, parser->end - (following + 2))
10384 if (!lexed_comment) parser_lex_ignored_newline(parser);
10385 lexed_comment =
false;
10386 previous_command_start =
false;
10387 goto lex_next_token;
10393 if (next_content[0] ==
'.') {
10397 if (peek_at(parser, next_content + 1) ==
'.') {
10398 if (!lexed_comment) {
10399 parser->current.type = PM_TOKEN_NEWLINE_TERMINATOR;
10400 parser_lex_callback(parser);
10403 lex_state_set(parser, PM_LEX_STATE_BEG);
10404 parser->command_start =
true;
10405 parser->current.type = PM_TOKEN_NEWLINE;
10409 if (!lexed_comment) parser_lex_ignored_newline(parser);
10410 lex_state_set(parser, PM_LEX_STATE_DOT);
10411 parser->current.start = next_content;
10412 parser->current.end = next_content + 1;
10413 parser->next_start = NULL;
10419 if (peek_at(parser, next_content) ==
'&' && peek_at(parser, next_content + 1) ==
'.') {
10420 if (!lexed_comment) parser_lex_ignored_newline(parser);
10421 lex_state_set(parser, PM_LEX_STATE_DOT);
10422 parser->current.start = next_content;
10423 parser->current.end = next_content + 2;
10424 parser->next_start = NULL;
10425 LEX(PM_TOKEN_AMPERSAND_DOT);
10428 if (parser->version >= PM_OPTIONS_VERSION_CRUBY_4_0) {
10431 if (peek_at(parser, next_content) ==
'&' && peek_at(parser, next_content + 1) ==
'&') {
10432 if (!lexed_comment) parser_lex_ignored_newline(parser);
10433 lex_state_set(parser, PM_LEX_STATE_BEG);
10434 parser->current.start = next_content;
10435 parser->current.end = next_content + 2;
10436 parser->next_start = NULL;
10437 LEX(PM_TOKEN_AMPERSAND_AMPERSAND);
10442 if (peek_at(parser, next_content) ==
'|' && peek_at(parser, next_content + 1) ==
'|') {
10443 if (!lexed_comment) parser_lex_ignored_newline(parser);
10444 lex_state_set(parser, PM_LEX_STATE_BEG);
10445 parser->current.start = next_content;
10446 parser->current.end = next_content + 2;
10447 parser->next_start = NULL;
10448 LEX(PM_TOKEN_PIPE_PIPE);
10454 peek_at(parser, next_content) ==
'a' &&
10455 peek_at(parser, next_content + 1) ==
'n' &&
10456 peek_at(parser, next_content + 2) ==
'd' &&
10457 peek_at(parser, next_content + 3) !=
'!' &&
10458 peek_at(parser, next_content + 3) !=
'?' &&
10459 !char_is_identifier(parser, next_content + 3, parser->end - (next_content + 3))
10461 if (!lexed_comment) parser_lex_ignored_newline(parser);
10462 lexed_comment =
false;
10463 previous_command_start =
false;
10464 goto lex_next_token;
10468 peek_at(parser, next_content) ==
'o' &&
10469 peek_at(parser, next_content + 1) ==
'r' &&
10470 peek_at(parser, next_content + 2) !=
'!' &&
10471 peek_at(parser, next_content + 2) !=
'?' &&
10472 !char_is_identifier(parser, next_content + 2, parser->end - (next_content + 2))
10474 if (!lexed_comment) parser_lex_ignored_newline(parser);
10475 lexed_comment =
false;
10476 previous_command_start =
false;
10477 goto lex_next_token;
10484 lex_state_set(parser, PM_LEX_STATE_BEG);
10485 parser->command_start =
true;
10486 parser->current.type = PM_TOKEN_NEWLINE;
10487 if (!lexed_comment) parser_lex_callback(parser);
10493 if ((parser->previous.
type == PM_TOKEN_COMMA) && (parser->enclosure_nesting > 0)) {
10494 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_ARRAY_TERM, pm_token_str(parser->current.type));
10497 lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
10498 LEX(PM_TOKEN_COMMA);
10506 pm_token_type_t
type = PM_TOKEN_PARENTHESIS_LEFT;
10508 if (lex_state_beg_p(parser)) {
10509 type = PM_TOKEN_PARENTHESIS_LEFT_GROUPING;
10510 }
else if (space_seen && (lex_state_arg_p(parser) || parser->lex_state == (PM_LEX_STATE_END | PM_LEX_STATE_LABEL))) {
10511 type = PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES;
10514 parser->enclosure_nesting++;
10515 lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
10516 pm_enclosure_frame_push(parser);
10522 parser->enclosure_nesting--;
10523 lex_state_set(parser, PM_LEX_STATE_ENDFN);
10524 pm_enclosure_frame_pop(parser);
10525 LEX(PM_TOKEN_PARENTHESIS_RIGHT);
10529 lex_state_set(parser, PM_LEX_STATE_BEG);
10530 parser->command_start =
true;
10531 LEX(PM_TOKEN_SEMICOLON);
10535 parser->enclosure_nesting++;
10536 pm_token_type_t
type = PM_TOKEN_BRACKET_LEFT;
10538 if (lex_state_operator_p(parser)) {
10539 if (match(parser,
']')) {
10540 parser->enclosure_nesting--;
10541 lex_state_set(parser, PM_LEX_STATE_ARG);
10542 LEX(match(parser,
'=') ? PM_TOKEN_BRACKET_LEFT_RIGHT_EQUAL : PM_TOKEN_BRACKET_LEFT_RIGHT);
10545 lex_state_set(parser, PM_LEX_STATE_ARG | PM_LEX_STATE_LABEL);
10549 if (lex_state_beg_p(parser) || (lex_state_arg_p(parser) && (space_seen || lex_state_p(parser, PM_LEX_STATE_LABELED)))) {
10550 type = PM_TOKEN_BRACKET_LEFT_ARRAY;
10553 lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
10554 pm_enclosure_frame_push(parser);
10559 parser->enclosure_nesting--;
10560 lex_state_set(parser, PM_LEX_STATE_END);
10561 pm_enclosure_frame_pop(parser);
10562 LEX(PM_TOKEN_BRACKET_RIGHT);
10566 pm_token_type_t
type = PM_TOKEN_BRACE_LEFT;
10568 if (parser->enclosure_nesting == parser->lambda_enclosure_nesting) {
10570 parser->command_start =
true;
10571 lex_state_set(parser, PM_LEX_STATE_BEG);
10572 type = PM_TOKEN_LAMBDA_BEGIN;
10573 }
else if (lex_state_p(parser, PM_LEX_STATE_LABELED)) {
10575 lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
10576 type = PM_TOKEN_BRACE_LEFT_HASH;
10577 }
else if (lex_state_p(parser, PM_LEX_STATE_ARG_ANY | PM_LEX_STATE_END | PM_LEX_STATE_ENDFN)) {
10579 parser->command_start =
true;
10580 lex_state_set(parser, PM_LEX_STATE_BEG);
10581 }
else if (lex_state_p(parser, PM_LEX_STATE_ENDARG)) {
10584 parser->command_start =
true;
10585 lex_state_set(parser, PM_LEX_STATE_BEG);
10586 type = PM_TOKEN_BRACE_LEFT_ARGUMENT;
10589 lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
10590 type = PM_TOKEN_BRACE_LEFT_HASH;
10593 parser->enclosure_nesting++;
10594 parser->brace_nesting++;
10595 pm_enclosure_frame_push(parser);
10602 parser->enclosure_nesting--;
10603 pm_enclosure_frame_pop(parser);
10605 if ((parser->lex_modes.current->mode == PM_LEX_EMBEXPR) && (parser->brace_nesting == 0)) {
10606 lex_mode_pop(parser);
10611 parser->explicit_encoding = NULL;
10612 LEX(PM_TOKEN_EMBEXPR_END);
10615 parser->brace_nesting--;
10616 lex_state_set(parser, PM_LEX_STATE_END);
10617 LEX(PM_TOKEN_BRACE_RIGHT);
10621 if (match(parser,
'*')) {
10622 if (match(parser,
'=')) {
10623 lex_state_set(parser, PM_LEX_STATE_BEG);
10624 LEX(PM_TOKEN_STAR_STAR_EQUAL);
10627 pm_token_type_t
type = PM_TOKEN_STAR_STAR;
10629 if (lex_state_spcarg_p(parser, space_seen)) {
10630 pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_PREFIX_STAR_STAR);
10631 type = PM_TOKEN_USTAR_STAR;
10632 }
else if (lex_state_beg_p(parser)) {
10633 type = PM_TOKEN_USTAR_STAR;
10634 }
else if (ambiguous_operator_p(parser, space_seen)) {
10635 PM_PARSER_WARN_TOKEN_FORMAT(parser, &parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR,
"**",
"argument prefix");
10638 if (lex_state_operator_p(parser)) {
10639 lex_state_set(parser, PM_LEX_STATE_ARG);
10641 lex_state_set(parser, PM_LEX_STATE_BEG);
10647 if (match(parser,
'=')) {
10648 lex_state_set(parser, PM_LEX_STATE_BEG);
10649 LEX(PM_TOKEN_STAR_EQUAL);
10652 pm_token_type_t
type = PM_TOKEN_STAR;
10654 if (lex_state_spcarg_p(parser, space_seen)) {
10655 pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_PREFIX_STAR);
10656 type = PM_TOKEN_USTAR;
10657 }
else if (lex_state_beg_p(parser)) {
10658 type = PM_TOKEN_USTAR;
10659 }
else if (ambiguous_operator_p(parser, space_seen)) {
10660 PM_PARSER_WARN_TOKEN_FORMAT(parser, &parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR,
"*",
"argument prefix");
10663 if (lex_state_operator_p(parser)) {
10664 lex_state_set(parser, PM_LEX_STATE_ARG);
10666 lex_state_set(parser, PM_LEX_STATE_BEG);
10674 if (lex_state_operator_p(parser)) {
10675 lex_state_set(parser, PM_LEX_STATE_ARG);
10676 if (match(parser,
'@')) {
10677 LEX(PM_TOKEN_BANG);
10680 lex_state_set(parser, PM_LEX_STATE_BEG);
10683 if (match(parser,
'=')) {
10684 LEX(PM_TOKEN_BANG_EQUAL);
10687 if (match(parser,
'~')) {
10688 LEX(PM_TOKEN_BANG_TILDE);
10691 LEX(PM_TOKEN_BANG);
10696 current_token_starts_line(parser) &&
10697 (parser->current.end + 5 <= parser->end) &&
10698 memcmp(parser->current.end,
"begin", 5) == 0 &&
10700 pm_char_is_whitespace(peek_offset(parser, 5)) ||
10701 (peek_offset(parser, 5) ==
'\0') ||
10702 (peek_offset(parser, 5) ==
'\004') ||
10703 (peek_offset(parser, 5) ==
'\032')
10706 pm_token_type_t
type = lex_embdoc(parser);
10707 if (type == PM_TOKEN_EOF) {
10708 parser->current.start = parser->current.end;
10712 goto lex_next_token;
10715 if (lex_state_operator_p(parser)) {
10716 lex_state_set(parser, PM_LEX_STATE_ARG);
10718 lex_state_set(parser, PM_LEX_STATE_BEG);
10721 if (match(parser,
'>')) {
10722 LEX(PM_TOKEN_EQUAL_GREATER);
10725 if (match(parser,
'~')) {
10726 LEX(PM_TOKEN_EQUAL_TILDE);
10729 if (match(parser,
'=')) {
10730 LEX(match(parser,
'=') ? PM_TOKEN_EQUAL_EQUAL_EQUAL : PM_TOKEN_EQUAL_EQUAL);
10733 LEX(PM_TOKEN_EQUAL);
10737 if (match(parser,
'<')) {
10739 !lex_state_p(parser, PM_LEX_STATE_DOT | PM_LEX_STATE_CLASS) &&
10740 !lex_state_end_p(parser) &&
10741 (!lex_state_p(parser, PM_LEX_STATE_ARG_ANY) || lex_state_p(parser, PM_LEX_STATE_LABELED) || space_seen)
10743 const uint8_t *end = parser->current.end;
10745 pm_heredoc_quote_t quote = PM_HEREDOC_QUOTE_NONE;
10746 pm_heredoc_indent_t indent = PM_HEREDOC_INDENT_NONE;
10748 if (match(parser,
'-')) {
10749 indent = PM_HEREDOC_INDENT_DASH;
10751 else if (match(parser,
'~')) {
10752 indent = PM_HEREDOC_INDENT_TILDE;
10755 if (match(parser,
'`')) {
10756 quote = PM_HEREDOC_QUOTE_BACKTICK;
10758 else if (match(parser,
'"')) {
10759 quote = PM_HEREDOC_QUOTE_DOUBLE;
10761 else if (match(parser,
'\'')) {
10762 quote = PM_HEREDOC_QUOTE_SINGLE;
10765 const uint8_t *ident_start = parser->current.end;
10768 if (parser->current.end >= parser->end) {
10769 parser->current.end = end;
10770 }
else if (quote == PM_HEREDOC_QUOTE_NONE && (width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end)) == 0) {
10771 parser->current.end = end;
10773 if (quote == PM_HEREDOC_QUOTE_NONE) {
10774 parser->current.end += width;
10776 while ((width = char_is_identifier(parser, parser->current.end, parser->end - parser->current.end))) {
10777 parser->current.end += width;
10782 while ((parser->current.end < parser->end) && quote != (pm_heredoc_quote_t) (*parser->current.end)) {
10783 if (*parser->current.end ==
'\r' || *parser->current.end ==
'\n')
break;
10784 parser->current.end++;
10788 size_t ident_length = (size_t) (parser->current.end - ident_start);
10789 bool ident_error =
false;
10791 if (quote != PM_HEREDOC_QUOTE_NONE && !match(parser, (uint8_t) quote)) {
10792 pm_parser_err(parser, U32(ident_start - parser->start), U32(ident_length), PM_ERR_HEREDOC_IDENTIFIER);
10793 ident_error =
true;
10796 parser->explicit_encoding = NULL;
10797 lex_mode_push(parser, (pm_lex_mode_t) {
10798 .mode = PM_LEX_HEREDOC,
10801 .ident_start = ident_start,
10802 .ident_length = ident_length,
10806 .next_start = parser->current.end,
10807 .common_whitespace = NULL,
10808 .line_continuation =
false
10812 if (parser->heredoc_end == NULL) {
10813 const uint8_t *body_start = next_newline(parser->current.end, parser->end - parser->current.end);
10815 if (body_start == NULL) {
10820 if (!ident_error) pm_parser_err_heredoc_term(parser, ident_start, ident_length);
10821 body_start = parser->end;
10825 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, U32(body_start - parser->start + 1));
10829 parser->next_start = body_start;
10831 parser->next_start = parser->heredoc_end;
10834 LEX(PM_TOKEN_HEREDOC_START);
10838 if (match(parser,
'=')) {
10839 lex_state_set(parser, PM_LEX_STATE_BEG);
10840 LEX(PM_TOKEN_LESS_LESS_EQUAL);
10843 if (ambiguous_operator_p(parser, space_seen)) {
10844 PM_PARSER_WARN_TOKEN_FORMAT(parser, &parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR,
"<<",
"here document");
10847 if (lex_state_operator_p(parser)) {
10848 lex_state_set(parser, PM_LEX_STATE_ARG);
10850 if (lex_state_p(parser, PM_LEX_STATE_CLASS)) parser->command_start =
true;
10851 lex_state_set(parser, PM_LEX_STATE_BEG);
10854 LEX(PM_TOKEN_LESS_LESS);
10857 if (lex_state_operator_p(parser)) {
10858 lex_state_set(parser, PM_LEX_STATE_ARG);
10860 if (lex_state_p(parser, PM_LEX_STATE_CLASS)) parser->command_start =
true;
10861 lex_state_set(parser, PM_LEX_STATE_BEG);
10864 if (match(parser,
'=')) {
10865 if (match(parser,
'>')) {
10866 LEX(PM_TOKEN_LESS_EQUAL_GREATER);
10869 LEX(PM_TOKEN_LESS_EQUAL);
10872 LEX(PM_TOKEN_LESS);
10876 if (match(parser,
'>')) {
10877 if (lex_state_operator_p(parser)) {
10878 lex_state_set(parser, PM_LEX_STATE_ARG);
10880 lex_state_set(parser, PM_LEX_STATE_BEG);
10882 LEX(match(parser,
'=') ? PM_TOKEN_GREATER_GREATER_EQUAL : PM_TOKEN_GREATER_GREATER);
10885 if (lex_state_operator_p(parser)) {
10886 lex_state_set(parser, PM_LEX_STATE_ARG);
10888 lex_state_set(parser, PM_LEX_STATE_BEG);
10891 LEX(match(parser,
'=') ? PM_TOKEN_GREATER_EQUAL : PM_TOKEN_GREATER);
10895 bool label_allowed = (lex_state_p(parser, PM_LEX_STATE_LABEL | PM_LEX_STATE_ENDFN) && !previous_command_start) || lex_state_arg_p(parser);
10896 lex_mode_push_string(parser,
true, label_allowed,
'\0',
'"');
10897 LEX(PM_TOKEN_STRING_BEGIN);
10902 if (lex_state_p(parser, PM_LEX_STATE_FNAME)) {
10903 lex_state_set(parser, PM_LEX_STATE_ENDFN);
10904 LEX(PM_TOKEN_BACKTICK);
10907 if (lex_state_p(parser, PM_LEX_STATE_DOT)) {
10908 if (previous_command_start) {
10909 lex_state_set(parser, PM_LEX_STATE_CMDARG);
10911 lex_state_set(parser, PM_LEX_STATE_ARG);
10914 LEX(PM_TOKEN_BACKTICK);
10917 lex_mode_push_string(parser,
true,
false,
'\0',
'`');
10918 LEX(PM_TOKEN_XSTRING_BEGIN);
10923 bool label_allowed = (lex_state_p(parser, PM_LEX_STATE_LABEL | PM_LEX_STATE_ENDFN) && !previous_command_start) || lex_state_arg_p(parser);
10924 lex_mode_push_string(parser,
false, label_allowed,
'\0',
'\'');
10925 LEX(PM_TOKEN_STRING_BEGIN);
10930 LEX(lex_question_mark(parser));
10934 if (match(parser,
'&')) {
10935 lex_state_set(parser, PM_LEX_STATE_BEG);
10937 if (match(parser,
'=')) {
10938 LEX(PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
10941 LEX(PM_TOKEN_AMPERSAND_AMPERSAND);
10944 if (match(parser,
'=')) {
10945 lex_state_set(parser, PM_LEX_STATE_BEG);
10946 LEX(PM_TOKEN_AMPERSAND_EQUAL);
10949 if (match(parser,
'.')) {
10950 lex_state_set(parser, PM_LEX_STATE_DOT);
10951 LEX(PM_TOKEN_AMPERSAND_DOT);
10954 pm_token_type_t
type = PM_TOKEN_AMPERSAND;
10955 if (lex_state_spcarg_p(parser, space_seen)) {
10956 if ((peek(parser) !=
':') || (peek_offset(parser, 1) ==
'\0')) {
10957 pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_PREFIX_AMPERSAND);
10959 const uint8_t delim = peek_offset(parser, 1);
10961 if ((delim !=
'\'') && (delim !=
'"') && !char_is_identifier(parser, parser->current.end + 1, parser->end - (parser->current.end + 1))) {
10962 pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_PREFIX_AMPERSAND);
10966 type = PM_TOKEN_UAMPERSAND;
10967 }
else if (lex_state_beg_p(parser)) {
10968 type = PM_TOKEN_UAMPERSAND;
10969 }
else if (ambiguous_operator_p(parser, space_seen)) {
10970 PM_PARSER_WARN_TOKEN_FORMAT(parser, &parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR,
"&",
"argument prefix");
10973 if (lex_state_operator_p(parser)) {
10974 lex_state_set(parser, PM_LEX_STATE_ARG);
10976 lex_state_set(parser, PM_LEX_STATE_BEG);
10984 if (match(parser,
'|')) {
10985 if (match(parser,
'=')) {
10986 lex_state_set(parser, PM_LEX_STATE_BEG);
10987 LEX(PM_TOKEN_PIPE_PIPE_EQUAL);
10990 if (lex_state_p(parser, PM_LEX_STATE_BEG)) {
10991 parser->current.end--;
10992 LEX(PM_TOKEN_PIPE);
10995 lex_state_set(parser, PM_LEX_STATE_BEG);
10996 LEX(PM_TOKEN_PIPE_PIPE);
10999 if (match(parser,
'=')) {
11000 lex_state_set(parser, PM_LEX_STATE_BEG);
11001 LEX(PM_TOKEN_PIPE_EQUAL);
11004 if (lex_state_operator_p(parser)) {
11005 lex_state_set(parser, PM_LEX_STATE_ARG);
11007 lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
11010 LEX(PM_TOKEN_PIPE);
11014 if (lex_state_operator_p(parser)) {
11015 lex_state_set(parser, PM_LEX_STATE_ARG);
11017 if (match(parser,
'@')) {
11018 LEX(PM_TOKEN_UPLUS);
11021 LEX(PM_TOKEN_PLUS);
11024 if (match(parser,
'=')) {
11025 lex_state_set(parser, PM_LEX_STATE_BEG);
11026 LEX(PM_TOKEN_PLUS_EQUAL);
11030 lex_state_beg_p(parser) ||
11031 (lex_state_spcarg_p(parser, space_seen) ? (pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_PLUS),
true) :
false)
11033 lex_state_set(parser, PM_LEX_STATE_BEG);
11035 if (pm_char_is_decimal_digit(peek(parser))) {
11036 parser->current.end++;
11037 pm_token_type_t
type = lex_numeric(parser);
11038 lex_state_set(parser, PM_LEX_STATE_END);
11042 LEX(PM_TOKEN_UPLUS);
11045 if (ambiguous_operator_p(parser, space_seen)) {
11046 PM_PARSER_WARN_TOKEN_FORMAT(parser, &parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR,
"+",
"unary operator");
11049 lex_state_set(parser, PM_LEX_STATE_BEG);
11050 LEX(PM_TOKEN_PLUS);
11055 if (lex_state_operator_p(parser)) {
11056 lex_state_set(parser, PM_LEX_STATE_ARG);
11058 if (match(parser,
'@')) {
11059 LEX(PM_TOKEN_UMINUS);
11062 LEX(PM_TOKEN_MINUS);
11065 if (match(parser,
'=')) {
11066 lex_state_set(parser, PM_LEX_STATE_BEG);
11067 LEX(PM_TOKEN_MINUS_EQUAL);
11070 if (match(parser,
'>')) {
11071 lex_state_set(parser, PM_LEX_STATE_ENDFN);
11072 LEX(PM_TOKEN_MINUS_GREATER);
11075 bool spcarg = lex_state_spcarg_p(parser, space_seen);
11076 bool is_beg = lex_state_beg_p(parser);
11077 if (!is_beg && spcarg) {
11078 pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_FIRST_ARGUMENT_MINUS);
11081 if (is_beg || spcarg) {
11082 lex_state_set(parser, PM_LEX_STATE_BEG);
11083 LEX(pm_char_is_decimal_digit(peek(parser)) ? PM_TOKEN_UMINUS_NUM : PM_TOKEN_UMINUS);
11086 if (ambiguous_operator_p(parser, space_seen)) {
11087 PM_PARSER_WARN_TOKEN_FORMAT(parser, &parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR,
"-",
"unary operator");
11090 lex_state_set(parser, PM_LEX_STATE_BEG);
11091 LEX(PM_TOKEN_MINUS);
11096 bool beg_p = lex_state_beg_p(parser);
11098 if (match(parser,
'.')) {
11099 if (match(parser,
'.')) {
11101 if (!context_p(parser, PM_CONTEXT_DEFAULT_PARAMS) && context_p(parser, PM_CONTEXT_DEF_PARAMS)) {
11102 if (lex_state_p(parser, PM_LEX_STATE_END)) {
11103 lex_state_set(parser, PM_LEX_STATE_BEG);
11105 lex_state_set(parser, PM_LEX_STATE_ENDARG);
11107 LEX(PM_TOKEN_UDOT_DOT_DOT);
11110 if (parser->enclosure_nesting == 0 && parser_end_of_line_p(parser)) {
11111 pm_parser_warn_token(parser, &parser->current, PM_WARN_DOT_DOT_DOT_EOL);
11114 lex_state_set(parser, PM_LEX_STATE_BEG);
11115 LEX(beg_p ? PM_TOKEN_UDOT_DOT_DOT : PM_TOKEN_DOT_DOT_DOT);
11118 lex_state_set(parser, PM_LEX_STATE_BEG);
11119 LEX(beg_p ? PM_TOKEN_UDOT_DOT : PM_TOKEN_DOT_DOT);
11122 lex_state_set(parser, PM_LEX_STATE_DOT);
11137 pm_token_type_t
type = lex_numeric(parser);
11138 lex_state_set(parser, PM_LEX_STATE_END);
11144 if (match(parser,
':')) {
11145 if (lex_state_beg_p(parser) || lex_state_p(parser, PM_LEX_STATE_CLASS) || (lex_state_p(parser, PM_LEX_STATE_ARG_ANY) && space_seen)) {
11146 lex_state_set(parser, PM_LEX_STATE_BEG);
11147 LEX(PM_TOKEN_UCOLON_COLON);
11150 lex_state_set(parser, PM_LEX_STATE_DOT);
11151 LEX(PM_TOKEN_COLON_COLON);
11154 if (lex_state_end_p(parser) || pm_char_is_whitespace(peek(parser)) || peek(parser) ==
'#') {
11155 lex_state_set(parser, PM_LEX_STATE_BEG);
11156 LEX(PM_TOKEN_COLON);
11159 if (peek(parser) ==
'"' || peek(parser) ==
'\'') {
11160 lex_mode_push_string(parser, peek(parser) ==
'"',
false,
'\0', *parser->current.end);
11161 parser->current.end++;
11168 parser->explicit_encoding = NULL;
11171 lex_state_set(parser, PM_LEX_STATE_FNAME);
11172 LEX(PM_TOKEN_SYMBOL_BEGIN);
11176 if (lex_state_beg_p(parser)) {
11177 lex_mode_push_regexp(parser,
'\0',
'/');
11178 LEX(PM_TOKEN_REGEXP_BEGIN);
11181 if (match(parser,
'=')) {
11182 lex_state_set(parser, PM_LEX_STATE_BEG);
11183 LEX(PM_TOKEN_SLASH_EQUAL);
11186 if (lex_state_spcarg_p(parser, space_seen)) {
11188 if (parser->version <= PM_OPTIONS_VERSION_CRUBY_4_0) {
11189 pm_parser_warn_token(parser, &parser->current, PM_WARN_AMBIGUOUS_SLASH);
11191 lex_mode_push_regexp(parser,
'\0',
'/');
11192 LEX(PM_TOKEN_REGEXP_BEGIN);
11195 if (ambiguous_operator_p(parser, space_seen)) {
11196 PM_PARSER_WARN_TOKEN_FORMAT(parser, &parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR,
"/",
"regexp literal");
11199 if (lex_state_operator_p(parser)) {
11200 lex_state_set(parser, PM_LEX_STATE_ARG);
11202 lex_state_set(parser, PM_LEX_STATE_BEG);
11205 LEX(PM_TOKEN_SLASH);
11209 if (lex_state_operator_p(parser)) {
11210 lex_state_set(parser, PM_LEX_STATE_ARG);
11212 lex_state_set(parser, PM_LEX_STATE_BEG);
11214 LEX(match(parser,
'=') ? PM_TOKEN_CARET_EQUAL : PM_TOKEN_CARET);
11218 if (lex_state_operator_p(parser)) {
11219 (void) match(parser,
'@');
11220 lex_state_set(parser, PM_LEX_STATE_ARG);
11222 lex_state_set(parser, PM_LEX_STATE_BEG);
11225 LEX(PM_TOKEN_TILDE);
11233 if ((lex_state_beg_p(parser) || lex_state_arg_p(parser)) && (parser->current.end >= parser->end)) {
11234 pm_parser_err_current(parser, PM_ERR_INVALID_PERCENT_EOF);
11235 LEX(PM_TOKEN_PERCENT);
11238 if (!lex_state_beg_p(parser) && match(parser,
'=')) {
11239 lex_state_set(parser, PM_LEX_STATE_BEG);
11240 LEX(PM_TOKEN_PERCENT_EQUAL);
11242 lex_state_beg_p(parser) ||
11243 (lex_state_p(parser, PM_LEX_STATE_FITEM) && (peek(parser) ==
's')) ||
11244 lex_state_spcarg_p(parser, space_seen)
11250 if (*parser->current.end >= 0x80) {
11251 pm_parser_err_current(parser, PM_ERR_INVALID_PERCENT);
11252 goto lex_next_token;
11255 if (!pm_encoding_ascii_alnum_p(*parser->current.end)) {
11256 const uint8_t delimiter = pm_lex_percent_delimiter(parser);
11257 lex_mode_push_string(parser,
true,
false, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
11258 LEX(PM_TOKEN_STRING_BEGIN);
11263 uint8_t delimiter = peek_offset(parser, 1);
11264 if (delimiter >= 0x80 || pm_encoding_ascii_alnum_p(delimiter)) {
11265 pm_parser_err_current(parser, PM_ERR_INVALID_PERCENT);
11266 goto lex_next_token;
11269 switch (peek(parser)) {
11271 parser->current.end++;
11273 if (parser->current.end < parser->end) {
11274 lex_mode_push_list(parser,
false, pm_lex_percent_delimiter(parser));
11276 lex_mode_push_list_eof(parser);
11279 LEX(PM_TOKEN_PERCENT_LOWER_I);
11282 parser->current.end++;
11284 if (parser->current.end < parser->end) {
11285 lex_mode_push_list(parser,
true, pm_lex_percent_delimiter(parser));
11287 lex_mode_push_list_eof(parser);
11290 LEX(PM_TOKEN_PERCENT_UPPER_I);
11293 parser->current.end++;
11295 if (parser->current.end < parser->end) {
11296 const uint8_t delimiter = pm_lex_percent_delimiter(parser);
11297 lex_mode_push_regexp(parser, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
11299 lex_mode_push_regexp(parser,
'\0',
'\0');
11302 LEX(PM_TOKEN_REGEXP_BEGIN);
11305 parser->current.end++;
11307 if (parser->current.end < parser->end) {
11308 const uint8_t delimiter = pm_lex_percent_delimiter(parser);
11309 lex_mode_push_string(parser,
false,
false, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
11311 lex_mode_push_string_eof(parser);
11314 LEX(PM_TOKEN_STRING_BEGIN);
11317 parser->current.end++;
11319 if (parser->current.end < parser->end) {
11320 const uint8_t delimiter = pm_lex_percent_delimiter(parser);
11321 lex_mode_push_string(parser,
true,
false, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
11323 lex_mode_push_string_eof(parser);
11326 LEX(PM_TOKEN_STRING_BEGIN);
11329 parser->current.end++;
11331 if (parser->current.end < parser->end) {
11332 const uint8_t delimiter = pm_lex_percent_delimiter(parser);
11333 lex_mode_push_string(parser,
false,
false, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
11334 lex_state_set(parser, PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM);
11336 lex_mode_push_string_eof(parser);
11339 LEX(PM_TOKEN_SYMBOL_BEGIN);
11342 parser->current.end++;
11344 if (parser->current.end < parser->end) {
11345 lex_mode_push_list(parser,
false, pm_lex_percent_delimiter(parser));
11347 lex_mode_push_list_eof(parser);
11350 LEX(PM_TOKEN_PERCENT_LOWER_W);
11353 parser->current.end++;
11355 if (parser->current.end < parser->end) {
11356 lex_mode_push_list(parser,
true, pm_lex_percent_delimiter(parser));
11358 lex_mode_push_list_eof(parser);
11361 LEX(PM_TOKEN_PERCENT_UPPER_W);
11364 parser->current.end++;
11366 if (parser->current.end < parser->end) {
11367 const uint8_t delimiter = pm_lex_percent_delimiter(parser);
11368 lex_mode_push_string(parser,
true,
false, lex_mode_incrementor(delimiter), lex_mode_terminator(delimiter));
11370 lex_mode_push_string_eof(parser);
11373 LEX(PM_TOKEN_PERCENT_LOWER_X);
11380 pm_parser_err_current(parser, PM_ERR_INVALID_PERCENT);
11381 goto lex_next_token;
11385 if (ambiguous_operator_p(parser, space_seen)) {
11386 PM_PARSER_WARN_TOKEN_FORMAT(parser, &parser->current, PM_WARN_AMBIGUOUS_BINARY_OPERATOR,
"%",
"string literal");
11389 lex_state_set(parser, lex_state_operator_p(parser) ? PM_LEX_STATE_ARG : PM_LEX_STATE_BEG);
11390 LEX(PM_TOKEN_PERCENT);
11395 pm_token_type_t
type = lex_global_variable(parser);
11399 if (parser->lex_modes.current->mode == PM_LEX_EMBVAR) {
11400 lex_mode_pop(parser);
11403 lex_state_set(parser, PM_LEX_STATE_END);
11409 lex_state_set(parser, parser->lex_state & PM_LEX_STATE_FNAME ? PM_LEX_STATE_ENDFN : PM_LEX_STATE_END);
11410 LEX(lex_at_variable(parser));
11413 if (*parser->current.start !=
'_') {
11414 size_t width = char_is_identifier_start(parser, parser->current.start, parser->end - parser->current.start);
11421 if (*parser->current.start >= 0x80) {
11422 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_INVALID_MULTIBYTE_CHARACTER, *parser->current.start);
11423 }
else if (*parser->current.start ==
'\\') {
11424 switch (peek_at(parser, parser->current.start + 1)) {
11426 parser->current.end++;
11427 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE,
"escaped space");
11430 parser->current.end++;
11431 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE,
"escaped form feed");
11434 parser->current.end++;
11435 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE,
"escaped horizontal tab");
11438 parser->current.end++;
11439 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE,
"escaped vertical tab");
11442 if (peek_at(parser, parser->current.start + 2) !=
'\n') {
11443 parser->current.end++;
11444 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE,
"escaped carriage return");
11449 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE,
"backslash");
11452 }
else if (char_is_ascii_printable(*parser->current.start)) {
11453 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_INVALID_PRINTABLE_CHARACTER, *parser->current.start);
11455 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_INVALID_CHARACTER, *parser->current.start);
11458 goto lex_next_token;
11461 parser->current.end = parser->current.start + width;
11464 pm_token_type_t
type = lex_identifier(parser, previous_command_start);
11471 ((parser->current.end - parser->current.start) == 7) &&
11472 current_token_starts_line(parser) &&
11473 (memcmp(parser->current.start,
"__END__", 7) == 0) &&
11474 (parser->current.end == parser->end || match_eol(parser))
11479 const uint8_t *cursor = parser->current.end;
11480 while ((cursor = next_newline(cursor, parser->end - cursor)) != NULL) {
11481 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, U32(++cursor - parser->start));
11484 parser->current.end = parser->end;
11485 parser->current.type = PM_TOKEN___END__;
11486 parser_lex_callback(parser);
11488 parser->data_loc.
start = PM_TOKEN_START(parser, &parser->current);
11489 parser->data_loc.
length = PM_TOKEN_LENGTH(&parser->current);
11491 parser->current.start = parser->current.end;
11495 pm_lex_state_t last_state = parser->lex_state;
11497 if (type == PM_TOKEN_IDENTIFIER || type == PM_TOKEN_CONSTANT || type == PM_TOKEN_METHOD_NAME) {
11498 if (lex_state_p(parser, PM_LEX_STATE_BEG_ANY | PM_LEX_STATE_ARG_ANY | PM_LEX_STATE_DOT)) {
11499 if (previous_command_start) {
11500 lex_state_set(parser, PM_LEX_STATE_CMDARG);
11502 lex_state_set(parser, PM_LEX_STATE_ARG);
11504 }
else if (parser->lex_state == PM_LEX_STATE_FNAME) {
11505 lex_state_set(parser, PM_LEX_STATE_ENDFN);
11507 lex_state_set(parser, PM_LEX_STATE_END);
11512 !(last_state & (PM_LEX_STATE_DOT | PM_LEX_STATE_FNAME)) &&
11513 (type == PM_TOKEN_IDENTIFIER) &&
11514 ((pm_parser_local_depth(parser, &parser->current) != -1) ||
11515 pm_token_is_numbered_parameter(parser, PM_TOKEN_START(parser, &parser->current), PM_TOKEN_LENGTH(&parser->current)))
11517 lex_state_set(parser, PM_LEX_STATE_END | PM_LEX_STATE_LABEL);
11524 case PM_LEX_LIST: {
11525 if (parser->next_start != NULL) {
11526 parser->current.end = parser->next_start;
11527 parser->next_start = NULL;
11531 parser->current.start = parser->current.end;
11533 pm_lex_mode_t *lex_mode = parser->lex_modes.current;
11539 if (lex_mode->as.list.terminator !=
'\n' && parser->heredoc_end) {
11540 whitespace = pm_strspn_inline_whitespace(parser->current.end, parser->end - parser->current.end);
11541 if (peek_offset(parser, (ptrdiff_t)whitespace) ==
'\n') {
11544 }
else if (lex_mode->as.list.terminator ==
'\n') {
11549 whitespace = pm_strspn_inline_whitespace(parser->current.end, parser->end - parser->current.end);
11551 whitespace = pm_strspn_whitespace_newlines(parser->current.end, parser->end - parser->current.end, &parser->metadata_arena, &parser->line_offsets, PM_TOKEN_END(parser, &parser->current));
11554 if (whitespace > 0) {
11555 parser->current.end += whitespace;
11556 if (peek_offset(parser, -1) ==
'\n') {
11558 parser_flush_heredoc_end(parser);
11561 lex_mode->as.list.started =
true;
11562 lex_mode->as.list.separated =
true;
11563 LEX(PM_TOKEN_WORDS_SEP);
11568 if (parser->current.end >= parser->end) {
11577 if (!lex_mode->as.list.started) {
11578 lex_mode->as.list.started =
true;
11579 lex_mode->as.list.separated =
true;
11580 parser->current.type = PM_TOKEN_WORDS_SEP_IMPLICIT;
11581 parser_lex_callback(parser);
11586 const uint8_t *breakpoints = lex_mode->as.list.breakpoints;
11587 const uint8_t *breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
11593 while (breakpoint != NULL) {
11598 if (pm_char_is_whitespace(*breakpoint) && *breakpoint != lex_mode->as.list.terminator) {
11599 parser->current.end = breakpoint;
11600 pm_token_buffer_flush(parser, &token_buffer);
11601 lex_mode->as.list.separated =
false;
11602 LEX(PM_TOKEN_STRING_CONTENT);
11607 if (*breakpoint == lex_mode->as.list.terminator) {
11610 if (lex_mode->as.list.nesting > 0) {
11611 parser->current.end = breakpoint + 1;
11612 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
11613 lex_mode->as.list.nesting--;
11619 if (breakpoint > parser->current.start) {
11620 parser->current.end = breakpoint;
11621 pm_token_buffer_flush(parser, &token_buffer);
11622 lex_mode->as.list.separated =
false;
11623 LEX(PM_TOKEN_STRING_CONTENT);
11631 if (!lex_mode->as.list.separated) {
11632 lex_mode->as.list.separated =
true;
11633 parser->current.end = breakpoint;
11634 parser->current.type = PM_TOKEN_WORDS_SEP_IMPLICIT;
11635 parser_lex_callback(parser);
11640 parser->current.end = breakpoint + 1;
11645 if (*breakpoint ==
'\n') {
11646 if (parser->heredoc_end == NULL) {
11647 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, PM_TOKEN_END(parser, &parser->current));
11649 parser_flush_heredoc_end(parser);
11653 lex_mode_pop(parser);
11654 lex_state_set(parser, PM_LEX_STATE_END);
11655 LEX(PM_TOKEN_STRING_END);
11659 if (*breakpoint ==
'\0') {
11660 breakpoint = pm_strpbrk(parser, breakpoint + 1, breakpoints, parser->end - (breakpoint + 1), PM_STRPBRK_STRING);
11667 if (*breakpoint ==
'\\') {
11668 parser->current.end = breakpoint + 1;
11672 if (parser->current.end == parser->end) {
11677 pm_token_buffer_escape(parser, &token_buffer);
11678 uint8_t peeked = peek(parser);
11686 pm_token_buffer_push_byte(&token_buffer, peeked);
11687 parser->current.end++;
11690 parser->current.end++;
11691 if (peek(parser) !=
'\n') {
11692 pm_token_buffer_push_byte(&token_buffer,
'\r');
11697 pm_token_buffer_push_byte(&token_buffer,
'\n');
11699 if (parser->heredoc_end) {
11703 parser_flush_heredoc_end(parser);
11704 pm_token_buffer_copy(parser, &token_buffer);
11705 LEX(PM_TOKEN_STRING_CONTENT);
11708 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, PM_TOKEN_END(parser, &parser->current) + 1);
11711 parser->current.end++;
11714 if (peeked == lex_mode->as.list.incrementor || peeked == lex_mode->as.list.terminator) {
11715 pm_token_buffer_push_byte(&token_buffer, peeked);
11716 parser->current.end++;
11717 }
else if (lex_mode->as.list.interpolation) {
11718 escape_read(parser, &token_buffer.
buffer, PM_ESCAPE_FLAG_NONE);
11721 if (parser->next_start != NULL) {
11722 pm_token_buffer_copy(parser, &token_buffer);
11723 lex_mode->as.list.separated =
false;
11724 LEX(PM_TOKEN_STRING_CONTENT);
11727 pm_token_buffer_push_byte(&token_buffer,
'\\');
11728 pm_token_buffer_push_escaped(&token_buffer, parser);
11734 token_buffer.
cursor = parser->current.end;
11735 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
11740 if (*breakpoint ==
'#') {
11741 pm_token_type_t
type = lex_interpolation(parser, breakpoint);
11748 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
11752 if (type == PM_TOKEN_STRING_CONTENT) {
11753 pm_token_buffer_flush(parser, &token_buffer);
11756 lex_mode->as.list.separated =
false;
11762 PRISM_ASSERT(*breakpoint == lex_mode->as.list.incrementor);
11763 parser->current.end = breakpoint + 1;
11764 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
11765 lex_mode->as.list.nesting++;
11772 parser->current.end = parser->end;
11773 pm_token_buffer_flush(parser, &token_buffer);
11774 LEX(PM_TOKEN_STRING_CONTENT);
11776 case PM_LEX_REGEXP: {
11778 if (parser->next_start == NULL) {
11779 parser->current.start = parser->current.end;
11781 parser->current.start = parser->next_start;
11782 parser->current.end = parser->next_start;
11783 parser->next_start = NULL;
11788 if (parser->current.end >= parser->end) {
11793 pm_lex_mode_t *lex_mode = parser->lex_modes.current;
11798 const uint8_t *breakpoints = lex_mode->as.regexp.breakpoints;
11799 const uint8_t *breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_REGEXP);
11802 while (breakpoint != NULL) {
11803 uint8_t term = lex_mode->as.regexp.terminator;
11804 bool is_terminator = (*breakpoint == term);
11809 if (*breakpoint ==
'\r' && peek_at(parser, breakpoint + 1) ==
'\n') {
11810 if (term ==
'\n') {
11811 is_terminator =
true;
11817 if (term ==
'\r') {
11818 is_terminator =
false;
11824 if (is_terminator) {
11825 if (lex_mode->as.regexp.nesting > 0) {
11826 parser->current.end = breakpoint + 1;
11827 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_REGEXP);
11828 lex_mode->as.regexp.nesting--;
11835 if (breakpoint > parser->current.start) {
11836 parser->current.end = breakpoint;
11837 pm_regexp_token_buffer_flush(parser, &token_buffer);
11838 LEX(PM_TOKEN_STRING_CONTENT);
11842 size_t eol_length = match_eol_at(parser, breakpoint);
11844 parser->current.end = breakpoint + eol_length;
11849 if (parser->heredoc_end == NULL) {
11850 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, PM_TOKEN_END(parser, &parser->current));
11852 parser_flush_heredoc_end(parser);
11855 parser->current.end = breakpoint + 1;
11860 if (parser->next_start == NULL) {
11861 parser->current.end += pm_strspn_regexp_option(parser->current.end, parser->end - parser->current.end);
11867 size_t options = pm_strspn_regexp_option(parser->next_start, parser->end - parser->next_start);
11870 parser->current.start = parser->next_start - 1;
11871 parser->current.end = parser->next_start + options;
11872 parser->next_start = NULL;
11876 lex_mode_pop(parser);
11877 lex_state_set(parser, PM_LEX_STATE_END);
11878 LEX(PM_TOKEN_REGEXP_END);
11883 if (*breakpoint && *breakpoint == lex_mode->as.regexp.incrementor) {
11884 parser->current.end = breakpoint + 1;
11885 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_REGEXP);
11886 lex_mode->as.regexp.nesting++;
11890 switch (*breakpoint) {
11893 parser->current.end = breakpoint + 1;
11894 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_REGEXP);
11897 if (peek_at(parser, breakpoint + 1) !=
'\n') {
11898 parser->current.end = breakpoint + 1;
11899 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_REGEXP);
11904 parser->current.end = breakpoint;
11905 pm_token_buffer_escape(parser, &token_buffer.
base);
11906 pm_regexp_token_buffer_resume(parser, &token_buffer, breakpoint);
11912 if (parser->heredoc_end == NULL) {
11913 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, U32(breakpoint - parser->start + 1));
11914 parser->current.end = breakpoint + 1;
11915 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_REGEXP);
11919 parser->current.end = breakpoint + 1;
11920 parser_flush_heredoc_end(parser);
11921 pm_regexp_token_buffer_flush(parser, &token_buffer);
11922 LEX(PM_TOKEN_STRING_CONTENT);
11927 parser->current.end = breakpoint + 1;
11932 if (parser->current.end == parser->end) {
11933 pm_token_buffer_escape(parser, &token_buffer.
base);
11934 pm_regexp_token_buffer_resume(parser, &token_buffer, parser->end);
11942 uint8_t peeked = peek(parser);
11944 if (pm_regexp_escape_kept_p(lex_mode, peeked)) {
11945 parser->current.end++;
11946 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_REGEXP);
11950 pm_token_buffer_escape(parser, &token_buffer.
base);
11954 parser->current.end++;
11955 if (peek(parser) !=
'\n') {
11956 if (lex_mode->as.regexp.terminator !=
'\r') {
11957 pm_token_buffer_push_byte(&token_buffer.
base,
'\\');
11959 pm_token_buffer_push_byte(&token_buffer.
base,
'\r');
11964 if (parser->heredoc_end) {
11968 parser_flush_heredoc_end(parser);
11969 pm_regexp_token_buffer_copy(parser, &token_buffer);
11970 LEX(PM_TOKEN_STRING_CONTENT);
11973 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, PM_TOKEN_END(parser, &parser->current) + 1);
11976 parser->current.end++;
11983 if (peeked ==
'u' && peek_offset(parser, 1) ==
'{') {
11984 pm_regexp_lex_braced_unicode(parser, &token_buffer.
base.
buffer, lex_mode->as.regexp.terminator);
11986 escape_read(parser, &token_buffer.
base.
buffer, PM_ESCAPE_FLAG_REGEXP);
11990 if (parser->next_start != NULL) {
11991 pm_regexp_token_buffer_copy(parser, &token_buffer);
11992 LEX(PM_TOKEN_STRING_CONTENT);
12001 if (peeked == lex_mode->as.regexp.terminator) {
12002 pm_token_buffer_push_byte(&token_buffer.
base, peeked);
12003 parser->current.end++;
12009 pm_regexp_token_buffer_resume(parser, &token_buffer, parser->current.end);
12010 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_REGEXP);
12016 pm_token_type_t
type = lex_interpolation(parser, breakpoint);
12023 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_REGEXP);
12027 if (type == PM_TOKEN_STRING_CONTENT) {
12028 pm_regexp_token_buffer_flush(parser, &token_buffer);
12034 PRISM_ASSERT(
false &&
"unreachable");
12042 parser->current.end = parser->end;
12043 pm_regexp_token_buffer_flush(parser, &token_buffer);
12044 LEX(PM_TOKEN_STRING_CONTENT);
12046 case PM_LEX_STRING: {
12048 if (parser->next_start == NULL) {
12049 parser->current.start = parser->current.end;
12051 parser->current.start = parser->next_start;
12052 parser->current.end = parser->next_start;
12053 parser->next_start = NULL;
12058 if (parser->current.end >= parser->end) {
12064 pm_lex_mode_t *lex_mode = parser->lex_modes.current;
12065 const uint8_t *breakpoints = lex_mode->as.string.breakpoints;
12066 const uint8_t *breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
12072 while (breakpoint != NULL) {
12075 if (lex_mode->as.string.incrementor !=
'\0' && *breakpoint == lex_mode->as.string.incrementor) {
12076 lex_mode->as.string.nesting++;
12077 parser->current.end = breakpoint + 1;
12078 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
12082 uint8_t term = lex_mode->as.string.terminator;
12083 bool is_terminator = (*breakpoint == term);
12088 if (*breakpoint ==
'\r' && peek_at(parser, breakpoint + 1) ==
'\n') {
12089 if (term ==
'\n') {
12090 is_terminator =
true;
12096 if (term ==
'\r') {
12097 is_terminator =
false;
12104 if (is_terminator) {
12107 if (lex_mode->as.string.nesting > 0) {
12108 parser->current.end = breakpoint + 1;
12109 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
12110 lex_mode->as.string.nesting--;
12116 if (breakpoint > parser->current.start) {
12117 parser->current.end = breakpoint;
12118 pm_token_buffer_flush(parser, &token_buffer);
12119 LEX(PM_TOKEN_STRING_CONTENT);
12124 size_t eol_length = match_eol_at(parser, breakpoint);
12126 parser->current.end = breakpoint + eol_length;
12131 if (parser->heredoc_end == NULL) {
12132 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, PM_TOKEN_END(parser, &parser->current));
12135 parser->current.end = breakpoint + 1;
12138 if (lex_mode->as.string.label_allowed && (peek(parser) ==
':') && (peek_offset(parser, 1) !=
':')) {
12139 parser->current.end++;
12140 lex_state_set(parser, PM_LEX_STATE_ARG | PM_LEX_STATE_LABELED);
12141 lex_mode_pop(parser);
12142 LEX(PM_TOKEN_LABEL_END);
12148 if (term ==
'\n' && parser->heredoc_end) {
12149 parser_flush_heredoc_end(parser);
12152 lex_state_set(parser, PM_LEX_STATE_END);
12153 lex_mode_pop(parser);
12154 LEX(PM_TOKEN_STRING_END);
12157 switch (*breakpoint) {
12160 parser->current.end = breakpoint + 1;
12161 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
12164 if (peek_at(parser, breakpoint + 1) !=
'\n') {
12165 parser->current.end = breakpoint + 1;
12166 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
12173 parser->current.end = breakpoint;
12174 pm_token_buffer_escape(parser, &token_buffer);
12175 token_buffer.
cursor = breakpoint;
12183 if (parser->heredoc_end == NULL) {
12184 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, U32(breakpoint - parser->start + 1));
12185 parser->current.end = breakpoint + 1;
12186 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
12190 parser->current.end = breakpoint + 1;
12191 parser_flush_heredoc_end(parser);
12192 pm_token_buffer_flush(parser, &token_buffer);
12193 LEX(PM_TOKEN_STRING_CONTENT);
12196 parser->current.end = breakpoint + 1;
12200 if (parser->current.end == parser->end) {
12205 pm_token_buffer_escape(parser, &token_buffer);
12206 uint8_t peeked = peek(parser);
12210 pm_token_buffer_push_byte(&token_buffer,
'\\');
12211 parser->current.end++;
12214 parser->current.end++;
12215 if (peek(parser) !=
'\n') {
12216 if (!lex_mode->as.string.interpolation) {
12217 pm_token_buffer_push_byte(&token_buffer,
'\\');
12219 pm_token_buffer_push_byte(&token_buffer,
'\r');
12224 if (!lex_mode->as.string.interpolation) {
12225 pm_token_buffer_push_byte(&token_buffer,
'\\');
12226 pm_token_buffer_push_byte(&token_buffer,
'\n');
12229 if (parser->heredoc_end) {
12233 parser_flush_heredoc_end(parser);
12234 pm_token_buffer_copy(parser, &token_buffer);
12235 LEX(PM_TOKEN_STRING_CONTENT);
12238 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, PM_TOKEN_END(parser, &parser->current) + 1);
12241 parser->current.end++;
12244 if (lex_mode->as.string.incrementor !=
'\0' && peeked == lex_mode->as.string.incrementor) {
12245 pm_token_buffer_push_byte(&token_buffer, peeked);
12246 parser->current.end++;
12247 }
else if (lex_mode->as.string.terminator !=
'\0' && peeked == lex_mode->as.string.terminator) {
12248 pm_token_buffer_push_byte(&token_buffer, peeked);
12249 parser->current.end++;
12250 }
else if (lex_mode->as.string.interpolation) {
12251 escape_read(parser, &token_buffer.
buffer, PM_ESCAPE_FLAG_NONE);
12254 if (parser->next_start != NULL) {
12255 pm_token_buffer_copy(parser, &token_buffer);
12256 LEX(PM_TOKEN_STRING_CONTENT);
12259 pm_token_buffer_push_byte(&token_buffer,
'\\');
12260 pm_token_buffer_push_escaped(&token_buffer, parser);
12266 token_buffer.
cursor = parser->current.end;
12267 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
12271 pm_token_type_t
type = lex_interpolation(parser, breakpoint);
12278 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, PM_STRPBRK_STRING);
12282 if (type == PM_TOKEN_STRING_CONTENT) {
12283 pm_token_buffer_flush(parser, &token_buffer);
12289 PRISM_ASSERT(
false &&
"unreachable");
12296 lex_mode->as.string.joined_at_eof = parser->current.end > parser->current.start && parser->current.end < parser->end;
12297 parser->current.end = parser->end;
12298 pm_token_buffer_flush(parser, &token_buffer);
12299 LEX(PM_TOKEN_STRING_CONTENT);
12301 case PM_LEX_HEREDOC: {
12303 if (parser->next_start == NULL) {
12304 parser->current.start = parser->current.end;
12306 parser->current.start = parser->next_start;
12307 parser->current.end = parser->next_start;
12308 parser->heredoc_end = NULL;
12309 parser->next_start = NULL;
12314 pm_lex_mode_t *lex_mode = parser->lex_modes.current;
12317 bool line_continuation = lex_mode->as.heredoc.line_continuation;
12318 lex_mode->as.heredoc.line_continuation =
false;
12324 if (parser->current.end >= parser->end) {
12325 pm_parser_err_heredoc_term(parser, heredoc_lex_mode->ident_start, heredoc_lex_mode->ident_length);
12326 parser->next_start = lex_mode->as.heredoc.next_start;
12327 parser->heredoc_end = parser->current.end;
12328 lex_state_set(parser, PM_LEX_STATE_END);
12329 lex_mode_pop(parser);
12330 LEX(PM_TOKEN_HEREDOC_END);
12333 const uint8_t *ident_start = heredoc_lex_mode->ident_start;
12334 size_t ident_length = heredoc_lex_mode->ident_length;
12338 if (current_token_starts_line(parser)) {
12339 const uint8_t *start = parser->current.start;
12341 if (!line_continuation && (start + ident_length <= parser->end)) {
12342 const uint8_t *newline = next_newline(start, parser->end - start);
12343 const uint8_t *ident_end = newline;
12344 const uint8_t *terminator_end = newline;
12346 if (newline == NULL) {
12347 terminator_end = parser->end;
12348 ident_end = parser->end;
12351 if (newline[-1] ==
'\r') {
12363 if ((
size_t) (ident_end - start) >= ident_length) {
12364 const uint8_t *terminator_start = ident_end - ident_length;
12365 const uint8_t *cursor = start;
12367 if (heredoc_lex_mode->indent == PM_HEREDOC_INDENT_DASH || heredoc_lex_mode->indent == PM_HEREDOC_INDENT_TILDE) {
12368 while (cursor < terminator_start && pm_char_is_inline_whitespace(*cursor)) {
12374 (cursor == terminator_start) &&
12375 (memcmp(terminator_start, ident_start, ident_length) == 0)
12377 if (newline != NULL) {
12378 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, U32(newline - parser->start + 1));
12381 parser->current.end = terminator_end;
12382 parser->next_start = lex_mode->as.heredoc.next_start;
12383 parser->heredoc_end = parser->current.end;
12385 lex_state_set(parser, PM_LEX_STATE_END);
12386 lex_mode_pop(parser);
12387 LEX(PM_TOKEN_HEREDOC_END);
12392 size_t whitespace = pm_heredoc_strspn_inline_whitespace(parser, &start, heredoc_lex_mode->indent);
12394 heredoc_lex_mode->indent == PM_HEREDOC_INDENT_TILDE &&
12395 lex_mode->as.heredoc.common_whitespace != NULL &&
12396 (*lex_mode->as.heredoc.common_whitespace > whitespace) &&
12397 peek_at(parser, start) !=
'\n'
12399 *lex_mode->as.heredoc.common_whitespace = whitespace;
12406 uint8_t breakpoints[PM_STRPBRK_CACHE_SIZE] =
"\r\n\\#";
12408 pm_heredoc_quote_t quote = heredoc_lex_mode->quote;
12410 pm_strpbrk_mode_t mode = (quote == PM_HEREDOC_QUOTE_SINGLE) ? PM_STRPBRK_RAW : PM_STRPBRK_STRING;
12411 if (quote == PM_HEREDOC_QUOTE_SINGLE) {
12412 breakpoints[3] =
'\0';
12415 const uint8_t *breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, mode);
12417 bool was_line_continuation =
false;
12419 while (breakpoint != NULL) {
12420 switch (*breakpoint) {
12423 parser->current.end = breakpoint + 1;
12424 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, mode);
12427 parser->current.end = breakpoint + 1;
12429 if (peek_at(parser, breakpoint + 1) !=
'\n') {
12430 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, mode);
12437 pm_token_buffer_escape(parser, &token_buffer);
12438 token_buffer.
cursor = breakpoint;
12442 if (parser->heredoc_end != NULL && (parser->heredoc_end > breakpoint)) {
12443 parser_flush_heredoc_end(parser);
12444 parser->current.end = breakpoint + 1;
12445 pm_token_buffer_flush(parser, &token_buffer);
12447 lex_mode->as.heredoc.line_continuation = was_line_continuation;
12448 LEX(PM_TOKEN_STRING_CONTENT);
12451 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, U32(breakpoint - parser->start + 1));
12455 const uint8_t *start = breakpoint + 1;
12457 if (!was_line_continuation && (start + ident_length <= parser->end)) {
12460 const uint8_t *newline = next_newline(start, parser->end - start);
12462 if (newline == NULL) {
12463 newline = parser->end;
12464 }
else if (newline[-1] ==
'\r') {
12476 if ((
size_t) (newline - start) >= ident_length) {
12478 const uint8_t *terminator_start = newline - ident_length;
12482 const uint8_t *cursor = start;
12484 if (heredoc_lex_mode->indent == PM_HEREDOC_INDENT_DASH || heredoc_lex_mode->indent == PM_HEREDOC_INDENT_TILDE) {
12485 while (cursor < terminator_start && pm_char_is_inline_whitespace(*cursor)) {
12491 cursor == terminator_start &&
12492 (memcmp(terminator_start, ident_start, ident_length) == 0)
12494 parser->current.end = breakpoint + 1;
12495 pm_token_buffer_flush(parser, &token_buffer);
12496 LEX(PM_TOKEN_STRING_CONTENT);
12501 size_t whitespace = pm_heredoc_strspn_inline_whitespace(parser, &start, lex_mode->as.heredoc.base.indent);
12508 if (lex_mode->as.heredoc.base.indent == PM_HEREDOC_INDENT_TILDE) {
12509 if ((lex_mode->as.heredoc.common_whitespace != NULL) && (*lex_mode->as.heredoc.common_whitespace > whitespace) && peek_at(parser, start) !=
'\n') {
12510 *lex_mode->as.heredoc.common_whitespace = whitespace;
12513 parser->current.end = breakpoint + 1;
12514 pm_token_buffer_flush(parser, &token_buffer);
12515 LEX(PM_TOKEN_STRING_CONTENT);
12520 parser->current.end = breakpoint + 1;
12521 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, mode);
12531 parser->current.end = breakpoint + 1;
12535 if (parser->current.end == parser->end) {
12540 pm_token_buffer_escape(parser, &token_buffer);
12541 uint8_t peeked = peek(parser);
12543 if (quote == PM_HEREDOC_QUOTE_SINGLE) {
12546 parser->current.end++;
12547 if (peek(parser) !=
'\n') {
12548 pm_token_buffer_push_byte(&token_buffer,
'\\');
12549 pm_token_buffer_push_byte(&token_buffer,
'\r');
12554 pm_token_buffer_push_byte(&token_buffer,
'\\');
12555 pm_token_buffer_push_byte(&token_buffer,
'\n');
12556 token_buffer.
cursor = parser->current.end + 1;
12557 breakpoint = parser->current.end;
12560 pm_token_buffer_push_byte(&token_buffer,
'\\');
12561 pm_token_buffer_push_escaped(&token_buffer, parser);
12567 parser->current.end++;
12568 if (peek(parser) !=
'\n') {
12569 pm_token_buffer_push_byte(&token_buffer,
'\r');
12577 if (heredoc_lex_mode->indent == PM_HEREDOC_INDENT_TILDE) {
12578 const uint8_t *end = parser->current.end;
12580 if (parser->heredoc_end == NULL) {
12581 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, U32(end - parser->start + 1));
12583 parser_flush_heredoc_end(parser);
12588 parser->current.end = breakpoint;
12589 pm_token_buffer_flush(parser, &token_buffer);
12593 parser->current.end = end + 1;
12594 lex_mode->as.heredoc.line_continuation =
true;
12595 LEX(PM_TOKEN_STRING_CONTENT);
12598 was_line_continuation =
true;
12599 token_buffer.
cursor = parser->current.end + 1;
12600 breakpoint = parser->current.end;
12603 escape_read(parser, &token_buffer.
buffer, PM_ESCAPE_FLAG_NONE);
12608 if (parser->next_start != NULL) {
12612 if (heredoc_lex_mode->indent == PM_HEREDOC_INDENT_TILDE) {
12613 parser->current.end = parser->next_start;
12614 parser->next_start = NULL;
12618 pm_token_buffer_copy(parser, &token_buffer);
12619 lex_mode->as.heredoc.line_continuation =
true;
12620 LEX(PM_TOKEN_STRING_CONTENT);
12627 token_buffer.
cursor = parser->current.end;
12628 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, mode);
12632 pm_token_type_t
type = lex_interpolation(parser, breakpoint);
12640 breakpoint = pm_strpbrk(parser, parser->current.end, breakpoints, parser->end - parser->current.end, mode);
12644 if (type == PM_TOKEN_STRING_CONTENT) {
12645 pm_token_buffer_flush(parser, &token_buffer);
12651 PRISM_ASSERT(
false &&
"unreachable");
12654 was_line_continuation =
false;
12657 if (parser->current.end > parser->current.start) {
12658 parser->current.end = parser->end;
12659 pm_token_buffer_flush(parser, &token_buffer);
12660 LEX(PM_TOKEN_STRING_CONTENT);
12665 parser->current.end = parser->end;
12666 pm_token_buffer_flush(parser, &token_buffer);
12667 LEX(PM_TOKEN_STRING_CONTENT);
12671 PRISM_ASSERT(
false &&
"unreachable");
12689 PM_BINDING_POWER_UNSET = 0,
12690 PM_BINDING_POWER_STATEMENT = 2,
12691 PM_BINDING_POWER_MODIFIER_RESCUE = 4,
12692 PM_BINDING_POWER_MODIFIER = 6,
12693 PM_BINDING_POWER_COMPOSITION = 8,
12694 PM_BINDING_POWER_NOT = 10,
12695 PM_BINDING_POWER_MATCH = 12,
12696 PM_BINDING_POWER_DEFINED = 14,
12697 PM_BINDING_POWER_MULTI_ASSIGNMENT = 16,
12698 PM_BINDING_POWER_ASSIGNMENT = 18,
12699 PM_BINDING_POWER_TERNARY = 20,
12700 PM_BINDING_POWER_RANGE = 22,
12701 PM_BINDING_POWER_LOGICAL_OR = 24,
12702 PM_BINDING_POWER_LOGICAL_AND = 26,
12703 PM_BINDING_POWER_EQUALITY = 28,
12704 PM_BINDING_POWER_COMPARISON = 30,
12705 PM_BINDING_POWER_BITWISE_OR = 32,
12706 PM_BINDING_POWER_BITWISE_AND = 34,
12707 PM_BINDING_POWER_SHIFT = 36,
12708 PM_BINDING_POWER_TERM = 38,
12709 PM_BINDING_POWER_FACTOR = 40,
12710 PM_BINDING_POWER_UMINUS = 42,
12711 PM_BINDING_POWER_EXPONENT = 44,
12712 PM_BINDING_POWER_UNARY = 46,
12713 PM_BINDING_POWER_INDEX = 48,
12714 PM_BINDING_POWER_CALL = 50,
12715 PM_BINDING_POWER_MAX = 52
12716} pm_binding_power_t;
12739#define BINDING_POWER_ASSIGNMENT { PM_BINDING_POWER_UNARY, PM_BINDING_POWER_ASSIGNMENT, true, false }
12740#define LEFT_ASSOCIATIVE(precedence) { precedence, precedence + 1, true, false }
12741#define RIGHT_ASSOCIATIVE(precedence) { precedence, precedence, true, false }
12742#define NON_ASSOCIATIVE(precedence) { precedence, precedence + 1, true, true }
12743#define RIGHT_ASSOCIATIVE_UNARY(precedence) { precedence, precedence, false, false }
12747 [PM_TOKEN_KEYWORD_RESCUE_MODIFIER] = { PM_BINDING_POWER_MODIFIER_RESCUE, PM_BINDING_POWER_COMPOSITION,
true,
false },
12750 [PM_TOKEN_KEYWORD_IF_MODIFIER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_MODIFIER),
12751 [PM_TOKEN_KEYWORD_UNLESS_MODIFIER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_MODIFIER),
12752 [PM_TOKEN_KEYWORD_UNTIL_MODIFIER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_MODIFIER),
12753 [PM_TOKEN_KEYWORD_WHILE_MODIFIER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_MODIFIER),
12756 [PM_TOKEN_KEYWORD_AND] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPOSITION),
12757 [PM_TOKEN_KEYWORD_OR] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPOSITION),
12760 [PM_TOKEN_EQUAL_GREATER] = NON_ASSOCIATIVE(PM_BINDING_POWER_MATCH),
12761 [PM_TOKEN_KEYWORD_IN] = NON_ASSOCIATIVE(PM_BINDING_POWER_MATCH),
12764 [PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL] = BINDING_POWER_ASSIGNMENT,
12765 [PM_TOKEN_AMPERSAND_EQUAL] = BINDING_POWER_ASSIGNMENT,
12766 [PM_TOKEN_CARET_EQUAL] = BINDING_POWER_ASSIGNMENT,
12767 [PM_TOKEN_EQUAL] = BINDING_POWER_ASSIGNMENT,
12768 [PM_TOKEN_GREATER_GREATER_EQUAL] = BINDING_POWER_ASSIGNMENT,
12769 [PM_TOKEN_LESS_LESS_EQUAL] = BINDING_POWER_ASSIGNMENT,
12770 [PM_TOKEN_MINUS_EQUAL] = BINDING_POWER_ASSIGNMENT,
12771 [PM_TOKEN_PERCENT_EQUAL] = BINDING_POWER_ASSIGNMENT,
12772 [PM_TOKEN_PIPE_EQUAL] = BINDING_POWER_ASSIGNMENT,
12773 [PM_TOKEN_PIPE_PIPE_EQUAL] = BINDING_POWER_ASSIGNMENT,
12774 [PM_TOKEN_PLUS_EQUAL] = BINDING_POWER_ASSIGNMENT,
12775 [PM_TOKEN_SLASH_EQUAL] = BINDING_POWER_ASSIGNMENT,
12776 [PM_TOKEN_STAR_EQUAL] = BINDING_POWER_ASSIGNMENT,
12777 [PM_TOKEN_STAR_STAR_EQUAL] = BINDING_POWER_ASSIGNMENT,
12780 [PM_TOKEN_QUESTION_MARK] = RIGHT_ASSOCIATIVE(PM_BINDING_POWER_TERNARY),
12783 [PM_TOKEN_DOT_DOT] = NON_ASSOCIATIVE(PM_BINDING_POWER_RANGE),
12784 [PM_TOKEN_DOT_DOT_DOT] = NON_ASSOCIATIVE(PM_BINDING_POWER_RANGE),
12785 [PM_TOKEN_UDOT_DOT] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_LOGICAL_OR),
12786 [PM_TOKEN_UDOT_DOT_DOT] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_LOGICAL_OR),
12789 [PM_TOKEN_PIPE_PIPE] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_LOGICAL_OR),
12792 [PM_TOKEN_AMPERSAND_AMPERSAND] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_LOGICAL_AND),
12795 [PM_TOKEN_BANG_EQUAL] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),
12796 [PM_TOKEN_BANG_TILDE] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),
12797 [PM_TOKEN_EQUAL_EQUAL] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),
12798 [PM_TOKEN_EQUAL_EQUAL_EQUAL] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),
12799 [PM_TOKEN_EQUAL_TILDE] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),
12800 [PM_TOKEN_LESS_EQUAL_GREATER] = NON_ASSOCIATIVE(PM_BINDING_POWER_EQUALITY),
12803 [PM_TOKEN_GREATER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPARISON),
12804 [PM_TOKEN_GREATER_EQUAL] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPARISON),
12805 [PM_TOKEN_LESS] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPARISON),
12806 [PM_TOKEN_LESS_EQUAL] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_COMPARISON),
12809 [PM_TOKEN_CARET] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_BITWISE_OR),
12810 [PM_TOKEN_PIPE] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_BITWISE_OR),
12813 [PM_TOKEN_AMPERSAND] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_BITWISE_AND),
12816 [PM_TOKEN_GREATER_GREATER] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_SHIFT),
12817 [PM_TOKEN_LESS_LESS] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_SHIFT),
12820 [PM_TOKEN_MINUS] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_TERM),
12821 [PM_TOKEN_PLUS] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_TERM),
12824 [PM_TOKEN_PERCENT] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_FACTOR),
12825 [PM_TOKEN_SLASH] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_FACTOR),
12826 [PM_TOKEN_STAR] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_FACTOR),
12827 [PM_TOKEN_USTAR] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_FACTOR),
12830 [PM_TOKEN_UMINUS] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_UMINUS),
12831 [PM_TOKEN_UMINUS_NUM] = { PM_BINDING_POWER_UMINUS, PM_BINDING_POWER_MAX,
false,
false },
12834 [PM_TOKEN_STAR_STAR] = RIGHT_ASSOCIATIVE(PM_BINDING_POWER_EXPONENT),
12835 [PM_TOKEN_USTAR_STAR] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_UNARY),
12838 [PM_TOKEN_BANG] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_UNARY),
12839 [PM_TOKEN_TILDE] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_UNARY),
12840 [PM_TOKEN_UPLUS] = RIGHT_ASSOCIATIVE_UNARY(PM_BINDING_POWER_UNARY),
12843 [PM_TOKEN_BRACKET_LEFT] = LEFT_ASSOCIATIVE(PM_BINDING_POWER_INDEX),
12846 [PM_TOKEN_COLON_COLON] = RIGHT_ASSOCIATIVE(PM_BINDING_POWER_CALL),
12847 [PM_TOKEN_DOT] = RIGHT_ASSOCIATIVE(PM_BINDING_POWER_CALL),
12848 [PM_TOKEN_AMPERSAND_DOT] = RIGHT_ASSOCIATIVE(PM_BINDING_POWER_CALL)
12851#undef BINDING_POWER_ASSIGNMENT
12852#undef LEFT_ASSOCIATIVE
12853#undef RIGHT_ASSOCIATIVE
12854#undef RIGHT_ASSOCIATIVE_UNARY
12860match1(
const pm_parser_t *parser, pm_token_type_t type) {
12861 return parser->current.type ==
type;
12868match2(
const pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2) {
12869 return match1(parser, type1) || match1(parser, type2);
12876match3(
const pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2, pm_token_type_t type3) {
12877 return match1(parser, type1) || match1(parser, type2) || match1(parser, type3);
12884match4(
const pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2, pm_token_type_t type3, pm_token_type_t type4) {
12885 return match1(parser, type1) || match1(parser, type2) || match1(parser, type3) || match1(parser, type4);
12892match5(
const pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2, pm_token_type_t type3, pm_token_type_t type4, pm_token_type_t type5) {
12893 return match1(parser, type1) || match1(parser, type2) || match1(parser, type3) || match1(parser, type4) || match1(parser, type5);
12900match6(
const pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2, pm_token_type_t type3, pm_token_type_t type4, pm_token_type_t type5, pm_token_type_t type6) {
12901 return match1(parser, type1) || match1(parser, type2) || match1(parser, type3) || match1(parser, type4) || match1(parser, type5) || match1(parser, type6);
12908match8(
const pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2, pm_token_type_t type3, pm_token_type_t type4, pm_token_type_t type5, pm_token_type_t type6, pm_token_type_t type7, pm_token_type_t type8) {
12909 return match1(parser, type1) || match1(parser, type2) || match1(parser, type3) || match1(parser, type4) || match1(parser, type5) || match1(parser, type6) || match1(parser, type7) || match1(parser, type8);
12919accept1(
pm_parser_t *parser, pm_token_type_t type) {
12920 if (match1(parser, type)) {
12921 parser_lex(parser);
12932accept2(
pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2) {
12933 if (match2(parser, type1, type2)) {
12934 parser_lex(parser);
12952expect1(
pm_parser_t *parser, pm_token_type_t type, pm_diagnostic_id_t diag_id) {
12953 if (accept1(parser, type))
return;
12955 const uint8_t *location = parser->previous.
end;
12956 pm_parser_err(parser, U32(location - parser->start), 0, diag_id);
12958 parser->previous.
start = location;
12959 parser->previous.
type = 0;
12967expect2(
pm_parser_t *parser, pm_token_type_t type1, pm_token_type_t type2, pm_diagnostic_id_t diag_id) {
12968 if (accept2(parser, type1, type2))
return;
12970 const uint8_t *location = parser->previous.
end;
12971 pm_parser_err(parser, U32(location - parser->start), 0, diag_id);
12973 parser->previous.
start = location;
12974 parser->previous.
type = 0;
12982expect1_heredoc_term(
pm_parser_t *parser,
const uint8_t *ident_start,
size_t ident_length) {
12983 if (match1(parser, PM_TOKEN_HEREDOC_END)) {
12984 lex_state_set(parser, PM_LEX_STATE_END);
12985 parser_lex(parser);
12987 pm_parser_err_heredoc_term(parser, ident_start, ident_length);
12988 parser->previous.
start = parser->previous.
end;
12989 parser->previous.
type = 0;
13000expect1_opening(
pm_parser_t *parser, pm_token_type_t type, pm_diagnostic_id_t diag_id,
const pm_token_t *opening) {
13001 if (accept1(parser, type))
return;
13003 const uint8_t *start = opening->
start;
13004 pm_parser_err(parser, U32(start - parser->start), U32(opening->
end - start), diag_id);
13006 parser->previous.
start = parser->previous.
end;
13007 parser->previous.
type = 0;
13011#define PM_PARSE_ACCEPTS_COMMAND_CALL ((uint8_t) 0x1)
13012#define PM_PARSE_ACCEPTS_LABEL ((uint8_t) 0x2)
13013#define PM_PARSE_ACCEPTS_DO_BLOCK ((uint8_t) 0x4)
13014#define PM_PARSE_IN_ENDLESS_DEF ((uint8_t) 0x8)
13025#define PM_PARSE_ACCEPTS_STATEMENT ((uint8_t) 0x10)
13038#define PM_PARSE_ACCEPTS_COMMAND_DEF ((uint8_t) 0x20)
13041parse_expression(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, pm_diagnostic_id_t diag_id, uint16_t depth);
13044parse_heredoc(
pm_parser_t *parser, uint16_t depth);
13050parse_resource_recovery(
pm_parser_t *parser, uint16_t depth) {
13051 if (depth >= PRISM_DEPTH_MAXIMUM) {
13052 pm_parser_err_current(parser, PM_ERR_NESTING_TOO_DEEP);
13054 pm_parser_err_stack_exhausted(parser, PM_TOKEN_START(parser, &parser->current), PM_TOKEN_LENGTH(&parser->current));
13057 if (context_recoverable(parser, &parser->current)) {
13058 parser->recovering =
true;
13061 if (match1(parser, PM_TOKEN_HEREDOC_START)) {
13063 PRISM_ASSERT(parser->lex_modes.current->mode == PM_LEX_HEREDOC);
13066 parser->lex_modes.current->as.heredoc.base.quote = PM_HEREDOC_QUOTE_SINGLE;
13069 parser_lex(parser);
13070 }
while (!match2(parser, PM_TOKEN_HEREDOC_END, PM_TOKEN_EOF));
13072 if (match1(parser, PM_TOKEN_HEREDOC_END)) {
13073 lex_state_set(parser, PM_LEX_STATE_END);
13074 parser_lex(parser);
13077 parser->previous = opening;
13078 return UP(pm_error_recovery_node_create(parser, PM_TOKEN_START(parser, &opening), PM_TOKEN_LENGTH(&opening)));
13081 return UP(pm_error_recovery_node_create(parser, PM_TOKEN_END(parser, &parser->previous), 0));
13088parse_discard_token(
pm_parser_t *parser, uint16_t depth) {
13089 if (match1(parser, PM_TOKEN_HEREDOC_START)) {
13090 (void) parse_heredoc(parser, depth);
13092 parser_lex(parser);
13101parse_value_expression(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, pm_diagnostic_id_t diag_id, uint16_t depth) {
13102 pm_node_t *node = parse_expression(parser, binding_power, flags, diag_id, depth);
13103 pm_assert_value_expression(parser, node);
13126token_begins_expression_p(pm_token_type_t type) {
13128 case PM_TOKEN_EQUAL_GREATER:
13129 case PM_TOKEN_KEYWORD_IN:
13133 case PM_TOKEN_BRACE_RIGHT:
13134 case PM_TOKEN_BRACKET_RIGHT:
13135 case PM_TOKEN_COLON:
13136 case PM_TOKEN_COMMA:
13137 case PM_TOKEN_EMBEXPR_END:
13139 case PM_TOKEN_HEREDOC_END:
13140 case PM_TOKEN_LAMBDA_BEGIN:
13141 case PM_TOKEN_KEYWORD_DO:
13142 case PM_TOKEN_KEYWORD_DO_BLOCK:
13143 case PM_TOKEN_KEYWORD_DO_LAMBDA:
13144 case PM_TOKEN_KEYWORD_DO_LOOP:
13145 case PM_TOKEN_KEYWORD_END:
13146 case PM_TOKEN_KEYWORD_ELSE:
13147 case PM_TOKEN_KEYWORD_ELSIF:
13148 case PM_TOKEN_KEYWORD_ENSURE:
13149 case PM_TOKEN_KEYWORD_THEN:
13150 case PM_TOKEN_KEYWORD_RESCUE:
13151 case PM_TOKEN_KEYWORD_WHEN:
13152 case PM_TOKEN_NEWLINE:
13153 case PM_TOKEN_PARENTHESIS_RIGHT:
13154 case PM_TOKEN_SEMICOLON:
13160 PRISM_ASSERT(pm_binding_powers[type].left == PM_BINDING_POWER_UNSET);
13162 case PM_TOKEN_UAMPERSAND:
13166 case PM_TOKEN_UCOLON_COLON:
13167 case PM_TOKEN_UMINUS:
13168 case PM_TOKEN_UMINUS_NUM:
13169 case PM_TOKEN_UPLUS:
13170 case PM_TOKEN_BANG:
13171 case PM_TOKEN_TILDE:
13172 case PM_TOKEN_UDOT_DOT:
13173 case PM_TOKEN_UDOT_DOT_DOT:
13180 return pm_binding_powers[
type].left == PM_BINDING_POWER_UNSET;
13200token_begins_pattern_p(pm_token_type_t type) {
13202 token_begins_expression_p(type) ||
13203 type == PM_TOKEN_USTAR ||
13204 type == PM_TOKEN_USTAR_STAR ||
13205 type == PM_TOKEN_CARET
13217token_begins_argument_p(pm_token_type_t type) {
13219 token_begins_expression_p(type) ||
13220 type == PM_TOKEN_UAMPERSAND ||
13221 type == PM_TOKEN_USTAR ||
13222 type == PM_TOKEN_USTAR_STAR
13231parse_starred_expression(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, pm_diagnostic_id_t diag_id, uint16_t depth) {
13232 if (accept1(parser, PM_TOKEN_USTAR)) {
13234 pm_node_t *expression = parse_value_expression(parser, binding_power, (uint8_t) (flags & PM_PARSE_ACCEPTS_DO_BLOCK), PM_ERR_EXPECT_EXPRESSION_AFTER_STAR, (uint16_t) (depth + 1));
13235 return UP(pm_splat_node_create(parser, &
operator, expression));
13238 return parse_value_expression(parser, binding_power, flags, diag_id, depth);
13242pm_node_unreference_each(
const pm_node_t *node,
void *data) {
13243 switch (PM_NODE_TYPE(node)) {
13248 case PM_BREAK_NODE:
13250 case PM_REDO_NODE: {
13254 while (index < parser->current_block_exits->size) {
13255 pm_node_t *block_exit = parser->current_block_exits->nodes[index];
13257 if (block_exit == node) {
13258 if (index + 1 < parser->current_block_exits->size) {
13260 &parser->current_block_exits->nodes[index],
13261 &parser->current_block_exits->nodes[index + 1],
13262 (parser->current_block_exits->size - index - 1) *
sizeof(pm_node_t *)
13265 parser->current_block_exits->size--;
13280 case PM_LOCAL_VARIABLE_READ_NODE:
13281 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
13285 for (
size_t index = 0; index < implicit_parameters->size; index++) {
13286 if (implicit_parameters->nodes[index] == node) {
13290 if (index != implicit_parameters->size - 1) {
13291 memmove(&implicit_parameters->nodes[index], &implicit_parameters->nodes[index + 1], (implicit_parameters->size - index - 1) *
sizeof(pm_node_t *));
13294 implicit_parameters->size--;
13312pm_node_unreference(
pm_parser_t *parser,
const pm_node_t *node) {
13313 pm_visit_node(node, pm_node_unreference_each, parser);
13328 uint8_t *name = PM_ARENA_ALLOC_ARRAY(parser->arena, uint8_t, length + 1);
13330 memcpy(name,
constant->start, length);
13331 name[length] =
'=';
13333 *name_field = pm_constant_pool_insert_owned(&parser->metadata_arena, &parser->constant_pool, name, length + 1);
13343parse_unwriteable_target(
pm_parser_t *parser, pm_node_t *target) {
13344 switch (PM_NODE_TYPE(target)) {
13345 case PM_SOURCE_ENCODING_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_ENCODING);
break;
13346 case PM_FALSE_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_FALSE);
break;
13347 case PM_SOURCE_FILE_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_FILE);
break;
13348 case PM_SOURCE_LINE_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_LINE);
break;
13349 case PM_NIL_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_NIL);
break;
13350 case PM_SELF_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_SELF);
break;
13351 case PM_TRUE_NODE: pm_parser_err_node(parser, target, PM_ERR_EXPRESSION_NOT_WRITABLE_TRUE);
break;
13355 pm_constant_id_t name = pm_parser_constant_id_raw(parser, parser->start + PM_NODE_START(target), parser->start + PM_NODE_END(target));
13356 pm_local_variable_target_node_t *result = pm_local_variable_target_node_create(parser, &target->
location, name, 0);
13370parse_target(
pm_parser_t *parser, pm_node_t *target,
bool multiple,
bool splat_parent) {
13371 switch (PM_NODE_TYPE(target)) {
13372 case PM_ERROR_RECOVERY_NODE:
13374 case PM_SOURCE_ENCODING_NODE:
13375 case PM_FALSE_NODE:
13376 case PM_SOURCE_FILE_NODE:
13377 case PM_SOURCE_LINE_NODE:
13380 case PM_TRUE_NODE: {
13383 return parse_unwriteable_target(parser, target);
13385 case PM_CLASS_VARIABLE_READ_NODE:
13386 PRISM_ASSERT(
sizeof(pm_class_variable_target_node_t) ==
sizeof(pm_class_variable_read_node_t));
13387 target->
type = PM_CLASS_VARIABLE_TARGET_NODE;
13389 case PM_CONSTANT_PATH_NODE:
13390 if (context_def_p(parser)) {
13391 pm_parser_err_node(parser, target, PM_ERR_WRITE_TARGET_IN_METHOD);
13394 PRISM_ASSERT(
sizeof(pm_constant_path_target_node_t) ==
sizeof(pm_constant_path_node_t));
13395 target->
type = PM_CONSTANT_PATH_TARGET_NODE;
13398 case PM_CONSTANT_READ_NODE:
13399 if (context_def_p(parser)) {
13400 pm_parser_err_node(parser, target, PM_ERR_WRITE_TARGET_IN_METHOD);
13403 PRISM_ASSERT(
sizeof(pm_constant_target_node_t) ==
sizeof(pm_constant_read_node_t));
13404 target->
type = PM_CONSTANT_TARGET_NODE;
13407 case PM_BACK_REFERENCE_READ_NODE:
13408 case PM_NUMBERED_REFERENCE_READ_NODE:
13409 PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, target, PM_ERR_WRITE_TARGET_READONLY);
13410 return UP(pm_error_recovery_node_create_unexpected(parser, target));
13411 case PM_GLOBAL_VARIABLE_READ_NODE:
13412 PRISM_ASSERT(
sizeof(pm_global_variable_target_node_t) ==
sizeof(pm_global_variable_read_node_t));
13413 target->
type = PM_GLOBAL_VARIABLE_TARGET_NODE;
13415 case PM_LOCAL_VARIABLE_READ_NODE: {
13416 if (pm_token_is_numbered_parameter(parser, PM_NODE_START(target), PM_NODE_LENGTH(target))) {
13417 PM_PARSER_ERR_FORMAT(parser, PM_NODE_START(target), PM_NODE_LENGTH(target), PM_ERR_PARAMETER_NUMBERED_RESERVED, parser->start + PM_NODE_START(target));
13418 pm_node_unreference(parser, target);
13421 const pm_local_variable_read_node_t *
cast = (
const pm_local_variable_read_node_t *) target;
13422 PRISM_ASSERT(pm_parser_local_depth_constant_id(parser,
cast->name) == (
int)
cast->depth);
13423 pm_locals_unread(parser,
cast->name);
13425 PRISM_ASSERT(
sizeof(pm_local_variable_target_node_t) ==
sizeof(pm_local_variable_read_node_t));
13426 target->
type = PM_LOCAL_VARIABLE_TARGET_NODE;
13430 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
13432 pm_node_t *node = UP(pm_local_variable_target_node_create(parser, &target->
location, name, 0));
13434 pm_node_unreference(parser, target);
13438 case PM_INSTANCE_VARIABLE_READ_NODE:
13439 PRISM_ASSERT(
sizeof(pm_instance_variable_target_node_t) ==
sizeof(pm_instance_variable_read_node_t));
13440 target->
type = PM_INSTANCE_VARIABLE_TARGET_NODE;
13442 case PM_MULTI_TARGET_NODE:
13443 if (splat_parent) {
13446 pm_parser_err_node(parser, target, PM_ERR_WRITE_TARGET_UNEXPECTED);
13450 case PM_SPLAT_NODE: {
13451 pm_splat_node_t *splat = (pm_splat_node_t *) target;
13459 case PM_CALL_NODE: {
13460 pm_call_node_t *call = (pm_call_node_t *) target;
13465 if (pm_call_node_writable_p(parser, call)) {
13477 pm_constant_id_t name = pm_parser_local_add_location(parser, &message_loc, 0);
13479 return UP(pm_local_variable_target_node_create(parser, &message_loc, name, 0));
13482 if (multiple && PM_NODE_FLAG_P(call, PM_CALL_NODE_FLAGS_SAFE_NAVIGATION)) {
13483 pm_parser_err_node(parser, (
const pm_node_t *) call, PM_ERR_UNEXPECTED_SAFE_NAVIGATION);
13486 parse_write_name(parser, &call->
name);
13487 return UP(pm_call_target_node_create(parser, call));
13493 if (PM_NODE_FLAG_P(call, PM_CALL_NODE_FLAGS_INDEX)) {
13494 return UP(pm_index_target_node_create(parser, call));
13500 pm_parser_err_node(parser, target, PM_ERR_WRITE_TARGET_UNEXPECTED);
13501 return UP(pm_error_recovery_node_create_unexpected(parser, target));
13510parse_target_validate(
pm_parser_t *parser, pm_node_t *target,
bool multiple) {
13511 pm_node_t *result = parse_target(parser, target, multiple,
false);
13513 bool parenthesized = context_p(parser, PM_CONTEXT_PARENS);
13514 bool newline = parenthesized && accept1(parser, PM_TOKEN_NEWLINE);
13517 bool assignment = !newline && (match1(parser, PM_TOKEN_EQUAL) || (context_p(parser, PM_CONTEXT_FOR_INDEX) && match1(parser, PM_TOKEN_KEYWORD_IN)));
13518 if (!assignment && !(parenthesized && match1(parser, PM_TOKEN_PARENTHESIS_RIGHT))) {
13519 pm_parser_err_node(parser, result, PM_ERR_WRITE_TARGET_UNEXPECTED);
13530parse_shareable_constant_write(
pm_parser_t *parser, pm_node_t *write) {
13531 pm_shareable_constant_value_t shareable_constant = pm_parser_scope_shareable_constant_get(parser);
13533 if (shareable_constant != PM_SCOPE_SHAREABLE_CONSTANT_NONE) {
13534 return UP(pm_shareable_constant_node_create(parser, write, shareable_constant));
13545 switch (PM_NODE_TYPE(target)) {
13546 case PM_ERROR_RECOVERY_NODE:
13548 case PM_CLASS_VARIABLE_READ_NODE: {
13549 pm_class_variable_write_node_t *node = pm_class_variable_write_node_create(parser, (pm_class_variable_read_node_t *) target,
operator, value);
13552 case PM_CONSTANT_PATH_NODE: {
13553 pm_node_t *node = UP(pm_constant_path_write_node_create(parser, (pm_constant_path_node_t *) target,
operator, value));
13555 if (context_def_p(parser)) {
13556 pm_parser_err_node(parser, node, PM_ERR_WRITE_TARGET_IN_METHOD);
13559 return parse_shareable_constant_write(parser, node);
13561 case PM_CONSTANT_READ_NODE: {
13562 pm_node_t *node = UP(pm_constant_write_node_create(parser, (pm_constant_read_node_t *) target,
operator, value));
13564 if (context_def_p(parser)) {
13565 pm_parser_err_node(parser, node, PM_ERR_WRITE_TARGET_IN_METHOD);
13568 return parse_shareable_constant_write(parser, node);
13570 case PM_BACK_REFERENCE_READ_NODE:
13571 case PM_NUMBERED_REFERENCE_READ_NODE:
13572 PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, target, PM_ERR_WRITE_TARGET_READONLY);
13574 case PM_GLOBAL_VARIABLE_READ_NODE: {
13575 pm_global_variable_write_node_t *node = pm_global_variable_write_node_create(parser, target,
operator, value);
13578 case PM_LOCAL_VARIABLE_READ_NODE: {
13579 pm_local_variable_read_node_t *local_read = (pm_local_variable_read_node_t *) target;
13583 uint32_t depth = local_read->
depth;
13584 pm_scope_t *scope = pm_parser_scope_find(parser, depth);
13586 if (pm_token_is_numbered_parameter(parser, PM_NODE_START(target), PM_NODE_LENGTH(target))) {
13587 pm_diagnostic_id_t diag_id = (scope->parameters & PM_SCOPE_PARAMETERS_NUMBERED_FOUND) ? PM_ERR_EXPRESSION_NOT_WRITABLE_NUMBERED : PM_ERR_PARAMETER_NUMBERED_RESERVED;
13588 PM_PARSER_ERR_FORMAT(parser, PM_NODE_START(target), PM_NODE_LENGTH(target), diag_id, parser->start + PM_NODE_START(target));
13589 pm_node_unreference(parser, target);
13592 PRISM_ASSERT(pm_parser_local_depth_constant_id(parser, name) == (
int) depth);
13593 pm_locals_unread(parser, name);
13595 return UP(pm_local_variable_write_node_create(parser, name, depth, value, &location,
operator));
13597 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
13599 pm_node_t *node = UP(pm_local_variable_write_node_create(parser, name, 0, value, &target->
location,
operator));
13601 pm_node_unreference(parser, target);
13605 case PM_INSTANCE_VARIABLE_READ_NODE: {
13606 pm_node_t *write_node = UP(pm_instance_variable_write_node_create(parser, (pm_instance_variable_read_node_t *) target,
operator, value));
13609 case PM_MULTI_TARGET_NODE:
13610 return UP(pm_multi_write_node_create(parser, (pm_multi_target_node_t *) target,
operator, value));
13611 case PM_SPLAT_NODE: {
13612 pm_splat_node_t *splat = (pm_splat_node_t *) target;
13619 pm_multi_targets_append(parser, &targets, UP(splat));
13620 pm_multi_target_node_t *multi_target = pm_multi_target_node_create(parser, &targets, NULL, NULL);
13622 return UP(pm_multi_write_node_create(parser, multi_target,
operator, value));
13624 case PM_CALL_NODE: {
13625 pm_call_node_t *call = (pm_call_node_t *) target;
13630 if (pm_call_node_writable_p(parser, call)) {
13643 pm_refute_numbered_parameter(parser, message_loc.
start, message_loc.
length);
13644 pm_parser_local_add_location(parser, &message_loc, 0);
13646 pm_constant_id_t constant_id = pm_parser_constant_id_raw(parser, parser->start + PM_LOCATION_START(&message_loc), parser->start + PM_LOCATION_END(&message_loc));
13647 target = UP(pm_local_variable_write_node_create(parser, constant_id, 0, value, &message_loc,
operator));
13653 pm_arguments_node_t *arguments = pm_arguments_node_single_create(parser, value);
13655 PM_NODE_LENGTH_SET_NODE(call, arguments);
13656 call->
equal_loc = TOK2LOC(parser,
operator);
13658 parse_write_name(parser, &call->
name);
13659 pm_node_flag_set(UP(call), PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE | pm_implicit_array_write_flags(value, PM_CALL_NODE_FLAGS_IMPLICIT_ARRAY));
13667 if (PM_NODE_FLAG_P(call, PM_CALL_NODE_FLAGS_INDEX)) {
13669 PM_NODE_LENGTH_SET_NODE(target, value);
13672 call->
name = pm_parser_constant_id_constant(parser,
"[]=", 3);
13673 call->
equal_loc = TOK2LOC(parser,
operator);
13677 pm_node_flag_set(UP(call), PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE | pm_implicit_array_write_flags(value, PM_CALL_NODE_FLAGS_IMPLICIT_ARRAY));
13692 pm_node_unreference(parser, value);
13699 pm_parser_err_token(parser,
operator, PM_ERR_WRITE_TARGET_UNEXPECTED);
13711parse_unwriteable_write(
pm_parser_t *parser, pm_node_t *target,
const pm_token_t *equals, pm_node_t *value) {
13712 switch (PM_NODE_TYPE(target)) {
13713 case PM_SOURCE_ENCODING_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_ENCODING);
break;
13714 case PM_FALSE_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_FALSE);
break;
13715 case PM_SOURCE_FILE_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_FILE);
break;
13716 case PM_SOURCE_LINE_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_LINE);
break;
13717 case PM_NIL_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_NIL);
break;
13718 case PM_SELF_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_SELF);
break;
13719 case PM_TRUE_NODE: pm_parser_err_token(parser, equals, PM_ERR_EXPRESSION_NOT_WRITABLE_TRUE);
break;
13724 pm_local_variable_write_node_t *result = pm_local_variable_write_node_create(parser, name, 0, value, &target->
location, equals);
13740parse_targets(
pm_parser_t *parser, pm_node_t *first_target, pm_binding_power_t binding_power, uint16_t depth) {
13741 bool has_rest = PM_NODE_TYPE_P(first_target, PM_SPLAT_NODE);
13744 pm_multi_targets_append(parser, &targets, parse_target(parser, first_target,
true,
false));
13746 while (accept1(parser, PM_TOKEN_COMMA)) {
13747 if (accept1(parser, PM_TOKEN_USTAR)) {
13752 pm_parser_err_previous(parser, PM_ERR_MULTI_ASSIGN_MULTI_SPLATS);
13755 pm_token_t star_operator = parser->previous;
13756 pm_node_t *name = NULL;
13758 if (token_begins_expression_p(parser->current.type)) {
13759 name = parse_expression(parser, binding_power, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_STAR, (uint16_t) (depth + 1));
13760 name = parse_target(parser, name,
true,
true);
13763 pm_node_t *splat = UP(pm_splat_node_create(parser, &star_operator, name));
13764 pm_multi_targets_append(parser, &targets, splat);
13766 }
else if (match1(parser, PM_TOKEN_PARENTHESIS_LEFT_GROUPING)) {
13767 context_push(parser, PM_CONTEXT_MULTI_TARGET);
13768 pm_node_t *target = parse_expression(parser, binding_power, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_COMMA, (uint16_t) (depth + 1));
13769 target = parse_target(parser, target,
true,
false);
13771 pm_multi_targets_append(parser, &targets, target);
13772 context_pop(parser);
13773 }
else if (token_begins_expression_p(parser->current.type)) {
13774 pm_node_t *target = parse_expression(parser, binding_power, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_COMMA, (uint16_t) (depth + 1));
13775 target = parse_target(parser, target,
true,
false);
13777 pm_multi_targets_append(parser, &targets, target);
13778 }
else if (!match1(parser, PM_TOKEN_EOF)) {
13781 pm_node_t *rest = UP(pm_implicit_rest_node_create(parser, &parser->previous));
13782 pm_multi_targets_append(parser, &targets, rest);
13787 return UP(pm_multi_target_node_create(parser, &targets, NULL, NULL));
13795parse_targets_validate(
pm_parser_t *parser, pm_node_t *first_target, pm_binding_power_t binding_power, uint16_t depth) {
13796 pm_node_t *result = parse_targets(parser, first_target, binding_power, depth);
13799 bool newline = (context_p(parser, PM_CONTEXT_PARENS) || context_p(parser, PM_CONTEXT_MULTI_TARGET)) && accept1(parser, PM_TOKEN_NEWLINE);
13800 if (!match1(parser, PM_TOKEN_PARENTHESIS_RIGHT) && (newline || !match1(parser, PM_TOKEN_EQUAL))) {
13801 pm_parser_err_node(parser, result, PM_ERR_WRITE_TARGET_UNEXPECTED);
13810static pm_statements_node_t *
13811parse_statements(
pm_parser_t *parser, pm_context_t context, uint16_t depth) {
13814 while (accept2(parser, PM_TOKEN_SEMICOLON, PM_TOKEN_NEWLINE));
13817 if (context_terminator(context, &parser->current))
return NULL;
13823 context_push(parser, context);
13826 pm_node_t *node = parse_expression(parser, PM_BINDING_POWER_STATEMENT, PM_PARSE_ACCEPTS_COMMAND_CALL | PM_PARSE_ACCEPTS_COMMAND_DEF | PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_CANNOT_PARSE_EXPRESSION, (uint16_t) (depth + 1));
13827 pm_statements_body_append(parser, &body, node,
true);
13831 if (parser->recovering) {
13834 if (context_terminator(context, &parser->current)) parser->recovering =
false;
13840 if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
13843 while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
13844 if (context_terminator(context, &parser->current))
break;
13854 if (context_terminator(context, &parser->current))
break;
13866 if (PM_NODE_TYPE_P(node, PM_ERROR_RECOVERY_NODE)) {
13867 parse_discard_token(parser, depth);
13873 if (match1(parser, PM_TOKEN_EOF)) {
13874 parser->recovering =
true;
13878 while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
13879 if (context_terminator(context, &parser->current))
break;
13880 }
else if (!accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_EOF)) {
13884 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(parser->current.type));
13885 parser->previous.
start = parser->previous.
end;
13886 parser->previous.
type = 0;
13890 context_pop(parser);
13892 bool last_value =
true;
13894 case PM_CONTEXT_BEGIN_ENSURE:
13895 case PM_CONTEXT_DEF_ENSURE:
13896 last_value =
false;
13902 pm_statements_node_t *statements = pm_statements_node_create(parser, &body);
13903 pm_void_statements_check(parser, statements, last_value);
13912pm_hash_key_duplicated_warn(
pm_parser_t *parser,
const pm_node_t *duplicated,
const pm_node_t *node) {
13914 pm_static_literal_inspect(&buffer, parser, duplicated);
13916 pm_diagnostic_list_append_format(
13917 &parser->metadata_arena,
13918 &parser->warning_list,
13921 PM_WARN_DUPLICATED_HASH_KEY,
13922 (
int) pm_buffer_length(&buffer),
13923 pm_buffer_value(&buffer),
13924 pm_line_offset_list_line_column(&parser->line_offsets, PM_NODE_START(node), parser->start_line).line
13927 pm_buffer_cleanup(&buffer);
13936 const pm_node_t *duplicated = pm_static_literals_add(parser, literals, node,
true);
13938 if (duplicated != NULL) {
13939 pm_hash_key_duplicated_warn(parser, duplicated, node);
13952 const pm_node_list_t *elements = &hash->elements;
13954 for (
size_t index = 0; index < elements->
size; index++) {
13955 pm_node_t *element = elements->
nodes[index];
13957 switch (PM_NODE_TYPE(element)) {
13958 case PM_ASSOC_NODE: {
13959 pm_node_t *key = ((pm_assoc_node_t *) element)->key;
13960 const pm_node_t *duplicated = pm_static_literals_add(parser, literals, key,
true);
13962 if (duplicated != NULL && PM_NODE_START(duplicated) < boundary) {
13963 pm_hash_key_duplicated_warn(parser, duplicated, key);
13968 case PM_ASSOC_SPLAT_NODE: {
13969 const pm_node_t *value = ((pm_assoc_splat_node_t *) element)->value;
13971 if (value != NULL && PM_NODE_TYPE_P(value, PM_HASH_NODE)) {
13972 pm_hash_key_static_literals_merge(parser, literals, (
const pm_hash_node_t *) value, boundary);
13989 pm_node_t *previous;
13991 if ((previous = pm_static_literals_add(parser, literals, node,
false)) != NULL) {
13992 pm_diagnostic_list_append_format(
13993 &parser->metadata_arena,
13994 &parser->warning_list,
13995 PM_NODE_START(node),
13996 PM_NODE_LENGTH(node),
13997 PM_WARN_DUPLICATED_WHEN_CLAUSE,
13998 pm_line_offset_list_line_column(&parser->line_offsets, PM_NODE_START(node), parser->start_line).line,
13999 pm_line_offset_list_line_column(&parser->line_offsets, PM_NODE_START(previous), parser->start_line).line
14010 bool contains_keyword_splat =
false;
14013 pm_node_t *element;
14015 switch (parser->current.type) {
14016 case PM_TOKEN_USTAR_STAR: {
14017 parser_lex(parser);
14019 pm_node_t *value = NULL;
14021 if (token_begins_expression_p(parser->current.type)) {
14022 value = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT_HASH, (uint16_t) (depth + 1));
14026 if (value != NULL && PM_NODE_TYPE_P(value, PM_HASH_NODE)) {
14027 pm_hash_key_static_literals_merge(parser, literals, (
const pm_hash_node_t *) value, PM_NODE_START(value));
14030 pm_parser_scope_forwarding_keywords_check(parser, &
operator);
14033 element = UP(pm_assoc_splat_node_create(parser, value, &
operator));
14034 contains_keyword_splat =
true;
14037 case PM_TOKEN_LABEL: {
14039 parser_lex(parser);
14041 pm_node_t *key = UP(pm_symbol_node_label_create(parser, &label));
14042 pm_hash_key_static_literals_add(parser, literals, key);
14044 pm_node_t *value = NULL;
14046 if (token_begins_expression_p(parser->current.type)) {
14047 value = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_HASH_EXPRESSION_AFTER_LABEL, (uint16_t) (depth + 1));
14049 pm_token_t identifier = { .type = PM_TOKEN_IDENTIFIER, .start = label.
start, .end = label.
end - 1 };
14050 bool constant = pm_encoding_isupper_char(parser->encoding, identifier.
start, identifier.
end - identifier.
start, parser->version);
14051 bool invalid = identifier.
end[-1] ==
'!' || identifier.
end[-1] ==
'?';
14054 PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, &identifier, constant ? PM_ERR_INVALID_CONSTANT_READ : PM_ERR_INVALID_LOCAL_VARIABLE_READ);
14058 identifier.
type = PM_TOKEN_CONSTANT;
14059 value = UP(pm_constant_read_node_create(parser, &identifier));
14061 int depth = invalid ? -1 : pm_parser_local_depth(parser, &identifier);
14063 value = UP(pm_call_node_variable_call_create(parser, &identifier));
14065 value = UP(pm_local_variable_read_node_create(parser, &identifier, (uint32_t) depth));
14070 value = UP(pm_implicit_node_create(parser, value));
14073 element = UP(pm_assoc_node_create(parser, key, NULL, value));
14077 pm_node_t *key = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, PM_PARSE_ACCEPTS_DO_BLOCK | PM_PARSE_ACCEPTS_LABEL, PM_ERR_HASH_KEY, (uint16_t) (depth + 1));
14081 if (PM_NODE_TYPE_P(key, PM_STRING_NODE)) {
14082 pm_node_flag_set(key, PM_STRING_FLAGS_FROZEN | PM_NODE_FLAG_STATIC_LITERAL);
14085 pm_hash_key_static_literals_add(parser, literals, key);
14088 if (!pm_symbol_node_label_p(parser, key)) {
14089 expect1(parser, PM_TOKEN_EQUAL_GREATER, PM_ERR_HASH_ROCKET);
14090 operator = parser->previous;
14093 pm_node_t *value = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_HASH_VALUE, (uint16_t) (depth + 1));
14094 element = UP(pm_assoc_node_create(parser, key, NTOK2PTR(
operator), value));
14099 pm_hash_elements_append(parser, elements, element);
14102 if (!accept1(parser, PM_TOKEN_COMMA))
break;
14106 if (match2(parser, PM_TOKEN_USTAR_STAR, PM_TOKEN_LABEL))
continue;
14110 if (token_begins_expression_p(parser->current.type))
continue;
14116 return contains_keyword_splat;
14120argument_allowed_for_bare_hash(
pm_parser_t *parser, pm_node_t *argument) {
14121 if (pm_symbol_node_label_p(parser, argument)) {
14125 switch (PM_NODE_TYPE(argument)) {
14126 case PM_CALL_NODE: {
14127 pm_call_node_t *
cast = (pm_call_node_t *) argument;
14128 if (
cast->opening_loc.length == 0 &&
cast->arguments != NULL) {
14129 if (PM_NODE_FLAG_P(
cast->arguments, PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS | PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT)) {
14132 if (
cast->block != NULL) {
14140 return accept1(parser, PM_TOKEN_EQUAL_GREATER);
14152 if (PM_LOCATION_END(&arguments->
list_loc) < PM_NODE_END(argument)) {
14156 pm_arguments_flags_update(&arguments->
list_flags, argument);
14157 pm_node_list_open_append(&parser->node_chunks, &arguments->
list, argument);
14165pm_call_node_command_p(
const pm_call_node_t *node) {
14168 (node->
block == NULL || PM_NODE_TYPE_P(node->
block, PM_BLOCK_ARGUMENT_NODE)) &&
14183pm_constant_path_command_call_p(
const pm_parser_t *parser,
const pm_call_node_t *call) {
14187 call->
block != NULL && PM_NODE_TYPE_P(call->
block, PM_BLOCK_NODE) &&
14201pm_command_call_value_p(
const pm_parser_t *parser,
const pm_node_t *node) {
14202 switch (PM_NODE_TYPE(node)) {
14203 case PM_CALL_NODE: {
14204 const pm_call_node_t *call = (
const pm_call_node_t *) node;
14208 if (pm_call_node_command_p(call) && !PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE) && (call->
receiver == NULL || call->
call_operator_loc.
length > 0)) {
14213 if (pm_constant_path_command_call_p(parser, call)) {
14220 return pm_command_call_value_p(parser, call->
receiver);
14225 case PM_SUPER_NODE: {
14229 const pm_super_node_t *
cast = (
const pm_super_node_t *) node;
14230 return cast->lparen_loc.length == 0 &&
14231 (
cast->arguments != NULL ||
cast->block != NULL) &&
14232 !(
cast->block != NULL && PM_NODE_TYPE_P(
cast->block, PM_BLOCK_NODE));
14234 case PM_YIELD_NODE: {
14235 const pm_yield_node_t *
cast = (
const pm_yield_node_t *) node;
14236 return cast->lparen_loc.length == 0 &&
cast->arguments != NULL;
14238 case PM_RESCUE_MODIFIER_NODE:
14239 return pm_command_call_value_p(parser, ((
const pm_rescue_modifier_node_t *) node)->expression);
14240 case PM_DEF_NODE: {
14241 const pm_def_node_t *
cast = (
const pm_def_node_t *) node;
14242 if (
cast->equal_loc.length > 0 &&
cast->body != NULL) {
14243 const pm_node_t *body =
cast->body;
14244 if (PM_NODE_TYPE_P(body, PM_STATEMENTS_NODE)) {
14245 body = ((
const pm_statements_node_t *) body)->body.nodes[((
const pm_statements_node_t *) body)->body.size - 1];
14247 return pm_command_call_value_p(parser, body);
14266pm_command_before_comma_p(
const pm_parser_t *parser,
const pm_node_t *node) {
14267 switch (PM_NODE_TYPE(node)) {
14269 return pm_constant_path_command_call_p(parser, (
const pm_call_node_t *) node);
14271 return pm_command_call_value_p(parser, node);
14284pm_block_call_p(
const pm_node_t *node) {
14285 while (PM_NODE_TYPE_P(node, PM_CALL_NODE)) {
14286 const pm_call_node_t *call = (
const pm_call_node_t *) node;
14316 if (PM_NODE_TYPE_P(node, PM_SUPER_NODE)) {
14317 const pm_super_node_t *super = (
const pm_super_node_t *) node;
14328parse_arguments(
pm_parser_t *parser,
pm_arguments_t *arguments,
bool accepts_forwarding, pm_token_type_t terminator, uint8_t flags, uint16_t depth) {
14329 pm_binding_power_t binding_power = pm_binding_powers[parser->current.type].left;
14334 match2(parser, terminator, PM_TOKEN_EOF) ||
14335 (binding_power != PM_BINDING_POWER_UNSET && binding_power < PM_BINDING_POWER_RANGE) ||
14336 context_terminator(parser->current_context->context, &parser->current)
14341 bool parsed_first_argument =
false;
14342 bool parsed_bare_hash =
false;
14343 bool parsed_block_argument =
false;
14344 bool parsed_forwarding_arguments =
false;
14346 while (!match1(parser, PM_TOKEN_EOF)) {
14347 if (parsed_forwarding_arguments) {
14348 pm_parser_err_current(parser, PM_ERR_ARGUMENT_AFTER_FORWARDING_ELLIPSES);
14351 pm_node_t *argument = NULL;
14353 switch (parser->current.type) {
14354 case PM_TOKEN_USTAR_STAR:
14355 case PM_TOKEN_LABEL: {
14356 if (parsed_bare_hash) {
14357 pm_parser_err_current(parser, PM_ERR_ARGUMENT_BARE_HASH);
14362 bool contains_keyword_splat = parse_assocs(parser, &hash_keys, &elements, (uint16_t) (depth + 1));
14363 argument = UP(pm_keyword_hash_node_create(parser, &elements));
14365 parse_arguments_append(parser, arguments, argument);
14367 pm_node_flags_t node_flags = PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS;
14368 if (contains_keyword_splat) node_flags |= PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT;
14371 pm_static_literals_free(&hash_keys);
14372 parsed_bare_hash =
true;
14376 case PM_TOKEN_UAMPERSAND: {
14377 parser_lex(parser);
14379 pm_node_t *expression = NULL;
14381 if (token_begins_expression_p(parser->current.type)) {
14382 expression = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_ARGUMENT, (uint16_t) (depth + 1));
14384 pm_parser_scope_forwarding_block_check(parser, &
operator);
14387 argument = UP(pm_block_argument_node_create(parser, &
operator, expression));
14388 if (parsed_block_argument) {
14389 parse_arguments_append(parser, arguments, argument);
14391 arguments->
block = argument;
14394 if (match1(parser, PM_TOKEN_COMMA)) {
14395 pm_parser_err_current(parser, PM_ERR_ARGUMENT_AFTER_BLOCK);
14398 parsed_block_argument =
true;
14401 case PM_TOKEN_USTAR: {
14402 parser_lex(parser);
14405 if (match4(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_TOKEN_COMMA, PM_TOKEN_SEMICOLON, PM_TOKEN_BRACKET_RIGHT)) {
14406 pm_parser_scope_forwarding_positionals_check(parser, &
operator);
14407 argument = UP(pm_splat_node_create(parser, &
operator, NULL));
14408 if (parsed_bare_hash) {
14409 pm_parser_err_previous(parser, PM_ERR_ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT);
14412 pm_node_t *expression = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_SPLAT, (uint16_t) (depth + 1));
14414 if (parsed_bare_hash) {
14415 pm_parser_err(parser, PM_TOKEN_START(parser, &
operator), PM_NODE_END(expression) - PM_TOKEN_START(parser, &
operator), PM_ERR_ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT);
14418 argument = UP(pm_splat_node_create(parser, &
operator, expression));
14421 parse_arguments_append(parser, arguments, argument);
14424 case PM_TOKEN_UDOT_DOT_DOT: {
14425 if (accepts_forwarding) {
14426 parser_lex(parser);
14428 if (token_begins_expression_p(parser->current.type)) {
14433 pm_node_t *right = parse_expression(parser, PM_BINDING_POWER_RANGE, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
14437 if (PM_NODE_TYPE_P(right, PM_RANGE_NODE)) {
14438 pm_range_node_t *range = (pm_range_node_t *) right;
14439 if (range->left != NULL) {
14440 pm_parser_err(parser, range->operator_loc.start, range->operator_loc.length, PM_ERR_UNEXPECTED_RANGE_OPERATOR);
14444 argument = UP(pm_range_node_create(parser, NULL, &
operator, right));
14446 pm_parser_scope_forwarding_all_check(parser, &parser->previous);
14447 if (parsed_first_argument && terminator == PM_TOKEN_EOF) {
14448 pm_parser_err_previous(parser, PM_ERR_ARGUMENT_FORWARDING_UNBOUND);
14451 argument = UP(pm_forwarding_arguments_node_create(parser, &parser->previous));
14452 parse_arguments_append(parser, arguments, argument);
14453 arguments->
list_flags |= PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING;
14455 parsed_forwarding_arguments =
true;
14462 if (argument == NULL) {
14467 uint8_t command_flags = 0;
14468 if (!parsed_first_argument) {
14469 command_flags = PM_PARSE_ACCEPTS_COMMAND_CALL;
14470 if (parser->version >= PM_OPTIONS_VERSION_CRUBY_4_0) command_flags |= PM_PARSE_ACCEPTS_COMMAND_DEF;
14473 argument = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | command_flags | PM_PARSE_ACCEPTS_LABEL), PM_ERR_EXPECT_ARGUMENT, (uint16_t) (depth + 1));
14476 bool contains_keywords =
false;
14477 bool contains_keyword_splat =
false;
14479 if (argument_allowed_for_bare_hash(parser, argument)) {
14480 if (parsed_bare_hash) {
14481 pm_parser_err_previous(parser, PM_ERR_ARGUMENT_BARE_HASH);
14490 if (pm_command_call_value_p(parser, argument) || pm_block_call_p(argument)) {
14491 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->previous, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(parser->previous.
type));
14495 if (parser->previous.
type == PM_TOKEN_EQUAL_GREATER) {
14496 operator = parser->previous;
14500 contains_keywords =
true;
14504 pm_hash_key_static_literals_add(parser, &hash_keys, argument);
14507 pm_node_t *value = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_HASH_VALUE, (uint16_t) (depth + 1));
14508 argument = UP(pm_assoc_node_create(parser, argument, NTOK2PTR(
operator), value));
14510 pm_hash_elements_append(parser, &elements, argument);
14513 if (accept1(parser, PM_TOKEN_COMMA) && (
14514 token_begins_expression_p(parser->current.type) ||
14515 match2(parser, PM_TOKEN_USTAR_STAR, PM_TOKEN_LABEL)
14517 contains_keyword_splat = parse_assocs(parser, &hash_keys, &elements, (uint16_t) (depth + 1));
14520 argument = UP(pm_keyword_hash_node_create(parser, &elements));
14522 pm_static_literals_free(&hash_keys);
14523 parsed_bare_hash =
true;
14526 parse_arguments_append(parser, arguments, argument);
14528 pm_node_flags_t node_flags = 0;
14529 if (contains_keywords) node_flags |= PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS;
14530 if (contains_keyword_splat) node_flags |= PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT;
14537 parsed_first_argument =
true;
14540 if (PM_NODE_TYPE_P(argument, PM_ERROR_RECOVERY_NODE) || parser->recovering)
break;
14545 bool accepted_newline =
false;
14546 if (terminator != PM_TOKEN_EOF) {
14547 accepted_newline = accept1(parser, PM_TOKEN_NEWLINE);
14550 if (parser->previous.
type == PM_TOKEN_COMMA && parsed_bare_hash) {
14554 }
else if (accept1(parser, PM_TOKEN_COMMA)) {
14557 if (accepted_newline) {
14558 pm_parser_err_previous(parser, PM_ERR_INVALID_COMMA);
14564 if (PM_NODE_TYPE_P(argument, PM_CALL_NODE)) {
14565 pm_call_node_t *call = (pm_call_node_t *) argument;
14567 pm_parser_err_previous(parser, PM_ERR_INVALID_COMMA);
14574 if (pm_command_before_comma_p(parser, argument)) {
14575 pm_parser_err_previous(parser, PM_ERR_INVALID_COMMA);
14585 if (match1(parser, terminator)) {
14591 if (parsed_forwarding_arguments) {
14592 pm_parser_err_previous(parser, PM_ERR_INVALID_COMMA);
14611parse_required_destructured_parameter(
pm_parser_t *parser, uint16_t depth) {
14612 if (
PRISM_UNLIKELY(depth >= PRISM_DEPTH_MAXIMUM || pm_parser_stack_exhausted(parser))) {
14613 return parse_resource_recovery(parser, depth);
14616 expect1(parser, PM_TOKEN_PARENTHESIS_LEFT_GROUPING, PM_ERR_EXPECT_LPAREN_REQ_PARAMETER);
14628 if ((targets.rest == NULL ? targets.nodes.
size : targets.rest_index) > 0 && match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
14629 param = UP(pm_implicit_rest_node_create(parser, &parser->previous));
14630 pm_multi_targets_append(parser, &targets, param);
14631 pm_parser_err_current(parser, PM_ERR_PARAMETER_WILD_LOOSE_COMMA);
14635 if (match1(parser, PM_TOKEN_PARENTHESIS_LEFT_GROUPING)) {
14636 param = parse_required_destructured_parameter(parser, (uint16_t) (depth + 1));
14637 }
else if (accept1(parser, PM_TOKEN_USTAR)) {
14639 pm_node_t *value = NULL;
14641 if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
14643 value = UP(pm_required_parameter_node_create(parser, &name));
14644 if (pm_parser_parameter_name_check(parser, &name)) {
14645 pm_node_flag_set_repeated_parameter(value);
14647 pm_parser_local_add_token(parser, &name, 1);
14650 param = UP(pm_splat_node_create(parser, &star, value));
14652 expect1(parser, PM_TOKEN_IDENTIFIER, PM_ERR_EXPECT_IDENT_REQ_PARAMETER);
14655 param = UP(pm_required_parameter_node_create(parser, &name));
14656 if (pm_parser_parameter_name_check(parser, &name)) {
14657 pm_node_flag_set_repeated_parameter(param);
14659 pm_parser_local_add_token(parser, &name, 1);
14662 pm_multi_targets_append(parser, &targets, param);
14663 }
while (accept1(parser, PM_TOKEN_COMMA));
14665 accept1(parser, PM_TOKEN_NEWLINE);
14666 expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN_REQ_PARAMETER);
14668 return UP(pm_multi_target_node_create(parser, &targets, &lparen, &parser->previous));
14676 PM_PARAMETERS_NO_CHANGE = 0,
14677 PM_PARAMETERS_ORDER_NOTHING_AFTER = 1,
14678 PM_PARAMETERS_ORDER_KEYWORDS_REST,
14679 PM_PARAMETERS_ORDER_KEYWORDS,
14680 PM_PARAMETERS_ORDER_REST,
14681 PM_PARAMETERS_ORDER_AFTER_OPTIONAL,
14682 PM_PARAMETERS_ORDER_OPTIONAL,
14683 PM_PARAMETERS_ORDER_NAMED,
14684 PM_PARAMETERS_ORDER_NONE,
14685} pm_parameters_order_t;
14690static pm_parameters_order_t parameters_ordering[PM_TOKEN_MAXIMUM] = {
14691 [0] = PM_PARAMETERS_NO_CHANGE,
14692 [PM_TOKEN_UAMPERSAND] = PM_PARAMETERS_ORDER_NOTHING_AFTER,
14693 [PM_TOKEN_AMPERSAND] = PM_PARAMETERS_ORDER_NOTHING_AFTER,
14694 [PM_TOKEN_UDOT_DOT_DOT] = PM_PARAMETERS_ORDER_NOTHING_AFTER,
14695 [PM_TOKEN_IDENTIFIER] = PM_PARAMETERS_ORDER_NAMED,
14696 [PM_TOKEN_PARENTHESIS_LEFT_GROUPING] = PM_PARAMETERS_ORDER_NAMED,
14697 [PM_TOKEN_EQUAL] = PM_PARAMETERS_ORDER_OPTIONAL,
14698 [PM_TOKEN_LABEL] = PM_PARAMETERS_ORDER_KEYWORDS,
14699 [PM_TOKEN_USTAR] = PM_PARAMETERS_ORDER_AFTER_OPTIONAL,
14700 [PM_TOKEN_STAR] = PM_PARAMETERS_ORDER_AFTER_OPTIONAL,
14701 [PM_TOKEN_USTAR_STAR] = PM_PARAMETERS_ORDER_KEYWORDS_REST,
14702 [PM_TOKEN_STAR_STAR] = PM_PARAMETERS_ORDER_KEYWORDS_REST
14714 pm_parameters_order_t state = parameters_ordering[token->type];
14715 if (state == PM_PARAMETERS_NO_CHANGE)
return true;
14719 if (*current == PM_PARAMETERS_ORDER_OPTIONAL && state == PM_PARAMETERS_ORDER_NAMED) {
14720 *current = PM_PARAMETERS_ORDER_AFTER_OPTIONAL;
14722 }
else if (*current == PM_PARAMETERS_ORDER_AFTER_OPTIONAL && state == PM_PARAMETERS_ORDER_NAMED) {
14726 if (token->type == PM_TOKEN_USTAR && *current == PM_PARAMETERS_ORDER_AFTER_OPTIONAL) {
14727 pm_parser_err_token(parser, token, PM_ERR_PARAMETER_STAR);
14729 }
else if (token->type == PM_TOKEN_UDOT_DOT_DOT && (*current >= PM_PARAMETERS_ORDER_KEYWORDS_REST && *current <= PM_PARAMETERS_ORDER_AFTER_OPTIONAL)) {
14730 pm_parser_err_token(parser, token, *current == PM_PARAMETERS_ORDER_AFTER_OPTIONAL ? PM_ERR_PARAMETER_FORWARDING_AFTER_REST : PM_ERR_PARAMETER_ORDER);
14732 }
else if (*current == PM_PARAMETERS_ORDER_NOTHING_AFTER || state > *current) {
14734 pm_parser_err_token(parser, token, PM_ERR_PARAMETER_ORDER);
14738 if (state < *current) *current = state;
14743parse_parameters_handle_trailing_comma(
14746 pm_parameters_order_t order,
14748 bool allows_trailing_comma
14750 if (!allows_trailing_comma) {
14751 pm_parser_err_previous(parser, PM_ERR_PARAMETER_WILD_LOOSE_COMMA);
14756 if (order >= PM_PARAMETERS_ORDER_NAMED) {
14758 pm_node_t *param = UP(pm_implicit_rest_node_create(parser, &parser->previous));
14760 if (params->rest == NULL) {
14761 pm_parameters_rest_set(params, param);
14763 pm_parser_err_node(parser, UP(param), PM_ERR_PARAMETER_SPLAT_MULTI);
14764 pm_parameters_posts_append(parser, params, UP(param));
14768 pm_parser_err_previous(parser, PM_ERR_PARAMETER_WILD_LOOSE_COMMA);
14773 if (parser->version < PM_OPTIONS_VERSION_CRUBY_4_1 || order == PM_PARAMETERS_ORDER_NOTHING_AFTER) {
14774 pm_parser_err_previous(parser, PM_ERR_PARAMETER_WILD_LOOSE_COMMA);
14782static pm_parameters_node_t *
14785 pm_binding_power_t binding_power,
14786 bool uses_parentheses,
14787 bool allows_trailing_comma,
14788 bool allows_forwarding_parameters,
14789 bool accepts_blocks_in_defaults,
14791 pm_diagnostic_id_t diag_id_forwarding,
14794 pm_do_loop_stack_push(parser,
false);
14797 pm_parameters_order_t order = PM_PARAMETERS_ORDER_NONE;
14800 bool parsing =
true;
14802 switch (parser->current.type) {
14803 case PM_TOKEN_PARENTHESIS_LEFT_GROUPING: {
14804 update_parameter_state(parser, &parser->current, &order);
14805 pm_node_t *param = parse_required_destructured_parameter(parser, (uint16_t) (depth + 1));
14807 if (order > PM_PARAMETERS_ORDER_AFTER_OPTIONAL) {
14808 pm_parameters_requireds_append(parser, ¶ms, param);
14810 pm_parameters_posts_append(parser, ¶ms, param);
14814 case PM_TOKEN_UAMPERSAND:
14815 case PM_TOKEN_AMPERSAND: {
14816 update_parameter_state(parser, &parser->current, &order);
14817 parser_lex(parser);
14822 if (parser->version >= PM_OPTIONS_VERSION_CRUBY_4_1 && accept1(parser, PM_TOKEN_KEYWORD_NIL)) {
14823 param = (pm_node_t *) pm_no_block_parameter_node_create(parser, &
operator, &parser->previous);
14827 bool repeated =
false;
14828 if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
14829 name = parser->previous;
14830 repeated = pm_parser_parameter_name_check(parser, &name);
14831 pm_parser_local_add_token(parser, &name, 1);
14833 parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_FORWARDING_BLOCK;
14836 param = (pm_node_t *) pm_block_parameter_node_create(parser, NTOK2PTR(name), &
operator);
14838 pm_node_flag_set_repeated_parameter(param);
14842 if (params.block == NULL) {
14843 pm_parameters_block_set(¶ms, param);
14845 pm_parser_err_node(parser, param, PM_ERR_PARAMETER_BLOCK_MULTI);
14846 pm_parameters_posts_append(parser, ¶ms, UP(pm_error_recovery_node_create_unexpected(parser, param)));
14851 case PM_TOKEN_UDOT_DOT_DOT: {
14852 if (!allows_forwarding_parameters) {
14853 pm_parser_err_current(parser, diag_id_forwarding);
14856 bool succeeded = update_parameter_state(parser, &parser->current, &order);
14857 parser_lex(parser);
14859 parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_FORWARDING_ALL;
14860 pm_forwarding_parameter_node_t *param = pm_forwarding_parameter_node_create(parser, &parser->previous);
14862 if (params.keyword_rest != NULL) {
14865 pm_node_t *keyword_rest = params.keyword_rest;
14866 pm_parameters_posts_append(parser, ¶ms, UP(pm_error_recovery_node_create_unexpected(parser, keyword_rest)));
14867 if (succeeded) pm_parser_err_previous(parser, PM_ERR_PARAMETER_UNEXPECTED_FWD);
14868 params.keyword_rest = NULL;
14871 pm_parameters_keyword_rest_set(¶ms, UP(param));
14874 case PM_TOKEN_CLASS_VARIABLE:
14875 case PM_TOKEN_IDENTIFIER:
14876 case PM_TOKEN_CONSTANT:
14877 case PM_TOKEN_INSTANCE_VARIABLE:
14878 case PM_TOKEN_GLOBAL_VARIABLE:
14879 case PM_TOKEN_METHOD_NAME: {
14880 parser_lex(parser);
14881 switch (parser->previous.
type) {
14882 case PM_TOKEN_CONSTANT:
14883 pm_parser_err_previous(parser, PM_ERR_ARGUMENT_FORMAL_CONSTANT);
14885 case PM_TOKEN_INSTANCE_VARIABLE:
14886 pm_parser_err_previous(parser, PM_ERR_ARGUMENT_FORMAL_IVAR);
14888 case PM_TOKEN_GLOBAL_VARIABLE:
14889 pm_parser_err_previous(parser, PM_ERR_ARGUMENT_FORMAL_GLOBAL);
14891 case PM_TOKEN_CLASS_VARIABLE:
14892 pm_parser_err_previous(parser, PM_ERR_ARGUMENT_FORMAL_CLASS);
14894 case PM_TOKEN_METHOD_NAME:
14895 pm_parser_err_previous(parser, PM_ERR_PARAMETER_METHOD_NAME);
14900 if (parser->current.type == PM_TOKEN_EQUAL) {
14901 update_parameter_state(parser, &parser->current, &order);
14903 update_parameter_state(parser, &parser->previous, &order);
14907 bool repeated = pm_parser_parameter_name_check(parser, &name);
14908 pm_parser_local_add_token(parser, &name, 1);
14910 if (match1(parser, PM_TOKEN_EQUAL)) {
14912 context_push(parser, PM_CONTEXT_DEFAULT_PARAMS);
14913 parser_lex(parser);
14916 uint32_t reads = parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 ? pm_locals_reads(parser, name_id) : 0;
14918 if (accepts_blocks_in_defaults) pm_accepts_block_stack_push(parser,
true);
14919 pm_node_t *value = parse_value_expression(parser, binding_power, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_PARAMETER_NO_DEFAULT, (uint16_t) (depth + 1));
14920 if (accepts_blocks_in_defaults) pm_accepts_block_stack_pop(parser);
14922 pm_optional_parameter_node_t *param = pm_optional_parameter_node_create(parser, &name, &
operator, value);
14925 pm_node_flag_set_repeated_parameter(UP(param));
14927 pm_parameters_optionals_append(parser, ¶ms, param);
14932 if ((parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3) && (pm_locals_reads(parser, name_id) != reads)) {
14933 PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, &name, PM_ERR_PARAMETER_CIRCULAR);
14936 context_pop(parser);
14941 if (parser->recovering) {
14945 }
else if (order > PM_PARAMETERS_ORDER_AFTER_OPTIONAL) {
14946 pm_required_parameter_node_t *param = pm_required_parameter_node_create(parser, &name);
14948 pm_node_flag_set_repeated_parameter(UP(param));
14950 pm_parameters_requireds_append(parser, ¶ms, UP(param));
14952 pm_required_parameter_node_t *param = pm_required_parameter_node_create(parser, &name);
14954 pm_node_flag_set_repeated_parameter(UP(param));
14956 pm_parameters_posts_append(parser, ¶ms, UP(param));
14961 case PM_TOKEN_LABEL: {
14962 if (!uses_parentheses && !in_block) parser->in_keyword_arg =
true;
14963 update_parameter_state(parser, &parser->current, &order);
14965 context_push(parser, PM_CONTEXT_DEFAULT_PARAMS);
14971 if (parser->encoding_changed ? pm_encoding_isupper_char(parser->encoding, local.
start, local.
end - local.
start, parser->version) : pm_encoding_utf_8_isupper_char(local.
start, local.
end - local.
start, parser->version)) {
14972 pm_parser_err(parser, PM_TOKEN_START(parser, &local), PM_TOKEN_LENGTH(&local), PM_ERR_ARGUMENT_FORMAL_CONSTANT);
14973 }
else if (local.
end[-1] ==
'!' || local.
end[-1] ==
'?') {
14974 PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, &local, PM_ERR_INVALID_LOCAL_VARIABLE_WRITE);
14977 bool repeated = pm_parser_parameter_name_check(parser, &local);
14979 pm_parser_local_add_token(parser, &local, 1);
14980 parser_lex(parser);
14982 switch (parser->current.type) {
14983 case PM_TOKEN_COMMA:
14984 case PM_TOKEN_PARENTHESIS_RIGHT:
14985 case PM_TOKEN_PIPE: {
14986 context_pop(parser);
14988 pm_node_t *param = UP(pm_required_keyword_parameter_node_create(parser, &name));
14990 pm_node_flag_set_repeated_parameter(param);
14993 pm_parameters_keywords_append(parser, ¶ms, param);
14996 case PM_TOKEN_SEMICOLON:
14997 case PM_TOKEN_NEWLINE: {
14998 context_pop(parser);
15000 if (uses_parentheses) {
15005 pm_node_t *param = UP(pm_required_keyword_parameter_node_create(parser, &name));
15007 pm_node_flag_set_repeated_parameter(param);
15010 pm_parameters_keywords_append(parser, ¶ms, param);
15016 if (token_begins_expression_p(parser->current.type)) {
15018 uint32_t reads = parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 ? pm_locals_reads(parser, name_id) : 0;
15020 if (accepts_blocks_in_defaults) pm_accepts_block_stack_push(parser,
true);
15021 pm_node_t *value = parse_value_expression(parser, binding_power, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_PARAMETER_NO_DEFAULT_KW, (uint16_t) (depth + 1));
15022 if (accepts_blocks_in_defaults) pm_accepts_block_stack_pop(parser);
15024 if (parser->version <= PM_OPTIONS_VERSION_CRUBY_3_3 && (pm_locals_reads(parser, name_id) != reads)) {
15025 PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, &local, PM_ERR_PARAMETER_CIRCULAR);
15028 param = UP(pm_optional_keyword_parameter_node_create(parser, &name, value));
15031 param = UP(pm_required_keyword_parameter_node_create(parser, &name));
15035 pm_node_flag_set_repeated_parameter(param);
15038 context_pop(parser);
15039 pm_parameters_keywords_append(parser, ¶ms, param);
15044 if (parser->recovering) {
15051 parser->in_keyword_arg =
false;
15054 case PM_TOKEN_USTAR:
15055 case PM_TOKEN_STAR: {
15056 update_parameter_state(parser, &parser->current, &order);
15057 parser_lex(parser);
15061 bool repeated =
false;
15063 if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
15064 name = parser->previous;
15065 repeated = pm_parser_parameter_name_check(parser, &name);
15066 pm_parser_local_add_token(parser, &name, 1);
15068 parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_FORWARDING_POSITIONALS;
15071 pm_node_t *param = UP(pm_rest_parameter_node_create(parser, &
operator, NTOK2PTR(name)));
15073 pm_node_flag_set_repeated_parameter(param);
15076 if (params.rest == NULL) {
15077 pm_parameters_rest_set(¶ms, param);
15079 pm_parser_err_node(parser, param, PM_ERR_PARAMETER_SPLAT_MULTI);
15080 pm_parameters_posts_append(parser, ¶ms, param);
15085 case PM_TOKEN_STAR_STAR:
15086 case PM_TOKEN_USTAR_STAR: {
15087 pm_parameters_order_t previous_order = order;
15088 update_parameter_state(parser, &parser->current, &order);
15089 parser_lex(parser);
15094 if (accept1(parser, PM_TOKEN_KEYWORD_NIL)) {
15095 if (previous_order <= PM_PARAMETERS_ORDER_KEYWORDS) {
15096 pm_parser_err_previous(parser, PM_ERR_PARAMETER_UNEXPECTED_NO_KW);
15099 param = UP(pm_no_keywords_parameter_node_create(parser, &
operator, &parser->previous));
15103 bool repeated =
false;
15104 if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
15105 name = parser->previous;
15106 repeated = pm_parser_parameter_name_check(parser, &name);
15107 pm_parser_local_add_token(parser, &name, 1);
15109 parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_FORWARDING_KEYWORDS;
15112 param = UP(pm_keyword_rest_parameter_node_create(parser, &
operator, NTOK2PTR(name)));
15114 pm_node_flag_set_repeated_parameter(param);
15118 if (params.keyword_rest == NULL) {
15119 pm_parameters_keyword_rest_set(¶ms, param);
15121 pm_parser_err_node(parser, param, PM_ERR_PARAMETER_ASSOC_SPLAT_MULTI);
15122 pm_parameters_posts_append(parser, ¶ms, UP(pm_error_recovery_node_create_unexpected(parser, param)));
15128 if (parser->previous.
type == PM_TOKEN_COMMA) {
15129 parse_parameters_handle_trailing_comma(parser, ¶ms, order, in_block, allows_trailing_comma);
15139 if (!parsing)
break;
15141 bool accepted_newline =
false;
15142 if (uses_parentheses) {
15143 accepted_newline = accept1(parser, PM_TOKEN_NEWLINE);
15146 if (accept1(parser, PM_TOKEN_COMMA)) {
15149 if (accepted_newline) {
15150 pm_parser_err_previous(parser, PM_ERR_INVALID_COMMA);
15158 pm_do_loop_stack_pop(parser);
15161 if (params.location.
length == 0) {
15165 return pm_parameters_node_create(parser, ¶ms);
15174 if (parser->heredoc_end == NULL) {
15178 return parser->line_offsets.
size - 1;
15184 return (
size_t) pm_line_offset_list_line(&parser->line_offsets, PM_TOKEN_START(parser, &parser->current), 0);
15193token_column(
const pm_parser_t *parser,
size_t newline_index,
const pm_token_t *token,
bool break_on_non_space) {
15194 const uint8_t *cursor = parser->start + parser->line_offsets.
offsets[newline_index];
15195 const uint8_t *end = token->start;
15199 newline_index == 0 &&
15200 parser->start[0] == 0xef &&
15201 parser->start[1] == 0xbb &&
15202 parser->start[2] == 0xbf
15205 int64_t column = 0;
15206 for (; cursor < end; cursor++) {
15209 column = ((column / PM_TAB_WHITESPACE_SIZE) + 1) * PM_TAB_WHITESPACE_SIZE;
15216 if (break_on_non_space)
return -1;
15229parser_warn_indentation_mismatch(
pm_parser_t *parser,
size_t opening_newline_index,
const pm_token_t *opening_token,
bool if_after_else,
bool allow_indent) {
15231 if (!parser->warn_mismatched_indentation)
return;
15234 size_t closing_newline_index = token_newline_index(parser);
15235 if (opening_newline_index == closing_newline_index)
return;
15240 int64_t opening_column = token_column(parser, opening_newline_index, opening_token, !if_after_else);
15241 if (!if_after_else && (opening_column == -1))
return;
15245 pm_token_t *closing_token = &parser->current;
15248 int64_t closing_column = token_column(parser, closing_newline_index, closing_token,
true);
15249 if ((closing_column == -1) || (opening_column == closing_column))
return;
15253 if (allow_indent && (closing_column > opening_column))
return;
15256 PM_PARSER_WARN_FORMAT(
15258 PM_TOKEN_START(parser, closing_token),
15259 PM_TOKEN_LENGTH(closing_token),
15260 PM_WARN_INDENTATION_MISMATCH,
15261 (
int) (closing_token->
end - closing_token->
start),
15262 (
const char *) closing_token->
start,
15263 (
int) (opening_token->
end - opening_token->
start),
15264 (
const char *) opening_token->
start,
15265 pm_line_offset_list_line_number(opening_newline_index, parser->start_line)
15270 PM_RESCUES_BEGIN = 1,
15277} pm_rescues_type_t;
15284parse_rescues(
pm_parser_t *parser,
size_t opening_newline_index,
const pm_token_t *opening, pm_begin_node_t *parent_node, pm_rescues_type_t type, uint16_t depth) {
15285 pm_rescue_node_t *current = NULL;
15287 while (match1(parser, PM_TOKEN_KEYWORD_RESCUE)) {
15288 if (opening != NULL) parser_warn_indentation_mismatch(parser, opening_newline_index, opening,
false,
false);
15289 parser_lex(parser);
15291 pm_token_t rescue_keyword = parser->previous;
15292 pm_node_list_t exceptions = { 0 };
15294 pm_node_t *reference = NULL;
15296 pm_statements_node_t *statements = NULL;
15298 switch (parser->current.type) {
15299 case PM_TOKEN_EQUAL_GREATER: {
15303 parser_lex(parser);
15304 operator = parser->previous;
15306 reference = parse_expression(parser, PM_BINDING_POWER_INDEX, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_RESCUE_VARIABLE, (uint16_t) (depth + 1));
15307 reference = parse_target(parser, reference,
false,
false);
15310 case PM_TOKEN_NEWLINE:
15311 case PM_TOKEN_SEMICOLON:
15312 case PM_TOKEN_KEYWORD_THEN:
15317 if (token_begins_expression_p(parser->current.type) || match1(parser, PM_TOKEN_USTAR)) {
15322 pm_node_t *expression = parse_starred_expression(parser, PM_BINDING_POWER_DEFINED,
false, PM_ERR_RESCUE_EXPRESSION, (uint16_t) (depth + 1));
15323 pm_node_list_open_append(&parser->node_chunks, &exceptions, expression);
15327 if (match3(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_TOKEN_KEYWORD_THEN))
break;
15331 if (accept1(parser, PM_TOKEN_EQUAL_GREATER)) {
15332 operator = parser->previous;
15334 reference = parse_expression(parser, PM_BINDING_POWER_INDEX, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_RESCUE_VARIABLE, (uint16_t) (depth + 1));
15335 reference = parse_target(parser, reference,
false,
false);
15338 }
while (accept1(parser, PM_TOKEN_COMMA));
15343 if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
15344 if (accept1(parser, PM_TOKEN_KEYWORD_THEN)) {
15345 then_keyword = parser->previous;
15348 expect1(parser, PM_TOKEN_KEYWORD_THEN, PM_ERR_RESCUE_TERM);
15349 then_keyword = parser->previous;
15352 if (!match3(parser, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_END)) {
15353 pm_accepts_block_stack_push(parser,
true);
15354 pm_context_t context;
15357 case PM_RESCUES_BEGIN: context = PM_CONTEXT_BEGIN_RESCUE;
break;
15358 case PM_RESCUES_BLOCK: context = PM_CONTEXT_BLOCK_RESCUE;
break;
15359 case PM_RESCUES_CLASS: context = PM_CONTEXT_CLASS_RESCUE;
break;
15360 case PM_RESCUES_DEF: context = PM_CONTEXT_DEF_RESCUE;
break;
15361 case PM_RESCUES_LAMBDA: context = PM_CONTEXT_LAMBDA_RESCUE;
break;
15362 case PM_RESCUES_MODULE: context = PM_CONTEXT_MODULE_RESCUE;
break;
15363 case PM_RESCUES_SCLASS: context = PM_CONTEXT_SCLASS_RESCUE;
break;
15364 default: PRISM_ASSERT(
false &&
"unreachable"); context = PM_CONTEXT_BEGIN_RESCUE;
break;
15367 statements = parse_statements(parser, context, (uint16_t) (depth + 1));
15369 pm_accepts_block_stack_pop(parser);
15370 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
15373 pm_rescue_node_t *rescue = pm_rescue_node_create(parser, &rescue_keyword, &exceptions, NTOK2PTR(
operator), reference, NTOK2PTR(then_keyword), statements);
15375 if (current == NULL) {
15376 pm_begin_node_rescue_clause_set(parent_node, rescue);
15378 pm_rescue_node_subsequent_set(current, rescue);
15387 if (current != NULL) {
15390 while (clause != NULL) {
15391 PM_NODE_LENGTH_SET_NODE(clause, current);
15397 if (match1(parser, PM_TOKEN_KEYWORD_ELSE)) {
15398 if (opening != NULL) parser_warn_indentation_mismatch(parser, opening_newline_index, opening,
false,
false);
15399 opening_newline_index = token_newline_index(parser);
15401 else_keyword = parser->current;
15402 opening = &else_keyword;
15404 parser_lex(parser);
15405 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
15407 pm_statements_node_t *else_statements = NULL;
15408 if (!match2(parser, PM_TOKEN_KEYWORD_END, PM_TOKEN_KEYWORD_ENSURE)) {
15409 pm_accepts_block_stack_push(parser,
true);
15410 pm_context_t context;
15413 case PM_RESCUES_BEGIN: context = PM_CONTEXT_BEGIN_ELSE;
break;
15414 case PM_RESCUES_BLOCK: context = PM_CONTEXT_BLOCK_ELSE;
break;
15415 case PM_RESCUES_CLASS: context = PM_CONTEXT_CLASS_ELSE;
break;
15416 case PM_RESCUES_DEF: context = PM_CONTEXT_DEF_ELSE;
break;
15417 case PM_RESCUES_LAMBDA: context = PM_CONTEXT_LAMBDA_ELSE;
break;
15418 case PM_RESCUES_MODULE: context = PM_CONTEXT_MODULE_ELSE;
break;
15419 case PM_RESCUES_SCLASS: context = PM_CONTEXT_SCLASS_ELSE;
break;
15420 default: PRISM_ASSERT(
false &&
"unreachable"); context = PM_CONTEXT_BEGIN_ELSE;
break;
15423 else_statements = parse_statements(parser, context, (uint16_t) (depth + 1));
15424 pm_accepts_block_stack_pop(parser);
15426 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
15429 pm_else_node_t *else_clause = pm_else_node_create(parser, &else_keyword, else_statements, &parser->current);
15430 pm_begin_node_else_clause_set(parent_node, else_clause);
15434 if (current == NULL) pm_parser_err_node(parser, UP(else_clause), PM_ERR_BEGIN_LONELY_ELSE);
15437 if (match1(parser, PM_TOKEN_KEYWORD_ENSURE)) {
15438 if (opening != NULL) parser_warn_indentation_mismatch(parser, opening_newline_index, opening,
false,
false);
15439 pm_token_t ensure_keyword = parser->current;
15441 parser_lex(parser);
15442 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
15444 pm_statements_node_t *ensure_statements = NULL;
15445 if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
15446 pm_accepts_block_stack_push(parser,
true);
15447 pm_context_t context;
15450 case PM_RESCUES_BEGIN: context = PM_CONTEXT_BEGIN_ENSURE;
break;
15451 case PM_RESCUES_BLOCK: context = PM_CONTEXT_BLOCK_ENSURE;
break;
15452 case PM_RESCUES_CLASS: context = PM_CONTEXT_CLASS_ENSURE;
break;
15453 case PM_RESCUES_DEF: context = PM_CONTEXT_DEF_ENSURE;
break;
15454 case PM_RESCUES_LAMBDA: context = PM_CONTEXT_LAMBDA_ENSURE;
break;
15455 case PM_RESCUES_MODULE: context = PM_CONTEXT_MODULE_ENSURE;
break;
15456 case PM_RESCUES_SCLASS: context = PM_CONTEXT_SCLASS_ENSURE;
break;
15457 default: PRISM_ASSERT(
false &&
"unreachable"); context = PM_CONTEXT_BEGIN_RESCUE;
break;
15460 ensure_statements = parse_statements(parser, context, (uint16_t) (depth + 1));
15461 pm_accepts_block_stack_pop(parser);
15463 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
15466 pm_ensure_node_t *ensure_clause = pm_ensure_node_create(parser, &ensure_keyword, ensure_statements, &parser->current);
15467 pm_begin_node_ensure_clause_set(parent_node, ensure_clause);
15470 if (match1(parser, PM_TOKEN_KEYWORD_END)) {
15471 if (opening != NULL) parser_warn_indentation_mismatch(parser, opening_newline_index, opening,
false,
false);
15472 pm_begin_node_end_keyword_set(parser, parent_node, &parser->current);
15474 pm_token_t end_keyword = (
pm_token_t) { .type = PM_TOKEN_KEYWORD_END, .start = parser->previous.
end, .end = parser->previous.
end };
15475 pm_begin_node_end_keyword_set(parser, parent_node, &end_keyword);
15483static pm_begin_node_t *
15484parse_rescues_implicit_begin(
pm_parser_t *parser,
size_t opening_newline_index,
const pm_token_t *opening,
const uint8_t *start, pm_statements_node_t *statements, pm_rescues_type_t type, uint16_t depth) {
15485 pm_begin_node_t *node = pm_begin_node_create(parser, NULL, statements);
15486 parse_rescues(parser, opening_newline_index, opening, node, type, (uint16_t) (depth + 1));
15489 PM_NODE_LENGTH_SET_TOKEN(parser, node, &parser->current);
15497static pm_block_parameters_node_t *
15498parse_block_parameters(
15500 bool allows_trailing_comma,
15502 bool is_lambda_literal,
15503 bool accepts_blocks_in_defaults,
15506 pm_parameters_node_t *parameters = NULL;
15507 if (!match1(parser, PM_TOKEN_SEMICOLON)) {
15508 if (!is_lambda_literal) {
15509 context_push(parser, PM_CONTEXT_BLOCK_PARAMETERS);
15511 parameters = parse_parameters(
15513 is_lambda_literal ? PM_BINDING_POWER_DEFINED : PM_BINDING_POWER_INDEX,
15515 allows_trailing_comma,
15517 accepts_blocks_in_defaults,
15519 is_lambda_literal ? PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES_LAMBDA : PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES_BLOCK,
15520 (uint16_t) (depth + 1)
15522 if (!is_lambda_literal) {
15523 context_pop(parser);
15527 pm_node_list_t locals = { 0 };
15528 if (opening != NULL) {
15529 accept1(parser, PM_TOKEN_NEWLINE);
15531 if (accept1(parser, PM_TOKEN_SEMICOLON)) {
15533 switch (parser->current.type) {
15534 case PM_TOKEN_CONSTANT:
15535 pm_parser_err_current(parser, PM_ERR_ARGUMENT_FORMAL_CONSTANT);
15536 parser_lex(parser);
15538 case PM_TOKEN_INSTANCE_VARIABLE:
15539 pm_parser_err_current(parser, PM_ERR_ARGUMENT_FORMAL_IVAR);
15540 parser_lex(parser);
15542 case PM_TOKEN_GLOBAL_VARIABLE:
15543 pm_parser_err_current(parser, PM_ERR_ARGUMENT_FORMAL_GLOBAL);
15544 parser_lex(parser);
15546 case PM_TOKEN_CLASS_VARIABLE:
15547 pm_parser_err_current(parser, PM_ERR_ARGUMENT_FORMAL_CLASS);
15548 parser_lex(parser);
15551 expect1(parser, PM_TOKEN_IDENTIFIER, PM_ERR_BLOCK_PARAM_LOCAL_VARIABLE);
15555 bool repeated = pm_parser_parameter_name_check(parser, &parser->previous);
15556 pm_parser_local_add_token(parser, &parser->previous, 1);
15558 pm_block_local_variable_node_t *local = pm_block_local_variable_node_create(parser, &parser->previous);
15559 if (repeated) pm_node_flag_set_repeated_parameter(UP(local));
15561 pm_node_list_open_append(&parser->node_chunks, &locals, UP(local));
15562 }
while (accept1(parser, PM_TOKEN_COMMA));
15566 return pm_block_parameters_node_create(parser, parameters, opening, &locals);
15574outer_scope_using_numbered_parameters_p(
pm_parser_t *parser) {
15575 for (pm_scope_t *scope = parser->current_scope->previous; scope != NULL && !scope->closed; scope = scope->previous) {
15576 if (scope->parameters & PM_SCOPE_PARAMETERS_NUMBERED_FOUND)
return true;
15587static const char *
const pm_numbered_parameter_names[] = {
15588 "_1",
"_2",
"_3",
"_4",
"_5",
"_6",
"_7",
"_8",
"_9"
15602 if (parameters != NULL) {
15604 if (implicit_parameters->size > 0) {
15605 pm_node_t *node = implicit_parameters->nodes[0];
15607 if (PM_NODE_TYPE_P(node, PM_LOCAL_VARIABLE_READ_NODE)) {
15608 pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_ORDINARY);
15609 }
else if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
15610 pm_parser_err_node(parser, node, PM_ERR_IT_NOT_ALLOWED_ORDINARY);
15612 PRISM_ASSERT(
false &&
"unreachable");
15621 if (implicit_parameters->size == 0) {
15628 uint8_t numbered_parameter = 0;
15629 bool it_parameter =
false;
15631 for (
size_t index = 0; index < implicit_parameters->size; index++) {
15632 pm_node_t *node = implicit_parameters->nodes[index];
15634 if (PM_NODE_TYPE_P(node, PM_LOCAL_VARIABLE_READ_NODE)) {
15635 if (it_parameter) {
15636 pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_IT);
15637 }
else if (outer_scope_using_numbered_parameters_p(parser)) {
15638 pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_OUTER_BLOCK);
15639 }
else if (parser->current_scope->parameters & PM_SCOPE_PARAMETERS_NUMBERED_INNER) {
15640 pm_parser_err_node(parser, node, PM_ERR_NUMBERED_PARAMETER_INNER_BLOCK);
15641 }
else if (pm_token_is_numbered_parameter(parser, PM_NODE_START(node), PM_NODE_LENGTH(node))) {
15642 numbered_parameter = MAX(numbered_parameter, (uint8_t) (parser->start[node->
location.
start + 1] -
'0'));
15644 PRISM_ASSERT(
false &&
"unreachable");
15646 }
else if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
15647 if (numbered_parameter > 0) {
15648 pm_parser_err_node(parser, node, PM_ERR_IT_NOT_ALLOWED_NUMBERED);
15650 it_parameter =
true;
15655 if (numbered_parameter > 0) {
15658 for (pm_scope_t *scope = parser->current_scope->previous; scope != NULL && !scope->closed; scope = scope->previous) {
15659 scope->parameters |= PM_SCOPE_PARAMETERS_NUMBERED_INNER;
15661 return UP(pm_numbered_parameters_node_create(parser, opening, closing, numbered_parameter));
15664 if (it_parameter) {
15665 return UP(pm_it_parameters_node_create(parser, opening, closing));
15674static pm_block_node_t *
15675parse_block(
pm_parser_t *parser, uint16_t depth) {
15677 accept1(parser, PM_TOKEN_NEWLINE);
15683 bool do_block = opening.
type != PM_TOKEN_BRACE_LEFT && opening.
type != PM_TOKEN_BRACE_LEFT_ARGUMENT;
15684 if (do_block) pm_accepts_block_stack_push(parser,
true);
15685 pm_parser_scope_push(parser,
false);
15687 pm_block_parameters_node_t *block_parameters = NULL;
15689 if (accept1(parser, PM_TOKEN_PIPE)) {
15690 pm_token_t block_parameters_opening = parser->previous;
15691 if (match1(parser, PM_TOKEN_PIPE)) {
15692 block_parameters = pm_block_parameters_node_create(parser, NULL, &block_parameters_opening, &((pm_node_list_t) { 0 }));
15693 parser->command_start =
true;
15694 parser_lex(parser);
15696 block_parameters = parse_block_parameters(parser,
true, &block_parameters_opening,
false,
true, (uint16_t) (depth + 1));
15697 accept1(parser, PM_TOKEN_NEWLINE);
15698 parser->command_start =
true;
15699 expect1(parser, PM_TOKEN_PIPE, PM_ERR_BLOCK_PARAM_PIPE_TERM);
15702 pm_block_parameters_node_closing_set(parser, block_parameters, &parser->previous);
15705 accept1(parser, PM_TOKEN_NEWLINE);
15706 pm_node_t *statements = NULL;
15709 if (!match1(parser, PM_TOKEN_BRACE_RIGHT)) {
15710 statements = UP(parse_statements(parser, PM_CONTEXT_BLOCK_BRACES, (uint16_t) (depth + 1)));
15713 expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_BLOCK_TERM_BRACE, &opening);
15715 if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
15716 if (!match3(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_ENSURE)) {
15717 statements = UP(parse_statements(parser, PM_CONTEXT_BLOCK_KEYWORDS, (uint16_t) (depth + 1)));
15720 if (match2(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE)) {
15721 PRISM_ASSERT(statements == NULL || PM_NODE_TYPE_P(statements, PM_STATEMENTS_NODE));
15722 statements = UP(parse_rescues_implicit_begin(parser, 0, NULL, opening.
start, (pm_statements_node_t *) statements, PM_RESCUES_BLOCK, (uint16_t) (depth + 1)));
15728 pm_accepts_block_stack_pop(parser);
15729 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_BLOCK_TERM_END, &opening);
15733 pm_locals_order(parser, &locals, pm_parser_scope_toplevel_p(parser));
15734 pm_node_t *parameters = parse_blocklike_parameters(parser, UP(block_parameters), &opening, &parser->previous);
15736 pm_parser_scope_pop(parser);
15737 return pm_block_node_create(parser, &locals, &opening, parameters, statements, &parser->previous);
15751parse_delimited_arguments_flags(
const pm_parser_t *parser, uint8_t flags,
bool index) {
15752 if (parser->version >= PM_OPTIONS_VERSION_CRUBY_3_4 && (!index || parser->version <= PM_OPTIONS_VERSION_CRUBY_4_0)) {
15753 return (uint8_t) (flags | PM_PARSE_ACCEPTS_DO_BLOCK);
15756 return (uint8_t) (flags & ~PM_PARSE_ACCEPTS_DO_BLOCK);
15771parse_arguments_list(
pm_parser_t *parser,
pm_arguments_t *arguments,
bool full_arguments, uint8_t flags, uint16_t depth) {
15776 !token_begins_expression_p(parser->current.type) &&
15777 !match6(parser, PM_TOKEN_PARENTHESIS_LEFT, PM_TOKEN_KEYWORD_DO, PM_TOKEN_KEYWORD_DO_BLOCK, PM_TOKEN_USTAR, PM_TOKEN_USTAR_STAR, PM_TOKEN_UAMPERSAND)
15782 bool found =
false;
15783 bool parsed_command_args =
false;
15785 if (accept1(parser, PM_TOKEN_PARENTHESIS_LEFT)) {
15787 arguments->
opening_loc = TOK2LOC(parser, &parser->previous);
15789 if (accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
15790 arguments->
closing_loc = TOK2LOC(parser, &parser->previous);
15792 parse_arguments(parser, arguments, full_arguments, PM_TOKEN_PARENTHESIS_RIGHT, parse_delimited_arguments_flags(parser, flags,
false), (uint16_t) (depth + 1));
15800 if (!full_arguments && parser->previous.
type == PM_TOKEN_COMMA) {
15801 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->previous, PM_ERR_EXPECT_ARGUMENT, pm_token_str(parser->current.type));
15804 if (!accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
15805 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_ARGUMENT_TERM_PAREN, pm_token_str(parser->current.type));
15806 parser->previous.
start = parser->previous.
end;
15807 parser->previous.
type = 0;
15810 arguments->
closing_loc = TOK2LOC(parser, &parser->previous);
15812 }
else if ((flags & PM_PARSE_ACCEPTS_COMMAND_CALL) && token_begins_argument_p(parser->current.type) && !match1(parser, PM_TOKEN_BRACE_LEFT)) {
15814 parsed_command_args =
true;
15824 bool lookahead_delimiter = match5(parser, PM_TOKEN_PARENTHESIS_LEFT, PM_TOKEN_PARENTHESIS_LEFT_GROUPING, PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES, PM_TOKEN_BRACKET_LEFT, PM_TOKEN_BRACKET_LEFT_ARRAY);
15825 if (lookahead_delimiter) pm_accepts_block_stack_pop(parser);
15826 pm_accepts_block_stack_push(parser,
false);
15827 if (lookahead_delimiter) pm_accepts_block_stack_push(parser,
true);
15832 parse_arguments(parser, arguments, full_arguments, PM_TOKEN_EOF, flags, (uint16_t) (depth + 1));
15837 if (parser->previous.
type == PM_TOKEN_COMMA && !match1(parser, PM_TOKEN_SEMICOLON)) {
15838 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->previous, PM_ERR_EXPECT_ARGUMENT, pm_token_str(parser->current.type));
15846 bool lookahead_brace = match2(parser, PM_TOKEN_BRACE_LEFT, PM_TOKEN_BRACE_LEFT_ARGUMENT);
15847 if (lookahead_brace) pm_accepts_block_stack_pop(parser);
15848 pm_accepts_block_stack_pop(parser);
15849 if (lookahead_brace) pm_accepts_block_stack_push(parser,
true);
15855 if (full_arguments) {
15856 pm_block_node_t *block = NULL;
15858 if (accept2(parser, PM_TOKEN_BRACE_LEFT, PM_TOKEN_BRACE_LEFT_ARGUMENT)) {
15860 block = parse_block(parser, (uint16_t) (depth + 1));
15861 pm_arguments_validate_block(parser, arguments, block);
15862 }
else if (pm_accepts_block_stack_p(parser) && accept1(parser, PM_TOKEN_KEYWORD_DO)) {
15864 block = parse_block(parser, (uint16_t) (depth + 1));
15865 }
else if (parsed_command_args && pm_accepts_block_stack_p(parser) && (flags & PM_PARSE_ACCEPTS_DO_BLOCK) && accept1(parser, PM_TOKEN_KEYWORD_DO_BLOCK)) {
15867 block = parse_block(parser, (uint16_t) (depth + 1));
15870 if (block != NULL) {
15872 arguments->
block = UP(block);
15874 pm_parser_err_node(parser, UP(block), PM_ERR_ARGUMENT_BLOCK_MULTI);
15876 if (arguments->
block != NULL) {
15877 parse_arguments_append(parser, arguments, arguments->
block);
15879 arguments->
block = UP(block);
15892ensure_valid_return(
pm_parser_t *parser, pm_node_t *node) {
15893 bool in_sclass =
false;
15894 for (pm_context_node_t *context_node = parser->current_context; context_node != NULL; context_node = context_node->prev) {
15895 switch (context_node->context) {
15896 case PM_CONTEXT_BEGIN_ELSE:
15897 case PM_CONTEXT_BEGIN_ENSURE:
15898 case PM_CONTEXT_BEGIN_RESCUE:
15899 case PM_CONTEXT_BEGIN:
15900 case PM_CONTEXT_CASE_IN:
15901 case PM_CONTEXT_CASE_WHEN:
15902 case PM_CONTEXT_DEFAULT_PARAMS:
15903 case PM_CONTEXT_DEFINED:
15904 case PM_CONTEXT_ELSE:
15905 case PM_CONTEXT_ELSIF:
15906 case PM_CONTEXT_EMBEXPR:
15907 case PM_CONTEXT_FOR_INDEX:
15908 case PM_CONTEXT_FOR:
15909 case PM_CONTEXT_IF:
15910 case PM_CONTEXT_LOOP_PREDICATE:
15911 case PM_CONTEXT_MAIN:
15912 case PM_CONTEXT_MULTI_TARGET:
15913 case PM_CONTEXT_PARENS:
15914 case PM_CONTEXT_POSTEXE:
15915 case PM_CONTEXT_PREDICATE:
15916 case PM_CONTEXT_PREEXE:
15917 case PM_CONTEXT_RESCUE_MODIFIER:
15918 case PM_CONTEXT_TERNARY:
15919 case PM_CONTEXT_UNLESS:
15920 case PM_CONTEXT_UNTIL:
15921 case PM_CONTEXT_WHILE:
15925 case PM_CONTEXT_SCLASS_ELSE:
15926 case PM_CONTEXT_SCLASS_ENSURE:
15927 case PM_CONTEXT_SCLASS_RESCUE:
15928 case PM_CONTEXT_SCLASS:
15931 case PM_CONTEXT_CLASS_ELSE:
15932 case PM_CONTEXT_CLASS_ENSURE:
15933 case PM_CONTEXT_CLASS_RESCUE:
15934 case PM_CONTEXT_CLASS:
15935 case PM_CONTEXT_MODULE_ELSE:
15936 case PM_CONTEXT_MODULE_ENSURE:
15937 case PM_CONTEXT_MODULE_RESCUE:
15938 case PM_CONTEXT_MODULE:
15940 pm_parser_err_node(parser, node, PM_ERR_RETURN_INVALID);
15942 case PM_CONTEXT_BLOCK_BRACES:
15943 case PM_CONTEXT_BLOCK_ELSE:
15944 case PM_CONTEXT_BLOCK_ENSURE:
15945 case PM_CONTEXT_BLOCK_KEYWORDS:
15946 case PM_CONTEXT_BLOCK_RESCUE:
15947 case PM_CONTEXT_BLOCK_PARAMETERS:
15948 case PM_CONTEXT_DEF_ELSE:
15949 case PM_CONTEXT_DEF_ENSURE:
15950 case PM_CONTEXT_DEF_PARAMS:
15951 case PM_CONTEXT_DEF_RESCUE:
15952 case PM_CONTEXT_DEF:
15953 case PM_CONTEXT_LAMBDA_BRACES:
15954 case PM_CONTEXT_LAMBDA_DO_END:
15955 case PM_CONTEXT_LAMBDA_ELSE:
15956 case PM_CONTEXT_LAMBDA_ENSURE:
15957 case PM_CONTEXT_LAMBDA_RESCUE:
15961 case PM_CONTEXT_NONE:
15962 case PM_CONTEXT_MAXIMUM:
15964 PRISM_ASSERT(
false &&
"unreachable");
15968 if (in_sclass && parser->version >= PM_OPTIONS_VERSION_CRUBY_3_4) {
15969 pm_parser_err_node(parser, node, PM_ERR_RETURN_INVALID);
15978ensure_valid_jump(
pm_parser_t *parser, pm_node_t *node) {
15979 for (pm_context_node_t *context_node = parser->current_context; context_node != NULL; context_node = context_node->prev) {
15980 switch (context_node->context) {
15981 case PM_CONTEXT_BLOCK_BRACES:
15982 case PM_CONTEXT_BLOCK_KEYWORDS:
15983 case PM_CONTEXT_BLOCK_ELSE:
15984 case PM_CONTEXT_BLOCK_ENSURE:
15985 case PM_CONTEXT_BLOCK_PARAMETERS:
15986 case PM_CONTEXT_BLOCK_RESCUE:
15987 case PM_CONTEXT_DEFINED:
15988 case PM_CONTEXT_FOR:
15989 case PM_CONTEXT_LAMBDA_BRACES:
15990 case PM_CONTEXT_LAMBDA_DO_END:
15991 case PM_CONTEXT_LAMBDA_ELSE:
15992 case PM_CONTEXT_LAMBDA_ENSURE:
15993 case PM_CONTEXT_LAMBDA_RESCUE:
15994 case PM_CONTEXT_LOOP_PREDICATE:
15995 case PM_CONTEXT_UNTIL:
15996 case PM_CONTEXT_WHILE:
16000 case PM_CONTEXT_POSTEXE:
16002 if (context_node->context == PM_CONTEXT_POSTEXE) {
16003 if (parser->version < PM_OPTIONS_VERSION_CRUBY_4_1) {
16008 case PM_CONTEXT_DEF:
16009 case PM_CONTEXT_DEF_PARAMS:
16010 case PM_CONTEXT_DEF_ELSE:
16011 case PM_CONTEXT_DEF_ENSURE:
16012 case PM_CONTEXT_DEF_RESCUE:
16013 case PM_CONTEXT_MAIN:
16014 case PM_CONTEXT_PREEXE:
16015 case PM_CONTEXT_SCLASS:
16016 case PM_CONTEXT_SCLASS_ELSE:
16017 case PM_CONTEXT_SCLASS_ENSURE:
16018 case PM_CONTEXT_SCLASS_RESCUE:
16028 PRISM_ASSERT(parser->current_block_exits != NULL);
16029 pm_scratch_node_list_append(&parser->scratch_arena, parser->current_block_exits, node);
16031 case PM_CONTEXT_BEGIN_ELSE:
16032 case PM_CONTEXT_BEGIN_ENSURE:
16033 case PM_CONTEXT_BEGIN_RESCUE:
16034 case PM_CONTEXT_BEGIN:
16035 case PM_CONTEXT_CASE_IN:
16036 case PM_CONTEXT_CASE_WHEN:
16037 case PM_CONTEXT_CLASS_ELSE:
16038 case PM_CONTEXT_CLASS_ENSURE:
16039 case PM_CONTEXT_CLASS_RESCUE:
16040 case PM_CONTEXT_CLASS:
16041 case PM_CONTEXT_DEFAULT_PARAMS:
16042 case PM_CONTEXT_ELSE:
16043 case PM_CONTEXT_ELSIF:
16044 case PM_CONTEXT_EMBEXPR:
16045 case PM_CONTEXT_FOR_INDEX:
16046 case PM_CONTEXT_IF:
16047 case PM_CONTEXT_MODULE_ELSE:
16048 case PM_CONTEXT_MODULE_ENSURE:
16049 case PM_CONTEXT_MODULE_RESCUE:
16050 case PM_CONTEXT_MODULE:
16051 case PM_CONTEXT_MULTI_TARGET:
16052 case PM_CONTEXT_PARENS:
16053 case PM_CONTEXT_PREDICATE:
16054 case PM_CONTEXT_RESCUE_MODIFIER:
16055 case PM_CONTEXT_TERNARY:
16056 case PM_CONTEXT_UNLESS:
16060 case PM_CONTEXT_NONE:
16061 case PM_CONTEXT_MAXIMUM:
16063 PRISM_ASSERT(
false &&
"unreachable");
16076 parser->current_block_exits = current_block_exits;
16077 return previous_block_exits;
16087 pm_node_t *block_exit;
16091 switch (PM_NODE_TYPE(block_exit)) {
16092 case PM_BREAK_NODE:
type =
"break";
break;
16093 case PM_NEXT_NODE:
type =
"next";
break;
16094 case PM_REDO_NODE:
type =
"redo";
break;
16095 default: PRISM_ASSERT(
false &&
"unreachable");
type =
"";
break;
16098 PM_PARSER_ERR_NODE_FORMAT(parser, block_exit, PM_ERR_INVALID_BLOCK_EXIT, type);
16101 parser->current_block_exits = previous_block_exits;
16110 if (match2(parser, PM_TOKEN_KEYWORD_WHILE_MODIFIER, PM_TOKEN_KEYWORD_UNTIL_MODIFIER)) {
16114 parser->current_block_exits = previous_block_exits;
16115 }
else if (previous_block_exits != NULL) {
16121 pm_scratch_node_list_concat(&parser->scratch_arena, previous_block_exits, parser->current_block_exits);
16122 parser->current_block_exits = previous_block_exits;
16127 flush_block_exits(parser, previous_block_exits);
16132parse_predicate(
pm_parser_t *parser, pm_binding_power_t binding_power, pm_context_t context,
pm_token_t *then_keyword, uint16_t depth) {
16133 context_push(parser, PM_CONTEXT_PREDICATE);
16134 pm_diagnostic_id_t error_id = context == PM_CONTEXT_IF ? PM_ERR_CONDITIONAL_IF_PREDICATE : PM_ERR_CONDITIONAL_UNLESS_PREDICATE;
16135 pm_node_t *predicate = parse_value_expression(parser, binding_power, PM_PARSE_ACCEPTS_COMMAND_CALL | PM_PARSE_ACCEPTS_DO_BLOCK, error_id, (uint16_t) (depth + 1));
16138 bool predicate_closed = accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
16140 if (accept1(parser, PM_TOKEN_KEYWORD_THEN)) {
16141 predicate_closed =
true;
16142 *then_keyword = parser->previous;
16145 if (!predicate_closed) {
16146 pm_parser_err_current(parser, PM_ERR_CONDITIONAL_PREDICATE_TERM);
16149 context_pop(parser);
16154parse_conditional(
pm_parser_t *parser, pm_context_t context,
size_t opening_newline_index,
bool if_after_else, uint16_t depth) {
16161 pm_node_t *predicate = parse_predicate(parser, PM_BINDING_POWER_COMPOSITION, context, &then_keyword, (uint16_t) (depth + 1));
16162 pm_statements_node_t *statements = NULL;
16164 if (!match3(parser, PM_TOKEN_KEYWORD_ELSIF, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
16165 pm_accepts_block_stack_push(parser,
true);
16166 statements = parse_statements(parser, context, (uint16_t) (depth + 1));
16167 pm_accepts_block_stack_pop(parser);
16168 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
16171 pm_node_t *parent = NULL;
16174 case PM_CONTEXT_IF:
16175 parent = UP(pm_if_node_create(parser, &keyword, predicate, NTOK2PTR(then_keyword), statements, NULL, NULL));
16177 case PM_CONTEXT_UNLESS:
16178 parent = UP(pm_unless_node_create(parser, &keyword, predicate, NTOK2PTR(then_keyword), statements));
16181 PRISM_ASSERT(
false &&
"unreachable");
16185 pm_node_t *current = parent;
16189 if (context == PM_CONTEXT_IF) {
16190 while (match1(parser, PM_TOKEN_KEYWORD_ELSIF)) {
16191 if (parser_end_of_line_p(parser)) {
16192 PM_PARSER_WARN_TOKEN_FORMAT_CONTENT(parser, &parser->current, PM_WARN_KEYWORD_EOL);
16195 parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword,
false,
false);
16197 parser_lex(parser);
16199 pm_node_t *predicate = parse_predicate(parser, PM_BINDING_POWER_COMPOSITION, PM_CONTEXT_ELSIF, &then_keyword, (uint16_t) (depth + 1));
16200 pm_accepts_block_stack_push(parser,
true);
16202 pm_statements_node_t *statements = parse_statements(parser, PM_CONTEXT_ELSIF, (uint16_t) (depth + 1));
16203 pm_accepts_block_stack_pop(parser);
16204 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
16206 pm_node_t *elsif = UP(pm_if_node_create(parser, &elsif_keyword, predicate, NTOK2PTR(then_keyword), statements, NULL, NULL));
16207 ((pm_if_node_t *) current)->subsequent = elsif;
16212 if (match1(parser, PM_TOKEN_KEYWORD_ELSE)) {
16213 parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword,
false,
false);
16214 opening_newline_index = token_newline_index(parser);
16216 parser_lex(parser);
16219 pm_accepts_block_stack_push(parser,
true);
16220 pm_statements_node_t *else_statements = parse_statements(parser, PM_CONTEXT_ELSE, (uint16_t) (depth + 1));
16221 pm_accepts_block_stack_pop(parser);
16223 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
16224 parser_warn_indentation_mismatch(parser, opening_newline_index, &else_keyword,
false,
false);
16225 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CONDITIONAL_TERM_ELSE, &keyword);
16227 pm_else_node_t *else_node = pm_else_node_create(parser, &else_keyword, else_statements, &parser->previous);
16230 case PM_CONTEXT_IF:
16231 ((pm_if_node_t *) current)->subsequent = UP(else_node);
16233 case PM_CONTEXT_UNLESS:
16234 ((pm_unless_node_t *) parent)->else_clause = else_node;
16237 PRISM_ASSERT(
false &&
"unreachable");
16241 parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword, if_after_else,
false);
16242 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CONDITIONAL_TERM, &keyword);
16247 case PM_CONTEXT_IF: {
16248 pm_node_t *current = parent;
16249 bool recursing =
true;
16251 while (recursing) {
16252 switch (PM_NODE_TYPE(current)) {
16254 pm_if_node_end_keyword_loc_set(parser, (pm_if_node_t *) current, &parser->previous);
16255 current = ((pm_if_node_t *) current)->subsequent;
16256 recursing = current != NULL;
16259 pm_else_node_end_keyword_loc_set(parser, (pm_else_node_t *) current, &parser->previous);
16270 case PM_CONTEXT_UNLESS:
16271 pm_unless_node_end_keyword_loc_set(parser, (pm_unless_node_t *) parent, &parser->previous);
16274 PRISM_ASSERT(
false &&
"unreachable");
16278 pop_block_exits(parser, previous_block_exits);
16286#define PM_CASE_KEYWORD PM_TOKEN_KEYWORD___ENCODING__: case PM_TOKEN_KEYWORD___FILE__: case PM_TOKEN_KEYWORD___LINE__: \
16287 case PM_TOKEN_KEYWORD_ALIAS: case PM_TOKEN_KEYWORD_AND: case PM_TOKEN_KEYWORD_BEGIN: case PM_TOKEN_KEYWORD_BEGIN_UPCASE: \
16288 case PM_TOKEN_KEYWORD_BREAK: case PM_TOKEN_KEYWORD_CASE: case PM_TOKEN_KEYWORD_CLASS: case PM_TOKEN_KEYWORD_DEF: \
16289 case PM_TOKEN_KEYWORD_DEFINED: case PM_TOKEN_KEYWORD_DO: case PM_TOKEN_KEYWORD_DO_BLOCK: case PM_TOKEN_KEYWORD_DO_LAMBDA: case PM_TOKEN_KEYWORD_DO_LOOP: case PM_TOKEN_KEYWORD_ELSE: \
16290 case PM_TOKEN_KEYWORD_ELSIF: case PM_TOKEN_KEYWORD_END: case PM_TOKEN_KEYWORD_END_UPCASE: case PM_TOKEN_KEYWORD_ENSURE: \
16291 case PM_TOKEN_KEYWORD_FALSE: case PM_TOKEN_KEYWORD_FOR: case PM_TOKEN_KEYWORD_IF: case PM_TOKEN_KEYWORD_IN: \
16292 case PM_TOKEN_KEYWORD_MODULE: case PM_TOKEN_KEYWORD_NEXT: case PM_TOKEN_KEYWORD_NIL: case PM_TOKEN_KEYWORD_NOT: \
16293 case PM_TOKEN_KEYWORD_OR: case PM_TOKEN_KEYWORD_REDO: case PM_TOKEN_KEYWORD_RESCUE: case PM_TOKEN_KEYWORD_RETRY: \
16294 case PM_TOKEN_KEYWORD_RETURN: case PM_TOKEN_KEYWORD_SELF: case PM_TOKEN_KEYWORD_SUPER: case PM_TOKEN_KEYWORD_THEN: \
16295 case PM_TOKEN_KEYWORD_TRUE: case PM_TOKEN_KEYWORD_UNDEF: case PM_TOKEN_KEYWORD_UNLESS: case PM_TOKEN_KEYWORD_UNTIL: \
16296 case PM_TOKEN_KEYWORD_WHEN: case PM_TOKEN_KEYWORD_WHILE: case PM_TOKEN_KEYWORD_YIELD
16302#define PM_CASE_OPERATOR PM_TOKEN_AMPERSAND: case PM_TOKEN_BACKTICK: case PM_TOKEN_BANG_EQUAL: \
16303 case PM_TOKEN_BANG_TILDE: case PM_TOKEN_BANG: case PM_TOKEN_BRACKET_LEFT_RIGHT_EQUAL: \
16304 case PM_TOKEN_BRACKET_LEFT_RIGHT: case PM_TOKEN_CARET: case PM_TOKEN_EQUAL_EQUAL_EQUAL: case PM_TOKEN_EQUAL_EQUAL: \
16305 case PM_TOKEN_EQUAL_TILDE: case PM_TOKEN_GREATER_EQUAL: case PM_TOKEN_GREATER_GREATER: case PM_TOKEN_GREATER: \
16306 case PM_TOKEN_LESS_EQUAL_GREATER: case PM_TOKEN_LESS_EQUAL: case PM_TOKEN_LESS_LESS: case PM_TOKEN_LESS: \
16307 case PM_TOKEN_MINUS: case PM_TOKEN_PERCENT: case PM_TOKEN_PIPE: case PM_TOKEN_PLUS: case PM_TOKEN_SLASH: \
16308 case PM_TOKEN_STAR_STAR: case PM_TOKEN_STAR: case PM_TOKEN_TILDE: case PM_TOKEN_UAMPERSAND: case PM_TOKEN_UMINUS: \
16309 case PM_TOKEN_UMINUS_NUM: case PM_TOKEN_UPLUS: case PM_TOKEN_USTAR: case PM_TOKEN_USTAR_STAR
16316#define PM_CASE_PRIMITIVE PM_TOKEN_INTEGER: case PM_TOKEN_INTEGER_IMAGINARY: case PM_TOKEN_INTEGER_RATIONAL: \
16317 case PM_TOKEN_INTEGER_RATIONAL_IMAGINARY: case PM_TOKEN_FLOAT: case PM_TOKEN_FLOAT_IMAGINARY: \
16318 case PM_TOKEN_FLOAT_RATIONAL: case PM_TOKEN_FLOAT_RATIONAL_IMAGINARY: case PM_TOKEN_SYMBOL_BEGIN: \
16319 case PM_TOKEN_REGEXP_BEGIN: case PM_TOKEN_XSTRING_BEGIN: case PM_TOKEN_PERCENT_LOWER_X: case PM_TOKEN_PERCENT_LOWER_I: \
16320 case PM_TOKEN_PERCENT_LOWER_W: case PM_TOKEN_PERCENT_UPPER_I: case PM_TOKEN_PERCENT_UPPER_W: \
16321 case PM_TOKEN_STRING_BEGIN: case PM_TOKEN_KEYWORD_NIL: case PM_TOKEN_KEYWORD_SELF: case PM_TOKEN_KEYWORD_TRUE: \
16322 case PM_TOKEN_KEYWORD_FALSE: case PM_TOKEN_KEYWORD___FILE__: case PM_TOKEN_KEYWORD___LINE__: \
16323 case PM_TOKEN_KEYWORD___ENCODING__: case PM_TOKEN_MINUS_GREATER: case PM_TOKEN_HEREDOC_START: \
16324 case PM_TOKEN_UMINUS_NUM: case PM_TOKEN_CHARACTER_LITERAL
16330#define PM_CASE_PARAMETER PM_TOKEN_UAMPERSAND: case PM_TOKEN_AMPERSAND: case PM_TOKEN_UDOT_DOT_DOT: \
16331 case PM_TOKEN_IDENTIFIER: case PM_TOKEN_LABEL: case PM_TOKEN_USTAR: case PM_TOKEN_STAR: case PM_TOKEN_STAR_STAR: \
16332 case PM_TOKEN_USTAR_STAR: case PM_TOKEN_CONSTANT: case PM_TOKEN_INSTANCE_VARIABLE: case PM_TOKEN_GLOBAL_VARIABLE: \
16333 case PM_TOKEN_CLASS_VARIABLE
16339#define PM_CASE_WRITABLE PM_CLASS_VARIABLE_READ_NODE: case PM_CONSTANT_PATH_NODE: \
16340 case PM_CONSTANT_READ_NODE: case PM_GLOBAL_VARIABLE_READ_NODE: case PM_LOCAL_VARIABLE_READ_NODE: \
16341 case PM_INSTANCE_VARIABLE_READ_NODE: case PM_MULTI_TARGET_NODE: case PM_BACK_REFERENCE_READ_NODE: \
16342 case PM_NUMBERED_REFERENCE_READ_NODE: case PM_IT_LOCAL_VARIABLE_READ_NODE
16346PM_STATIC_ASSERT(__LINE__, ((
int) PM_STRING_FLAGS_FORCED_UTF8_ENCODING) == ((
int) PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING),
"Expected the flags to match.");
16354 if (explicit_encoding != NULL) {
16355 if (explicit_encoding == PM_ENCODING_UTF_8_ENTRY) {
16358 return PM_STRING_FLAGS_FORCED_UTF8_ENCODING;
16359 }
else if (parser->encoding == PM_ENCODING_US_ASCII_ENTRY) {
16364 return PM_STRING_FLAGS_FORCED_BINARY_ENCODING;
16375parse_string_part(
pm_parser_t *parser, uint16_t depth) {
16376 switch (parser->current.type) {
16383 case PM_TOKEN_STRING_CONTENT: {
16384 pm_node_t *node = UP(pm_string_node_create_current_string(parser, NULL, &parser->current, NULL));
16385 pm_node_flag_set(node, parse_unescaped_encoding(parser, parser->explicit_encoding));
16387 parser_lex(parser);
16396 case PM_TOKEN_EMBEXPR_BEGIN: {
16399 parser->explicit_encoding = NULL;
16401 pm_lex_state_t state = parser->lex_state;
16402 int brace_nesting = parser->brace_nesting;
16404 parser->brace_nesting = 0;
16405 lex_state_set(parser, PM_LEX_STATE_BEG);
16406 parser_lex(parser);
16409 pm_statements_node_t *statements = NULL;
16411 if (!match3(parser, PM_TOKEN_EMBEXPR_END, PM_TOKEN_HEREDOC_END, PM_TOKEN_EOF)) {
16412 statements = parse_statements(parser, PM_CONTEXT_EMBEXPR, (uint16_t) (depth + 1));
16415 parser->brace_nesting = brace_nesting;
16416 lex_state_set(parser, state);
16417 expect1(parser, PM_TOKEN_EMBEXPR_END, PM_ERR_EMBEXPR_END);
16422 if (statements != NULL && statements->
body.
size == 1) {
16423 pm_node_flag_unset(statements->
body.
nodes[0], PM_NODE_FLAG_NEWLINE);
16426 return UP(pm_embedded_statements_node_create(parser, &opening, statements, &parser->previous));
16435 case PM_TOKEN_EMBVAR: {
16438 parser->explicit_encoding = NULL;
16440 lex_state_set(parser, PM_LEX_STATE_BEG);
16441 parser_lex(parser);
16444 pm_node_t *variable;
16446 switch (parser->current.type) {
16449 case PM_TOKEN_BACK_REFERENCE:
16450 parser_lex(parser);
16451 variable = UP(pm_back_reference_read_node_create(parser, &parser->previous));
16455 case PM_TOKEN_NUMBERED_REFERENCE:
16456 parser_lex(parser);
16457 variable = UP(pm_numbered_reference_read_node_create(parser, &parser->previous));
16461 case PM_TOKEN_GLOBAL_VARIABLE:
16462 parser_lex(parser);
16463 variable = UP(pm_global_variable_read_node_create(parser, &parser->previous));
16467 case PM_TOKEN_INSTANCE_VARIABLE:
16468 parser_lex(parser);
16469 variable = UP(pm_instance_variable_read_node_create(parser, &parser->previous));
16473 case PM_TOKEN_CLASS_VARIABLE:
16474 parser_lex(parser);
16475 variable = UP(pm_class_variable_read_node_create(parser, &parser->previous));
16481 expect1(parser, PM_TOKEN_IDENTIFIER, PM_ERR_EMBVAR_INVALID);
16482 variable = UP(pm_error_recovery_node_create(parser, PM_TOKEN_END(parser, &parser->previous), 0));
16486 return UP(pm_embedded_variable_node_create(parser, &
operator, variable));
16489 parse_discard_token(parser, depth);
16490 pm_parser_err_previous(parser, PM_ERR_CANNOT_PARSE_STRING_PART);
16500static const uint8_t *
16501parse_operator_symbol_name(
const pm_token_t *name) {
16502 switch (name->
type) {
16503 case PM_TOKEN_TILDE:
16504 case PM_TOKEN_BANG:
16505 if (name->
end[-1] ==
'@')
return name->
end - 1;
16514 pm_symbol_node_t *symbol = pm_symbol_node_create(parser, opening, &parser->current, NULL);
16515 const uint8_t *end = parse_operator_symbol_name(&parser->current);
16517 if (next_state != PM_LEX_STATE_NONE) lex_state_set(parser, next_state);
16518 parser_lex(parser);
16520 pm_string_shared_init(&symbol->
unescaped, parser->previous.
start, end);
16521 pm_node_flag_set(UP(symbol), PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING);
16532parse_symbol(
pm_parser_t *parser, pm_lex_state_t next_state, uint16_t depth) {
16533 pm_lex_mode_t lex_mode = *parser->lex_modes.current;
16534 parser_lex(parser);
16536 const pm_token_t opening = parser->previous;
16538 if (lex_mode.mode != PM_LEX_STRING) {
16539 if (next_state != PM_LEX_STATE_NONE) lex_state_set(parser, next_state);
16541 switch (parser->current.type) {
16542 case PM_CASE_OPERATOR:
16543 return parse_operator_symbol(parser, &opening, next_state == PM_LEX_STATE_NONE ? PM_LEX_STATE_ENDFN : next_state);
16544 case PM_TOKEN_IDENTIFIER:
16545 case PM_TOKEN_CONSTANT:
16546 case PM_TOKEN_INSTANCE_VARIABLE:
16547 case PM_TOKEN_METHOD_NAME:
16548 case PM_TOKEN_CLASS_VARIABLE:
16549 case PM_TOKEN_GLOBAL_VARIABLE:
16550 case PM_TOKEN_NUMBERED_REFERENCE:
16551 case PM_TOKEN_BACK_REFERENCE:
16552 case PM_CASE_KEYWORD:
16553 parser_lex(parser);
16556 expect2(parser, PM_TOKEN_IDENTIFIER, PM_TOKEN_METHOD_NAME, PM_ERR_SYMBOL_INVALID);
16560 pm_symbol_node_t *symbol = pm_symbol_node_create(parser, &opening, &parser->previous, NULL);
16561 pm_string_shared_init(&symbol->
unescaped, parser->previous.
start, parser->previous.
end);
16562 pm_node_flag_set(UP(symbol), parse_symbol_encoding(parser, parser->explicit_encoding, &parser->previous, &symbol->
unescaped,
false));
16567 if (lex_mode.as.string.interpolation) {
16569 if (match1(parser, PM_TOKEN_STRING_END)) {
16570 if (next_state != PM_LEX_STATE_NONE) lex_state_set(parser, next_state);
16571 parser_lex(parser);
16573 .type = PM_TOKEN_STRING_CONTENT,
16574 .start = parser->previous.
start,
16575 .end = parser->previous.
start
16578 return UP(pm_symbol_node_create(parser, &opening, &content, &parser->previous));
16582 pm_node_t *part = parse_string_part(parser, (uint16_t) (depth + 1));
16586 if (part && PM_NODE_TYPE_P(part, PM_STRING_NODE) && match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
16587 if (next_state != PM_LEX_STATE_NONE) lex_state_set(parser, next_state);
16588 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_SYMBOL_TERM_INTERPOLATED);
16590 return UP(pm_string_node_to_symbol_node(parser, (pm_string_node_t *) part, &opening, &parser->previous));
16593 pm_node_list_t parts = { 0 };
16594 if (part) pm_node_list_open_append(&parser->node_chunks, &parts, part);
16596 while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
16597 if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
16598 pm_node_list_open_append(&parser->node_chunks, &parts, part);
16602 if (next_state != PM_LEX_STATE_NONE) lex_state_set(parser, next_state);
16603 if (match1(parser, PM_TOKEN_EOF)) {
16604 pm_parser_err_token(parser, &opening, PM_ERR_SYMBOL_TERM_INTERPOLATED);
16605 return UP(pm_interpolated_symbol_node_create(parser, &opening, &parts, NULL));
16608 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_SYMBOL_TERM_INTERPOLATED);
16609 return UP(pm_interpolated_symbol_node_create(parser, &opening, &parts, &parser->previous));
16615 if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
16616 content = parser->current;
16617 unescaped = parser->current_string;
16618 parser_lex(parser);
16629 if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
16630 pm_node_list_t parts = { 0 };
16631 pm_node_t *part = UP(pm_string_node_create_unescaped(parser, NULL, &content, NULL, &unescaped));
16632 pm_node_list_open_append(&parser->node_chunks, &parts, part);
16634 part = UP(pm_string_node_create_unescaped(parser, NULL, &parser->current, NULL, &parser->current_string));
16635 pm_node_list_open_append(&parser->node_chunks, &parts, part);
16637 if (next_state != PM_LEX_STATE_NONE) {
16638 lex_state_set(parser, next_state);
16641 parser_lex(parser);
16642 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_SYMBOL_TERM_DYNAMIC);
16644 return UP(pm_interpolated_symbol_node_create(parser, &opening, &parts, &parser->previous));
16647 content = (
pm_token_t) { .type = PM_TOKEN_STRING_CONTENT, .start = parser->previous.
end, .end = parser->previous.
end };
16648 pm_string_shared_init(&unescaped, content.
start, content.
end);
16651 if (next_state != PM_LEX_STATE_NONE) {
16652 lex_state_set(parser, next_state);
16656 if (match1(parser, PM_TOKEN_EOF)) {
16657 pm_parser_err_token(parser, &opening, PM_ERR_SYMBOL_TERM_DYNAMIC);
16659 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_SYMBOL_TERM_DYNAMIC);
16660 closing = &parser->previous;
16663 return UP(pm_symbol_node_create_unescaped(parser, &opening, &content, closing, &unescaped, parse_symbol_encoding(parser, parser->explicit_encoding, &content, &unescaped,
false)));
16671parse_undef_argument(
pm_parser_t *parser, uint16_t depth) {
16672 switch (parser->current.type) {
16673 case PM_CASE_OPERATOR:
16674 return parse_operator_symbol(parser, NULL, PM_LEX_STATE_NONE);
16675 case PM_CASE_KEYWORD:
16676 case PM_TOKEN_CONSTANT:
16677 case PM_TOKEN_IDENTIFIER:
16678 case PM_TOKEN_METHOD_NAME: {
16679 parser_lex(parser);
16681 pm_symbol_node_t *symbol = pm_symbol_node_create(parser, NULL, &parser->previous, NULL);
16682 pm_string_shared_init(&symbol->
unescaped, parser->previous.
start, parser->previous.
end);
16683 pm_node_flag_set(UP(symbol), parse_symbol_encoding(parser, parser->explicit_encoding, &parser->previous, &symbol->
unescaped,
false));
16687 case PM_TOKEN_SYMBOL_BEGIN:
16688 return parse_symbol(parser, PM_LEX_STATE_NONE, (uint16_t) (depth + 1));
16690 pm_parser_err_current(parser, PM_ERR_UNDEF_ARGUMENT);
16691 return UP(pm_error_recovery_node_create(parser, PM_TOKEN_END(parser, &parser->previous), 0));
16702parse_alias_argument(
pm_parser_t *parser,
bool first, uint16_t depth) {
16703 switch (parser->current.type) {
16704 case PM_CASE_OPERATOR:
16705 return parse_operator_symbol(parser, NULL, first ? PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM : PM_LEX_STATE_NONE);
16706 case PM_CASE_KEYWORD:
16707 case PM_TOKEN_CONSTANT:
16708 case PM_TOKEN_IDENTIFIER:
16709 case PM_TOKEN_METHOD_NAME: {
16710 if (first) lex_state_set(parser, PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM);
16711 parser_lex(parser);
16713 pm_symbol_node_t *symbol = pm_symbol_node_create(parser, NULL, &parser->previous, NULL);
16714 pm_string_shared_init(&symbol->
unescaped, parser->previous.
start, parser->previous.
end);
16715 pm_node_flag_set(UP(symbol), parse_symbol_encoding(parser, parser->explicit_encoding, &parser->previous, &symbol->
unescaped,
false));
16719 case PM_TOKEN_SYMBOL_BEGIN:
16720 return parse_symbol(parser, first ? PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM : PM_LEX_STATE_NONE, (uint16_t) (depth + 1));
16721 case PM_TOKEN_BACK_REFERENCE:
16722 parser_lex(parser);
16723 return UP(pm_back_reference_read_node_create(parser, &parser->previous));
16724 case PM_TOKEN_NUMBERED_REFERENCE:
16725 parser_lex(parser);
16726 return UP(pm_numbered_reference_read_node_create(parser, &parser->previous));
16727 case PM_TOKEN_GLOBAL_VARIABLE:
16728 parser_lex(parser);
16729 return UP(pm_global_variable_read_node_create(parser, &parser->previous));
16731 pm_parser_err_current(parser, PM_ERR_ALIAS_ARGUMENT);
16732 return UP(pm_error_recovery_node_create(parser, PM_TOKEN_END(parser, &parser->previous), 0));
16742 pm_constant_id_t name_id = pm_parser_constant_id_token(parser, &parser->previous);
16744 bool is_numbered_param = pm_token_is_numbered_parameter(parser, PM_TOKEN_START(parser, &parser->previous), PM_TOKEN_LENGTH(&parser->previous));
16746 if (!is_numbered_param && ((depth = pm_parser_local_depth_constant_id(parser, name_id)) != -1)) {
16747 return UP(pm_local_variable_read_node_create_constant_id(parser, &parser->previous, name_id, (uint32_t) depth,
false));
16750 pm_scope_t *current_scope = parser->current_scope;
16751 if (!current_scope->closed && !(current_scope->parameters & PM_SCOPE_PARAMETERS_IMPLICIT_DISALLOWED)) {
16752 if (is_numbered_param) {
16757 uint8_t maximum = (uint8_t) (parser->previous.
start[1] -
'0');
16758 for (uint8_t number = 1; number <= maximum; number++) {
16759 pm_parser_local_add_constant(parser, pm_numbered_parameter_names[number - 1], 2);
16762 if (!match1(parser, PM_TOKEN_EQUAL)) {
16763 parser->current_scope->parameters |= PM_SCOPE_PARAMETERS_NUMBERED_FOUND;
16766 pm_node_t *node = UP(pm_local_variable_read_node_create_constant_id(parser, &parser->previous, name_id, 0,
false));
16767 pm_scratch_node_list_append(&parser->scratch_arena, ¤t_scope->implicit_parameters, node);
16770 }
else if ((parser->version >= PM_OPTIONS_VERSION_CRUBY_3_4) && pm_token_is_it(parser->previous.
start, parser->previous.
end)) {
16771 pm_node_t *node = UP(pm_it_local_variable_read_node_create(parser, &parser->previous));
16772 pm_scratch_node_list_append(&parser->scratch_arena, ¤t_scope->implicit_parameters, node);
16786 pm_node_flags_t flags = 0;
16788 if (!match1(parser, PM_TOKEN_PARENTHESIS_LEFT) && (parser->previous.
end[-1] !=
'!') && (parser->previous.
end[-1] !=
'?')) {
16789 pm_node_t *node = parse_variable(parser);
16790 if (node != NULL)
return node;
16791 flags |= PM_CALL_NODE_FLAGS_VARIABLE_CALL;
16794 pm_call_node_t *node = pm_call_node_variable_call_create(parser, &parser->previous);
16795 pm_node_flag_set(UP(node), flags);
16806parse_method_definition_name(
pm_parser_t *parser) {
16807 switch (parser->current.type) {
16808 case PM_CASE_KEYWORD:
16809 case PM_TOKEN_CONSTANT:
16810 case PM_TOKEN_METHOD_NAME:
16811 parser_lex(parser);
16812 return parser->previous;
16813 case PM_TOKEN_IDENTIFIER:
16814 pm_refute_numbered_parameter(parser, PM_TOKEN_START(parser, &parser->current), PM_TOKEN_LENGTH(&parser->current));
16815 parser_lex(parser);
16816 return parser->previous;
16817 case PM_CASE_OPERATOR:
16818 lex_state_set(parser, PM_LEX_STATE_ENDFN);
16819 parser_lex(parser);
16820 return parser->previous;
16822 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_DEF_NAME, pm_token_str(parser->current.type));
16823 return (
pm_token_t) { .type = 0, .start = parser->current.start, .end = parser->current.end };
16833 size_t length = pm_string_length(
string);
16834 uint8_t *writable = (uint8_t *) pm_arena_memdup(arena, pm_string_source(
string), length,
PRISM_ALIGNOF(uint8_t));
16835 pm_string_init(
string, writable, length);
16840 size_t dest_length = pm_string_length(
string);
16841 const uint8_t *source_cursor = writable;
16842 const uint8_t *source_end = source_cursor + dest_length;
16847 size_t trimmed_whitespace = 0;
16853 while ((source_cursor < source_end) && pm_char_is_inline_whitespace(*source_cursor) && trimmed_whitespace < common_whitespace) {
16854 if (*source_cursor ==
'\t') {
16855 trimmed_whitespace = (trimmed_whitespace / PM_TAB_WHITESPACE_SIZE + 1) * PM_TAB_WHITESPACE_SIZE;
16856 if (trimmed_whitespace > common_whitespace)
break;
16858 trimmed_whitespace++;
16865 memmove(writable, source_cursor, (
size_t) (source_end - source_cursor));
16866 string->length = dest_length;
16874heredoc_dedent_discard_string_node(
pm_parser_t *parser, pm_string_node_t *string_node) {
16876 const uint8_t *cursor = parser->start + PM_LOCATION_START(&string_node->
content_loc);
16877 return pm_memchr(cursor,
'\\', string_node->
content_loc.
length, parser->encoding_changed, parser->encoding) == NULL;
16886parse_heredoc_dedent(
pm_parser_t *parser, pm_node_list_t *nodes,
size_t common_whitespace) {
16889 bool dedent_next =
true;
16893 uint32_t write_index = 0;
16900 if (!PM_NODE_TYPE_P(node, PM_STRING_NODE)) {
16901 nodes->
nodes[write_index++] = node;
16902 dedent_next =
false;
16906 pm_string_node_t *string_node = ((pm_string_node_t *) node);
16908 parse_heredoc_dedent_string(parser->arena, &string_node->
unescaped, common_whitespace);
16911 if (heredoc_dedent_discard_string_node(parser, string_node)) {
16913 nodes->
nodes[write_index++] = node;
16917 dedent_next =
true;
16920 nodes->
size = write_index;
16927parse_strings_empty_content(
const uint8_t *location) {
16928 return (
pm_token_t) { .type = PM_TOKEN_STRING_CONTENT, .start = location, .end = location };
16935parse_strings(
pm_parser_t *parser, pm_node_t *current,
bool accepts_label, uint16_t depth) {
16936 PRISM_ASSERT(parser->current.type == PM_TOKEN_STRING_BEGIN);
16937 bool concating =
false;
16938 pm_node_list_t container = { 0 };
16940 while (match1(parser, PM_TOKEN_STRING_BEGIN)) {
16941 pm_node_t *node = NULL;
16945 const pm_lex_mode_t *lex_mode = parser->lex_modes.current;
16946 PRISM_ASSERT(lex_mode->mode == PM_LEX_STRING);
16947 bool lex_interpolation = lex_mode->as.string.interpolation;
16948 bool label_allowed = lex_mode->as.string.label_allowed && accepts_label;
16951 parser_lex(parser);
16953 if (match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
16954 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_STRING_LITERAL_EOF);
16958 pm_token_t content = parse_strings_empty_content(parser->previous.
start);
16959 pm_string_node_t *
string = pm_string_node_create(parser, &opening, &content, &parser->previous);
16963 }
else if (accept1(parser, PM_TOKEN_LABEL_END)) {
16967 pm_symbol_node_t *symbol = pm_symbol_node_create(parser, &opening, NULL, &parser->previous);
16968 pm_string_shared_init(&symbol->
unescaped, parser->previous.
start, parser->previous.
start);
16971 if (!label_allowed) pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_LABEL);
16972 }
else if (!lex_interpolation) {
16978 if (match1(parser, PM_TOKEN_EOF)) {
16979 unescaped = PM_STRING_EMPTY;
16980 content = (
pm_token_t) { .type = PM_TOKEN_STRING_CONTENT, .start = parser->start, .end = parser->start };
16982 unescaped = parser->current_string;
16983 expect1(parser, PM_TOKEN_STRING_CONTENT, PM_ERR_EXPECT_STRING_CONTENT);
16984 content = parser->previous;
16998 if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
16999 pm_node_list_t parts = { 0 };
17000 pm_node_t *part = UP(pm_string_node_create_unescaped(parser, NULL, &content, NULL, &unescaped));
17001 pm_node_list_open_append(&parser->node_chunks, &parts, part);
17004 part = UP(pm_string_node_create_current_string(parser, NULL, &parser->current, NULL));
17005 pm_node_list_open_append(&parser->node_chunks, &parts, part);
17006 parser_lex(parser);
17007 }
while (match1(parser, PM_TOKEN_STRING_CONTENT));
17009 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_STRING_LITERAL_EOF);
17010 node = UP(pm_interpolated_string_node_create(parser, &opening, &parts, &parser->previous));
17011 }
else if (accept1(parser, PM_TOKEN_LABEL_END)) {
17012 node = UP(pm_symbol_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped, parse_symbol_encoding(parser, parser->explicit_encoding, &content, &unescaped,
true)));
17013 if (!label_allowed) pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_LABEL);
17014 }
else if (match1(parser, PM_TOKEN_EOF)) {
17015 pm_parser_err_token(parser, &opening, PM_ERR_STRING_LITERAL_EOF);
17016 node = UP(pm_string_node_create_unescaped(parser, &opening, &content, &parser->current, &unescaped));
17017 }
else if (accept1(parser, PM_TOKEN_STRING_END)) {
17018 node = UP(pm_string_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped));
17020 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->previous, PM_ERR_STRING_LITERAL_TERM, pm_token_str(parser->previous.
type));
17021 parser->previous.
start = parser->previous.
end;
17022 parser->previous.
type = 0;
17023 node = UP(pm_string_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped));
17025 }
else if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
17032 const pm_encoding_t *explicit_encoding = parser->explicit_encoding;
17033 bool joined_at_eof = lex_mode->as.string.joined_at_eof;
17034 parser_lex(parser);
17036 if (match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
17037 node = UP(pm_string_node_create_unescaped(parser, &opening, &content, &parser->current, &unescaped));
17038 pm_node_flag_set(node, parse_unescaped_encoding(parser, explicit_encoding));
17040 if (!accept1(parser, PM_TOKEN_STRING_END)) {
17041 if (joined_at_eof) {
17044 pm_parser_err_token(parser, &opening, PM_ERR_STRING_INTERPOLATED_TERM);
17048 const uint8_t *location = parser->previous.
end;
17049 if (location > parser->start && location[-1] ==
'\n') location--;
17050 pm_parser_err(parser, U32(location - parser->start), 0, PM_ERR_STRING_LITERAL_EOF);
17053 parser->previous.
start = parser->previous.
end;
17054 parser->previous.
type = 0;
17056 }
else if (accept1(parser, PM_TOKEN_LABEL_END)) {
17057 node = UP(pm_symbol_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped, parse_symbol_encoding(parser, explicit_encoding, &content, &unescaped,
true)));
17058 if (!label_allowed) pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_LABEL);
17062 pm_node_list_t parts = { 0 };
17063 pm_node_t *part = UP(pm_string_node_create_unescaped(parser, NULL, &parser->previous, NULL, &unescaped));
17064 pm_node_flag_set(part, parse_unescaped_encoding(parser, explicit_encoding));
17065 pm_node_list_open_append(&parser->node_chunks, &parts, part);
17067 while (!match3(parser, PM_TOKEN_STRING_END, PM_TOKEN_LABEL_END, PM_TOKEN_EOF)) {
17068 if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
17069 pm_node_list_open_append(&parser->node_chunks, &parts, part);
17073 if (accept1(parser, PM_TOKEN_LABEL_END)) {
17074 node = UP(pm_interpolated_symbol_node_create(parser, &opening, &parts, &parser->previous));
17075 if (!label_allowed) pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_LABEL);
17076 }
else if (match1(parser, PM_TOKEN_EOF)) {
17077 pm_parser_err_token(parser, &opening, PM_ERR_STRING_INTERPOLATED_TERM);
17078 node = UP(pm_interpolated_string_node_create(parser, &opening, &parts, &parser->current));
17080 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_STRING_INTERPOLATED_TERM);
17081 node = UP(pm_interpolated_string_node_create(parser, &opening, &parts, &parser->previous));
17088 pm_node_list_t parts = { 0 };
17091 while (!match3(parser, PM_TOKEN_STRING_END, PM_TOKEN_LABEL_END, PM_TOKEN_EOF)) {
17092 if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
17093 pm_node_list_open_append(&parser->node_chunks, &parts, part);
17097 if (accept1(parser, PM_TOKEN_LABEL_END)) {
17098 node = UP(pm_interpolated_symbol_node_create(parser, &opening, &parts, &parser->previous));
17099 if (!label_allowed) pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_LABEL);
17100 }
else if (match1(parser, PM_TOKEN_EOF)) {
17101 pm_parser_err_token(parser, &opening, PM_ERR_STRING_INTERPOLATED_TERM);
17102 node = UP(pm_interpolated_string_node_create(parser, &opening, &parts, &parser->current));
17104 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_STRING_INTERPOLATED_TERM);
17105 node = UP(pm_interpolated_string_node_create(parser, &opening, &parts, &parser->previous));
17109 if (current == NULL) {
17113 if (PM_NODE_TYPE_P(node, PM_SYMBOL_NODE) || PM_NODE_TYPE_P(node, PM_INTERPOLATED_SYMBOL_NODE)) {
17124 if (!PM_NODE_TYPE_P(node, PM_STRING_NODE) && !PM_NODE_TYPE_P(node, PM_INTERPOLATED_STRING_NODE)) {
17125 pm_parser_err_node(parser, node, PM_ERR_STRING_CONCATENATION);
17131 if (!PM_NODE_TYPE_P(current, PM_STRING_NODE) && !PM_NODE_TYPE_P(current, PM_INTERPOLATED_STRING_NODE)) {
17132 pm_parser_err_node(parser, current, PM_ERR_STRING_CONCATENATION);
17136 pm_node_list_open_append(&parser->node_chunks, &container, current);
17139 pm_node_list_open_append(&parser->node_chunks, &container, node);
17144 return UP(pm_interpolated_string_node_create(parser, NULL, &container, NULL));
17150#define PM_PARSE_PATTERN_SINGLE 0
17151#define PM_PARSE_PATTERN_TOP 1
17152#define PM_PARSE_PATTERN_MULTI 2
17165 if (peek_at(parser, parser->start + location->
start) ==
'_')
return;
17167 if (!pm_constant_id_set_insert(&parser->scratch_arena, captures, capture)) {
17168 pm_parser_err(parser, location->
start, location->
length, PM_ERR_PATTERN_CAPTURE_DUPLICATE);
17179 while (accept1(parser, PM_TOKEN_COLON_COLON)) {
17181 expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
17182 node = UP(pm_constant_path_node_create(parser, node, &delimiter, &parser->previous));
17188 if (!match2(parser, PM_TOKEN_BRACKET_LEFT, PM_TOKEN_PARENTHESIS_LEFT)) {
17194 pm_node_t *inner = NULL;
17196 if (accept1(parser, PM_TOKEN_BRACKET_LEFT)) {
17197 opening = parser->previous;
17198 accept1(parser, PM_TOKEN_NEWLINE);
17200 if (!accept1(parser, PM_TOKEN_BRACKET_RIGHT)) {
17201 inner = parse_pattern(parser, captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET, (uint16_t) (depth + 1));
17202 accept1(parser, PM_TOKEN_NEWLINE);
17203 expect1_opening(parser, PM_TOKEN_BRACKET_RIGHT, PM_ERR_PATTERN_TERM_BRACKET, &opening);
17206 closing = parser->previous;
17208 parser_lex(parser);
17209 opening = parser->previous;
17210 accept1(parser, PM_TOKEN_NEWLINE);
17212 if (!accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
17213 inner = parse_pattern(parser, captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_PAREN, (uint16_t) (depth + 1));
17214 accept1(parser, PM_TOKEN_NEWLINE);
17215 expect1_opening(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN, &opening);
17218 closing = parser->previous;
17224 return UP(pm_array_pattern_node_constant_create(parser, node, &opening, NULL, &closing));
17231 switch (PM_NODE_TYPE(inner)) {
17232 case PM_ARRAY_PATTERN_NODE: {
17233 pm_array_pattern_node_t *pattern_node = (pm_array_pattern_node_t *) inner;
17236 PM_NODE_START_SET_NODE(pattern_node, node);
17237 PM_NODE_LENGTH_SET_TOKEN(parser, pattern_node, &closing);
17240 pattern_node->
opening_loc = TOK2LOC(parser, &opening);
17241 pattern_node->
closing_loc = TOK2LOC(parser, &closing);
17243 return UP(pattern_node);
17248 case PM_FIND_PATTERN_NODE: {
17249 pm_find_pattern_node_t *pattern_node = (pm_find_pattern_node_t *) inner;
17252 PM_NODE_START_SET_NODE(pattern_node, node);
17253 PM_NODE_LENGTH_SET_TOKEN(parser, pattern_node, &closing);
17256 pattern_node->
opening_loc = TOK2LOC(parser, &opening);
17257 pattern_node->
closing_loc = TOK2LOC(parser, &closing);
17259 return UP(pattern_node);
17264 case PM_HASH_PATTERN_NODE: {
17265 pm_hash_pattern_node_t *pattern_node = (pm_hash_pattern_node_t *) inner;
17268 PM_NODE_START_SET_NODE(pattern_node, node);
17269 PM_NODE_LENGTH_SET_TOKEN(parser, pattern_node, &closing);
17272 pattern_node->
opening_loc = TOK2LOC(parser, &opening);
17273 pattern_node->
closing_loc = TOK2LOC(parser, &closing);
17275 return UP(pattern_node);
17287 return UP(pm_array_pattern_node_constant_create(parser, node, &opening, inner, &closing));
17293static pm_splat_node_t *
17295 PRISM_ASSERT(parser->previous.
type == PM_TOKEN_USTAR);
17297 pm_node_t *name = NULL;
17302 if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
17303 pm_constant_id_t constant_id = pm_parser_constant_id_token(parser, &parser->previous);
17306 if ((depth = pm_parser_local_depth_constant_id(parser, constant_id)) == -1) {
17307 pm_parser_local_add(parser, constant_id, parser->previous.
start, parser->previous.
end, 0);
17310 pm_location_t previous_loc = TOK2LOC(parser, &parser->previous);
17311 parse_pattern_capture(parser, captures, constant_id, &previous_loc);
17312 name = UP(pm_local_variable_target_node_create(
17316 (uint32_t) (depth == -1 ? 0 : depth)
17321 return pm_splat_node_create(parser, &
operator, name);
17329 PRISM_ASSERT(parser->current.type == PM_TOKEN_USTAR_STAR);
17330 parser_lex(parser);
17333 pm_node_t *value = NULL;
17335 if (accept1(parser, PM_TOKEN_KEYWORD_NIL)) {
17336 return UP(pm_no_keywords_parameter_node_create(parser, &
operator, &parser->previous));
17339 if (accept1(parser, PM_TOKEN_IDENTIFIER)) {
17340 pm_constant_id_t constant_id = pm_parser_constant_id_token(parser, &parser->previous);
17343 if ((depth = pm_parser_local_depth_constant_id(parser, constant_id)) == -1) {
17344 pm_parser_local_add(parser, constant_id, parser->previous.
start, parser->previous.
end, 0);
17347 pm_location_t previous_loc = TOK2LOC(parser, &parser->previous);
17348 parse_pattern_capture(parser, captures, constant_id, &previous_loc);
17349 value = UP(pm_local_variable_target_node_create(
17353 (uint32_t) (depth == -1 ? 0 : depth)
17357 return UP(pm_assoc_splat_node_create(parser, value, &
operator));
17365pm_slice_is_valid_local(
const pm_parser_t *parser,
const uint8_t *start,
const uint8_t *end) {
17366 ptrdiff_t length = end - start;
17367 if (length == 0)
return false;
17370 size_t width = char_is_identifier_start(parser, start, end - start);
17371 if (width == 0)
return false;
17374 if (parser->encoding_changed) {
17375 if (pm_encoding_isupper_char(parser->encoding, start, length, parser->version))
return false;
17377 if (pm_encoding_utf_8_isupper_char(start, length, parser->version))
return false;
17382 const uint8_t *cursor = start + width;
17383 while ((width = char_is_identifier(parser, cursor, end - cursor))) cursor += width;
17384 return cursor == end;
17393 const pm_location_t *value_loc = &((pm_symbol_node_t *) key)->content_loc;
17394 const uint8_t *start = parser->start + PM_LOCATION_START(value_loc);
17395 const uint8_t *end = parser->start + PM_LOCATION_END(value_loc);
17397 pm_constant_id_t constant_id = pm_parser_constant_id_raw(parser, start, end);
17400 if (pm_slice_is_valid_local(parser, start, end)) {
17401 depth = pm_parser_local_depth_constant_id(parser, constant_id);
17403 pm_parser_err(parser, PM_NODE_START(key), PM_NODE_LENGTH(key), PM_ERR_PATTERN_HASH_KEY_LOCALS);
17405 if ((end > start) && ((end[-1] ==
'!') || (end[-1] ==
'?'))) {
17406 PM_PARSER_ERR_FORMAT(parser, value_loc->
start, value_loc->
length, PM_ERR_INVALID_LOCAL_VARIABLE_WRITE, (
int) (end - start), (
const char *) start);
17411 pm_parser_local_add(parser, constant_id, start, end, 0);
17414 parse_pattern_capture(parser, captures, constant_id, value_loc);
17415 pm_local_variable_target_node_t *target = pm_local_variable_target_node_create(
17419 (uint32_t) (depth == -1 ? 0 : depth)
17422 return UP(pm_implicit_node_create(parser, UP(target)));
17431 if (pm_static_literals_add(parser, keys, node,
true) != NULL) {
17432 pm_parser_err_node(parser, node, PM_ERR_PATTERN_HASH_KEY_DUPLICATE);
17439static pm_hash_pattern_node_t *
17441 pm_node_list_t assocs = { 0 };
17443 pm_node_t *rest = NULL;
17445 switch (PM_NODE_TYPE(first_node)) {
17446 case PM_ASSOC_SPLAT_NODE:
17447 case PM_NO_KEYWORDS_PARAMETER_NODE:
17450 case PM_INTERPOLATED_SYMBOL_NODE:
17451 case PM_SYMBOL_NODE: {
17452 if (pm_symbol_node_label_p(parser, first_node)) {
17453 if (PM_NODE_TYPE_P(first_node, PM_INTERPOLATED_SYMBOL_NODE)) {
17454 pm_parser_err_node(parser, first_node, PM_ERR_PATTERN_HASH_KEY_INTERPOLATED);
17456 parse_pattern_hash_key(parser, &keys, first_node);
17466 if (!token_begins_pattern_p(parser->current.type)) {
17467 if (PM_NODE_TYPE_P(first_node, PM_SYMBOL_NODE)) {
17468 value = parse_pattern_hash_implicit_value(parser, captures, (pm_symbol_node_t *) first_node);
17470 value = UP(pm_error_recovery_node_create(parser, PM_NODE_END(first_node), 0));
17475 value = parse_pattern(parser, captures, PM_PARSE_PATTERN_SINGLE, PM_ERR_PATTERN_EXPRESSION_AFTER_KEY, (uint16_t) (depth + 1));
17478 pm_node_t *assoc = UP(pm_assoc_node_create(parser, first_node, NULL, value));
17479 pm_node_list_open_append(&parser->node_chunks, &assocs, assoc);
17488 pm_diagnostic_id_t diag_id = PM_NODE_TYPE_P(first_node, PM_INTERPOLATED_SYMBOL_NODE) ? PM_ERR_PATTERN_HASH_KEY_INTERPOLATED : PM_ERR_PATTERN_HASH_KEY_LABEL;
17489 pm_parser_err_node(parser, first_node, diag_id);
17491 pm_node_t *value = UP(pm_error_recovery_node_create(parser, PM_NODE_START(first_node), PM_NODE_LENGTH(first_node)));
17492 pm_node_t *assoc = UP(pm_assoc_node_create(parser, first_node, NULL, value));
17494 pm_node_list_open_append(&parser->node_chunks, &assocs, assoc);
17500 while (accept1(parser, PM_TOKEN_COMMA)) {
17506 if (!token_begins_pattern_p(parser->current.type)) {
17508 if (rest != NULL) {
17509 pm_parser_err_token(parser, &parser->current, PM_ERR_PATTERN_EXPRESSION_AFTER_REST);
17515 if (match1(parser, PM_TOKEN_USTAR_STAR)) {
17516 pm_node_t *assoc = parse_pattern_keyword_rest(parser, captures);
17518 if (rest == NULL) {
17521 pm_parser_err_node(parser, assoc, PM_ERR_PATTERN_EXPRESSION_AFTER_REST);
17522 pm_node_list_open_append(&parser->node_chunks, &assocs, assoc);
17527 if (match1(parser, PM_TOKEN_STRING_BEGIN)) {
17528 key = parse_strings(parser, NULL,
true, (uint16_t) (depth + 1));
17530 if (PM_NODE_TYPE_P(key, PM_INTERPOLATED_SYMBOL_NODE)) {
17531 pm_parser_err_node(parser, key, PM_ERR_PATTERN_HASH_KEY_INTERPOLATED);
17532 }
else if (!pm_symbol_node_label_p(parser, key)) {
17533 pm_parser_err_node(parser, key, PM_ERR_PATTERN_LABEL_AFTER_COMMA);
17535 }
else if (accept1(parser, PM_TOKEN_LABEL)) {
17536 key = UP(pm_symbol_node_label_create(parser, &parser->previous));
17538 expect1(parser, PM_TOKEN_LABEL, PM_ERR_PATTERN_LABEL_AFTER_COMMA);
17540 pm_token_t label = { .type = PM_TOKEN_LABEL, .start = parser->previous.
end, .end = parser->previous.
end };
17541 key = UP(pm_symbol_node_create(parser, NULL, &label, NULL));
17544 parse_pattern_hash_key(parser, &keys, key);
17545 pm_node_t *value = NULL;
17552 if (!token_begins_pattern_p(parser->current.type)) {
17553 if (PM_NODE_TYPE_P(key, PM_SYMBOL_NODE)) {
17554 value = parse_pattern_hash_implicit_value(parser, captures, (pm_symbol_node_t *) key);
17556 value = UP(pm_error_recovery_node_create(parser, PM_NODE_END(key), 0));
17559 value = parse_pattern(parser, captures, PM_PARSE_PATTERN_SINGLE, PM_ERR_PATTERN_EXPRESSION_AFTER_KEY, (uint16_t) (depth + 1));
17562 pm_node_t *assoc = UP(pm_assoc_node_create(parser, key, NULL, value));
17564 if (rest != NULL) {
17565 pm_parser_err_node(parser, assoc, PM_ERR_PATTERN_EXPRESSION_AFTER_REST);
17568 pm_node_list_open_append(&parser->node_chunks, &assocs, assoc);
17572 pm_hash_pattern_node_t *node = pm_hash_pattern_node_node_list_create(parser, &assocs, rest);
17574 pm_static_literals_free(&keys);
17583 switch (parser->current.type) {
17584 case PM_TOKEN_IDENTIFIER:
17585 case PM_TOKEN_METHOD_NAME: {
17586 parser_lex(parser);
17587 pm_constant_id_t constant_id = pm_parser_constant_id_token(parser, &parser->previous);
17590 if ((depth = pm_parser_local_depth_constant_id(parser, constant_id)) == -1) {
17591 pm_parser_local_add(parser, constant_id, parser->previous.
start, parser->previous.
end, 0);
17594 pm_location_t previous_loc = TOK2LOC(parser, &parser->previous);
17595 parse_pattern_capture(parser, captures, constant_id, &previous_loc);
17596 return UP(pm_local_variable_target_node_create(
17600 (uint32_t) (depth == -1 ? 0 : depth)
17603 case PM_TOKEN_BRACKET_LEFT_ARRAY: {
17605 parser_lex(parser);
17607 if (accept1(parser, PM_TOKEN_BRACKET_RIGHT)) {
17610 return UP(pm_array_pattern_node_bracket_create(parser, &opening, NULL, &parser->previous));
17615 pm_node_t *inner = parse_pattern(parser, captures, PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_BRACKET, (uint16_t) (depth + 1));
17617 accept1(parser, PM_TOKEN_NEWLINE);
17618 expect1_opening(parser, PM_TOKEN_BRACKET_RIGHT, PM_ERR_PATTERN_TERM_BRACKET, &opening);
17621 switch (PM_NODE_TYPE(inner)) {
17622 case PM_ARRAY_PATTERN_NODE: {
17623 pm_array_pattern_node_t *pattern_node = (pm_array_pattern_node_t *) inner;
17625 PM_NODE_START_SET_TOKEN(parser, pattern_node, &opening);
17626 PM_NODE_LENGTH_SET_TOKEN(parser, pattern_node, &closing);
17628 pattern_node->
opening_loc = TOK2LOC(parser, &opening);
17629 pattern_node->
closing_loc = TOK2LOC(parser, &closing);
17631 return UP(pattern_node);
17636 case PM_FIND_PATTERN_NODE: {
17637 pm_find_pattern_node_t *pattern_node = (pm_find_pattern_node_t *) inner;
17639 PM_NODE_START_SET_TOKEN(parser, pattern_node, &opening);
17640 PM_NODE_LENGTH_SET_TOKEN(parser, pattern_node, &closing);
17642 pattern_node->
opening_loc = TOK2LOC(parser, &opening);
17643 pattern_node->
closing_loc = TOK2LOC(parser, &closing);
17645 return UP(pattern_node);
17654 return UP(pm_array_pattern_node_bracket_create(parser, &opening, inner, &closing));
17656 case PM_TOKEN_BRACE_LEFT_HASH: {
17657 bool previous_pattern_matching_newlines = parser->pattern_matching_newlines;
17658 parser->pattern_matching_newlines =
false;
17660 pm_hash_pattern_node_t *node;
17662 parser_lex(parser);
17664 if (accept1(parser, PM_TOKEN_BRACE_RIGHT)) {
17667 node = pm_hash_pattern_node_empty_create(parser, &opening, &parser->previous);
17669 pm_node_t *first_node;
17671 switch (parser->current.type) {
17672 case PM_TOKEN_LABEL:
17673 parser_lex(parser);
17674 first_node = UP(pm_symbol_node_label_create(parser, &parser->previous));
17676 case PM_TOKEN_USTAR_STAR:
17677 first_node = parse_pattern_keyword_rest(parser, captures);
17679 case PM_TOKEN_STRING_BEGIN:
17680 first_node = parse_expression(parser, PM_BINDING_POWER_MAX, PM_PARSE_ACCEPTS_DO_BLOCK | PM_PARSE_ACCEPTS_LABEL, PM_ERR_PATTERN_HASH_KEY_LABEL, (uint16_t) (depth + 1));
17683 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_PATTERN_HASH_KEY, pm_token_str(parser->current.type));
17684 parse_discard_token(parser, depth);
17686 first_node = UP(pm_error_recovery_node_create(parser, PM_TOKEN_START(parser, &parser->previous), PM_TOKEN_LENGTH(&parser->previous)));
17691 node = parse_pattern_hash(parser, captures, first_node, (uint16_t) (depth + 1));
17693 accept1(parser, PM_TOKEN_NEWLINE);
17694 expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_PATTERN_TERM_BRACE, &opening);
17697 PM_NODE_START_SET_TOKEN(parser, node, &opening);
17698 PM_NODE_LENGTH_SET_TOKEN(parser, node, &closing);
17704 parser->pattern_matching_newlines = previous_pattern_matching_newlines;
17707 case PM_TOKEN_UDOT_DOT:
17708 case PM_TOKEN_UDOT_DOT_DOT: {
17710 parser_lex(parser);
17714 switch (parser->current.type) {
17715 case PM_CASE_PRIMITIVE: {
17716 pm_node_t *right = parse_expression(parser, PM_BINDING_POWER_MAX, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_PATTERN_EXPRESSION_AFTER_RANGE, (uint16_t) (depth + 1));
17717 return UP(pm_range_node_create(parser, NULL, &
operator, right));
17720 pm_parser_err_token(parser, &
operator, PM_ERR_PATTERN_EXPRESSION_AFTER_RANGE);
17721 pm_node_t *right = UP(pm_error_recovery_node_create(parser, PM_TOKEN_START(parser, &
operator), PM_TOKEN_LENGTH(&
operator)));
17722 return UP(pm_range_node_create(parser, NULL, &
operator, right));
17726 case PM_CASE_PRIMITIVE: {
17727 pm_node_t *node = parse_expression(parser, PM_BINDING_POWER_MAX, PM_PARSE_ACCEPTS_LABEL | PM_PARSE_ACCEPTS_DO_BLOCK, diag_id, (uint16_t) (depth + 1));
17730 if (pm_symbol_node_label_p(parser, node))
return node;
17733 if (PM_NODE_TYPE(node) == PM_CALL_NODE) {
17734 pm_parser_err_node(parser, node, diag_id);
17735 return UP(pm_error_recovery_node_create_unexpected(parser, node));
17739 if (accept2(parser, PM_TOKEN_DOT_DOT, PM_TOKEN_DOT_DOT_DOT)) {
17745 switch (parser->current.type) {
17746 case PM_CASE_PRIMITIVE: {
17747 pm_node_t *right = parse_expression(parser, PM_BINDING_POWER_MAX, PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_PATTERN_EXPRESSION_AFTER_RANGE, (uint16_t) (depth + 1));
17748 return UP(pm_range_node_create(parser, node, &
operator, right));
17751 return UP(pm_range_node_create(parser, node, &
operator, NULL));
17757 case PM_TOKEN_CARET: {
17758 parser_lex(parser);
17763 switch (parser->current.type) {
17764 case PM_TOKEN_IDENTIFIER: {
17765 parser_lex(parser);
17766 pm_node_t *variable = UP(parse_variable(parser));
17768 if (variable == NULL) {
17769 PM_PARSER_ERR_TOKEN_FORMAT_CONTENT(parser, &parser->previous, PM_ERR_NO_LOCAL_VARIABLE);
17770 variable = UP(pm_local_variable_read_node_missing_create(parser, &parser->previous, 0));
17773 return UP(pm_pinned_variable_node_create(parser, &
operator, variable));
17775 case PM_TOKEN_INSTANCE_VARIABLE: {
17776 parser_lex(parser);
17777 pm_node_t *variable = UP(pm_instance_variable_read_node_create(parser, &parser->previous));
17779 return UP(pm_pinned_variable_node_create(parser, &
operator, variable));
17781 case PM_TOKEN_CLASS_VARIABLE: {
17782 parser_lex(parser);
17783 pm_node_t *variable = UP(pm_class_variable_read_node_create(parser, &parser->previous));
17785 return UP(pm_pinned_variable_node_create(parser, &
operator, variable));
17787 case PM_TOKEN_GLOBAL_VARIABLE: {
17788 parser_lex(parser);
17789 pm_node_t *variable = UP(pm_global_variable_read_node_create(parser, &parser->previous));
17791 return UP(pm_pinned_variable_node_create(parser, &
operator, variable));
17793 case PM_TOKEN_PARENTHESIS_LEFT_GROUPING: {
17794 bool previous_pattern_matching_newlines = parser->pattern_matching_newlines;
17795 parser->pattern_matching_newlines =
false;
17798 parser_lex(parser);
17800 pm_node_t *expression = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, PM_PARSE_ACCEPTS_DO_BLOCK | PM_PARSE_ACCEPTS_COMMAND_CALL, PM_ERR_PATTERN_EXPRESSION_AFTER_PIN, (uint16_t) (depth + 1));
17801 parser->pattern_matching_newlines = previous_pattern_matching_newlines;
17803 accept1(parser, PM_TOKEN_NEWLINE);
17804 expect1_opening(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN, &lparen);
17805 return UP(pm_pinned_expression_node_create(parser, expression, &
operator, &lparen, &parser->previous));
17810 pm_parser_err_token(parser, &
operator, PM_ERR_PATTERN_EXPRESSION_AFTER_PIN);
17811 pm_node_t *variable = UP(pm_error_recovery_node_create(parser, PM_TOKEN_START(parser, &
operator), PM_TOKEN_LENGTH(&
operator)));
17812 return UP(pm_pinned_variable_node_create(parser, &
operator, variable));
17816 case PM_TOKEN_UCOLON_COLON: {
17818 parser_lex(parser);
17820 expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
17821 pm_constant_path_node_t *node = pm_constant_path_node_create(parser, NULL, &delimiter, &parser->previous);
17823 return parse_pattern_constant_path(parser, captures, UP(node), (uint16_t) (depth + 1));
17825 case PM_TOKEN_CONSTANT: {
17827 parser_lex(parser);
17829 pm_node_t *node = UP(pm_constant_read_node_create(parser, &constant));
17830 return parse_pattern_constant_path(parser, captures, node, (uint16_t) (depth + 1));
17833 pm_parser_err_current(parser, diag_id);
17834 return UP(pm_error_recovery_node_create(parser, PM_TOKEN_END(parser, &parser->previous), 0));
17846parse_pattern_alternation_error_each(
const pm_node_t *node,
void *data) {
17849 switch (PM_NODE_TYPE(node)) {
17850 case PM_LOCAL_VARIABLE_TARGET_NODE:
17853 if (peek_at(parser, parser->start + PM_NODE_START(node)) !=
'_') {
17854 pm_parser_err(parser, PM_NODE_START(node), PM_NODE_LENGTH(node), PM_ERR_PATTERN_CAPTURE_IN_ALTERNATIVE);
17857 case PM_ARRAY_PATTERN_NODE:
17858 case PM_ASSOC_NODE:
17859 case PM_ASSOC_SPLAT_NODE:
17860 case PM_CAPTURE_PATTERN_NODE:
17861 case PM_FIND_PATTERN_NODE:
17862 case PM_HASH_PATTERN_NODE:
17863 case PM_IMPLICIT_NODE:
17864 case PM_PARENTHESES_NODE:
17865 case PM_SPLAT_NODE:
17878parse_pattern_alternation_error(
pm_parser_t *parser,
const pm_node_t *node) {
17879 pm_visit_node(node, parse_pattern_alternation_error_each, parser);
17888 pm_node_t *node = first_node;
17889 bool alternation =
false;
17891 while ((node == NULL) || (alternation = accept1(parser, PM_TOKEN_PIPE))) {
17892 if (alternation && !PM_NODE_TYPE_P(node, PM_ALTERNATION_PATTERN_NODE) && captures->size) {
17893 parse_pattern_alternation_error(parser, node);
17896 switch (parser->current.type) {
17897 case PM_TOKEN_IDENTIFIER:
17898 case PM_TOKEN_BRACKET_LEFT_ARRAY:
17899 case PM_TOKEN_BRACE_LEFT_HASH:
17900 case PM_TOKEN_CARET:
17901 case PM_TOKEN_CONSTANT:
17902 case PM_TOKEN_UCOLON_COLON:
17903 case PM_TOKEN_UDOT_DOT:
17904 case PM_TOKEN_UDOT_DOT_DOT:
17905 case PM_CASE_PRIMITIVE: {
17906 if (!alternation) {
17907 node = parse_pattern_primitive(parser, captures, diag_id, (uint16_t) (depth + 1));
17910 pm_node_t *right = parse_pattern_primitive(parser, captures, PM_ERR_PATTERN_EXPRESSION_AFTER_PIPE, (uint16_t) (depth + 1));
17912 if (captures->size) parse_pattern_alternation_error(parser, right);
17913 node = UP(pm_alternation_pattern_node_create(parser, node, right, &
operator));
17918 case PM_TOKEN_PARENTHESIS_LEFT_GROUPING:
17919 case PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES: {
17922 parser_lex(parser);
17924 pm_node_t *body = parse_pattern(parser, captures, PM_PARSE_PATTERN_SINGLE, PM_ERR_PATTERN_EXPRESSION_AFTER_PAREN, (uint16_t) (depth + 1));
17925 accept1(parser, PM_TOKEN_NEWLINE);
17926 expect1_opening(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_PATTERN_TERM_PAREN, &opening);
17927 pm_node_t *right = UP(pm_parentheses_node_create(parser, &opening, body, &parser->previous, 0));
17929 if (!alternation) {
17932 if (captures->size) parse_pattern_alternation_error(parser, right);
17933 node = UP(pm_alternation_pattern_node_create(parser, node, right, &
operator));
17939 pm_parser_err_current(parser, diag_id);
17940 pm_node_t *right = UP(pm_error_recovery_node_create(parser, PM_TOKEN_END(parser, &parser->previous), 0));
17942 if (!alternation) {
17945 if (captures->size) parse_pattern_alternation_error(parser, right);
17946 node = UP(pm_alternation_pattern_node_create(parser, node, right, &parser->previous));
17956 while (accept1(parser, PM_TOKEN_EQUAL_GREATER)) {
17958 expect1(parser, PM_TOKEN_IDENTIFIER, PM_ERR_PATTERN_IDENT_AFTER_HROCKET);
17960 pm_constant_id_t constant_id = pm_parser_constant_id_token(parser, &parser->previous);
17963 if ((depth = pm_parser_local_depth_constant_id(parser, constant_id)) == -1) {
17964 pm_parser_local_add(parser, constant_id, parser->previous.
start, parser->previous.
end, 0);
17967 pm_location_t previous_loc = TOK2LOC(parser, &parser->previous);
17968 parse_pattern_capture(parser, captures, constant_id, &previous_loc);
17969 pm_local_variable_target_node_t *target = pm_local_variable_target_node_create(
17973 (uint32_t) (depth == -1 ? 0 : depth)
17976 node = UP(pm_capture_pattern_node_create(parser, node, target, &
operator));
17989 if (
PRISM_UNLIKELY(depth >= PRISM_DEPTH_MAXIMUM || pm_parser_stack_exhausted(parser))) {
17990 return parse_resource_recovery(parser, depth);
17993 pm_node_t *node = NULL;
17995 bool leading_rest =
false;
17996 bool trailing_rest =
false;
17998 switch (parser->current.type) {
17999 case PM_TOKEN_LABEL: {
18000 parser_lex(parser);
18001 pm_node_t *key = UP(pm_symbol_node_label_create(parser, &parser->previous));
18002 node = UP(parse_pattern_hash(parser, captures, key, (uint16_t) (depth + 1)));
18004 if (!(flags & PM_PARSE_PATTERN_TOP)) {
18005 pm_parser_err_node(parser, node, PM_ERR_PATTERN_HASH_IMPLICIT);
18010 case PM_TOKEN_USTAR_STAR: {
18011 node = parse_pattern_keyword_rest(parser, captures);
18012 node = UP(parse_pattern_hash(parser, captures, node, (uint16_t) (depth + 1)));
18014 if (!(flags & PM_PARSE_PATTERN_TOP)) {
18015 pm_parser_err_node(parser, node, PM_ERR_PATTERN_HASH_IMPLICIT);
18020 case PM_TOKEN_STRING_BEGIN: {
18023 node = parse_pattern_primitive(parser, captures, diag_id, (uint16_t) (depth + 1));
18025 if (pm_symbol_node_label_p(parser, node)) {
18026 node = UP(parse_pattern_hash(parser, captures, node, (uint16_t) (depth + 1)));
18028 if (!(flags & PM_PARSE_PATTERN_TOP)) {
18029 pm_parser_err_node(parser, node, PM_ERR_PATTERN_HASH_IMPLICIT);
18035 node = parse_pattern_primitives(parser, captures, node, diag_id, (uint16_t) (depth + 1));
18038 case PM_TOKEN_USTAR: {
18039 if (flags & (PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI)) {
18040 parser_lex(parser);
18041 node = UP(parse_pattern_rest(parser, captures));
18042 leading_rest =
true;
18048 node = parse_pattern_primitives(parser, captures, NULL, diag_id, (uint16_t) (depth + 1));
18054 if (pm_symbol_node_label_p(parser, node)) {
18055 return UP(parse_pattern_hash(parser, captures, node, (uint16_t) (depth + 1)));
18058 if ((flags & PM_PARSE_PATTERN_MULTI) && match1(parser, PM_TOKEN_COMMA)) {
18062 pm_node_list_t nodes = { 0 };
18063 pm_node_list_open_append(&parser->node_chunks, &nodes, node);
18066 while (accept1(parser, PM_TOKEN_COMMA)) {
18072 if (!token_begins_pattern_p(parser->current.type)) {
18077 if (trailing_rest) {
18078 pm_parser_err_previous(parser, PM_ERR_PATTERN_REST);
18081 node = UP(pm_implicit_rest_node_create(parser, &parser->previous));
18082 pm_node_list_open_append(&parser->node_chunks, &nodes, node);
18083 trailing_rest =
true;
18087 if (accept1(parser, PM_TOKEN_USTAR)) {
18088 node = UP(parse_pattern_rest(parser, captures));
18093 if (trailing_rest) {
18094 pm_parser_err_previous(parser, PM_ERR_PATTERN_REST);
18097 trailing_rest =
true;
18099 node = parse_pattern_primitives(parser, captures, NULL, PM_ERR_PATTERN_EXPRESSION_AFTER_COMMA, (uint16_t) (depth + 1));
18102 pm_node_list_open_append(&parser->node_chunks, &nodes, node);
18105 pm_node_list_finalize(&parser->node_chunks, parser->arena, &nodes);
18111 if (leading_rest && PM_NODE_TYPE_P(nodes.
nodes[nodes.
size - 1], PM_SPLAT_NODE)) {
18112 node = UP(pm_find_pattern_node_create(parser, &nodes));
18114 if (nodes.
size == 2) {
18115 pm_parser_err_node(parser, node, PM_ERR_PATTERN_FIND_MISSING_INNER);
18118 node = UP(pm_array_pattern_node_node_list_create(parser, &nodes));
18120 if (leading_rest && trailing_rest) {
18121 pm_parser_err_node(parser, node, PM_ERR_PATTERN_ARRAY_MULTIPLE_RESTS);
18124 }
else if (leading_rest) {
18127 node = UP(pm_array_pattern_node_rest_create(parser, node));
18139parse_negative_numeric(pm_node_t *node) {
18140 switch (PM_NODE_TYPE(node)) {
18141 case PM_INTEGER_NODE: {
18142 pm_integer_node_t *
cast = (pm_integer_node_t *) node;
18143 cast->base.location.start--;
18144 cast->base.location.length++;
18145 cast->value.negative =
true;
18148 case PM_FLOAT_NODE: {
18149 pm_float_node_t *
cast = (pm_float_node_t *) node;
18150 cast->base.location.start--;
18151 cast->base.location.length++;
18155 case PM_RATIONAL_NODE: {
18156 pm_rational_node_t *
cast = (pm_rational_node_t *) node;
18157 cast->base.location.start--;
18158 cast->base.location.length++;
18159 cast->numerator.negative =
true;
18162 case PM_IMAGINARY_NODE:
18165 parse_negative_numeric(((pm_imaginary_node_t *) node)->numeric);
18168 PRISM_ASSERT(
false &&
"unreachable");
18179pm_parser_err_prefix(
pm_parser_t *parser, pm_diagnostic_id_t diag_id) {
18181 case PM_ERR_HASH_KEY: {
18182 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->previous, diag_id, pm_token_str(parser->previous.
type));
18185 case PM_ERR_HASH_VALUE:
18186 case PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR: {
18187 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, diag_id, pm_token_str(parser->current.type));
18190 case PM_ERR_UNARY_RECEIVER: {
18191 const char *human = (parser->current.type == PM_TOKEN_EOF ?
"end-of-input" : pm_token_str(parser->current.type));
18192 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->previous, diag_id, human, parser->previous.
start[0]);
18195 case PM_ERR_UNARY_DISALLOWED:
18196 case PM_ERR_EXPECT_ARGUMENT: {
18197 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, diag_id, pm_token_str(parser->current.type));
18201 pm_parser_err_previous(parser, diag_id);
18210ensure_valid_retry(
pm_parser_t *parser,
const pm_node_t *node) {
18211#define CONTEXT_NONE 0
18212#define CONTEXT_THROUGH_ENSURE 1
18213#define CONTEXT_THROUGH_ELSE 2
18215 pm_context_node_t *context_node = parser->current_context;
18216 int context = CONTEXT_NONE;
18218 while (context_node != NULL) {
18219 switch (context_node->context) {
18220 case PM_CONTEXT_BEGIN_RESCUE:
18221 case PM_CONTEXT_BLOCK_RESCUE:
18222 case PM_CONTEXT_CLASS_RESCUE:
18223 case PM_CONTEXT_DEF_RESCUE:
18224 case PM_CONTEXT_LAMBDA_RESCUE:
18225 case PM_CONTEXT_MODULE_RESCUE:
18226 case PM_CONTEXT_SCLASS_RESCUE:
18227 case PM_CONTEXT_DEFINED:
18228 case PM_CONTEXT_RESCUE_MODIFIER:
18231 case PM_CONTEXT_CLASS:
18232 case PM_CONTEXT_DEF:
18233 case PM_CONTEXT_DEF_PARAMS:
18234 case PM_CONTEXT_MAIN:
18235 case PM_CONTEXT_MODULE:
18236 case PM_CONTEXT_PREEXE:
18237 case PM_CONTEXT_SCLASS:
18240 if (context == CONTEXT_NONE) {
18241 pm_parser_err_node(parser, node, PM_ERR_INVALID_RETRY_WITHOUT_RESCUE);
18242 }
else if (context == CONTEXT_THROUGH_ENSURE) {
18243 pm_parser_err_node(parser, node, PM_ERR_INVALID_RETRY_AFTER_ENSURE);
18244 }
else if (context == CONTEXT_THROUGH_ELSE) {
18245 pm_parser_err_node(parser, node, PM_ERR_INVALID_RETRY_AFTER_ELSE);
18248 case PM_CONTEXT_BEGIN_ELSE:
18249 case PM_CONTEXT_BLOCK_ELSE:
18250 case PM_CONTEXT_CLASS_ELSE:
18251 case PM_CONTEXT_DEF_ELSE:
18252 case PM_CONTEXT_LAMBDA_ELSE:
18253 case PM_CONTEXT_MODULE_ELSE:
18254 case PM_CONTEXT_SCLASS_ELSE:
18257 context = CONTEXT_THROUGH_ELSE;
18259 case PM_CONTEXT_BEGIN_ENSURE:
18260 case PM_CONTEXT_BLOCK_ENSURE:
18261 case PM_CONTEXT_CLASS_ENSURE:
18262 case PM_CONTEXT_DEF_ENSURE:
18263 case PM_CONTEXT_LAMBDA_ENSURE:
18264 case PM_CONTEXT_MODULE_ENSURE:
18265 case PM_CONTEXT_SCLASS_ENSURE:
18268 context = CONTEXT_THROUGH_ENSURE;
18270 case PM_CONTEXT_NONE:
18271 case PM_CONTEXT_MAXIMUM:
18273 PRISM_ASSERT(
false &&
"unreachable");
18275 case PM_CONTEXT_BEGIN:
18276 case PM_CONTEXT_BLOCK_BRACES:
18277 case PM_CONTEXT_BLOCK_KEYWORDS:
18278 case PM_CONTEXT_BLOCK_PARAMETERS:
18279 case PM_CONTEXT_CASE_IN:
18280 case PM_CONTEXT_CASE_WHEN:
18281 case PM_CONTEXT_DEFAULT_PARAMS:
18282 case PM_CONTEXT_ELSE:
18283 case PM_CONTEXT_ELSIF:
18284 case PM_CONTEXT_EMBEXPR:
18285 case PM_CONTEXT_FOR_INDEX:
18286 case PM_CONTEXT_FOR:
18287 case PM_CONTEXT_IF:
18288 case PM_CONTEXT_LAMBDA_BRACES:
18289 case PM_CONTEXT_LAMBDA_DO_END:
18290 case PM_CONTEXT_LOOP_PREDICATE:
18291 case PM_CONTEXT_MULTI_TARGET:
18292 case PM_CONTEXT_PARENS:
18293 case PM_CONTEXT_POSTEXE:
18294 case PM_CONTEXT_PREDICATE:
18295 case PM_CONTEXT_TERNARY:
18296 case PM_CONTEXT_UNLESS:
18297 case PM_CONTEXT_UNTIL:
18298 case PM_CONTEXT_WHILE:
18304 context_node = context_node->prev;
18308#undef CONTEXT_ENSURE
18316ensure_valid_yield(
pm_parser_t *parser,
const pm_yield_node_t *node) {
18317 pm_context_node_t *context_node = parser->current_context;
18319 while (context_node != NULL) {
18320 switch (context_node->context) {
18321 case PM_CONTEXT_DEF:
18322 case PM_CONTEXT_DEF_PARAMS:
18323 case PM_CONTEXT_DEFINED:
18324 case PM_CONTEXT_DEF_ENSURE:
18325 case PM_CONTEXT_DEF_RESCUE:
18326 case PM_CONTEXT_DEF_ELSE:
18330 case PM_CONTEXT_CLASS:
18331 case PM_CONTEXT_CLASS_ENSURE:
18332 case PM_CONTEXT_CLASS_RESCUE:
18333 case PM_CONTEXT_CLASS_ELSE:
18334 case PM_CONTEXT_MAIN:
18335 case PM_CONTEXT_MODULE:
18336 case PM_CONTEXT_MODULE_ENSURE:
18337 case PM_CONTEXT_MODULE_RESCUE:
18338 case PM_CONTEXT_MODULE_ELSE:
18339 case PM_CONTEXT_SCLASS:
18340 case PM_CONTEXT_SCLASS_RESCUE:
18341 case PM_CONTEXT_SCLASS_ENSURE:
18342 case PM_CONTEXT_SCLASS_ELSE:
18345 pm_parser_err_node(parser, UP(node), PM_ERR_INVALID_YIELD);
18347 case PM_CONTEXT_NONE:
18348 case PM_CONTEXT_MAXIMUM:
18350 PRISM_ASSERT(
false &&
"unreachable");
18352 case PM_CONTEXT_BEGIN:
18353 case PM_CONTEXT_BEGIN_ELSE:
18354 case PM_CONTEXT_BEGIN_ENSURE:
18355 case PM_CONTEXT_BEGIN_RESCUE:
18356 case PM_CONTEXT_BLOCK_BRACES:
18357 case PM_CONTEXT_BLOCK_KEYWORDS:
18358 case PM_CONTEXT_BLOCK_ELSE:
18359 case PM_CONTEXT_BLOCK_ENSURE:
18360 case PM_CONTEXT_BLOCK_PARAMETERS:
18361 case PM_CONTEXT_BLOCK_RESCUE:
18362 case PM_CONTEXT_CASE_IN:
18363 case PM_CONTEXT_CASE_WHEN:
18364 case PM_CONTEXT_DEFAULT_PARAMS:
18365 case PM_CONTEXT_ELSE:
18366 case PM_CONTEXT_ELSIF:
18367 case PM_CONTEXT_EMBEXPR:
18368 case PM_CONTEXT_FOR_INDEX:
18369 case PM_CONTEXT_FOR:
18370 case PM_CONTEXT_IF:
18371 case PM_CONTEXT_LAMBDA_BRACES:
18372 case PM_CONTEXT_LAMBDA_DO_END:
18373 case PM_CONTEXT_LAMBDA_ELSE:
18374 case PM_CONTEXT_LAMBDA_ENSURE:
18375 case PM_CONTEXT_LAMBDA_RESCUE:
18376 case PM_CONTEXT_LOOP_PREDICATE:
18377 case PM_CONTEXT_MULTI_TARGET:
18378 case PM_CONTEXT_PARENS:
18379 case PM_CONTEXT_POSTEXE:
18380 case PM_CONTEXT_PREDICATE:
18381 case PM_CONTEXT_PREEXE:
18382 case PM_CONTEXT_RESCUE_MODIFIER:
18383 case PM_CONTEXT_TERNARY:
18384 case PM_CONTEXT_UNLESS:
18385 case PM_CONTEXT_UNTIL:
18386 case PM_CONTEXT_WHILE:
18392 context_node = context_node->prev;
18401parse_case(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
18402 size_t opening_newline_index = token_newline_index(parser);
18403 parser_lex(parser);
18406 pm_node_t *predicate = NULL;
18411 if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
18412 while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
18414 }
else if (match3(parser, PM_TOKEN_KEYWORD_WHEN, PM_TOKEN_KEYWORD_IN, PM_TOKEN_KEYWORD_END)) {
18416 }
else if (!token_begins_expression_p(parser->current.type)) {
18419 predicate = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_CASE_EXPRESSION_AFTER_CASE, (uint16_t) (depth + 1));
18420 while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
18423 if (match1(parser, PM_TOKEN_KEYWORD_END)) {
18424 parser_warn_indentation_mismatch(parser, opening_newline_index, &case_keyword,
false,
false);
18425 parser_lex(parser);
18426 pop_block_exits(parser, previous_block_exits);
18427 pm_parser_err_token(parser, &case_keyword, PM_ERR_CASE_MISSING_CONDITIONS);
18429 pm_node_list_t conditions = { 0 };
18430 return UP(pm_case_node_create(parser, &case_keyword, predicate, &conditions, NULL, &parser->previous));
18435 pm_node_list_t conditions = { 0 };
18436 bool case_when = match1(parser, PM_TOKEN_KEYWORD_WHEN);
18444 while (match1(parser, PM_TOKEN_KEYWORD_WHEN)) {
18445 parser_warn_indentation_mismatch(parser, opening_newline_index, &case_keyword,
false,
true);
18446 parser_lex(parser);
18449 pm_node_list_t when_conditions = { 0 };
18451 pm_statements_node_t *statements = NULL;
18454 if (accept1(parser, PM_TOKEN_USTAR)) {
18456 pm_node_t *expression = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_STAR, (uint16_t) (depth + 1));
18458 pm_splat_node_t *splat_node = pm_splat_node_create(parser, &
operator, expression);
18459 pm_node_list_open_append(&parser->node_chunks, &when_conditions, UP(splat_node));
18461 if (PM_NODE_TYPE_P(expression, PM_ERROR_RECOVERY_NODE))
break;
18463 pm_node_t *condition = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_CASE_EXPRESSION_AFTER_WHEN, (uint16_t) (depth + 1));
18464 pm_node_list_open_append(&parser->node_chunks, &when_conditions, condition);
18468 if (PM_NODE_TYPE_P(condition, PM_ERROR_RECOVERY_NODE))
break;
18472 if (PM_NODE_TYPE_P(condition, PM_STRING_NODE)) {
18473 pm_node_flag_set(condition, PM_STRING_FLAGS_FROZEN | PM_NODE_FLAG_STATIC_LITERAL);
18474 }
else if (PM_NODE_TYPE_P(condition, PM_SOURCE_FILE_NODE) && parser->version < PM_OPTIONS_VERSION_CRUBY_4_1) {
18475 pm_node_flag_set(condition, PM_NODE_FLAG_STATIC_LITERAL);
18478 pm_when_clause_static_literals_add(parser, &literals, condition);
18480 }
while (accept1(parser, PM_TOKEN_COMMA));
18482 if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
18483 if (accept1(parser, PM_TOKEN_KEYWORD_THEN)) {
18484 then_keyword = parser->previous;
18487 expect1(parser, PM_TOKEN_KEYWORD_THEN, PM_ERR_EXPECT_WHEN_DELIMITER);
18488 then_keyword = parser->previous;
18491 if (!match3(parser, PM_TOKEN_KEYWORD_WHEN, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
18492 statements = parse_statements(parser, PM_CONTEXT_CASE_WHEN, (uint16_t) (depth + 1));
18495 pm_when_node_t *when_node = pm_when_node_create(parser, &when_keyword, &when_conditions, NTOK2PTR(then_keyword), statements);
18496 pm_node_list_open_append(&parser->node_chunks, &conditions, UP(when_node));
18499 pm_static_literals_free(&literals);
18503 if (predicate == NULL) {
18504 pm_parser_err_token(parser, &case_keyword, PM_ERR_CASE_MATCH_MISSING_PREDICATE);
18509 while (match1(parser, PM_TOKEN_KEYWORD_IN)) {
18510 parser_warn_indentation_mismatch(parser, opening_newline_index, &case_keyword,
false,
true);
18512 bool previous_pattern_matching_newlines = parser->pattern_matching_newlines;
18513 parser->pattern_matching_newlines =
true;
18515 lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
18516 parser->command_start =
false;
18517 parser_lex(parser);
18521 pm_node_t *pattern;
18523 pm_statements_node_t *statements = NULL;
18525 pattern = parse_pattern(parser, &captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_IN, (uint16_t) (depth + 1));
18526 parser->pattern_matching_newlines = previous_pattern_matching_newlines;
18530 if (accept1(parser, PM_TOKEN_KEYWORD_IF_MODIFIER)) {
18532 pm_node_t *predicate = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_CONDITIONAL_IF_PREDICATE, (uint16_t) (depth + 1));
18533 pattern = UP(pm_if_node_modifier_create(parser, pattern, &keyword, predicate));
18534 }
else if (accept1(parser, PM_TOKEN_KEYWORD_UNLESS_MODIFIER)) {
18536 pm_node_t *predicate = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_CONDITIONAL_UNLESS_PREDICATE, (uint16_t) (depth + 1));
18537 pattern = UP(pm_unless_node_modifier_create(parser, pattern, &keyword, predicate));
18540 if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
18541 if (accept1(parser, PM_TOKEN_KEYWORD_THEN)) {
18542 then_keyword = parser->previous;
18545 expect1(parser, PM_TOKEN_KEYWORD_THEN, PM_ERR_EXPECT_IN_DELIMITER);
18546 then_keyword = parser->previous;
18549 if (!match3(parser, PM_TOKEN_KEYWORD_IN, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
18550 statements = parse_statements(parser, PM_CONTEXT_CASE_IN, (uint16_t) (depth + 1));
18553 pm_node_t *condition = UP(pm_in_node_create(parser, pattern, statements, &in_keyword, NTOK2PTR(then_keyword)));
18554 pm_node_list_open_append(&parser->node_chunks, &conditions, condition);
18560 if (conditions.
size == 0) {
18561 pm_parser_err_token(parser, &case_keyword, PM_ERR_CASE_MISSING_CONDITIONS);
18564 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
18565 pm_else_node_t *else_clause = NULL;
18567 if (accept1(parser, PM_TOKEN_KEYWORD_ELSE)) {
18570 if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
18571 else_clause = pm_else_node_create(parser, &else_keyword, parse_statements(parser, PM_CONTEXT_ELSE, (uint16_t) (depth + 1)), &parser->current);
18573 else_clause = pm_else_node_create(parser, &else_keyword, NULL, &parser->current);
18577 parser_warn_indentation_mismatch(parser, opening_newline_index, &case_keyword,
false,
false);
18578 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CASE_TERM, &case_keyword);
18582 node = UP(pm_case_node_create(parser, &case_keyword, predicate, &conditions, else_clause, &parser->previous));
18584 node = UP(pm_case_match_node_create(parser, &case_keyword, predicate, &conditions, else_clause, &parser->previous));
18587 pop_block_exits(parser, previous_block_exits);
18596parse_class(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
18597 size_t opening_newline_index = token_newline_index(parser);
18598 parser_lex(parser);
18600 pm_token_t class_keyword = parser->previous;
18605 if (accept1(parser, PM_TOKEN_LESS_LESS)) {
18607 pm_node_t *expression = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_EXPECT_EXPRESSION_AFTER_LESS_LESS, (uint16_t) (depth + 1));
18610 pm_do_loop_stack_push(parser,
false);
18611 pm_parser_scope_push(parser,
true);
18612 if (!match2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
18613 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_EXPECT_SINGLETON_CLASS_DELIMITER, pm_token_str(parser->current.type));
18616 pm_node_t *statements = NULL;
18617 if (!match4(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
18618 pm_accepts_block_stack_push(parser,
true);
18619 statements = UP(parse_statements(parser, PM_CONTEXT_SCLASS, (uint16_t) (depth + 1)));
18620 pm_accepts_block_stack_pop(parser);
18623 if (match2(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE)) {
18624 PRISM_ASSERT(statements == NULL || PM_NODE_TYPE_P(statements, PM_STATEMENTS_NODE));
18625 statements = UP(parse_rescues_implicit_begin(parser, opening_newline_index, &class_keyword, class_keyword.
start, (pm_statements_node_t *) statements, PM_RESCUES_SCLASS, (uint16_t) (depth + 1)));
18627 parser_warn_indentation_mismatch(parser, opening_newline_index, &class_keyword,
false,
false);
18630 pm_do_loop_stack_pop(parser);
18631 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CLASS_TERM, &class_keyword);
18634 pm_locals_order(parser, &locals,
false);
18636 pm_parser_scope_pop(parser);
18638 flush_block_exits(parser, previous_block_exits);
18639 return UP(pm_singleton_class_node_create(parser, &locals, &class_keyword, &
operator, expression, statements, &parser->previous));
18642 pm_node_t *constant_path = parse_expression(parser, PM_BINDING_POWER_INDEX, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_CLASS_NAME, (uint16_t) (depth + 1));
18644 if (name.
type != PM_TOKEN_CONSTANT) {
18645 pm_parser_err_token(parser, &name, PM_ERR_CLASS_NAME);
18649 pm_node_t *superclass;
18651 if (match1(parser, PM_TOKEN_LESS)) {
18652 inheritance_operator = parser->current;
18653 lex_state_set(parser, PM_LEX_STATE_BEG);
18655 parser->command_start =
true;
18656 parser_lex(parser);
18658 superclass = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_CLASS_SUPERCLASS, (uint16_t) (depth + 1));
18663 pm_do_loop_stack_push(parser,
false);
18664 pm_parser_scope_push(parser,
true);
18666 if (inheritance_operator.
start != NULL) {
18667 expect2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_ERR_CLASS_UNEXPECTED_END);
18669 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
18671 pm_node_t *statements = NULL;
18673 if (!match4(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
18674 pm_accepts_block_stack_push(parser,
true);
18675 statements = UP(parse_statements(parser, PM_CONTEXT_CLASS, (uint16_t) (depth + 1)));
18676 pm_accepts_block_stack_pop(parser);
18679 if (match2(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE)) {
18680 PRISM_ASSERT(statements == NULL || PM_NODE_TYPE_P(statements, PM_STATEMENTS_NODE));
18681 statements = UP(parse_rescues_implicit_begin(parser, opening_newline_index, &class_keyword, class_keyword.
start, (pm_statements_node_t *) statements, PM_RESCUES_CLASS, (uint16_t) (depth + 1)));
18683 parser_warn_indentation_mismatch(parser, opening_newline_index, &class_keyword,
false,
false);
18686 pm_do_loop_stack_pop(parser);
18687 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_CLASS_TERM, &class_keyword);
18689 if (context_def_p(parser)) {
18690 pm_parser_err_token(parser, &class_keyword, PM_ERR_CLASS_IN_METHOD);
18694 pm_locals_order(parser, &locals,
false);
18696 pm_parser_scope_pop(parser);
18698 if (!PM_NODE_TYPE_P(constant_path, PM_CONSTANT_PATH_NODE) && !(PM_NODE_TYPE_P(constant_path, PM_CONSTANT_READ_NODE))) {
18699 pm_parser_err_node(parser, constant_path, PM_ERR_CLASS_NAME);
18700 if (!PM_NODE_TYPE_P(constant_path, PM_ERROR_RECOVERY_NODE)) {
18701 constant_path = UP(pm_error_recovery_node_create_unexpected(parser, constant_path));
18705 pop_block_exits(parser, previous_block_exits);
18706 return UP(pm_class_node_create(parser, &locals, &class_keyword, constant_path, &name, NTOK2PTR(inheritance_operator), superclass, statements, &parser->previous));
18713parse_def(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
18718 size_t opening_newline_index = token_newline_index(parser);
18720 pm_node_t *receiver = NULL;
18726 context_push(parser, PM_CONTEXT_DEF_PARAMS);
18727 parser_lex(parser);
18731 bool valid_name =
true;
18733 switch (parser->current.type) {
18734 case PM_CASE_OPERATOR:
18735 pm_parser_scope_push(parser,
true);
18736 lex_state_set(parser, PM_LEX_STATE_ENDFN);
18737 parser_lex(parser);
18739 name = parser->previous;
18741 case PM_TOKEN_IDENTIFIER: {
18742 parser_lex(parser);
18744 if (match2(parser, PM_TOKEN_DOT, PM_TOKEN_COLON_COLON)) {
18745 if (parser->previous.
end[-1] ==
'=') {
18746 pm_parser_err_previous(parser, PM_ERR_DEF_RECEIVER_SETTER);
18748 receiver = parse_variable_call(parser);
18750 pm_parser_scope_push(parser,
true);
18751 lex_state_set(parser, PM_LEX_STATE_FNAME);
18752 parser_lex(parser);
18754 operator = parser->previous;
18755 name = parse_method_definition_name(parser);
18757 pm_refute_numbered_parameter(parser, PM_TOKEN_START(parser, &parser->previous), PM_TOKEN_LENGTH(&parser->previous));
18758 pm_parser_scope_push(parser,
true);
18760 name = parser->previous;
18765 case PM_TOKEN_INSTANCE_VARIABLE:
18766 case PM_TOKEN_CLASS_VARIABLE:
18767 case PM_TOKEN_GLOBAL_VARIABLE:
18768 valid_name =
false;
18770 case PM_TOKEN_CONSTANT:
18771 case PM_TOKEN_KEYWORD_NIL:
18772 case PM_TOKEN_KEYWORD_SELF:
18773 case PM_TOKEN_KEYWORD_TRUE:
18774 case PM_TOKEN_KEYWORD_FALSE:
18775 case PM_TOKEN_KEYWORD___FILE__:
18776 case PM_TOKEN_KEYWORD___LINE__:
18777 case PM_TOKEN_KEYWORD___ENCODING__: {
18778 pm_parser_scope_push(parser,
true);
18779 parser_lex(parser);
18783 if (match2(parser, PM_TOKEN_DOT, PM_TOKEN_COLON_COLON)) {
18784 lex_state_set(parser, PM_LEX_STATE_FNAME);
18785 parser_lex(parser);
18786 operator = parser->previous;
18788 switch (identifier.
type) {
18789 case PM_TOKEN_CONSTANT:
18790 receiver = UP(pm_constant_read_node_create(parser, &identifier));
18792 case PM_TOKEN_INSTANCE_VARIABLE:
18793 receiver = UP(pm_instance_variable_read_node_create(parser, &identifier));
18795 case PM_TOKEN_CLASS_VARIABLE:
18796 receiver = UP(pm_class_variable_read_node_create(parser, &identifier));
18798 case PM_TOKEN_GLOBAL_VARIABLE:
18799 receiver = UP(pm_global_variable_read_node_create(parser, &identifier));
18801 case PM_TOKEN_KEYWORD_NIL:
18802 receiver = UP(pm_nil_node_create(parser, &identifier));
18804 case PM_TOKEN_KEYWORD_SELF:
18805 receiver = UP(pm_self_node_create(parser, &identifier));
18807 case PM_TOKEN_KEYWORD_TRUE:
18808 receiver = UP(pm_true_node_create(parser, &identifier));
18810 case PM_TOKEN_KEYWORD_FALSE:
18811 receiver = UP(pm_false_node_create(parser, &identifier));
18813 case PM_TOKEN_KEYWORD___FILE__:
18814 receiver = UP(pm_source_file_node_create(parser, &identifier));
18816 case PM_TOKEN_KEYWORD___LINE__:
18817 receiver = UP(pm_source_line_node_create(parser, &identifier));
18819 case PM_TOKEN_KEYWORD___ENCODING__:
18820 receiver = UP(pm_source_encoding_node_create(parser, &identifier));
18826 name = parse_method_definition_name(parser);
18829 PM_PARSER_ERR_TOKEN_FORMAT(parser, &identifier, PM_ERR_DEF_NAME, pm_token_str(identifier.
type));
18836 case PM_TOKEN_PARENTHESIS_LEFT: {
18840 context_pop(parser);
18841 lex_state_set(parser, PM_LEX_STATE_BEG);
18842 parser_lex(parser);
18845 pm_node_t *expression = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_DEF_RECEIVER, (uint16_t) (depth + 1));
18847 accept1(parser, PM_TOKEN_NEWLINE);
18848 expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);
18851 lex_state_set(parser, PM_LEX_STATE_FNAME);
18852 expect2(parser, PM_TOKEN_DOT, PM_TOKEN_COLON_COLON, PM_ERR_DEF_RECEIVER_TERM);
18854 operator = parser->previous;
18855 receiver = UP(pm_parentheses_node_create(parser, &lparen, expression, &rparen, 0));
18859 pm_parser_scope_push(parser,
true);
18860 context_push(parser, PM_CONTEXT_DEF_PARAMS);
18861 name = parse_method_definition_name(parser);
18865 pm_parser_scope_push(parser,
true);
18866 name = parse_method_definition_name(parser);
18872 pm_parameters_node_t *params;
18874 bool accept_endless_def =
true;
18875 switch (parser->current.type) {
18876 case PM_TOKEN_PARENTHESIS_LEFT: {
18877 parser_lex(parser);
18878 lparen = parser->previous;
18880 if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
18884 bool allow_trailing_comma = parser->version >= PM_OPTIONS_VERSION_CRUBY_4_1;
18885 params = parse_parameters(
18887 PM_BINDING_POWER_DEFINED,
18889 allow_trailing_comma,
18893 PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES,
18894 (uint16_t) (depth + 1)
18898 lex_state_set(parser, PM_LEX_STATE_BEG);
18899 parser->command_start =
true;
18901 context_pop(parser);
18902 if (!accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
18903 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_DEF_PARAMS_TERM_PAREN, pm_token_str(parser->current.type));
18904 parser->previous.
start = parser->previous.
end;
18905 parser->previous.
type = 0;
18908 rparen = parser->previous;
18911 case PM_CASE_PARAMETER: {
18914 if (parser->current.type == PM_TOKEN_LABEL) {
18915 lex_state_set(parser, parser->lex_state | PM_LEX_STATE_LABEL);
18918 params = parse_parameters(
18920 PM_BINDING_POWER_DEFINED,
18926 PM_ERR_ARGUMENT_NO_FORWARDING_ELLIPSES,
18927 (uint16_t) (depth + 1)
18932 accept_endless_def =
false;
18934 context_pop(parser);
18939 context_pop(parser);
18944 pm_node_t *statements = NULL;
18948 if (accept1(parser, PM_TOKEN_EQUAL)) {
18949 if (token_is_setter_name(&name)) {
18950 pm_parser_err_token(parser, &name, PM_ERR_DEF_ENDLESS_SETTER);
18952 if (!accept_endless_def) {
18953 pm_parser_err_previous(parser, PM_ERR_DEF_ENDLESS_PARAMETERS);
18956 parser->current_context->context == PM_CONTEXT_DEFAULT_PARAMS &&
18957 parser->current_context->prev->context == PM_CONTEXT_BLOCK_PARAMETERS
18959 PM_PARSER_ERR_FORMAT(parser, PM_TOKEN_START(parser, &def_keyword), PM_TOKENS_LENGTH(&def_keyword, &parser->previous), PM_ERR_UNEXPECTED_PARAMETER_DEFAULT_VALUE,
"endless method definition");
18961 equal = parser->previous;
18963 context_push(parser, PM_CONTEXT_DEF);
18964 pm_do_loop_stack_push(parser,
false);
18968 uint8_t allow_flags = (flags & PM_PARSE_ACCEPTS_COMMAND_DEF) ? PM_PARSE_ACCEPTS_COMMAND_CALL : 0;
18980 pm_accepts_block_stack_push(parser,
true);
18981 pm_node_t *statement = parse_expression(parser, PM_BINDING_POWER_DEFINED + 1, allow_flags | PM_PARSE_IN_ENDLESS_DEF, PM_ERR_DEF_ENDLESS, (uint16_t) (depth + 1));
18987 while (accept1(parser, PM_TOKEN_KEYWORD_RESCUE_MODIFIER)) {
18988 context_push(parser, PM_CONTEXT_RESCUE_MODIFIER);
18990 pm_token_t rescue_keyword = parser->previous;
18994 pm_node_t *value = parse_expression(parser, PM_BINDING_POWER_MATCH + 1, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_RESCUE_MODIFIER_VALUE, (uint16_t) (depth + 1));
18995 context_pop(parser);
18997 statement = UP(pm_rescue_modifier_node_create(parser, statement, &rescue_keyword, value));
19002 if (accept1(parser, PM_TOKEN_KEYWORD_DO)) {
19003 pm_block_node_t *block = parse_block(parser, (uint16_t) (depth + 1));
19004 pm_parser_err_node(parser, UP(block), PM_ERR_DEF_ENDLESS_DO_BLOCK);
19007 pm_accepts_block_stack_pop(parser);
19012 if (PM_NODE_TYPE_P(statement, PM_DEF_NODE) && pm_command_call_value_p(parser, statement)) {
19013 PM_PARSER_ERR_NODE_FORMAT(parser, statement, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(parser->current.type));
19016 statements = UP(pm_statements_node_single_create(parser, statement,
false));
19017 pm_do_loop_stack_pop(parser);
19018 context_pop(parser);
19020 if (lparen.
start == NULL) {
19021 lex_state_set(parser, PM_LEX_STATE_BEG);
19022 parser->command_start =
true;
19023 expect2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_ERR_DEF_PARAMS_TERM);
19025 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
19028 pm_accepts_block_stack_push(parser,
true);
19029 pm_do_loop_stack_push(parser,
false);
19031 if (!match4(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
19032 pm_accepts_block_stack_push(parser,
true);
19033 statements = UP(parse_statements(parser, PM_CONTEXT_DEF, (uint16_t) (depth + 1)));
19034 pm_accepts_block_stack_pop(parser);
19037 if (match3(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE)) {
19038 PRISM_ASSERT(statements == NULL || PM_NODE_TYPE_P(statements, PM_STATEMENTS_NODE));
19039 context_push(parser, PM_CONTEXT_DEF);
19040 statements = UP(parse_rescues_implicit_begin(parser, opening_newline_index, &def_keyword, def_keyword.
start, (pm_statements_node_t *) statements, PM_RESCUES_DEF, (uint16_t) (depth + 1)));
19041 context_pop(parser);
19043 parser_warn_indentation_mismatch(parser, opening_newline_index, &def_keyword,
false,
false);
19046 pm_accepts_block_stack_pop(parser);
19047 pm_do_loop_stack_pop(parser);
19049 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_DEF_TERM, &def_keyword);
19050 end_keyword = parser->previous;
19054 pm_locals_order(parser, &locals,
false);
19055 pm_parser_scope_pop(parser);
19060 pm_constant_id_t name_id = pm_parser_constant_id_raw(parser, name.
start, parse_operator_symbol_name(&name));
19062 flush_block_exits(parser, previous_block_exits);
19064 return UP(pm_def_node_create(
19073 NTOK2PTR(
operator),
19077 NTOK2PTR(end_keyword)
19085parse_module(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
19089 size_t opening_newline_index = token_newline_index(parser);
19090 parser_lex(parser);
19091 pm_token_t module_keyword = parser->previous;
19093 pm_node_t *constant_path = parse_expression(parser, PM_BINDING_POWER_INDEX, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_MODULE_NAME, (uint16_t) (depth + 1));
19098 if (PM_NODE_TYPE_P(constant_path, PM_ERROR_RECOVERY_NODE)) {
19099 pop_block_exits(parser, previous_block_exits);
19102 return UP(pm_module_node_create(parser, NULL, &module_keyword, constant_path, &missing, NULL, &missing));
19105 while (accept1(parser, PM_TOKEN_COLON_COLON)) {
19108 expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
19109 constant_path = UP(pm_constant_path_node_create(parser, constant_path, &double_colon, &parser->previous));
19115 name = parser->previous;
19116 if (name.
type != PM_TOKEN_CONSTANT) {
19117 pm_parser_err_token(parser, &name, PM_ERR_MODULE_NAME);
19120 if (!PM_NODE_TYPE_P(constant_path, PM_CONSTANT_READ_NODE) && !PM_NODE_TYPE_P(constant_path, PM_CONSTANT_PATH_NODE) && !PM_NODE_TYPE_P(constant_path, PM_ERROR_RECOVERY_NODE)) {
19121 if (name.
type == PM_TOKEN_CONSTANT) pm_parser_err_node(parser, constant_path, PM_ERR_MODULE_NAME);
19122 constant_path = UP(pm_error_recovery_node_create_unexpected(parser, constant_path));
19125 pm_parser_scope_push(parser,
true);
19126 accept2(parser, PM_TOKEN_SEMICOLON, PM_TOKEN_NEWLINE);
19127 pm_node_t *statements = NULL;
19129 if (!match4(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
19130 pm_accepts_block_stack_push(parser,
true);
19131 statements = UP(parse_statements(parser, PM_CONTEXT_MODULE, (uint16_t) (depth + 1)));
19132 pm_accepts_block_stack_pop(parser);
19135 if (match3(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE)) {
19136 PRISM_ASSERT(statements == NULL || PM_NODE_TYPE_P(statements, PM_STATEMENTS_NODE));
19137 statements = UP(parse_rescues_implicit_begin(parser, opening_newline_index, &module_keyword, module_keyword.
start, (pm_statements_node_t *) statements, PM_RESCUES_MODULE, (uint16_t) (depth + 1)));
19139 parser_warn_indentation_mismatch(parser, opening_newline_index, &module_keyword,
false,
false);
19143 pm_locals_order(parser, &locals,
false);
19145 pm_parser_scope_pop(parser);
19146 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_MODULE_TERM, &module_keyword);
19148 if (context_def_p(parser)) {
19149 pm_parser_err_token(parser, &module_keyword, PM_ERR_MODULE_IN_METHOD);
19152 pop_block_exits(parser, previous_block_exits);
19154 return UP(pm_module_node_create(parser, &locals, &module_keyword, constant_path, &name, statements, &parser->previous));
19162parse_parentheses(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
19164 pm_node_flags_t paren_flags = 0;
19169 parser_lex(parser);
19171 if (accept1(parser, PM_TOKEN_SEMICOLON)) {
19172 paren_flags |= PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS;
19173 }
else if (!accept1(parser, PM_TOKEN_NEWLINE)) {
19180 if (match2(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_TOKEN_EOF)) {
19184 if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT) && opening.
type == PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES) {
19185 lex_state_set(parser, PM_LEX_STATE_ENDARG);
19188 expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);
19189 pop_block_exits(parser, previous_block_exits);
19190 return UP(pm_parentheses_node_create(parser, &opening, NULL, &parser->previous, paren_flags));
19195 context_push(parser, PM_CONTEXT_PARENS);
19196 pm_node_t *statement = parse_expression(parser, PM_BINDING_POWER_STATEMENT, PM_PARSE_ACCEPTS_COMMAND_CALL | PM_PARSE_ACCEPTS_COMMAND_DEF | PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_CANNOT_PARSE_EXPRESSION, (uint16_t) (depth + 1));
19197 context_pop(parser);
19202 bool terminator_found =
false;
19204 if (accept1(parser, PM_TOKEN_SEMICOLON)) {
19205 terminator_found =
true;
19206 paren_flags |= PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS;
19207 }
else if (accept1(parser, PM_TOKEN_NEWLINE)) {
19208 terminator_found =
true;
19211 if (terminator_found) {
19213 if (accept1(parser, PM_TOKEN_SEMICOLON)) {
19214 paren_flags |= PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS;
19215 }
else if (!accept1(parser, PM_TOKEN_NEWLINE)) {
19223 if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
19224 if (opening.
type == PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES) {
19225 lex_state_set(parser, PM_LEX_STATE_ENDARG);
19228 parser_lex(parser);
19229 pop_block_exits(parser, previous_block_exits);
19231 if (PM_NODE_TYPE_P(statement, PM_MULTI_TARGET_NODE) || PM_NODE_TYPE_P(statement, PM_SPLAT_NODE)) {
19235 pm_multi_target_node_t *multi_target;
19237 if (PM_NODE_TYPE_P(statement, PM_MULTI_TARGET_NODE) && ((pm_multi_target_node_t *) statement)->lparen_loc.length == 0) {
19238 multi_target = (pm_multi_target_node_t *) statement;
19239 multi_target->
lparen_loc = TOK2LOC(parser, &opening);
19240 multi_target->
rparen_loc = TOK2LOC(parser, &parser->previous);
19241 PM_NODE_START_SET_TOKEN(parser, multi_target, &opening);
19242 PM_NODE_LENGTH_SET_TOKEN(parser, multi_target, &parser->previous);
19245 pm_multi_targets_append(parser, &targets, statement);
19246 multi_target = pm_multi_target_node_create(parser, &targets, &opening, &parser->previous);
19250 if (match1(parser, PM_TOKEN_COMMA) && (binding_power == PM_BINDING_POWER_STATEMENT)) {
19251 result = parse_targets(parser, UP(multi_target), PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
19253 result = UP(multi_target);
19256 if (context_p(parser, PM_CONTEXT_MULTI_TARGET)) {
19258 }
else if (context_p(parser, PM_CONTEXT_FOR_INDEX) && match2(parser, PM_TOKEN_KEYWORD_IN, PM_TOKEN_COMMA)) {
19262 }
else if (flags & PM_PARSE_ACCEPTS_STATEMENT) {
19266 if (pm_binding_powers[parser->current.type].binary && !match1(parser, PM_TOKEN_EQUAL)) {
19267 pm_parser_err_node(parser, result, PM_ERR_WRITE_TARGET_UNEXPECTED);
19269 }
else if (binding_power != PM_BINDING_POWER_STATEMENT) {
19272 pm_parser_err_node(parser, result, PM_ERR_WRITE_TARGET_UNEXPECTED);
19273 }
else if (context_p(parser, PM_CONTEXT_PARENS) && accept1(parser, PM_TOKEN_NEWLINE)) {
19274 if (!match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) pm_parser_err_node(parser, result, PM_ERR_WRITE_TARGET_UNEXPECTED);
19275 }
else if (!match2(parser, PM_TOKEN_EQUAL, PM_TOKEN_PARENTHESIS_RIGHT)) {
19278 pm_parser_err_node(parser, result, PM_ERR_WRITE_TARGET_UNEXPECTED);
19287 pm_statements_node_t *statements = pm_statements_node_single_create(parser, statement,
true);
19288 return UP(pm_parentheses_node_create(parser, &opening, UP(statements), &parser->previous, paren_flags));
19294 context_push(parser, PM_CONTEXT_PARENS);
19295 paren_flags |= PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS;
19298 pm_statements_body_append(parser, &body, statement,
true);
19302 if (!terminator_found && !match1(parser, PM_TOKEN_EOF)) {
19303 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(parser->current.type));
19308 pm_node_t *node = parse_expression(parser, PM_BINDING_POWER_STATEMENT, PM_PARSE_ACCEPTS_COMMAND_CALL | PM_PARSE_ACCEPTS_COMMAND_DEF | PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_CANNOT_PARSE_EXPRESSION, (uint16_t) (depth + 1));
19309 pm_statements_body_append(parser, &body, node,
true);
19313 if (parser->recovering) {
19316 if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) parser->recovering =
false;
19322 if (PM_NODE_TYPE_P(node, PM_ERROR_RECOVERY_NODE))
break;
19326 if (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON)) {
19327 while (accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON));
19328 if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT))
break;
19329 }
else if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
19331 }
else if (!match1(parser, PM_TOKEN_EOF)) {
19334 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(parser->current.type));
19338 context_pop(parser);
19339 expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);
19340 pm_statements_node_t *statements = pm_statements_node_create(parser, &body);
19349 if (PM_NODE_TYPE_P(statement, PM_SPLAT_NODE)) {
19351 pm_multi_targets_append(parser, &targets, statement);
19352 statement = UP(pm_multi_target_node_create(parser, &targets, NULL, NULL));
19356 if (PM_NODE_TYPE_P(statement, PM_MULTI_TARGET_NODE)) {
19357 const uint8_t *offset = parser->start + PM_NODE_END(statement);
19358 pm_token_t operator = { .type = PM_TOKEN_EQUAL, .start = offset, .end = offset };
19359 pm_node_t *value = UP(pm_error_recovery_node_create(parser, PM_NODE_END(statement), 0));
19361 statement = UP(pm_multi_write_node_create(parser, (pm_multi_target_node_t *) statement, &
operator, value));
19364 pm_parser_err_node(parser, statement, PM_ERR_WRITE_TARGET_UNEXPECTED);
19368 pop_block_exits(parser, previous_block_exits);
19369 pm_void_statements_check(parser, statements,
true);
19370 return UP(pm_parentheses_node_create(parser, &opening, UP(statements), &parser->previous, paren_flags));
19379parse_splat(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
19381 pm_node_t *name = NULL;
19383 if (token_begins_expression_p(parser->current.type)) {
19384 name = parse_expression(parser, PM_BINDING_POWER_INDEX, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_STAR, (uint16_t) (depth + 1));
19387 return UP(pm_splat_node_create(parser, &
operator, name));
19390static pm_keyword_hash_node_t *
19391parse_array_keyword_hash(
pm_parser_t *parser, pm_node_t *key, uint8_t flags, uint16_t depth) {
19395 pm_hash_key_static_literals_add(parser, &hash_keys, key);
19398 if (parser->previous.
type == PM_TOKEN_EQUAL_GREATER) {
19399 operator = parser->previous;
19402 pm_node_t *value = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_HASH_VALUE, (uint16_t) (depth + 1));
19403 pm_node_t *assoc = UP(pm_assoc_node_create(parser, key, NTOK2PTR(
operator), value));
19404 pm_hash_elements_append(parser, &elements, assoc);
19406 if (accept1(parser, PM_TOKEN_COMMA) && !match1(parser, PM_TOKEN_BRACKET_RIGHT)) {
19407 parse_assocs(parser, &hash_keys, &elements, (uint16_t) (depth + 1));
19410 pm_static_literals_free(&hash_keys);
19411 return pm_keyword_hash_node_create(parser, &elements);
19414static pm_array_node_t *
19415parse_array(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
19417 parser_lex(parser);
19421 bool parsed_bare_hash =
false;
19422 while (!match2(parser, PM_TOKEN_BRACKET_RIGHT, PM_TOKEN_EOF)) {
19423 bool accepted_newline = accept1(parser, PM_TOKEN_NEWLINE);
19427 if (accepted_newline && match1(parser, PM_TOKEN_BRACKET_RIGHT)) {
19433 if (accept1(parser, PM_TOKEN_COMMA)) {
19436 if (accepted_newline) {
19437 pm_parser_err_previous(parser, PM_ERR_INVALID_COMMA);
19442 PM_PARSER_ERR_FORMAT(parser, PM_TOKEN_END(parser, &parser->previous), 0, PM_ERR_ARRAY_SEPARATOR, pm_token_str(parser->current.type));
19443 parser->previous.
start = parser->previous.
end;
19444 parser->previous.
type = 0;
19451 if (match1(parser, PM_TOKEN_BRACKET_RIGHT))
break;
19453 pm_node_t *element;
19455 if (accept1(parser, PM_TOKEN_USTAR)) {
19457 pm_node_t *expression = NULL;
19459 if (match3(parser, PM_TOKEN_BRACKET_RIGHT, PM_TOKEN_COMMA, PM_TOKEN_EOF)) {
19460 pm_parser_scope_forwarding_positionals_check(parser, &
operator);
19462 expression = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_ARRAY_EXPRESSION_AFTER_STAR, (uint16_t) (depth + 1));
19465 element = UP(pm_splat_node_create(parser, &
operator, expression));
19466 }
else if (match2(parser, PM_TOKEN_LABEL, PM_TOKEN_USTAR_STAR)) {
19467 if (parsed_bare_hash) {
19468 pm_parser_err_current(parser, PM_ERR_EXPRESSION_BARE_HASH);
19474 if (!match8(parser, PM_TOKEN_EOF, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_TOKEN_KEYWORD_DO_BLOCK, PM_TOKEN_BRACE_RIGHT, PM_TOKEN_BRACKET_RIGHT, PM_TOKEN_KEYWORD_DO, PM_TOKEN_PARENTHESIS_RIGHT)) {
19475 parse_assocs(parser, &hash_keys, &hash_elements, (uint16_t) (depth + 1));
19478 pm_static_literals_free(&hash_keys);
19479 element = UP(pm_keyword_hash_node_create(parser, &hash_elements));
19480 parsed_bare_hash =
true;
19482 element = parse_value_expression(parser, PM_BINDING_POWER_DEFINED, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_LABEL), PM_ERR_ARRAY_EXPRESSION, (uint16_t) (depth + 1));
19484 if (pm_symbol_node_label_p(parser, element) || accept1(parser, PM_TOKEN_EQUAL_GREATER)) {
19485 if (parsed_bare_hash) {
19486 pm_parser_err_previous(parser, PM_ERR_EXPRESSION_BARE_HASH);
19489 element = UP(parse_array_keyword_hash(parser, element, flags, depth));
19490 parsed_bare_hash =
true;
19494 pm_array_elements_append(parser, &elements, element);
19495 if (PM_NODE_TYPE_P(element, PM_ERROR_RECOVERY_NODE))
break;
19498 accept1(parser, PM_TOKEN_NEWLINE);
19500 if (!accept1(parser, PM_TOKEN_BRACKET_RIGHT)) {
19501 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_ARRAY_TERM, pm_token_str(parser->current.type));
19502 const uint8_t *end = match1(parser, PM_TOKEN_EOF) ? parser->current.end : parser->previous.
end;
19503 parser->previous.
start = end;
19504 parser->previous.
end = end;
19505 parser->previous.
type = 0;
19508 return pm_array_node_create(parser, &opening, &elements, &parser->previous);
19511static pm_hash_node_t *
19514 parser_lex(parser);
19517 if (!match2(parser, PM_TOKEN_BRACE_RIGHT, PM_TOKEN_EOF)) {
19519 parse_assocs(parser, &hash_keys, &elements, (uint16_t) (depth + 1));
19520 pm_static_literals_free(&hash_keys);
19522 accept1(parser, PM_TOKEN_NEWLINE);
19525 expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_HASH_TERM, &opening);
19526 return pm_hash_node_create(parser, &opening, &elements, &parser->previous);
19530parse_heredoc(
pm_parser_t *parser, uint16_t depth) {
19531 if (
PRISM_UNLIKELY(depth >= PRISM_DEPTH_MAXIMUM || pm_parser_stack_exhausted(parser))) {
19532 return parse_resource_recovery(parser, depth);
19535 PRISM_ASSERT(parser->lex_modes.current->mode == PM_LEX_HEREDOC);
19538 size_t common_whitespace = (size_t) -1;
19539 parser->lex_modes.current->as.heredoc.common_whitespace = &common_whitespace;
19541 parser_lex(parser);
19547 if (match2(parser, PM_TOKEN_HEREDOC_END, PM_TOKEN_EOF)) {
19550 expect1_heredoc_term(parser, lex_mode.ident_start, lex_mode.ident_length);
19551 pm_token_t content = parse_strings_empty_content(parser->previous.
start);
19553 if (lex_mode.quote == PM_HEREDOC_QUOTE_BACKTICK) {
19554 node = UP(pm_xstring_node_create_unescaped(parser, &opening, &content, &parser->previous, &PM_STRING_EMPTY));
19556 node = UP(pm_string_node_create_unescaped(parser, &opening, &content, &parser->previous, &PM_STRING_EMPTY));
19559 PM_NODE_LENGTH_SET_TOKEN(parser, node, &opening);
19560 }
else if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) == NULL) {
19567 node = UP(pm_error_recovery_node_create(parser, PM_TOKEN_START(parser, &parser->previous), PM_TOKEN_LENGTH(&parser->previous)));
19568 }
else if (PM_NODE_TYPE_P(part, PM_STRING_NODE) && match2(parser, PM_TOKEN_HEREDOC_END, PM_TOKEN_EOF)) {
19573 pm_node_flag_set(part, parse_unescaped_encoding(parser, parser->explicit_encoding));
19574 pm_string_node_t *
cast = (pm_string_node_t *) part;
19576 cast->opening_loc = TOK2LOC(parser, &opening);
19577 cast->closing_loc = TOK2LOC(parser, &parser->current);
19578 cast->base.location =
cast->opening_loc;
19580 if (lex_mode.quote == PM_HEREDOC_QUOTE_BACKTICK) {
19581 PRISM_ASSERT(
sizeof(pm_string_node_t) ==
sizeof(pm_x_string_node_t));
19582 cast->base.type = PM_X_STRING_NODE;
19585 if (lex_mode.indent == PM_HEREDOC_INDENT_TILDE && (common_whitespace != (
size_t) -1) && (common_whitespace != 0)) {
19586 parse_heredoc_dedent_string(parser->arena, &
cast->unescaped, common_whitespace);
19590 expect1_heredoc_term(parser, lex_mode.ident_start, lex_mode.ident_length);
19595 pm_node_list_t parts = { 0 };
19596 pm_node_list_open_append(&parser->node_chunks, &parts, part);
19598 while (!match2(parser, PM_TOKEN_HEREDOC_END, PM_TOKEN_EOF)) {
19599 if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
19600 pm_node_list_open_append(&parser->node_chunks, &parts, part);
19606 expect1_heredoc_term(parser, lex_mode.ident_start, lex_mode.ident_length);
19608 if (lex_mode.quote == PM_HEREDOC_QUOTE_BACKTICK) {
19611 pm_node_list_finalize(&parser->node_chunks, parser->arena, &parts);
19613 node = UP(pm_interpolated_x_string_node_new(
19617 TOK2LOC(parser, &opening),
19618 TOK2LOC(parser, &opening),
19620 TOK2LOC(parser, &parser->previous)
19623 pm_interpolated_string_node_t *
cast = pm_interpolated_string_node_create(parser, &opening, &parts, &parser->previous);
19624 cast->base.location =
cast->opening_loc;
19630 if (lex_mode.indent == PM_HEREDOC_INDENT_TILDE && (common_whitespace != (
size_t) -1) && (common_whitespace != 0)) {
19631 pm_node_list_t *nodes;
19632 if (lex_mode.quote == PM_HEREDOC_QUOTE_BACKTICK) {
19633 nodes = &((pm_interpolated_x_string_node_t *) node)->parts;
19635 nodes = &((pm_interpolated_string_node_t *) node)->parts;
19638 parse_heredoc_dedent(parser, nodes, common_whitespace);
19646 pm_lex_mode_t *whitespace_mode = parser->lex_modes.current;
19648 if (whitespace_mode->mode == PM_LEX_HEREDOC && whitespace_mode->as.heredoc.common_whitespace == &common_whitespace) {
19649 whitespace_mode->as.heredoc.common_whitespace = NULL;
19651 whitespace_mode = whitespace_mode->prev;
19652 }
while (whitespace_mode != NULL);
19656 parser->previous = opening;
19660static pm_begin_node_t *
19661parse_begin(
pm_parser_t *parser, uint16_t depth) {
19663 size_t opening_newline_index = token_newline_index(parser);
19664 parser_lex(parser);
19666 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
19670 pm_statements_node_t *begin_statements = NULL;
19672 if (!match4(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE, PM_TOKEN_KEYWORD_ELSE, PM_TOKEN_KEYWORD_END)) {
19673 pm_accepts_block_stack_push(parser,
true);
19674 begin_statements = parse_statements(parser, PM_CONTEXT_BEGIN, (uint16_t) (depth + 1));
19675 pm_accepts_block_stack_pop(parser);
19676 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
19679 pm_begin_node_t *node = pm_begin_node_create(parser, &begin_keyword, begin_statements);
19680 parse_rescues(parser, opening_newline_index, &begin_keyword, node, PM_RESCUES_BEGIN, (uint16_t) (depth + 1));
19681 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_BEGIN_TERM, &begin_keyword);
19683 PM_NODE_LENGTH_SET_TOKEN(parser, node, &parser->previous);
19684 pm_begin_node_end_keyword_set(parser, node, &parser->previous);
19685 pop_block_exits(parser, previous_block_exits);
19689static pm_defined_node_t *
19690parse_defined(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
19692 parser_lex(parser);
19696 pm_node_t *expression;
19698 context_push(parser, PM_CONTEXT_DEFINED);
19699 bool newline = accept1(parser, PM_TOKEN_NEWLINE);
19701 if (!newline && accept2(parser, PM_TOKEN_PARENTHESIS_LEFT, PM_TOKEN_PARENTHESIS_LEFT_GROUPING)) {
19702 lparen = parser->previous;
19703 expression = parse_expression(parser, PM_BINDING_POWER_COMPOSITION, PM_PARSE_ACCEPTS_COMMAND_CALL | PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_DEFINED_EXPRESSION, (uint16_t) (depth + 1));
19705 if (!parser->recovering) {
19706 accept1(parser, PM_TOKEN_NEWLINE);
19707 expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);
19708 rparen = parser->previous;
19711 expression = parse_expression(parser, PM_BINDING_POWER_DEFINED, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_DEFINED_EXPRESSION, (uint16_t) (depth + 1));
19714 context_pop(parser);
19715 return pm_defined_node_create(parser, NTOK2PTR(lparen), expression, NTOK2PTR(rparen), &keyword);
19718static pm_for_node_t *
19719parse_for(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
19721 size_t opening_newline_index = token_newline_index(parser);
19722 parser_lex(parser);
19725 context_push(parser, PM_CONTEXT_FOR_INDEX);
19728 if (accept1(parser, PM_TOKEN_USTAR)) {
19729 index = parse_splat(parser, flags, depth);
19730 }
else if (token_begins_expression_p(parser->current.type)) {
19731 index = parse_expression(parser, PM_BINDING_POWER_INDEX, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_COMMA, (uint16_t) (depth + 1));
19733 pm_parser_err_token(parser, &for_keyword, PM_ERR_FOR_INDEX);
19734 index = UP(pm_error_recovery_node_create(parser, PM_TOKEN_START(parser, &for_keyword), PM_TOKEN_LENGTH(&for_keyword)));
19738 if (match1(parser, PM_TOKEN_COMMA)) {
19739 index = parse_targets(parser, index, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
19741 index = parse_target(parser, index,
false,
false);
19744 context_pop(parser);
19745 pm_do_loop_stack_push(parser,
true);
19747 expect1(parser, PM_TOKEN_KEYWORD_IN, PM_ERR_FOR_IN);
19750 pm_node_t *collection = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_FOR_COLLECTION, (uint16_t) (depth + 1));
19751 pm_do_loop_stack_pop(parser);
19754 if (accept1(parser, PM_TOKEN_KEYWORD_DO_LOOP)) {
19755 do_keyword = parser->previous;
19757 if (!match2(parser, PM_TOKEN_SEMICOLON, PM_TOKEN_NEWLINE)) {
19758 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_EXPECT_FOR_DELIMITER, pm_token_str(parser->current.type));
19762 pm_statements_node_t *statements = NULL;
19763 if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
19764 statements = parse_statements(parser, PM_CONTEXT_FOR, (uint16_t) (depth + 1));
19767 parser_warn_indentation_mismatch(parser, opening_newline_index, &for_keyword,
false,
false);
19768 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_FOR_TERM, &for_keyword);
19770 return pm_for_node_create(parser, index, collection, statements, &for_keyword, &in_keyword, NTOK2PTR(do_keyword), &parser->previous);
19773static pm_lambda_node_t *
19774parse_lambda(
pm_parser_t *parser, uint16_t depth) {
19775 int previous_lambda_enclosure_nesting = parser->lambda_enclosure_nesting;
19776 parser->lambda_enclosure_nesting = parser->enclosure_nesting;
19779 size_t opening_newline_index = token_newline_index(parser);
19780 parser_lex(parser);
19782 pm_parser_scope_push(parser,
false);
19783 pm_block_parameters_node_t *block_parameters;
19785 switch (parser->current.type) {
19786 case PM_TOKEN_PARENTHESIS_LEFT: {
19788 parser_lex(parser);
19790 if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
19791 block_parameters = pm_block_parameters_node_create(parser, NULL, &opening, &((pm_node_list_t) { 0 }));
19793 block_parameters = parse_block_parameters(parser,
false, &opening,
true,
true, (uint16_t) (depth + 1));
19796 accept1(parser, PM_TOKEN_NEWLINE);
19797 expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);
19799 pm_block_parameters_node_closing_set(parser, block_parameters, &parser->previous);
19802 case PM_CASE_PARAMETER: {
19803 block_parameters = parse_block_parameters(parser,
false, NULL,
true,
false, (uint16_t) (depth + 1));
19807 block_parameters = NULL;
19813 pm_node_t *body = NULL;
19815 if (accept1(parser, PM_TOKEN_LAMBDA_BEGIN)) {
19816 opening = parser->previous;
19818 if (!match1(parser, PM_TOKEN_BRACE_RIGHT)) {
19819 body = UP(parse_statements(parser, PM_CONTEXT_LAMBDA_BRACES, (uint16_t) (depth + 1)));
19822 parser_warn_indentation_mismatch(parser, opening_newline_index, &
operator,
false,
false);
19828 parser->lambda_enclosure_nesting = previous_lambda_enclosure_nesting;
19829 expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_LAMBDA_TERM_BRACE, &opening);
19837 pm_enclosure_frame_push(parser);
19838 expect1(parser, PM_TOKEN_KEYWORD_DO_LAMBDA, PM_ERR_LAMBDA_OPEN);
19839 opening = parser->previous;
19845 parser->lambda_enclosure_nesting = -1;
19847 if (!match3(parser, PM_TOKEN_KEYWORD_END, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE)) {
19848 body = UP(parse_statements(parser, PM_CONTEXT_LAMBDA_DO_END, (uint16_t) (depth + 1)));
19851 if (match2(parser, PM_TOKEN_KEYWORD_RESCUE, PM_TOKEN_KEYWORD_ENSURE)) {
19852 PRISM_ASSERT(body == NULL || PM_NODE_TYPE_P(body, PM_STATEMENTS_NODE));
19853 body = UP(parse_rescues_implicit_begin(parser, opening_newline_index, &
operator, opening.
start, (pm_statements_node_t *) body, PM_RESCUES_LAMBDA, (uint16_t) (depth + 1)));
19855 parser_warn_indentation_mismatch(parser, opening_newline_index, &
operator,
false,
false);
19858 pm_enclosure_frame_pop(parser);
19862 parser->lambda_enclosure_nesting = previous_lambda_enclosure_nesting;
19863 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_LAMBDA_TERM_END, &
operator);
19867 pm_locals_order(parser, &locals, pm_parser_scope_toplevel_p(parser));
19868 pm_node_t *parameters = parse_blocklike_parameters(parser, UP(block_parameters), &
operator, &parser->previous);
19870 pm_parser_scope_pop(parser);
19871 return pm_lambda_node_create(parser, &locals, &
operator, &opening, &parser->previous, parameters, body);
19875parse_regexp(
pm_parser_t *parser, uint16_t depth) {
19877 parser_lex(parser);
19879 if (match1(parser, PM_TOKEN_REGEXP_END)) {
19884 .type = PM_TOKEN_STRING_CONTENT,
19885 .start = parser->previous.
end,
19886 .end = parser->previous.
end
19889 parser_lex(parser);
19891 pm_regular_expression_node_t *node = pm_regular_expression_node_create(parser, &opening, &content, &parser->previous);
19893 pm_node_flag_set(UP(node), pm_regexp_parse(parser, node, &offsets));
19897 pm_node_list_t parts = { 0 };
19899 if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
19907 parser_lex(parser);
19912 if (accept1(parser, PM_TOKEN_REGEXP_END)) {
19913 pm_regular_expression_node_t *node = (pm_regular_expression_node_t *) pm_regular_expression_node_create_unescaped(parser, &opening, &content, &parser->previous, &unescaped);
19918 pm_node_flag_set(UP(node), pm_regexp_parse(parser, node, &offsets));
19924 pm_node_t *part = UP(pm_string_node_create_unescaped(parser, NULL, &parser->previous, NULL, &unescaped));
19925 if (parser->encoding == PM_ENCODING_US_ASCII_ENTRY) {
19929 pm_node_flag_set(part, PM_STRING_FLAGS_FORCED_BINARY_ENCODING);
19932 pm_node_list_open_append(&parser->node_chunks, &parts, part);
19938 while (!match2(parser, PM_TOKEN_REGEXP_END, PM_TOKEN_EOF)) {
19939 if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
19940 pm_node_list_open_append(&parser->node_chunks, &parts, part);
19945 bool terminated = !match1(parser, PM_TOKEN_EOF);
19948 expect1(parser, PM_TOKEN_REGEXP_END, PM_ERR_REGEXP_TERM);
19950 pm_parser_err_token(parser, &opening, PM_ERR_REGEXP_TERM);
19951 closing = (
pm_token_t) { .type = 0, .start = parser->previous.
end, .end = parser->previous.
end };
19956 pm_interpolated_regular_expression_node_t *interpolated = pm_interpolated_regular_expression_node_create(parser, &opening, &parts, &closing);
19957 pm_regexp_parse_interpolated(parser, interpolated);
19959 return UP(interpolated);
19963parse_alias(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
19964 if (binding_power != PM_BINDING_POWER_STATEMENT && !(flags & PM_PARSE_ACCEPTS_STATEMENT)) {
19965 pm_parser_err_current(parser, PM_ERR_STATEMENT_ALIAS);
19969 parser_lex(parser);
19971 pm_node_t *new_name = parse_alias_argument(parser,
true, (uint16_t) (depth + 1));
19972 pm_node_t *old_name = parse_alias_argument(parser,
false, (uint16_t) (depth + 1));
19974 switch (PM_NODE_TYPE(new_name)) {
19975 case PM_BACK_REFERENCE_READ_NODE:
19976 case PM_NUMBERED_REFERENCE_READ_NODE:
19977 case PM_GLOBAL_VARIABLE_READ_NODE: {
19978 if (PM_NODE_TYPE_P(old_name, PM_BACK_REFERENCE_READ_NODE) || PM_NODE_TYPE_P(old_name, PM_NUMBERED_REFERENCE_READ_NODE) || PM_NODE_TYPE_P(old_name, PM_GLOBAL_VARIABLE_READ_NODE)) {
19979 if (PM_NODE_TYPE_P(old_name, PM_NUMBERED_REFERENCE_READ_NODE)) {
19980 pm_parser_err_node(parser, old_name, PM_ERR_ALIAS_ARGUMENT_NUMBERED_REFERENCE);
19982 }
else if (!PM_NODE_TYPE_P(old_name, PM_ERROR_RECOVERY_NODE)) {
19983 pm_parser_err_node(parser, old_name, PM_ERR_ALIAS_ARGUMENT);
19984 old_name = UP(pm_error_recovery_node_create_unexpected(parser, old_name));
19987 return UP(pm_alias_global_variable_node_create(parser, &keyword, new_name, old_name));
19989 case PM_SYMBOL_NODE:
19990 case PM_INTERPOLATED_SYMBOL_NODE: {
19991 if (!PM_NODE_TYPE_P(old_name, PM_SYMBOL_NODE) && !PM_NODE_TYPE_P(old_name, PM_INTERPOLATED_SYMBOL_NODE) && !PM_NODE_TYPE_P(old_name, PM_ERROR_RECOVERY_NODE)) {
19992 pm_parser_err_node(parser, old_name, PM_ERR_ALIAS_ARGUMENT);
19993 old_name = UP(pm_error_recovery_node_create_unexpected(parser, old_name));
19998 return UP(pm_alias_method_node_create(parser, &keyword, new_name, old_name));
20002static pm_until_node_t *
20003parse_until(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
20005 size_t opening_newline_index = token_newline_index(parser);
20007 context_push(parser, PM_CONTEXT_LOOP_PREDICATE);
20008 pm_do_loop_stack_push(parser,
true);
20010 parser_lex(parser);
20011 pm_node_t *predicate = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_CONDITIONAL_UNTIL_PREDICATE, (uint16_t) (depth + 1));
20013 pm_do_loop_stack_pop(parser);
20014 context_pop(parser);
20017 if (accept1(parser, PM_TOKEN_KEYWORD_DO_LOOP)) {
20018 do_keyword = parser->previous;
20020 expect2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_ERR_CONDITIONAL_UNTIL_PREDICATE);
20023 pm_statements_node_t *statements = NULL;
20024 if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
20025 pm_accepts_block_stack_push(parser,
true);
20026 statements = parse_statements(parser, PM_CONTEXT_UNTIL, (uint16_t) (depth + 1));
20027 pm_accepts_block_stack_pop(parser);
20028 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
20031 parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword,
false,
false);
20032 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_UNTIL_TERM, &keyword);
20034 return pm_until_node_create(parser, &keyword, NTOK2PTR(do_keyword), &parser->previous, predicate, statements, 0);
20037static pm_while_node_t *
20038parse_while(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
20040 size_t opening_newline_index = token_newline_index(parser);
20042 context_push(parser, PM_CONTEXT_LOOP_PREDICATE);
20043 pm_do_loop_stack_push(parser,
true);
20045 parser_lex(parser);
20046 pm_node_t *predicate = parse_value_expression(parser, PM_BINDING_POWER_COMPOSITION, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_CONDITIONAL_WHILE_PREDICATE, (uint16_t) (depth + 1));
20048 pm_do_loop_stack_pop(parser);
20049 context_pop(parser);
20052 if (accept1(parser, PM_TOKEN_KEYWORD_DO_LOOP)) {
20053 do_keyword = parser->previous;
20055 expect2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON, PM_ERR_CONDITIONAL_WHILE_PREDICATE);
20058 pm_statements_node_t *statements = NULL;
20059 if (!match1(parser, PM_TOKEN_KEYWORD_END)) {
20060 pm_accepts_block_stack_push(parser,
true);
20061 statements = parse_statements(parser, PM_CONTEXT_WHILE, (uint16_t) (depth + 1));
20062 pm_accepts_block_stack_pop(parser);
20063 accept2(parser, PM_TOKEN_NEWLINE, PM_TOKEN_SEMICOLON);
20066 parser_warn_indentation_mismatch(parser, opening_newline_index, &keyword,
false,
false);
20067 expect1_opening(parser, PM_TOKEN_KEYWORD_END, PM_ERR_WHILE_TERM, &keyword);
20069 return pm_while_node_create(parser, &keyword, NTOK2PTR(do_keyword), &parser->previous, predicate, statements, 0);
20073parse_xstring(
pm_parser_t *parser, uint16_t depth) {
20075 parser_lex(parser);
20081 if (match1(parser, PM_TOKEN_STRING_END)) {
20086 .type = PM_TOKEN_STRING_CONTENT,
20087 .start = parser->previous.
end,
20088 .end = parser->previous.
end
20091 parser_lex(parser);
20092 return UP(pm_xstring_node_create(parser, &opening, &content, &parser->previous));
20095 pm_node_list_t parts = { 0 };
20097 if (match1(parser, PM_TOKEN_STRING_CONTENT)) {
20104 parser_lex(parser);
20106 if (match1(parser, PM_TOKEN_STRING_END)) {
20107 pm_node_t *node = UP(pm_xstring_node_create_unescaped(parser, &opening, &content, &parser->current, &unescaped));
20108 pm_node_flag_set(node, parse_unescaped_encoding(parser, parser->explicit_encoding));
20109 parser_lex(parser);
20115 pm_node_t *part = UP(pm_string_node_create_unescaped(parser, NULL, &parser->previous, NULL, &unescaped));
20116 pm_node_flag_set(part, parse_unescaped_encoding(parser, parser->explicit_encoding));
20118 pm_node_list_open_append(&parser->node_chunks, &parts, part);
20122 while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
20123 if ((part = parse_string_part(parser, (uint16_t) (depth + 1))) != NULL) {
20124 pm_node_list_open_append(&parser->node_chunks, &parts, part);
20129 if (match1(parser, PM_TOKEN_EOF)) {
20130 pm_parser_err_token(parser, &opening, PM_ERR_XSTRING_TERM);
20131 closing = (
pm_token_t) { .type = 0, .start = parser->previous.
end, .end = parser->previous.
end };
20133 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_XSTRING_TERM);
20136 return UP(pm_interpolated_xstring_node_create(parser, &opening, &parts, &closing));
20140parse_multi_target(
pm_parser_t *parser, pm_node_t *node, pm_binding_power_t binding_power, uint16_t depth) {
20141 if ((binding_power == PM_BINDING_POWER_STATEMENT) && match1(parser, PM_TOKEN_COMMA)) {
20144 node = parse_targets_validate(parser, node, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
20150parse_identifier(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
20152 parser_lex(parser);
20155 ((flags & PM_PARSE_ACCEPTS_COMMAND_CALL) && token_begins_argument_p(parser->current.type)) ||
20156 (pm_accepts_block_stack_p(parser) && match1(parser, PM_TOKEN_KEYWORD_DO)) ||
20157 match1(parser, PM_TOKEN_BRACE_LEFT)
20163 if (followed && pm_token_is_numbered_parameter(parser, PM_TOKEN_START(parser, &identifier), PM_TOKEN_LENGTH(&identifier))) {
20164 node = UP(pm_call_node_variable_call_create(parser, &identifier));
20166 node = parse_variable_call(parser);
20169 if (PM_NODE_TYPE_P(node, PM_CALL_NODE)) {
20174 pm_call_node_t *call = (pm_call_node_t *) node;
20177 if (parse_arguments_list(parser, &arguments,
true, flags, (uint16_t) (depth + 1))) {
20180 pm_node_flag_unset(UP(call), PM_CALL_NODE_FLAGS_VARIABLE_CALL);
20183 call->
arguments = pm_arguments_node_create(parser, &arguments);
20189 PM_NODE_LENGTH_SET_LOCATION(call, &call->
message_loc);
20191 PM_NODE_LENGTH_SET_LOCATION(call, end);
20194 }
else if (followed) {
20199 parse_arguments_list(parser, &arguments,
true, flags, (uint16_t) (depth + 1));
20200 pm_call_node_t *fcall = pm_call_node_fcall_create(parser, &identifier, &arguments);
20202 if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
20206 pm_node_unreference(parser, node);
20212 PRISM_ASSERT(PM_NODE_TYPE_P(node, PM_LOCAL_VARIABLE_READ_NODE));
20214 pm_local_variable_read_node_t *
cast = (pm_local_variable_read_node_t *) node;
20215 PRISM_ASSERT(pm_parser_local_depth_constant_id(parser,
cast->name) == (
int)
cast->depth);
20216 pm_locals_unread(parser,
cast->name);
20222 return parse_multi_target(parser, node, binding_power, depth);
20225static pm_array_node_t *
20226parse_uninterpolated_symbol_array(
pm_parser_t *parser) {
20228 parser_lex(parser);
20235 pm_node_t *current = NULL;
20236 pm_node_list_t parts = { 0 };
20238 while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
20239 accept1(parser, PM_TOKEN_WORDS_SEP);
20240 if (match1(parser, PM_TOKEN_STRING_END))
break;
20244 while (match1(parser, PM_TOKEN_STRING_CONTENT)) {
20246 if (parts.
size > 0) {
20247 pm_node_t *
string = UP(pm_string_node_create_current_string(parser, NULL, &parser->current, NULL));
20248 parser_lex(parser);
20249 pm_node_list_open_append(&parser->node_chunks, &parts,
string);
20250 }
else if (current == NULL) {
20251 current = UP(pm_symbol_node_create_current_string(parser, NULL, &parser->current, NULL));
20252 parser_lex(parser);
20254 pm_symbol_node_t *
cast = (pm_symbol_node_t *) current;
20255 pm_token_t content = { .type = PM_TOKEN_STRING_CONTENT, .start = parser->start +
cast->content_loc.start, .end = parser->start +
cast->content_loc.start +
cast->content_loc.length };
20256 pm_node_t *first_string = UP(pm_string_node_create_unescaped(parser, NULL, &content, NULL, &
cast->unescaped));
20257 pm_node_t *second_string = UP(pm_string_node_create_current_string(parser, NULL, &parser->current, NULL));
20258 parser_lex(parser);
20260 pm_node_list_open_append(&parser->node_chunks, &parts, first_string);
20261 pm_node_list_open_append(&parser->node_chunks, &parts, second_string);
20266 if (parts.
size > 0) {
20267 pm_array_elements_append(parser, &elements, UP(pm_interpolated_symbol_node_create(parser, NULL, &parts, NULL)));
20268 parts = (pm_node_list_t) { 0 };
20269 }
else if (current != NULL) {
20270 pm_array_elements_append(parser, &elements, current);
20273 expect1(parser, PM_TOKEN_STRING_CONTENT, PM_ERR_LIST_I_LOWER_ELEMENT);
20278 if (match1(parser, PM_TOKEN_EOF)) {
20279 pm_parser_err_token(parser, &opening, PM_ERR_LIST_I_LOWER_TERM);
20280 closing = (
pm_token_t) { .type = 0, .start = parser->previous.
end, .end = parser->previous.
end };
20282 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_LIST_I_LOWER_TERM);
20285 return pm_array_node_create(parser, &opening, &elements, &closing);
20294 if (PM_NODE_TYPE_P(element, PM_SYMBOL_NODE) && !PM_NODE_FLAG_P(element, PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING | PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING)) {
20295 const pm_symbol_node_t *symbol = (
const pm_symbol_node_t *) element;
20297 .type = PM_TOKEN_STRING_CONTENT,
20299 .end = parser->start + PM_LOCATION_END(&symbol->
content_loc)
20302 if (PM_NODE_FLAG_P(element, PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING)) {
20303 parse_symbol_encoding_validate_utf8(parser, &content, &symbol->
unescaped);
20305 parse_symbol_encoding_validate_other(parser, &content, &symbol->
unescaped);
20309 pm_array_elements_append(parser, elements, element);
20312static pm_array_node_t *
20313parse_interpolated_symbol_array(
pm_parser_t *parser, uint16_t depth) {
20314 parser_lex(parser);
20321 pm_node_t *current = NULL;
20322 pm_node_list_t parts = { 0 };
20324 while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
20325 switch (parser->current.type) {
20326 case PM_TOKEN_WORDS_SEP: {
20329 parser->explicit_encoding = NULL;
20333 if (parts.
size > 0) {
20334 pm_array_elements_append(parser, &elements, UP(pm_interpolated_symbol_node_create(parser, NULL, &parts, NULL)));
20335 parts = (pm_node_list_t) { 0 };
20336 }
else if (current != NULL) {
20337 parse_interpolated_symbol_array_element(parser, &elements, current);
20341 parser_lex(parser);
20344 case PM_TOKEN_STRING_CONTENT: {
20345 if (parts.
size > 0) {
20349 pm_node_t *
string = UP(pm_string_node_create_current_string(parser, NULL, &parser->current, NULL));
20350 parser_lex(parser);
20352 pm_node_list_open_append(&parser->node_chunks, &parts,
string);
20353 }
else if (current == NULL) {
20357 current = UP(pm_symbol_node_create_current_string(parser, NULL, &parser->current, NULL));
20358 parser_lex(parser);
20364 pm_symbol_node_t *
cast = (pm_symbol_node_t *) current;
20366 .type = PM_TOKEN_STRING_CONTENT,
20367 .start = parser->start +
cast->content_loc.start,
20368 .end = parser->start +
cast->content_loc.start +
cast->content_loc.length
20371 pm_node_t *first_string = UP(pm_string_node_create_unescaped(parser, NULL, &content, NULL, &
cast->unescaped));
20372 pm_node_t *second_string = UP(pm_string_node_create_current_string(parser, NULL, &parser->current, NULL));
20373 parser_lex(parser);
20375 pm_node_list_open_append(&parser->node_chunks, &parts, first_string);
20376 pm_node_list_open_append(&parser->node_chunks, &parts, second_string);
20382 case PM_TOKEN_EMBVAR:
20383 case PM_TOKEN_EMBEXPR_BEGIN: {
20387 if (current != NULL) {
20388 pm_node_list_open_append(&parser->node_chunks, &parts, UP(pm_symbol_node_to_string_node(parser, (pm_symbol_node_t *) current)));
20392 pm_node_t *part = parse_string_part(parser, (uint16_t) (depth + 1));
20393 pm_node_list_open_append(&parser->node_chunks, &parts, part);
20397 expect1(parser, PM_TOKEN_STRING_CONTENT, PM_ERR_LIST_I_UPPER_ELEMENT);
20398 parse_discard_token(parser, depth);
20404 if (parts.
size > 0) {
20405 pm_array_elements_append(parser, &elements, UP(pm_interpolated_symbol_node_create(parser, NULL, &parts, NULL)));
20406 }
else if (current != NULL) {
20407 parse_interpolated_symbol_array_element(parser, &elements, current);
20411 if (match1(parser, PM_TOKEN_EOF)) {
20412 pm_parser_err_token(parser, &opening, PM_ERR_LIST_I_UPPER_TERM);
20413 closing = (
pm_token_t) { .type = 0, .start = parser->previous.
end, .end = parser->previous.
end };
20415 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_LIST_I_UPPER_TERM);
20418 return pm_array_node_create(parser, &opening, &elements, &closing);
20421static pm_array_node_t *
20422parse_uninterpolated_string_array(
pm_parser_t *parser) {
20424 parser_lex(parser);
20431 pm_node_t *current = NULL;
20432 pm_node_list_t parts = { 0 };
20434 while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
20435 accept1(parser, PM_TOKEN_WORDS_SEP);
20436 if (match1(parser, PM_TOKEN_STRING_END))
break;
20440 while (match1(parser, PM_TOKEN_STRING_CONTENT)) {
20441 pm_node_t *
string = UP(pm_string_node_create_current_string(parser, NULL, &parser->current, NULL));
20444 if (parts.
size > 0) {
20445 pm_node_list_open_append(&parser->node_chunks, &parts,
string);
20446 }
else if (current == NULL) {
20449 pm_node_list_open_append(&parser->node_chunks, &parts, current);
20450 pm_node_list_open_append(&parser->node_chunks, &parts,
string);
20453 parser_lex(parser);
20456 if (parts.
size > 0) {
20457 pm_array_elements_append(parser, &elements, UP(pm_interpolated_string_node_create(parser, NULL, &parts, NULL)));
20458 parts = (pm_node_list_t) { 0 };
20459 }
else if (current != NULL) {
20460 pm_array_elements_append(parser, &elements, current);
20463 expect1(parser, PM_TOKEN_STRING_CONTENT, PM_ERR_LIST_W_LOWER_ELEMENT);
20468 if (match1(parser, PM_TOKEN_EOF)) {
20469 pm_parser_err_token(parser, &opening, PM_ERR_LIST_W_LOWER_TERM);
20470 closing = (
pm_token_t) { .type = 0, .start = parser->previous.
end, .end = parser->previous.
end };
20472 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_LIST_W_LOWER_TERM);
20475 return pm_array_node_create(parser, &opening, &elements, &closing);
20478static pm_array_node_t *
20479parse_interpolated_string_array(
pm_parser_t *parser, uint16_t depth) {
20481 parser_lex(parser);
20488 pm_node_t *current = NULL;
20489 pm_node_list_t parts = { 0 };
20491 while (!match2(parser, PM_TOKEN_STRING_END, PM_TOKEN_EOF)) {
20492 switch (parser->current.type) {
20493 case PM_TOKEN_WORDS_SEP: {
20496 parser->explicit_encoding = NULL;
20500 if (parts.
size > 0) {
20501 pm_array_elements_append(parser, &elements, UP(pm_interpolated_string_node_create(parser, NULL, &parts, NULL)));
20502 parts = (pm_node_list_t) { 0 };
20503 }
else if (current != NULL) {
20504 pm_array_elements_append(parser, &elements, current);
20508 parser_lex(parser);
20511 case PM_TOKEN_STRING_CONTENT: {
20512 pm_node_t *
string = UP(pm_string_node_create_current_string(parser, NULL, &parser->current, NULL));
20513 pm_node_flag_set(
string, parse_unescaped_encoding(parser, parser->explicit_encoding));
20514 parser_lex(parser);
20516 if (parts.
size > 0) {
20520 pm_node_list_open_append(&parser->node_chunks, &parts,
string);
20521 }
else if (current == NULL) {
20531 pm_node_list_open_append(&parser->node_chunks, &parts, current);
20532 pm_node_list_open_append(&parser->node_chunks, &parts,
string);
20538 case PM_TOKEN_EMBVAR:
20539 case PM_TOKEN_EMBEXPR_BEGIN: {
20543 if (current != NULL) {
20544 pm_node_list_open_append(&parser->node_chunks, &parts, current);
20548 pm_node_t *part = parse_string_part(parser, (uint16_t) (depth + 1));
20549 pm_node_list_open_append(&parser->node_chunks, &parts, part);
20553 expect1(parser, PM_TOKEN_STRING_CONTENT, PM_ERR_LIST_W_UPPER_ELEMENT);
20554 parse_discard_token(parser, depth);
20560 if (parts.
size > 0) {
20561 pm_array_elements_append(parser, &elements, UP(pm_interpolated_string_node_create(parser, NULL, &parts, NULL)));
20562 }
else if (current != NULL) {
20563 pm_array_elements_append(parser, &elements, current);
20567 if (match1(parser, PM_TOKEN_EOF)) {
20568 pm_parser_err_token(parser, &opening, PM_ERR_LIST_W_UPPER_TERM);
20569 closing = (
pm_token_t) { .type = 0, .start = parser->previous.
end, .end = parser->previous.
end };
20571 expect1(parser, PM_TOKEN_STRING_END, PM_ERR_LIST_W_UPPER_TERM);
20574 return pm_array_node_create(parser, &opening, &elements, &closing);
20578parse_jump(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
20579 parser_lex(parser);
20584 if (token_begins_expression_p(parser->current.type) || match2(parser, PM_TOKEN_USTAR, PM_TOKEN_USTAR_STAR)) {
20585 pm_binding_power_t binding_power = pm_binding_powers[parser->current.type].left;
20587 if (binding_power == PM_BINDING_POWER_UNSET || binding_power >= PM_BINDING_POWER_RANGE) {
20594 pm_accepts_block_stack_push(parser,
true);
20595 parse_arguments(parser, &arguments,
false, PM_TOKEN_EOF, flags, (uint16_t) (depth + 1));
20596 pm_accepts_block_stack_pop(parser);
20599 if (!(flags & PM_PARSE_ACCEPTS_COMMAND_CALL) && arguments.
list.
size > 0) {
20600 PM_PARSER_ERR_TOKEN_FORMAT(parser, &next, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(next.
type));
20609 if (parser->previous.
type == PM_TOKEN_COMMA && match1(parser, PM_TOKEN_EOF)) {
20610 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->previous, PM_ERR_EXPECT_ARGUMENT, pm_token_str(parser->current.type));
20617 if (arguments.
block != NULL) {
20618 pm_parser_err_node(parser, arguments.
block, PM_ERR_UNEXPECTED_BLOCK_ARGUMENT);
20619 pm_node_unreference(parser, arguments.
block);
20620 arguments.
block = NULL;
20624 switch (keyword.
type) {
20625 case PM_TOKEN_KEYWORD_BREAK: {
20626 pm_node_t *node = UP(pm_break_node_create(parser, &keyword, pm_arguments_node_create(parser, &arguments)));
20627 if (!parser->partial_script) ensure_valid_jump(parser, node);
20630 case PM_TOKEN_KEYWORD_NEXT: {
20631 pm_node_t *node = UP(pm_next_node_create(parser, &keyword, pm_arguments_node_create(parser, &arguments)));
20632 if (!parser->partial_script) ensure_valid_jump(parser, node);
20635 case PM_TOKEN_KEYWORD_RETURN: {
20636 pm_node_t *node = UP(pm_return_node_create(parser, &keyword, pm_arguments_node_create(parser, &arguments)));
20637 ensure_valid_return(parser, node);
20641 PRISM_ASSERT(
false &&
"unreachable");
20642 return UP(pm_error_recovery_node_create(parser, PM_TOKEN_START(parser, &parser->previous), PM_TOKEN_LENGTH(&parser->previous)));
20647parse_not(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
20649 parser_lex(parser);
20652 pm_node_t *receiver = NULL;
20660 if (binding_power > PM_BINDING_POWER_NOT && !(flags & PM_PARSE_IN_ENDLESS_DEF) && !match1(parser, PM_TOKEN_PARENTHESIS_LEFT)) {
20661 if (match1(parser, PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES)) {
20662 pm_parser_err(parser, PM_TOKEN_END(parser, &parser->previous), 1, PM_ERR_EXPECT_LPAREN_AFTER_NOT_LPAREN);
20664 accept1(parser, PM_TOKEN_NEWLINE);
20665 pm_parser_err_current(parser, PM_ERR_EXPECT_LPAREN_AFTER_NOT_OTHER);
20668 return UP(pm_error_recovery_node_create(parser, PM_TOKEN_END(parser, &parser->previous), 0));
20671 bool newline = accept1(parser, PM_TOKEN_NEWLINE);
20673 if (!newline && accept2(parser, PM_TOKEN_PARENTHESIS_LEFT, PM_TOKEN_PARENTHESIS_LEFT_GROUPING)) {
20676 if (accept1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) {
20677 receiver = UP(pm_parentheses_node_create(parser, &lparen, NULL, &parser->previous, 0));
20679 arguments.
opening_loc = TOK2LOC(parser, &lparen);
20680 receiver = parse_expression(parser, PM_BINDING_POWER_COMPOSITION, PM_PARSE_ACCEPTS_COMMAND_CALL | PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_NOT_EXPRESSION, (uint16_t) (depth + 1));
20682 if (!parser->recovering) {
20683 accept1(parser, PM_TOKEN_NEWLINE);
20684 expect1(parser, PM_TOKEN_PARENTHESIS_RIGHT, PM_ERR_EXPECT_RPAREN);
20685 arguments.
closing_loc = TOK2LOC(parser, &parser->previous);
20695 uint8_t operand_flags = (flags & PM_PARSE_IN_ENDLESS_DEF)
20696 ? (uint8_t) (flags & (PM_PARSE_ACCEPTS_COMMAND_CALL | PM_PARSE_IN_ENDLESS_DEF))
20697 : PM_PARSE_ACCEPTS_COMMAND_CALL;
20698 receiver = parse_expression(parser, PM_BINDING_POWER_NOT, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | operand_flags), PM_ERR_NOT_EXPRESSION, (uint16_t) (depth + 1));
20701 return UP(pm_call_node_not_create(parser, receiver, &message, &arguments));
20704static pm_pre_execution_node_t *
20705parse_preexe(
pm_parser_t *parser, pm_binding_power_t binding_power, uint16_t depth) {
20709 if (binding_power != PM_BINDING_POWER_STATEMENT) {
20710 pm_parser_err_current(parser, PM_ERR_STATEMENT_PREEXE_BEGIN);
20714 parser_lex(parser);
20716 expect1(parser, PM_TOKEN_BRACE_LEFT, PM_ERR_BEGIN_UPCASE_BRACE);
20718 pm_statements_node_t *statements = parse_statements(parser, PM_CONTEXT_PREEXE, (uint16_t) (depth + 1));
20720 expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_BEGIN_UPCASE_TERM, &opening);
20721 pm_context_t context = parser->current_context->context;
20722 if ((context != PM_CONTEXT_MAIN) && (context != PM_CONTEXT_PREEXE)) {
20723 pm_parser_err_token(parser, &keyword, PM_ERR_BEGIN_UPCASE_TOPLEVEL);
20726 flush_block_exits(parser, previous_block_exits);
20727 return pm_pre_execution_node_create(parser, &keyword, &opening, statements, &parser->previous);
20730static pm_post_execution_node_t *
20731parse_postexe(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
20732 if (binding_power != PM_BINDING_POWER_STATEMENT && !(flags & PM_PARSE_ACCEPTS_STATEMENT)) {
20733 pm_parser_err_current(parser, PM_ERR_STATEMENT_POSTEXE_END);
20737 parser_lex(parser);
20739 if (context_def_p(parser)) {
20740 pm_parser_warn_token(parser, &keyword, PM_WARN_END_IN_METHOD);
20743 expect1(parser, PM_TOKEN_BRACE_LEFT, PM_ERR_END_UPCASE_BRACE);
20745 pm_statements_node_t *statements = parse_statements(parser, PM_CONTEXT_POSTEXE, (uint16_t) (depth + 1));
20747 expect1_opening(parser, PM_TOKEN_BRACE_RIGHT, PM_ERR_END_UPCASE_TERM, &opening);
20748 return pm_post_execution_node_create(parser, &keyword, &opening, statements, &parser->previous);
20751static pm_undef_node_t *
20752parse_undef(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
20753 if (binding_power != PM_BINDING_POWER_STATEMENT && !(flags & PM_PARSE_ACCEPTS_STATEMENT)) {
20754 pm_parser_err_current(parser, PM_ERR_STATEMENT_UNDEF);
20757 parser_lex(parser);
20760 pm_node_list_t names = { 0 };
20761 pm_node_t *name = parse_undef_argument(parser, (uint16_t) (depth + 1));
20763 if (!PM_NODE_TYPE_P(name, PM_ERROR_RECOVERY_NODE)) {
20764 pm_node_list_open_append(&parser->node_chunks, &names, name);
20766 while (match1(parser, PM_TOKEN_COMMA)) {
20767 lex_state_set(parser, PM_LEX_STATE_FNAME | PM_LEX_STATE_FITEM);
20768 parser_lex(parser);
20770 name = parse_undef_argument(parser, (uint16_t) (depth + 1));
20771 if (PM_NODE_TYPE_P(name, PM_ERROR_RECOVERY_NODE)) {
20775 pm_node_list_open_append(&parser->node_chunks, &names, name);
20779 return pm_undef_node_create(parser, &keyword, &names);
20782static pm_yield_node_t *
20783parse_yield(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
20785 parser_lex(parser);
20788 parse_arguments_list(parser, &arguments,
false, flags, (uint16_t) (depth + 1));
20793 if (arguments.
block != NULL) {
20794 pm_parser_err_node(parser, arguments.
block, PM_ERR_UNEXPECTED_BLOCK_ARGUMENT);
20795 pm_node_unreference(parser, arguments.
block);
20796 arguments.
block = NULL;
20799 pm_yield_node_t *node = pm_yield_node_create(parser, &keyword, &arguments.
opening_loc, pm_arguments_node_create(parser, &arguments), &arguments.
closing_loc);
20800 if (!parser->parsing_eval && !parser->partial_script) ensure_valid_yield(parser, node);
20807 pm_node_t *node = UP(pm_string_node_create_current_string(
20810 .type = PM_TOKEN_STRING_BEGIN,
20811 .start = parser->current.start,
20812 .end = parser->current.start + 1
20815 .type = PM_TOKEN_STRING_CONTENT,
20816 .start = parser->current.start + 1,
20817 .end = parser->current.end
20822 pm_node_flag_set(node, parse_unescaped_encoding(parser, parser->explicit_encoding));
20826 parser_lex(parser);
20830 if (match1(parser, PM_TOKEN_STRING_BEGIN)) {
20831 return parse_strings(parser, node,
false, (uint16_t) (depth + 1));
20838parse_constant(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
20840 parser_lex(parser);
20845 match1(parser, PM_TOKEN_PARENTHESIS_LEFT) ||
20846 ((flags & PM_PARSE_ACCEPTS_COMMAND_CALL) && token_begins_argument_p(parser->current.type)) ||
20847 (pm_accepts_block_stack_p(parser) && match1(parser, PM_TOKEN_KEYWORD_DO)) ||
20848 match1(parser, PM_TOKEN_BRACE_LEFT)
20851 parse_arguments_list(parser, &arguments,
true, flags, (uint16_t) (depth + 1));
20852 return UP(pm_call_node_fcall_create(parser, &constant, &arguments));
20855 return parse_multi_target(parser, UP(pm_constant_read_node_create(parser, &parser->previous)), binding_power, depth);
20859parse_constant_path_prefix(
pm_parser_t *parser, pm_binding_power_t binding_power, uint16_t depth) {
20861 parser_lex(parser);
20863 expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
20864 return parse_multi_target(parser, UP(pm_constant_path_node_create(parser, NULL, &delimiter, &parser->previous)), binding_power, depth);
20867static pm_call_node_t *
20868parse_unary_plus(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
20869 if (binding_power > PM_BINDING_POWER_UNARY) {
20870 pm_parser_err_prefix(parser, PM_ERR_UNARY_DISALLOWED);
20872 parser_lex(parser);
20875 pm_node_t *receiver = parse_expression(parser, pm_binding_powers[parser->previous.
type].right, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_UNARY_RECEIVER, (uint16_t) (depth + 1));
20876 return pm_call_node_unary_create(parser, &
operator, receiver,
"+@");
20879static pm_call_node_t *
20880parse_unary_minus(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
20881 if (binding_power > PM_BINDING_POWER_UNARY) {
20882 pm_parser_err_prefix(parser, PM_ERR_UNARY_DISALLOWED);
20884 parser_lex(parser);
20887 pm_node_t *receiver = parse_expression(parser, pm_binding_powers[parser->previous.
type].right, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_UNARY_RECEIVER, (uint16_t) (depth + 1));
20888 return pm_call_node_unary_create(parser, &
operator, receiver,
"-@");
20892parse_unary_minus_number(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
20894 parser_lex(parser);
20896 pm_node_t *node = parse_expression(parser, pm_binding_powers[parser->previous.
type].right, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_UNARY_RECEIVER, (uint16_t) (depth + 1));
20898 if (accept1(parser, PM_TOKEN_STAR_STAR)) {
20899 pm_token_t exponent_operator = parser->previous;
20900 pm_node_t *exponent = parse_expression(parser, pm_binding_powers[exponent_operator.
type].right, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_ARGUMENT, (uint16_t) (depth + 1));
20901 node = UP(pm_call_node_binary_create(parser, node, &exponent_operator, exponent, 0));
20902 node = UP(pm_call_node_unary_create(parser, &
operator, node,
"-@"));
20904 switch (PM_NODE_TYPE(node)) {
20905 case PM_INTEGER_NODE:
20906 case PM_FLOAT_NODE:
20907 case PM_RATIONAL_NODE:
20908 case PM_IMAGINARY_NODE:
20909 parse_negative_numeric(node);
20912 node = UP(pm_call_node_unary_create(parser, &
operator, node,
"-@"));
20921parse_unary_star(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, pm_diagnostic_id_t diag_id, uint16_t depth) {
20922 parser_lex(parser);
20927 if (binding_power != PM_BINDING_POWER_STATEMENT) {
20928 pm_parser_err_prefix(parser, diag_id);
20929 return UP(pm_error_recovery_node_create(parser, PM_TOKEN_START(parser, &parser->previous), PM_TOKEN_LENGTH(&parser->previous)));
20932 pm_node_t *splat = parse_splat(parser, flags, depth);
20934 if (match1(parser, PM_TOKEN_COMMA)) {
20935 return parse_targets_validate(parser, splat, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
20937 return parse_target_validate(parser, splat,
true);
20942parse_super(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
20944 parser_lex(parser);
20947 parse_arguments_list(parser, &arguments,
true, flags, (uint16_t) (depth + 1));
20952 ((arguments.
block == NULL) || PM_NODE_TYPE_P(arguments.
block, PM_BLOCK_NODE))
20954 return UP(pm_forwarding_super_node_create(parser, &keyword, &arguments));
20957 return UP(pm_super_node_create(parser, &keyword, &arguments));
20960static pm_range_node_t *
20961parse_range(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
20963 parser_lex(parser);
20965 pm_node_t *right = parse_expression(parser, pm_binding_powers[
operator.type].left, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
20970 if (match2(parser, PM_TOKEN_DOT_DOT, PM_TOKEN_DOT_DOT_DOT)) {
20971 pm_parser_err_current(parser, PM_ERR_UNEXPECTED_RANGE_OPERATOR);
20974 return pm_range_node_create(parser, NULL, &
operator, right);
20977static pm_call_node_t *
20978parse_bang(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
20979 if (binding_power > PM_BINDING_POWER_UNARY) {
20980 pm_parser_err_prefix(parser, PM_ERR_UNARY_DISALLOWED);
20983 parser_lex(parser);
20986 pm_node_t *receiver = parse_expression(parser, pm_binding_powers[parser->previous.
type].right, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | (binding_power < PM_BINDING_POWER_MATCH ? PM_PARSE_ACCEPTS_COMMAND_CALL : 0)), PM_ERR_UNARY_RECEIVER, (uint16_t) (depth + 1));
20987 pm_conditional_predicate(parser, receiver, PM_CONDITIONAL_PREDICATE_TYPE_NOT);
20988 return pm_call_node_unary_create(parser, &
operator, receiver,
"!");
20991static pm_call_node_t *
20992parse_tilde(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
20993 if (binding_power > PM_BINDING_POWER_UNARY) {
20994 pm_parser_err_prefix(parser, PM_ERR_UNARY_DISALLOWED);
20997 parser_lex(parser);
21000 pm_node_t *receiver = parse_expression(parser, pm_binding_powers[parser->previous.
type].right, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_UNARY_RECEIVER, (uint16_t) (depth + 1));
21001 return pm_call_node_unary_create(parser, &
operator, receiver,
"~");
21008parse_expression_prefix(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, pm_diagnostic_id_t diag_id, uint16_t depth) {
21009 switch (parser->current.type) {
21010 case PM_TOKEN_BRACKET_LEFT_ARRAY:
21011 return UP(parse_array(parser, flags, depth));
21012 case PM_TOKEN_PARENTHESIS_LEFT_GROUPING:
21013 case PM_TOKEN_PARENTHESIS_LEFT_PARENTHESES:
21014 return parse_parentheses(parser, binding_power, flags, depth);
21015 case PM_TOKEN_BRACE_LEFT_HASH:
21016 return UP(parse_hash(parser, depth));
21017 case PM_TOKEN_CHARACTER_LITERAL:
21018 return parse_char(parser, depth);
21019 case PM_TOKEN_CONSTANT:
21020 return parse_constant(parser, binding_power, flags, depth);
21021 case PM_TOKEN_UCOLON_COLON:
21022 return parse_constant_path_prefix(parser, binding_power, depth);
21023 case PM_TOKEN_UDOT_DOT:
21024 case PM_TOKEN_UDOT_DOT_DOT:
21025 return UP(parse_range(parser, flags, depth));
21026 case PM_TOKEN_FLOAT:
21027 parser_lex(parser);
21028 return UP(pm_float_node_create(parser, &parser->previous));
21029 case PM_TOKEN_FLOAT_IMAGINARY:
21030 parser_lex(parser);
21031 return UP(pm_float_node_imaginary_create(parser, &parser->previous));
21032 case PM_TOKEN_FLOAT_RATIONAL:
21033 parser_lex(parser);
21034 return UP(pm_float_node_rational_create(parser, &parser->previous));
21035 case PM_TOKEN_FLOAT_RATIONAL_IMAGINARY:
21036 parser_lex(parser);
21037 return UP(pm_float_node_rational_imaginary_create(parser, &parser->previous));
21038 case PM_TOKEN_IDENTIFIER:
21039 case PM_TOKEN_METHOD_NAME:
21040 return parse_identifier(parser, binding_power, flags, depth);
21041 case PM_TOKEN_HEREDOC_START: {
21042 pm_node_t *node = parse_heredoc(parser, depth);
21043 if (match1(parser, PM_TOKEN_STRING_BEGIN)) {
21044 return parse_strings(parser, node,
false, (uint16_t) (depth + 1));
21048 case PM_TOKEN_CLASS_VARIABLE:
21049 parser_lex(parser);
21050 return parse_multi_target(parser, UP(pm_class_variable_read_node_create(parser, &parser->previous)), binding_power, depth);
21051 case PM_TOKEN_NUMBERED_REFERENCE:
21052 parser_lex(parser);
21053 return parse_multi_target(parser, UP(pm_numbered_reference_read_node_create(parser, &parser->previous)), binding_power, depth);
21054 case PM_TOKEN_GLOBAL_VARIABLE:
21055 parser_lex(parser);
21056 return parse_multi_target(parser, UP(pm_global_variable_read_node_create(parser, &parser->previous)), binding_power, depth);
21057 case PM_TOKEN_BACK_REFERENCE:
21058 parser_lex(parser);
21059 return parse_multi_target(parser, UP(pm_back_reference_read_node_create(parser, &parser->previous)), binding_power, depth);
21060 case PM_TOKEN_INSTANCE_VARIABLE:
21061 parser_lex(parser);
21062 return parse_multi_target(parser, UP(pm_instance_variable_read_node_create(parser, &parser->previous)), binding_power, depth);
21063 case PM_TOKEN_INTEGER: {
21064 pm_node_flags_t base = parser->integer.base;
21065 parser_lex(parser);
21066 return UP(pm_integer_node_create(parser, base, &parser->previous));
21068 case PM_TOKEN_INTEGER_IMAGINARY: {
21069 pm_node_flags_t base = parser->integer.base;
21070 parser_lex(parser);
21071 return UP(pm_integer_node_imaginary_create(parser, base, &parser->previous));
21073 case PM_TOKEN_INTEGER_RATIONAL: {
21074 pm_node_flags_t base = parser->integer.base;
21075 parser_lex(parser);
21076 return UP(pm_integer_node_rational_create(parser, base, &parser->previous));
21078 case PM_TOKEN_INTEGER_RATIONAL_IMAGINARY: {
21079 pm_node_flags_t base = parser->integer.base;
21080 parser_lex(parser);
21081 return UP(pm_integer_node_rational_imaginary_create(parser, base, &parser->previous));
21083 case PM_TOKEN_KEYWORD___ENCODING__:
21084 parser_lex(parser);
21085 return UP(pm_source_encoding_node_create(parser, &parser->previous));
21086 case PM_TOKEN_KEYWORD___FILE__:
21087 parser_lex(parser);
21088 return UP(pm_source_file_node_create(parser, &parser->previous));
21089 case PM_TOKEN_KEYWORD___LINE__:
21090 parser_lex(parser);
21091 return UP(pm_source_line_node_create(parser, &parser->previous));
21092 case PM_TOKEN_KEYWORD_ALIAS:
21093 return parse_alias(parser, binding_power, flags, depth);
21094 case PM_TOKEN_KEYWORD_CASE:
21095 return parse_case(parser, flags, depth);
21096 case PM_TOKEN_KEYWORD_BEGIN:
21097 return UP(parse_begin(parser, depth));
21098 case PM_TOKEN_KEYWORD_BEGIN_UPCASE:
21099 return UP(parse_preexe(parser, binding_power, depth));
21100 case PM_TOKEN_KEYWORD_BREAK:
21101 case PM_TOKEN_KEYWORD_NEXT:
21102 case PM_TOKEN_KEYWORD_RETURN:
21103 return parse_jump(parser, flags, depth);
21104 case PM_TOKEN_KEYWORD_SUPER:
21105 return parse_super(parser, flags, depth);
21106 case PM_TOKEN_KEYWORD_YIELD:
21107 return UP(parse_yield(parser, flags, depth));
21108 case PM_TOKEN_KEYWORD_CLASS:
21109 return parse_class(parser, flags, depth);
21110 case PM_TOKEN_KEYWORD_DEF:
21111 return parse_def(parser, flags, depth);
21112 case PM_TOKEN_KEYWORD_DEFINED:
21113 return UP(parse_defined(parser, flags, depth));
21114 case PM_TOKEN_KEYWORD_END_UPCASE:
21115 return UP(parse_postexe(parser, binding_power, flags, depth));
21116 case PM_TOKEN_KEYWORD_FALSE:
21117 parser_lex(parser);
21118 return UP(pm_false_node_create(parser, &parser->previous));
21119 case PM_TOKEN_KEYWORD_FOR:
21120 return UP(parse_for(parser, flags, depth));
21121 case PM_TOKEN_KEYWORD_IF:
21122 if (parser_end_of_line_p(parser)) {
21123 PM_PARSER_WARN_TOKEN_FORMAT_CONTENT(parser, &parser->current, PM_WARN_KEYWORD_EOL);
21126 size_t opening_newline_index = token_newline_index(parser);
21127 bool if_after_else = parser->previous.
type == PM_TOKEN_KEYWORD_ELSE;
21128 parser_lex(parser);
21130 return parse_conditional(parser, PM_CONTEXT_IF, opening_newline_index, if_after_else, (uint16_t) (depth + 1));
21131 case PM_TOKEN_KEYWORD_UNDEF:
21132 return UP(parse_undef(parser, binding_power, flags, depth));
21133 case PM_TOKEN_KEYWORD_NOT:
21134 return parse_not(parser, binding_power, flags, depth);
21135 case PM_TOKEN_KEYWORD_UNLESS: {
21136 size_t opening_newline_index = token_newline_index(parser);
21137 parser_lex(parser);
21139 return parse_conditional(parser, PM_CONTEXT_UNLESS, opening_newline_index,
false, (uint16_t) (depth + 1));
21141 case PM_TOKEN_KEYWORD_MODULE:
21142 return parse_module(parser, flags, depth);
21143 case PM_TOKEN_KEYWORD_NIL:
21144 parser_lex(parser);
21145 return UP(pm_nil_node_create(parser, &parser->previous));
21146 case PM_TOKEN_KEYWORD_REDO: {
21147 parser_lex(parser);
21149 pm_node_t *node = UP(pm_redo_node_create(parser, &parser->previous));
21150 if (!parser->partial_script) ensure_valid_jump(parser, node);
21154 case PM_TOKEN_KEYWORD_RETRY: {
21155 parser_lex(parser);
21157 pm_node_t *node = UP(pm_retry_node_create(parser, &parser->previous));
21158 ensure_valid_retry(parser, node);
21162 case PM_TOKEN_KEYWORD_SELF:
21163 parser_lex(parser);
21164 return UP(pm_self_node_create(parser, &parser->previous));
21165 case PM_TOKEN_KEYWORD_TRUE:
21166 parser_lex(parser);
21167 return UP(pm_true_node_create(parser, &parser->previous));
21168 case PM_TOKEN_KEYWORD_UNTIL:
21169 return UP(parse_until(parser, flags, depth));
21170 case PM_TOKEN_KEYWORD_WHILE:
21171 return UP(parse_while(parser, flags, depth));
21172 case PM_TOKEN_PERCENT_LOWER_I:
21173 return UP(parse_uninterpolated_symbol_array(parser));
21174 case PM_TOKEN_PERCENT_UPPER_I:
21175 return UP(parse_interpolated_symbol_array(parser, depth));
21176 case PM_TOKEN_PERCENT_LOWER_W:
21177 return UP(parse_uninterpolated_string_array(parser));
21178 case PM_TOKEN_PERCENT_UPPER_W:
21179 return UP(parse_interpolated_string_array(parser, depth));
21180 case PM_TOKEN_REGEXP_BEGIN:
21181 return parse_regexp(parser, depth);
21182 case PM_TOKEN_XSTRING_BEGIN:
21183 case PM_TOKEN_PERCENT_LOWER_X:
21184 return parse_xstring(parser, depth);
21185 case PM_TOKEN_USTAR:
21186 return parse_unary_star(parser, binding_power, flags, diag_id, depth);
21187 case PM_TOKEN_BANG:
21188 return UP(parse_bang(parser, binding_power, flags, depth));
21189 case PM_TOKEN_TILDE:
21190 return UP(parse_tilde(parser, binding_power, flags, depth));
21191 case PM_TOKEN_UMINUS:
21192 return UP(parse_unary_minus(parser, binding_power, flags, depth));
21193 case PM_TOKEN_UMINUS_NUM:
21194 return UP(parse_unary_minus_number(parser, flags, depth));
21195 case PM_TOKEN_MINUS_GREATER:
21196 return UP(parse_lambda(parser, depth));
21197 case PM_TOKEN_UPLUS:
21198 return UP(parse_unary_plus(parser, binding_power, flags, depth));
21199 case PM_TOKEN_STRING_BEGIN:
21200 return parse_strings(parser, NULL, flags & PM_PARSE_ACCEPTS_LABEL, (uint16_t) (depth + 1));
21201 case PM_TOKEN_SYMBOL_BEGIN:
21202 return parse_symbol(parser, PM_LEX_STATE_END, (uint16_t) (depth + 1));
21204 pm_context_t recoverable = context_recoverable(parser, &parser->current);
21206 if (recoverable != PM_CONTEXT_NONE) {
21207 parser->recovering =
true;
21212 if (diag_id != PM_ERR_CANNOT_PARSE_EXPRESSION) {
21213 pm_parser_err_prefix(parser, diag_id);
21219 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT, pm_token_str(parser->current.type), context_human(recoverable));
21220 }
else if (diag_id == PM_ERR_CANNOT_PARSE_EXPRESSION) {
21224 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_UNEXPECTED_TOKEN_IGNORE, pm_token_str(parser->current.type));
21226 pm_parser_err_prefix(parser, diag_id);
21229 return UP(pm_error_recovery_node_create(parser, PM_TOKEN_START(parser, &parser->previous), PM_TOKEN_LENGTH(&parser->previous)));
21235parse_rescue_modifier_value(
pm_parser_t *parser, uint8_t flags,
bool statement, uint16_t depth);
21245parse_rescue_modifier_terminator(
pm_parser_t *parser, uint8_t flags, uint16_t depth) {
21246 if (pm_binding_powers[parser->current.type].left > PM_BINDING_POWER_MODIFIER) {
21247 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(parser->current.type));
21248 parser_lex(parser);
21249 parse_expression(parser, pm_binding_powers[parser->previous.
type].right, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
21259parse_write_value_comma_check(
pm_parser_t *parser,
const pm_node_t *value) {
21260 if (match1(parser, PM_TOKEN_COMMA) && pm_command_before_comma_p(parser, value)) {
21261 pm_parser_err_current(parser, PM_ERR_INVALID_COMMA);
21275parse_assignment_value(
pm_parser_t *parser, pm_binding_power_t previous_binding_power, pm_binding_power_t binding_power, uint8_t flags, pm_diagnostic_id_t diag_id, uint16_t depth) {
21278 uint8_t command_flags = (previous_binding_power == PM_BINDING_POWER_ASSIGNMENT)
21279 ? (uint8_t) (flags & PM_PARSE_ACCEPTS_COMMAND_CALL)
21280 : (previous_binding_power < PM_BINDING_POWER_MATCH ? PM_PARSE_ACCEPTS_COMMAND_CALL : 0);
21281 if (command_flags) command_flags |= PM_PARSE_ACCEPTS_COMMAND_DEF;
21283 pm_node_t *value = parse_value_expression(parser, binding_power, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | command_flags), diag_id, (uint16_t) (depth + 1));
21288 if (previous_binding_power != PM_BINDING_POWER_STATEMENT && !(flags & PM_PARSE_ACCEPTS_STATEMENT)) {
21289 parse_write_value_comma_check(parser, value);
21296 if (pm_binding_powers[parser->current.type].left > PM_BINDING_POWER_MODIFIER && (pm_command_call_value_p(parser, value) || pm_block_call_p(value))) {
21297 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(parser->current.type));
21298 parser_lex(parser);
21299 parse_expression(parser, pm_binding_powers[parser->previous.
type].right, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
21304 if (match1(parser, PM_TOKEN_KEYWORD_RESCUE_MODIFIER)) {
21305 context_push(parser, PM_CONTEXT_RESCUE_MODIFIER);
21308 parser_lex(parser);
21313 bool statement_value = pm_command_call_value_p(parser, value) || pm_block_call_p(value);
21314 uint8_t rescue_flags = (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | (statement_value ? PM_PARSE_ACCEPTS_COMMAND_CALL : 0));
21316 pm_node_t *right = parse_rescue_modifier_value(parser, rescue_flags, statement_value, (uint16_t) (depth + 1));
21317 context_pop(parser);
21322 if (PM_NODE_TYPE_P(right, PM_MATCH_REQUIRED_NODE) || PM_NODE_TYPE_P(right, PM_MATCH_PREDICATE_NODE)) {
21323 parse_rescue_modifier_terminator(parser, flags, depth);
21326 return UP(pm_rescue_modifier_node_create(parser, value, &rescue, right));
21337parse_assignment_value_local(
pm_parser_t *parser,
const pm_node_t *node) {
21338 switch (PM_NODE_TYPE(node)) {
21339 case PM_BEGIN_NODE: {
21340 const pm_begin_node_t *
cast = (
const pm_begin_node_t *) node;
21341 if (
cast->statements != NULL) parse_assignment_value_local(parser, (
const pm_node_t *)
cast->statements);
21344 case PM_LOCAL_VARIABLE_WRITE_NODE: {
21345 const pm_local_variable_write_node_t *
cast = (
const pm_local_variable_write_node_t *) node;
21346 PRISM_ASSERT(pm_parser_local_depth_constant_id(parser,
cast->name) == (
int)
cast->depth);
21347 pm_locals_read(parser,
cast->name);
21350 case PM_PARENTHESES_NODE: {
21351 const pm_parentheses_node_t *
cast = (
const pm_parentheses_node_t *) node;
21352 if (
cast->body != NULL) parse_assignment_value_local(parser,
cast->body);
21355 case PM_STATEMENTS_NODE: {
21356 const pm_statements_node_t *
cast = (
const pm_statements_node_t *) node;
21357 const pm_node_t *statement;
21360 parse_assignment_value_local(parser, statement);
21382parse_assignment_values(
pm_parser_t *parser, pm_binding_power_t previous_binding_power, pm_binding_power_t binding_power, uint8_t flags, pm_diagnostic_id_t diag_id, uint16_t depth) {
21383 bool statement_level = (previous_binding_power == PM_BINDING_POWER_STATEMENT) || (flags & PM_PARSE_ACCEPTS_STATEMENT);
21385 bool permitted =
true;
21386 if (!statement_level && match1(parser, PM_TOKEN_USTAR)) permitted =
false;
21391 uint8_t command_call_flag = (previous_binding_power == PM_BINDING_POWER_ASSIGNMENT)
21392 ? (uint8_t) (flags & PM_PARSE_ACCEPTS_COMMAND_CALL)
21393 : ((previous_binding_power < PM_BINDING_POWER_MODIFIER || statement_level) ? PM_PARSE_ACCEPTS_COMMAND_CALL : 0);
21398 if (command_call_flag && binding_power != PM_BINDING_POWER_MULTI_ASSIGNMENT + 1) {
21399 command_call_flag |= PM_PARSE_ACCEPTS_COMMAND_DEF;
21402 pm_node_t *value = parse_starred_expression(parser, binding_power, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | command_call_flag), diag_id, (uint16_t) (depth + 1));
21403 if (!permitted) pm_parser_err_node(parser, value, PM_ERR_UNEXPECTED_MULTI_WRITE);
21405 parse_assignment_value_local(parser, value);
21406 bool single_value =
true;
21408 parse_write_value_comma_check(parser, value);
21413 if (statement_level && !pm_block_call_p(value) && (PM_NODE_TYPE_P(value, PM_SPLAT_NODE) || match1(parser, PM_TOKEN_COMMA))) {
21414 single_value =
false;
21417 pm_array_elements_append(parser, &elements, value);
21419 while (accept1(parser, PM_TOKEN_COMMA)) {
21420 pm_node_t *element = parse_starred_expression(parser, binding_power,
false, PM_ERR_ARRAY_ELEMENT, (uint16_t) (depth + 1));
21422 pm_array_elements_append(parser, &elements, element);
21423 if (PM_NODE_TYPE_P(element, PM_ERROR_RECOVERY_NODE))
break;
21425 parse_assignment_value_local(parser, element);
21428 value = UP(pm_array_node_create(parser, NULL, &elements, NULL));
21435 if (single_value && pm_binding_powers[parser->current.type].left > PM_BINDING_POWER_MODIFIER && (pm_command_call_value_p(parser, value) || pm_block_call_p(value))) {
21436 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(parser->current.type));
21437 parser_lex(parser);
21438 parse_expression(parser, pm_binding_powers[parser->previous.
type].right, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
21443 bool multiple_assignment = (binding_power == (PM_BINDING_POWER_MULTI_ASSIGNMENT + 1));
21444 if ((single_value || multiple_assignment) && match1(parser, PM_TOKEN_KEYWORD_RESCUE_MODIFIER)) {
21445 bool command_value = pm_command_call_value_p(parser, value) || pm_block_call_p(value);
21454 if (multiple_assignment && command_value)
return value;
21456 context_push(parser, PM_CONTEXT_RESCUE_MODIFIER);
21459 parser_lex(parser);
21465 bool statement_value = multiple_assignment || command_value;
21466 uint8_t rescue_flags = (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | (statement_value ? PM_PARSE_ACCEPTS_COMMAND_CALL : 0));
21468 pm_node_t *right = parse_rescue_modifier_value(parser, rescue_flags, statement_value, (uint16_t) (depth + 1));
21469 context_pop(parser);
21474 if (PM_NODE_TYPE_P(right, PM_MATCH_REQUIRED_NODE) || PM_NODE_TYPE_P(right, PM_MATCH_PREDICATE_NODE)) {
21475 parse_rescue_modifier_terminator(parser, flags, depth);
21478 return UP(pm_rescue_modifier_node_create(parser, value, &rescue, right));
21497parse_rescue_modifier_value(
pm_parser_t *parser, uint8_t flags,
bool statement, uint16_t depth) {
21502 if (match1(parser, PM_TOKEN_USTAR)) {
21504 parser_lex(parser);
21505 value = parse_splat(parser, flags, depth);
21512 value = parse_expression(parser, pm_binding_powers[PM_TOKEN_KEYWORD_RESCUE_MODIFIER].right, flags | PM_PARSE_ACCEPTS_STATEMENT | PM_PARSE_ACCEPTS_COMMAND_DEF, PM_ERR_RESCUE_MODIFIER_VALUE, (uint16_t) (depth + 1));
21513 multiple = match1(parser, PM_TOKEN_COMMA) || PM_NODE_TYPE_P(value, PM_MULTI_TARGET_NODE);
21517 pm_node_t *target = parse_targets_validate(parser, value, PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
21524 if (!match1(parser, PM_TOKEN_EQUAL)) {
21525 if (match1(parser, PM_TOKEN_PARENTHESIS_RIGHT)) pm_parser_err_node(parser, target, PM_ERR_WRITE_TARGET_UNEXPECTED);
21530 parser_lex(parser);
21532 pm_node_t *values = parse_assignment_values(parser, PM_BINDING_POWER_STATEMENT, PM_BINDING_POWER_MULTI_ASSIGNMENT + 1, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL, (uint16_t) (depth + 1));
21533 value = parse_write(parser, target, &
operator, values);
21540 if (!PM_NODE_TYPE_P(value, PM_MATCH_REQUIRED_NODE) && !PM_NODE_TYPE_P(value, PM_MATCH_PREDICATE_NODE)) {
21541 parse_rescue_modifier_terminator(parser, flags, depth);
21549 return parse_expression(parser, PM_BINDING_POWER_DEFINED, flags, PM_ERR_RESCUE_MODIFIER_VALUE, (uint16_t) (depth + 1));
21560parse_call_operator_write(
pm_parser_t *parser, pm_call_node_t *call_node,
const pm_token_t *
operator) {
21562 pm_parser_err_token(parser,
operator, PM_ERR_OPERATOR_WRITE_ARGUMENTS);
21563 pm_node_unreference(parser, UP(call_node->
arguments));
21567 if (call_node->
block != NULL) {
21568 pm_parser_err_token(parser,
operator, PM_ERR_OPERATOR_WRITE_BLOCK);
21569 pm_node_unreference(parser, UP(call_node->
block));
21570 call_node->
block = NULL;
21578parse_match_write(
pm_parser_t *parser, pm_call_node_t *call,
const pm_regexp_match_t *match) {
21579 pm_node_list_t targets = { 0 };
21582 for (
size_t index = 0; index < match->size; index++) {
21584 const uint8_t *name = capture->name;
21585 size_t length = capture->length;
21587 if (!pm_slice_is_valid_local(parser, name, name + length))
continue;
21589 const uint8_t *start = parser->start + capture->location.
start;
21590 const uint8_t *end = start + capture->location.
length;
21593 if (length == capture->location.
length && (name == start || memcmp(name, start, length) == 0)) {
21594 id = pm_parser_constant_id_raw(parser, start, end);
21596 uint8_t *copy = PM_ARENA_ALLOC_ARRAY(parser->arena, uint8_t, length);
21597 memcpy(copy, name, length);
21598 id = pm_parser_constant_id_owned(parser, copy, length);
21601 if (
id == 0 || !pm_constant_id_set_insert(&parser->scratch_arena, &names,
id))
continue;
21603 int depth = pm_parser_local_depth_constant_id(parser,
id);
21605 if (pm_local_is_keyword((
const char *) name, length))
continue;
21606 pm_parser_local_add(parser,
id, start, end, 0);
21609 pm_node_t *target = UP(pm_local_variable_target_node_create(parser, &capture->location,
id, depth == -1 ? 0 : (uint32_t) depth));
21610 pm_node_list_open_append(&parser->node_chunks, &targets, target);
21613 return targets.
size == 0 ? UP(call) : UP(pm_match_write_node_create(parser, call, &targets));
21616static pm_if_node_t *
21617parse_ternary(
pm_parser_t *parser, pm_node_t *node, uint8_t flags, uint16_t depth) {
21618 context_push(parser, PM_CONTEXT_TERNARY);
21623 parser_lex(parser);
21625 pm_node_t *true_expression = parse_expression(parser, PM_BINDING_POWER_DEFINED, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_TERNARY_EXPRESSION_TRUE, (uint16_t) (depth + 1));
21627 if (parser->recovering) {
21635 pm_node_t *false_expression = UP(pm_error_recovery_node_create(parser, PM_TOKEN_START(parser, &colon), PM_TOKEN_LENGTH(&colon)));
21637 context_pop(parser);
21638 pop_block_exits(parser, previous_block_exits);
21639 return pm_if_node_ternary_create(parser, node, &qmark, true_expression, &colon, false_expression);
21642 accept1(parser, PM_TOKEN_NEWLINE);
21643 expect1(parser, PM_TOKEN_COLON, PM_ERR_TERNARY_COLON);
21646 pm_node_t *false_expression = parse_expression(parser, PM_BINDING_POWER_DEFINED, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_TERNARY_EXPRESSION_FALSE, (uint16_t) (depth + 1));
21648 context_pop(parser);
21649 pop_block_exits(parser, previous_block_exits);
21650 return pm_if_node_ternary_create(parser, node, &qmark, true_expression, &colon, false_expression);
21654parse_constant_path_infix(
pm_parser_t *parser, pm_node_t *node, pm_binding_power_t previous_binding_power, uint8_t flags, uint16_t depth) {
21656 parser_lex(parser);
21658 switch (parser->current.type) {
21659 case PM_TOKEN_CONSTANT: {
21660 parser_lex(parser);
21664 (parser->current.type == PM_TOKEN_PARENTHESIS_LEFT) ||
21665 ((flags & PM_PARSE_ACCEPTS_COMMAND_CALL) && token_begins_argument_p(parser->current.type))
21676 parse_arguments_list(parser, &arguments,
true, flags, (uint16_t) (depth + 1));
21677 path = UP(pm_call_node_call_create(parser, node, &delimiter, &message, &arguments));
21681 path = UP(pm_constant_path_node_create(parser, node, &delimiter, &parser->previous));
21684 return parse_multi_target(parser, path, previous_binding_power, depth);
21686 case PM_CASE_OPERATOR:
21687 case PM_CASE_KEYWORD:
21688 case PM_TOKEN_IDENTIFIER:
21689 case PM_TOKEN_METHOD_NAME: {
21690 parser_lex(parser);
21696 parse_arguments_list(parser, &arguments,
true, flags, (uint16_t) (depth + 1));
21698 pm_call_node_t *call = pm_call_node_call_create(parser, node, &delimiter, &message, &arguments);
21699 return parse_multi_target(parser, UP(call), previous_binding_power, depth);
21701 case PM_TOKEN_PARENTHESIS_LEFT: {
21705 parse_arguments_list(parser, &arguments,
true,
false, (uint16_t) (depth + 1));
21707 return UP(pm_call_node_shorthand_create(parser, node, &delimiter, &arguments));
21710 expect1(parser, PM_TOKEN_CONSTANT, PM_ERR_CONSTANT_PATH_COLON_COLON_CONSTANT);
21711 return UP(pm_constant_path_node_create(parser, node, &delimiter, &parser->previous));
21716parse_match(
pm_parser_t *parser, pm_node_t *node, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
21725 const pm_regexp_match_t *match = parser->regexp_match;
21726 parser->regexp_match = NULL;
21729 parser_lex(parser);
21731 pm_node_t *argument = parse_expression(parser, binding_power, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
21732 pm_call_node_t *call = pm_call_node_binary_create(parser, node, &
operator, argument, 0);
21734 return match != NULL && match->receiver == node ? parse_match_write(parser, call, match) : UP(call);
21738parse_equal(
pm_parser_t *parser, pm_node_t *node, pm_binding_power_t previous_binding_power, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
21741 switch (PM_NODE_TYPE(node)) {
21742 case PM_CALL_NODE: {
21747 pm_call_node_t *call_node = (pm_call_node_t *) node;
21748 if (PM_NODE_FLAG_P(call_node, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
21749 pm_parser_local_add_location(parser, &call_node->
message_loc, 0);
21753 case PM_CASE_WRITABLE: {
21757 if (PM_NODE_TYPE_P(node, PM_IT_LOCAL_VARIABLE_READ_NODE)) {
21758 pm_parser_local_add_location(parser, &node->
location, 0);
21761 parser_lex(parser);
21762 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, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL, (uint16_t) (depth + 1));
21764 if (PM_NODE_TYPE_P(node, PM_MULTI_TARGET_NODE) && previous_binding_power != PM_BINDING_POWER_STATEMENT && !(flags & PM_PARSE_ACCEPTS_STATEMENT)) {
21765 pm_parser_err_node(parser, node, PM_ERR_UNEXPECTED_MULTI_WRITE);
21768 return parse_write(parser, node, &
operator, value);
21770 case PM_SPLAT_NODE: {
21772 pm_multi_targets_append(parser, &targets, node);
21773 pm_multi_target_node_t *multi_target = pm_multi_target_node_create(parser, &targets, NULL, NULL);
21775 parser_lex(parser);
21776 pm_node_t *value = parse_assignment_values(parser, previous_binding_power, PM_BINDING_POWER_MULTI_ASSIGNMENT + 1, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL, (uint16_t) (depth + 1));
21777 return parse_write(parser, UP(multi_target), &
operator, value);
21779 case PM_SOURCE_ENCODING_NODE:
21780 case PM_FALSE_NODE:
21781 case PM_SOURCE_FILE_NODE:
21782 case PM_SOURCE_LINE_NODE:
21785 case PM_TRUE_NODE: {
21788 parser_lex(parser);
21789 pm_node_t *value = parse_assignment_values(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_EQUAL, (uint16_t) (depth + 1));
21790 return parse_unwriteable_write(parser, node, &
operator, value);
21796 parser_lex(parser);
21797 pm_parser_err_token(parser, &
operator, PM_ERR_EXPRESSION_NOT_WRITABLE);
21803parse_and_equal(
pm_parser_t *parser, pm_node_t *node, pm_binding_power_t previous_binding_power, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
21806 switch (PM_NODE_TYPE(node)) {
21807 case PM_BACK_REFERENCE_READ_NODE:
21808 case PM_NUMBERED_REFERENCE_READ_NODE:
21809 PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, node, PM_ERR_WRITE_TARGET_READONLY);
21811 case PM_GLOBAL_VARIABLE_READ_NODE: {
21812 parser_lex(parser);
21814 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
21815 pm_node_t *result = UP(pm_global_variable_and_write_node_create(parser, node, &
operator, value));
21819 case PM_CLASS_VARIABLE_READ_NODE: {
21820 parser_lex(parser);
21822 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
21823 pm_node_t *result = UP(pm_class_variable_and_write_node_create(parser, (pm_class_variable_read_node_t *) node, &
operator, value));
21827 case PM_CONSTANT_PATH_NODE: {
21828 parser_lex(parser);
21830 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
21831 pm_node_t *write = UP(pm_constant_path_and_write_node_create(parser, (pm_constant_path_node_t *) node, &
operator, value));
21833 return parse_shareable_constant_write(parser, write);
21835 case PM_CONSTANT_READ_NODE: {
21836 parser_lex(parser);
21838 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
21839 pm_node_t *write = UP(pm_constant_and_write_node_create(parser, (pm_constant_read_node_t *) node, &
operator, value));
21841 if (context_def_p(parser)) {
21842 pm_parser_err_node(parser, write, PM_ERR_WRITE_TARGET_IN_METHOD);
21845 return parse_shareable_constant_write(parser, write);
21847 case PM_INSTANCE_VARIABLE_READ_NODE: {
21848 parser_lex(parser);
21850 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
21851 pm_node_t *result = UP(pm_instance_variable_and_write_node_create(parser, (pm_instance_variable_read_node_t *) node, &
operator, value));
21855 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
21857 parser_lex(parser);
21859 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
21860 pm_node_t *result = UP(pm_local_variable_and_write_node_create(parser, node, &
operator, value, name, 0));
21862 pm_node_unreference(parser, node);
21865 case PM_LOCAL_VARIABLE_READ_NODE: {
21866 if (pm_token_is_numbered_parameter(parser, PM_NODE_START(node), PM_NODE_LENGTH(node))) {
21868 pm_node_unreference(parser, node);
21871 pm_local_variable_read_node_t *
cast = (pm_local_variable_read_node_t *) node;
21872 parser_lex(parser);
21874 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
21875 pm_node_t *result = UP(pm_local_variable_and_write_node_create(parser, node, &
operator, value,
cast->name,
cast->depth));
21879 case PM_CALL_NODE: {
21880 pm_call_node_t *
cast = (pm_call_node_t *) node;
21885 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
21886 pm_refute_numbered_parameter(parser,
cast->message_loc.start,
cast->message_loc.length);
21888 parser_lex(parser);
21890 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
21891 pm_node_t *result = UP(pm_local_variable_and_write_node_create(parser, UP(cast), &
operator, value, constant_id, 0));
21898 parser_lex(parser);
21903 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_INDEX)) {
21904 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
21905 return UP(pm_index_and_write_node_create(parser, cast, &
operator, value));
21909 if (pm_call_node_writable_p(parser, cast)) {
21910 parse_write_name(parser, &
cast->name);
21912 pm_parser_err_node(parser, node, PM_ERR_WRITE_TARGET_UNEXPECTED);
21915 parse_call_operator_write(parser, cast, &
operator);
21916 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ, (uint16_t) (depth + 1));
21917 return UP(pm_call_and_write_node_create(parser, cast, &
operator, value));
21919 case PM_MULTI_WRITE_NODE: {
21920 parser_lex(parser);
21922 pm_parser_err_token(parser, &
operator, PM_ERR_AMPAMPEQ_MULTI_ASSIGN);
21926 parser_lex(parser);
21931 pm_parser_err_token(parser, &
operator, PM_ERR_EXPECT_EXPRESSION_AFTER_AMPAMPEQ);
21937parse_or_equal(
pm_parser_t *parser, pm_node_t *node, pm_binding_power_t previous_binding_power, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
21940 switch (PM_NODE_TYPE(node)) {
21941 case PM_BACK_REFERENCE_READ_NODE:
21942 case PM_NUMBERED_REFERENCE_READ_NODE:
21943 PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, node, PM_ERR_WRITE_TARGET_READONLY);
21945 case PM_GLOBAL_VARIABLE_READ_NODE: {
21946 parser_lex(parser);
21948 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
21949 pm_node_t *result = UP(pm_global_variable_or_write_node_create(parser, node, &
operator, value));
21953 case PM_CLASS_VARIABLE_READ_NODE: {
21954 parser_lex(parser);
21956 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
21957 pm_node_t *result = UP(pm_class_variable_or_write_node_create(parser, (pm_class_variable_read_node_t *) node, &
operator, value));
21961 case PM_CONSTANT_PATH_NODE: {
21962 parser_lex(parser);
21964 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
21965 pm_node_t *write = UP(pm_constant_path_or_write_node_create(parser, (pm_constant_path_node_t *) node, &
operator, value));
21967 return parse_shareable_constant_write(parser, write);
21969 case PM_CONSTANT_READ_NODE: {
21970 parser_lex(parser);
21972 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
21973 pm_node_t *write = UP(pm_constant_or_write_node_create(parser, (pm_constant_read_node_t *) node, &
operator, value));
21975 if (context_def_p(parser)) {
21976 pm_parser_err_node(parser, write, PM_ERR_WRITE_TARGET_IN_METHOD);
21979 return parse_shareable_constant_write(parser, write);
21981 case PM_INSTANCE_VARIABLE_READ_NODE: {
21982 parser_lex(parser);
21984 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
21985 pm_node_t *result = UP(pm_instance_variable_or_write_node_create(parser, (pm_instance_variable_read_node_t *) node, &
operator, value));
21989 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
21991 parser_lex(parser);
21993 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
21994 pm_node_t *result = UP(pm_local_variable_or_write_node_create(parser, node, &
operator, value, name, 0));
21996 pm_node_unreference(parser, node);
21999 case PM_LOCAL_VARIABLE_READ_NODE: {
22000 if (pm_token_is_numbered_parameter(parser, PM_NODE_START(node), PM_NODE_LENGTH(node))) {
22001 PM_PARSER_ERR_FORMAT(parser, PM_NODE_START(node), PM_NODE_LENGTH(node), PM_ERR_PARAMETER_NUMBERED_RESERVED, parser->start + PM_NODE_START(node));
22002 pm_node_unreference(parser, node);
22005 pm_local_variable_read_node_t *
cast = (pm_local_variable_read_node_t *) node;
22006 parser_lex(parser);
22008 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
22009 pm_node_t *result = UP(pm_local_variable_or_write_node_create(parser, node, &
operator, value,
cast->name,
cast->depth));
22013 case PM_CALL_NODE: {
22014 pm_call_node_t *
cast = (pm_call_node_t *) node;
22019 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
22020 pm_refute_numbered_parameter(parser,
cast->message_loc.start,
cast->message_loc.length);
22022 parser_lex(parser);
22024 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
22025 pm_node_t *result = UP(pm_local_variable_or_write_node_create(parser, UP(cast), &
operator, value, constant_id, 0));
22032 parser_lex(parser);
22037 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_INDEX)) {
22038 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
22039 return UP(pm_index_or_write_node_create(parser, cast, &
operator, value));
22043 if (pm_call_node_writable_p(parser, cast)) {
22044 parse_write_name(parser, &
cast->name);
22046 pm_parser_err_node(parser, node, PM_ERR_WRITE_TARGET_UNEXPECTED);
22049 parse_call_operator_write(parser, cast, &
operator);
22050 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ, (uint16_t) (depth + 1));
22051 return UP(pm_call_or_write_node_create(parser, cast, &
operator, value));
22053 case PM_MULTI_WRITE_NODE: {
22054 parser_lex(parser);
22055 pm_parser_err_token(parser, &
operator, PM_ERR_PIPEPIPEEQ_MULTI_ASSIGN);
22059 parser_lex(parser);
22064 pm_parser_err_token(parser, &
operator, PM_ERR_EXPECT_EXPRESSION_AFTER_PIPEPIPEEQ);
22070parse_operator_equal(
pm_parser_t *parser, pm_node_t *node, pm_binding_power_t previous_binding_power, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
22073 switch (PM_NODE_TYPE(node)) {
22074 case PM_BACK_REFERENCE_READ_NODE:
22075 case PM_NUMBERED_REFERENCE_READ_NODE:
22076 PM_PARSER_ERR_NODE_FORMAT_CONTENT(parser, node, PM_ERR_WRITE_TARGET_READONLY);
22078 case PM_GLOBAL_VARIABLE_READ_NODE: {
22079 parser_lex(parser);
22081 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22082 pm_node_t *result = UP(pm_global_variable_operator_write_node_create(parser, node, &
operator, value));
22086 case PM_CLASS_VARIABLE_READ_NODE: {
22087 parser_lex(parser);
22089 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22090 pm_node_t *result = UP(pm_class_variable_operator_write_node_create(parser, (pm_class_variable_read_node_t *) node, &
operator, value));
22094 case PM_CONSTANT_PATH_NODE: {
22095 parser_lex(parser);
22097 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22098 pm_node_t *write = UP(pm_constant_path_operator_write_node_create(parser, (pm_constant_path_node_t *) node, &
operator, value));
22100 return parse_shareable_constant_write(parser, write);
22102 case PM_CONSTANT_READ_NODE: {
22103 parser_lex(parser);
22105 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22106 pm_node_t *write = UP(pm_constant_operator_write_node_create(parser, (pm_constant_read_node_t *) node, &
operator, value));
22108 if (context_def_p(parser)) {
22109 pm_parser_err_node(parser, write, PM_ERR_WRITE_TARGET_IN_METHOD);
22112 return parse_shareable_constant_write(parser, write);
22114 case PM_INSTANCE_VARIABLE_READ_NODE: {
22115 parser_lex(parser);
22117 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22118 pm_node_t *result = UP(pm_instance_variable_operator_write_node_create(parser, (pm_instance_variable_read_node_t *) node, &
operator, value));
22122 case PM_IT_LOCAL_VARIABLE_READ_NODE: {
22124 parser_lex(parser);
22126 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22127 pm_node_t *result = UP(pm_local_variable_operator_write_node_create(parser, node, &
operator, value, name, 0));
22129 pm_node_unreference(parser, node);
22132 case PM_LOCAL_VARIABLE_READ_NODE: {
22133 if (pm_token_is_numbered_parameter(parser, PM_NODE_START(node), PM_NODE_LENGTH(node))) {
22134 PM_PARSER_ERR_FORMAT(parser, PM_NODE_START(node), PM_NODE_LENGTH(node), PM_ERR_PARAMETER_NUMBERED_RESERVED, parser->start + PM_NODE_START(node));
22135 pm_node_unreference(parser, node);
22138 pm_local_variable_read_node_t *
cast = (pm_local_variable_read_node_t *) node;
22139 parser_lex(parser);
22141 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22142 pm_node_t *result = UP(pm_local_variable_operator_write_node_create(parser, node, &
operator, value,
cast->name,
cast->depth));
22146 case PM_CALL_NODE: {
22147 pm_call_node_t *
cast = (pm_call_node_t *) node;
22150 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_VARIABLE_CALL)) {
22151 pm_refute_numbered_parameter(parser,
cast->message_loc.start,
cast->message_loc.length);
22153 parser_lex(parser);
22155 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22156 pm_node_t *result = UP(pm_local_variable_operator_write_node_create(parser, UP(cast), &
operator, value, constant_id, 0));
22161 parser_lex(parser);
22166 if (PM_NODE_FLAG_P(cast, PM_CALL_NODE_FLAGS_INDEX)) {
22167 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22168 return UP(pm_index_operator_write_node_create(parser, cast, &
operator, value));
22172 if (pm_call_node_writable_p(parser, cast)) {
22173 parse_write_name(parser, &
cast->name);
22175 pm_parser_err_node(parser, node, PM_ERR_WRITE_TARGET_UNEXPECTED);
22178 parse_call_operator_write(parser, cast, &
operator);
22179 pm_node_t *value = parse_assignment_value(parser, previous_binding_power, binding_power, flags, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22180 return UP(pm_call_operator_write_node_create(parser, cast, &
operator, value));
22182 case PM_MULTI_WRITE_NODE: {
22183 parser_lex(parser);
22184 pm_parser_err_token(parser, &
operator, PM_ERR_OPERATOR_MULTI_ASSIGN);
22188 parser_lex(parser);
22193 PM_PARSER_ERR_TOKEN_FORMAT(parser, &
operator, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, pm_token_str(parser->current.type));
22199parse_call(
pm_parser_t *parser, pm_node_t *node, pm_binding_power_t previous_binding_power, uint8_t flags, uint16_t depth) {
22201 parser_lex(parser);
22206 if (match1(parser, PM_TOKEN_PARENTHESIS_LEFT)) {
22207 parse_arguments_list(parser, &arguments,
true,
false, (uint16_t) (depth + 1));
22208 return UP(pm_call_node_shorthand_create(parser, node, &
operator, &arguments));
22211 switch (PM_NODE_TYPE(node)) {
22212 case PM_RESCUE_MODIFIER_NODE: {
22213 pm_rescue_modifier_node_t *
cast = (pm_rescue_modifier_node_t *) node;
22214 if (PM_NODE_TYPE_P(
cast->rescue_expression, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(
cast->rescue_expression, PM_MATCH_REQUIRED_NODE)) {
22215 PM_PARSER_ERR_TOKEN_FORMAT(parser, &
operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(
operator.type));
22219 case PM_AND_NODE: {
22220 pm_and_node_t *
cast = (pm_and_node_t *) node;
22221 if (PM_NODE_TYPE_P(
cast->right, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(
cast->right, PM_MATCH_REQUIRED_NODE)) {
22222 PM_PARSER_ERR_TOKEN_FORMAT(parser, &
operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(
operator.type));
22227 pm_or_node_t *
cast = (pm_or_node_t *) node;
22228 if (PM_NODE_TYPE_P(
cast->right, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(
cast->right, PM_MATCH_REQUIRED_NODE)) {
22229 PM_PARSER_ERR_TOKEN_FORMAT(parser, &
operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(
operator.type));
22239 switch (parser->current.type) {
22240 case PM_CASE_OPERATOR:
22241 case PM_CASE_KEYWORD:
22242 case PM_TOKEN_CONSTANT:
22243 case PM_TOKEN_IDENTIFIER:
22244 case PM_TOKEN_METHOD_NAME: {
22245 parser_lex(parser);
22246 message = parser->previous;
22250 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_EXPECT_MESSAGE, pm_token_str(parser->current.type));
22251 message = (
pm_token_t) { .type = 0, .start = parser->previous.
end, .end = parser->previous.
end };
22255 parse_arguments_list(parser, &arguments,
true, flags, (uint16_t) (depth + 1));
22256 pm_call_node_t *call = pm_call_node_call_create(parser, node, &
operator, &message, &arguments);
22259 (previous_binding_power == PM_BINDING_POWER_STATEMENT) &&
22262 match1(parser, PM_TOKEN_COMMA)
22264 return parse_targets_validate(parser, UP(call), PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
22271parse_aref(
pm_parser_t *parser, pm_node_t *node, pm_binding_power_t previous_binding_power, uint8_t flags, uint16_t depth) {
22272 parser_lex(parser);
22275 arguments.
opening_loc = TOK2LOC(parser, &parser->previous);
22277 if (!accept1(parser, PM_TOKEN_BRACKET_RIGHT)) {
22278 parse_arguments(parser, &arguments,
false, PM_TOKEN_BRACKET_RIGHT, parse_delimited_arguments_flags(parser, flags,
true), (uint16_t) (depth + 1));
22279 expect1(parser, PM_TOKEN_BRACKET_RIGHT, PM_ERR_EXPECT_RBRACKET);
22282 arguments.
closing_loc = TOK2LOC(parser, &parser->previous);
22286 if (previous_binding_power == PM_BINDING_POWER_STATEMENT && match1(parser, PM_TOKEN_COMMA)) {
22287 pm_call_node_t *aref = pm_call_node_aref_create(parser, node, &arguments);
22288 return parse_targets_validate(parser, UP(aref), PM_BINDING_POWER_INDEX, (uint16_t) (depth + 1));
22294 pm_block_node_t *block = NULL;
22295 if (accept1(parser, PM_TOKEN_BRACE_LEFT)) {
22296 block = parse_block(parser, (uint16_t) (depth + 1));
22297 pm_arguments_validate_block(parser, &arguments, block);
22298 }
else if (pm_accepts_block_stack_p(parser) && accept1(parser, PM_TOKEN_KEYWORD_DO)) {
22299 block = parse_block(parser, (uint16_t) (depth + 1));
22302 if (block != NULL) {
22303 if (arguments.
block != NULL) {
22304 pm_parser_err_node(parser, UP(block), PM_ERR_ARGUMENT_AFTER_BLOCK);
22305 parse_arguments_append(parser, &arguments, arguments.
block);
22308 arguments.
block = UP(block);
22311 return UP(pm_call_node_aref_create(parser, node, &arguments));
22315parse_expression_infix(
pm_parser_t *parser, pm_node_t *node, pm_binding_power_t previous_binding_power, pm_binding_power_t binding_power, uint8_t flags, uint16_t depth) {
22318 switch (token.type) {
22319 case PM_TOKEN_EQUAL:
22320 return parse_equal(parser, node, previous_binding_power, binding_power, flags, depth);
22321 case PM_TOKEN_AMPERSAND_AMPERSAND_EQUAL:
22322 return parse_and_equal(parser, node, previous_binding_power, binding_power, flags, depth);
22323 case PM_TOKEN_PIPE_PIPE_EQUAL:
22324 return parse_or_equal(parser, node, previous_binding_power, binding_power, flags, depth);
22325 case PM_TOKEN_AMPERSAND_EQUAL:
22326 case PM_TOKEN_CARET_EQUAL:
22327 case PM_TOKEN_GREATER_GREATER_EQUAL:
22328 case PM_TOKEN_LESS_LESS_EQUAL:
22329 case PM_TOKEN_MINUS_EQUAL:
22330 case PM_TOKEN_PERCENT_EQUAL:
22331 case PM_TOKEN_PIPE_EQUAL:
22332 case PM_TOKEN_PLUS_EQUAL:
22333 case PM_TOKEN_SLASH_EQUAL:
22334 case PM_TOKEN_STAR_EQUAL:
22335 case PM_TOKEN_STAR_STAR_EQUAL:
22336 return parse_operator_equal(parser, node, previous_binding_power, binding_power, flags, depth);
22337 case PM_TOKEN_AMPERSAND_AMPERSAND:
22338 case PM_TOKEN_KEYWORD_AND: {
22339 parser_lex(parser);
22341 pm_node_t *right = parse_expression(parser, binding_power, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | (parser->previous.
type == PM_TOKEN_KEYWORD_AND ? PM_PARSE_ACCEPTS_COMMAND_CALL : 0)), PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22342 return UP(pm_and_node_create(parser, node, &token, right));
22344 case PM_TOKEN_KEYWORD_OR:
22345 case PM_TOKEN_PIPE_PIPE: {
22346 parser_lex(parser);
22348 pm_node_t *right = parse_expression(parser, binding_power, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | (parser->previous.
type == PM_TOKEN_KEYWORD_OR ? PM_PARSE_ACCEPTS_COMMAND_CALL : 0)), PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22349 return UP(pm_or_node_create(parser, node, &token, right));
22351 case PM_TOKEN_EQUAL_TILDE:
22352 return parse_match(parser, node, binding_power, flags, depth);
22353 case PM_TOKEN_UAMPERSAND:
22354 case PM_TOKEN_USTAR:
22355 case PM_TOKEN_USTAR_STAR:
22358 case PM_TOKEN_BANG_EQUAL:
22359 case PM_TOKEN_BANG_TILDE:
22360 case PM_TOKEN_EQUAL_EQUAL:
22361 case PM_TOKEN_EQUAL_EQUAL_EQUAL:
22362 case PM_TOKEN_LESS_EQUAL_GREATER:
22363 case PM_TOKEN_CARET:
22364 case PM_TOKEN_PIPE:
22365 case PM_TOKEN_AMPERSAND:
22366 case PM_TOKEN_GREATER_GREATER:
22367 case PM_TOKEN_LESS_LESS:
22368 case PM_TOKEN_MINUS:
22369 case PM_TOKEN_PLUS:
22370 case PM_TOKEN_PERCENT:
22371 case PM_TOKEN_SLASH:
22372 case PM_TOKEN_STAR:
22373 case PM_TOKEN_STAR_STAR: {
22374 parser_lex(parser);
22376 switch (PM_NODE_TYPE(node)) {
22377 case PM_RESCUE_MODIFIER_NODE: {
22378 pm_rescue_modifier_node_t *
cast = (pm_rescue_modifier_node_t *) node;
22379 if (PM_NODE_TYPE_P(
cast->rescue_expression, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(
cast->rescue_expression, PM_MATCH_REQUIRED_NODE)) {
22380 PM_PARSER_ERR_TOKEN_FORMAT(parser, &
operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(
operator.type));
22384 case PM_AND_NODE: {
22385 pm_and_node_t *
cast = (pm_and_node_t *) node;
22386 if (PM_NODE_TYPE_P(
cast->right, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(
cast->right, PM_MATCH_REQUIRED_NODE)) {
22387 PM_PARSER_ERR_TOKEN_FORMAT(parser, &
operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(
operator.type));
22392 pm_or_node_t *
cast = (pm_or_node_t *) node;
22393 if (PM_NODE_TYPE_P(
cast->right, PM_MATCH_PREDICATE_NODE) || PM_NODE_TYPE_P(
cast->right, PM_MATCH_REQUIRED_NODE)) {
22394 PM_PARSER_ERR_TOKEN_FORMAT(parser, &
operator, PM_ERR_EXPECT_EOL_AFTER_STATEMENT, pm_token_str(
operator.type));
22402 pm_node_t *argument = parse_expression(parser, binding_power, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22403 return UP(pm_call_node_binary_create(parser, node, &token, argument, 0));
22405 case PM_TOKEN_GREATER:
22406 case PM_TOKEN_GREATER_EQUAL:
22407 case PM_TOKEN_LESS:
22408 case PM_TOKEN_LESS_EQUAL: {
22409 if (PM_NODE_TYPE_P(node, PM_CALL_NODE) && PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_COMPARISON)) {
22410 PM_PARSER_WARN_TOKEN_FORMAT_CONTENT(parser, &parser->current, PM_WARN_COMPARISON_AFTER_COMPARISON);
22413 parser_lex(parser);
22414 pm_node_t *argument = parse_expression(parser, binding_power, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22415 return UP(pm_call_node_binary_create(parser, node, &token, argument, PM_CALL_NODE_FLAGS_COMPARISON));
22417 case PM_TOKEN_AMPERSAND_DOT:
22419 return parse_call(parser, node, previous_binding_power, flags, depth);
22420 case PM_TOKEN_DOT_DOT:
22421 case PM_TOKEN_DOT_DOT_DOT: {
22422 parser_lex(parser);
22424 pm_node_t *right = NULL;
22425 if (token_begins_expression_p(parser->current.type)) {
22426 right = parse_expression(parser, binding_power, flags & PM_PARSE_ACCEPTS_DO_BLOCK, PM_ERR_EXPECT_EXPRESSION_AFTER_OPERATOR, (uint16_t) (depth + 1));
22429 return UP(pm_range_node_create(parser, node, &token, right));
22431 case PM_TOKEN_KEYWORD_IF_MODIFIER: {
22433 parser_lex(parser);
22435 pm_node_t *predicate = parse_value_expression(parser, binding_power, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_CONDITIONAL_IF_PREDICATE, (uint16_t) (depth + 1));
22436 return UP(pm_if_node_modifier_create(parser, node, &keyword, predicate));
22438 case PM_TOKEN_KEYWORD_UNLESS_MODIFIER: {
22440 parser_lex(parser);
22442 pm_node_t *predicate = parse_value_expression(parser, binding_power, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_CONDITIONAL_UNLESS_PREDICATE, (uint16_t) (depth + 1));
22443 return UP(pm_unless_node_modifier_create(parser, node, &keyword, predicate));
22445 case PM_TOKEN_KEYWORD_UNTIL_MODIFIER: {
22446 parser_lex(parser);
22447 pm_statements_node_t *statements = pm_statements_node_single_create(parser, node,
true);
22449 pm_node_t *predicate = parse_value_expression(parser, binding_power, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_CONDITIONAL_UNTIL_PREDICATE, (uint16_t) (depth + 1));
22450 return UP(pm_until_node_modifier_create(parser, &token, predicate, statements, PM_NODE_TYPE_P(node, PM_BEGIN_NODE) ? PM_LOOP_FLAGS_BEGIN_MODIFIER : 0));
22452 case PM_TOKEN_KEYWORD_WHILE_MODIFIER: {
22453 parser_lex(parser);
22454 pm_statements_node_t *statements = pm_statements_node_single_create(parser, node,
true);
22456 pm_node_t *predicate = parse_value_expression(parser, binding_power, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), PM_ERR_CONDITIONAL_WHILE_PREDICATE, (uint16_t) (depth + 1));
22457 return UP(pm_while_node_modifier_create(parser, &token, predicate, statements, PM_NODE_TYPE_P(node, PM_BEGIN_NODE) ? PM_LOOP_FLAGS_BEGIN_MODIFIER : 0));
22459 case PM_TOKEN_QUESTION_MARK:
22460 return UP(parse_ternary(parser, node, flags, depth));
22461 case PM_TOKEN_COLON_COLON:
22462 return parse_constant_path_infix(parser, node, previous_binding_power, flags, depth);
22463 case PM_TOKEN_KEYWORD_RESCUE_MODIFIER: {
22464 context_push(parser, PM_CONTEXT_RESCUE_MODIFIER);
22465 parser_lex(parser);
22466 accept1(parser, PM_TOKEN_NEWLINE);
22468 pm_node_t *value = parse_rescue_modifier_value(parser, (uint8_t) ((flags & PM_PARSE_ACCEPTS_DO_BLOCK) | PM_PARSE_ACCEPTS_COMMAND_CALL), previous_binding_power == PM_BINDING_POWER_STATEMENT, (uint16_t) (depth + 1));
22469 context_pop(parser);
22471 return UP(pm_rescue_modifier_node_create(parser, node, &token, value));
22473 case PM_TOKEN_BRACKET_LEFT:
22474 return parse_aref(parser, node, previous_binding_power, flags, depth);
22475 case PM_TOKEN_KEYWORD_IN: {
22476 bool previous_pattern_matching_newlines = parser->pattern_matching_newlines;
22477 parser->pattern_matching_newlines =
true;
22480 parser->command_start =
false;
22481 lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
22482 parser_lex(parser);
22485 pm_node_t *pattern = parse_pattern(parser, &captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_IN, (uint16_t) (depth + 1));
22487 parser->pattern_matching_newlines = previous_pattern_matching_newlines;
22489 return UP(pm_match_predicate_node_create(parser, node, pattern, &
operator));
22491 case PM_TOKEN_EQUAL_GREATER: {
22492 bool previous_pattern_matching_newlines = parser->pattern_matching_newlines;
22493 parser->pattern_matching_newlines =
true;
22496 parser->command_start =
false;
22497 lex_state_set(parser, PM_LEX_STATE_BEG | PM_LEX_STATE_LABEL);
22498 parser_lex(parser);
22501 pm_node_t *pattern = parse_pattern(parser, &captures, PM_PARSE_PATTERN_TOP | PM_PARSE_PATTERN_MULTI, PM_ERR_PATTERN_EXPRESSION_AFTER_HROCKET, (uint16_t) (depth + 1));
22503 parser->pattern_matching_newlines = previous_pattern_matching_newlines;
22505 return UP(pm_match_required_node_create(parser, node, pattern, &
operator));
22508 PRISM_ASSERT(
false &&
"unreachable");
22513#undef PM_PARSE_PATTERN_SINGLE
22514#undef PM_PARSE_PATTERN_TOP
22515#undef PM_PARSE_PATTERN_MULTI
22530parse_expression_terminator(
pm_parser_t *parser, pm_node_t *node) {
22531 pm_binding_power_t left = pm_binding_powers[parser->current.type].left;
22533 switch (PM_NODE_TYPE(node)) {
22534 case PM_MULTI_WRITE_NODE:
22535 case PM_RETURN_NODE:
22536 case PM_BREAK_NODE:
22538 return left > PM_BINDING_POWER_MODIFIER;
22539 case PM_CLASS_VARIABLE_WRITE_NODE:
22540 case PM_CONSTANT_PATH_WRITE_NODE:
22541 case PM_CONSTANT_WRITE_NODE:
22542 case PM_GLOBAL_VARIABLE_WRITE_NODE:
22543 case PM_INSTANCE_VARIABLE_WRITE_NODE:
22544 case PM_LOCAL_VARIABLE_WRITE_NODE:
22545 return PM_NODE_FLAG_P(node, PM_WRITE_NODE_FLAGS_IMPLICIT_ARRAY) && left > PM_BINDING_POWER_MODIFIER;
22546 case PM_CALL_NODE: {
22549 if (PM_NODE_FLAG_P(node, PM_CALL_NODE_FLAGS_IMPLICIT_ARRAY)) {
22550 return left > PM_BINDING_POWER_MODIFIER;
22556 if (pm_command_call_value_p(parser, node)) {
22557 return left > PM_BINDING_POWER_COMPOSITION;
22563 return left > PM_BINDING_POWER_COMPOSITION && left < PM_BINDING_POWER_CALL && pm_block_call_p(node);
22565 case PM_SUPER_NODE:
22566 case PM_YIELD_NODE:
22569 if (pm_command_call_value_p(parser, node)) {
22570 return left > PM_BINDING_POWER_COMPOSITION;
22575 return left > PM_BINDING_POWER_COMPOSITION && left < PM_BINDING_POWER_CALL && pm_block_call_p(node);
22580 return left > PM_BINDING_POWER_MODIFIER && pm_command_call_value_p(parser, node);
22581 case PM_RESCUE_MODIFIER_NODE:
22585 if (left > PM_BINDING_POWER_MODIFIER) {
22586 pm_rescue_modifier_node_t *
cast = (pm_rescue_modifier_node_t *) node;
22587 pm_node_t *rescue_expression =
cast->rescue_expression;
22588 return PM_NODE_TYPE_P(rescue_expression, PM_MATCH_REQUIRED_NODE) || PM_NODE_TYPE_P(rescue_expression, PM_MATCH_PREDICATE_NODE);
22605parse_expression(
pm_parser_t *parser, pm_binding_power_t binding_power, uint8_t flags, pm_diagnostic_id_t diag_id, uint16_t depth) {
22606 if (
PRISM_UNLIKELY(depth >= PRISM_DEPTH_MAXIMUM || pm_parser_stack_exhausted(parser))) {
22607 return parse_resource_recovery(parser, depth);
22610 pm_node_t *node = parse_expression_prefix(parser, binding_power, flags, diag_id, depth);
22615 switch (PM_NODE_TYPE(node)) {
22616 case PM_ERROR_RECOVERY_NODE:
22618 case PM_PRE_EXECUTION_NODE:
22620 case PM_POST_EXECUTION_NODE:
22621 case PM_ALIAS_GLOBAL_VARIABLE_NODE:
22622 case PM_ALIAS_METHOD_NODE:
22623 case PM_UNDEF_NODE:
22624 if (pm_binding_powers[parser->current.type].left > PM_BINDING_POWER_MODIFIER) {
22629 case PM_SUPER_NODE:
22630 case PM_YIELD_NODE:
22632 if (parse_expression_terminator(parser, node)) {
22636 case PM_SYMBOL_NODE:
22637 if (pm_symbol_node_label_p(parser, node)) {
22648 pm_token_type_t current_token_type;
22651 current_token_type = parser->current.type,
22652 current_binding_powers = pm_binding_powers[current_token_type],
22653 binding_power <= current_binding_powers.
left &&
22654 current_binding_powers.
binary
22656 node = parse_expression_infix(parser, node, binding_power, current_binding_powers.
right, flags, (uint16_t) (depth + 1));
22657 if (parse_expression_terminator(parser, node))
return node;
22661 if (current_binding_powers.
nonassoc) {
22669 if (next_binding_powers.
nonassoc && next_binding_powers.
left == current_binding_powers.
left) {
22670 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_NON_ASSOCIATIVE_OPERATOR, pm_token_str(parser->current.type), pm_token_str(current_token_type));
22681 if (PM_NODE_TYPE_P(node, PM_RANGE_NODE) && ((pm_range_node_t *) node)->right == NULL) {
22682 if (match4(parser, PM_TOKEN_UAMPERSAND, PM_TOKEN_USTAR, PM_TOKEN_DOT, PM_TOKEN_AMPERSAND_DOT)) {
22683 PM_PARSER_ERR_TOKEN_FORMAT(parser, &parser->current, PM_ERR_NON_ASSOCIATIVE_OPERATOR, pm_token_str(parser->current.type), pm_token_str(current_token_type));
22687 if (PM_BINDING_POWER_TERM <= next_binding_powers.
left) {
22690 }
else if (current_binding_powers.
left <= next_binding_powers.
left) {
22695 if (flags & PM_PARSE_ACCEPTS_COMMAND_CALL) {
22704 switch (node->
type) {
22705 case PM_CALL_NODE: {
22706 pm_call_node_t *
cast = (pm_call_node_t *)node;
22710 cast->call_operator_loc.length == 0 &&
22711 cast->message_loc.length > 0 &&
22712 parser->start[
cast->message_loc.start] ==
'[' &&
22713 parser->start[
cast->message_loc.start +
cast->message_loc.length - 1] ==
']'
22717 cast->call_operator_loc.length > 0 &&
22718 cast->arguments == NULL &&
22719 cast->block == NULL &&
22720 cast->opening_loc.length == 0
22724 cast->call_operator_loc.length > 0 &&
22725 cast->opening_loc.length > 0
22729 cast->block != NULL && PM_NODE_TYPE_P(
cast->block, PM_BLOCK_NODE)
22732 flags &= (uint8_t) ~(PM_PARSE_ACCEPTS_COMMAND_CALL | PM_PARSE_ACCEPTS_COMMAND_DEF);
22737 case PM_CONSTANT_PATH_NODE:
22740 flags &= (uint8_t) ~(PM_PARSE_ACCEPTS_COMMAND_CALL | PM_PARSE_ACCEPTS_COMMAND_DEF);
22745 if (context_terminator(parser->current_context->context, &parser->current)) {
22748 !next_binding_powers.
binary ||
22749 binding_power > next_binding_powers.
left ||
22750 (PM_NODE_TYPE_P(node, PM_CALL_NODE) && pm_call_node_command_p((pm_call_node_t *) node))
22764static pm_statements_node_t *
22765wrap_statements(
pm_parser_t *parser, pm_statements_node_t *statements) {
22768 if (PM_PARSER_COMMAND_LINE_OPTION_P(parser)) {
22769 if (statements == NULL) {
22770 statements = pm_statements_node_create(parser, &((
pm_statements_t) { 0 }));
22773 pm_arguments_node_t *arguments = pm_arguments_node_single_create(
22775 UP(pm_global_variable_read_node_synthesized_create(parser, pm_parser_constant_id_constant(parser,
"$_", 2)))
22778 pm_statements_node_body_append(parser, statements, UP(pm_call_node_fcall_synthesized_create(
22781 pm_parser_constant_id_constant(parser,
"print", 5)
22785 if (PM_PARSER_COMMAND_LINE_OPTION_N(parser)) {
22786 if (PM_PARSER_COMMAND_LINE_OPTION_A(parser)) {
22787 if (statements == NULL) {
22788 statements = pm_statements_node_create(parser, &((
pm_statements_t) { 0 }));
22791 pm_arguments_node_t *arguments = pm_arguments_node_single_create(
22793 UP(pm_global_variable_read_node_synthesized_create(parser, pm_parser_constant_id_constant(parser,
"$;", 2)))
22796 pm_global_variable_read_node_t *receiver = pm_global_variable_read_node_synthesized_create(parser, pm_parser_constant_id_constant(parser,
"$_", 2));
22797 pm_call_node_t *call = pm_call_node_call_synthesized_create(parser, UP(receiver),
"split", arguments, location);
22799 pm_global_variable_write_node_t *write = pm_global_variable_write_node_synthesized_create(
22801 pm_parser_constant_id_constant(parser,
"$F", 2),
22805 pm_statements_node_body_prepend(parser->arena, statements, UP(write));
22809 parse_arguments_append(
22812 UP(pm_global_variable_read_node_synthesized_create(parser, pm_parser_constant_id_constant(parser,
"$/", 2)))
22815 if (PM_PARSER_COMMAND_LINE_OPTION_L(parser)) {
22817 pm_hash_elements_append(parser, &elements, UP(pm_assoc_node_create(
22819 UP(pm_symbol_node_synthesized_create(parser,
"chomp")),
22821 UP(pm_true_node_synthesized_create(parser))
22824 pm_keyword_hash_node_t *keywords = pm_keyword_hash_node_create(parser, &elements);
22826 parse_arguments_append(parser, &gets_arguments, UP(keywords));
22827 gets_arguments.
list_flags |= PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORDS;
22830 pm_arguments_node_t *arguments = pm_arguments_node_create(parser, &gets_arguments);
22832 pm_statements_node_t *wrapped_statements = pm_statements_node_single_create(parser, UP(pm_while_node_synthesized_create(
22834 UP(pm_call_node_fcall_synthesized_create(parser, arguments, pm_parser_constant_id_constant(parser,
"gets", 4))),
22838 statements = wrapped_statements;
22852 if (parser->current_scope == NULL) {
22853 pm_parser_scope_push(parser,
true);
22859 parser_lex(parser);
22860 pm_statements_node_t *statements = parse_statements(parser, PM_CONTEXT_MAIN, 0);
22862 if (statements != NULL && !parser->parsing_eval) {
22866 PRISM_ASSERT(statements->
body.
size > 0);
22867 pm_void_statement_check_unwrap(parser, statements->
body.
nodes[statements->
body.
size - 1]);
22871 pm_locals_order(parser, &locals,
true);
22872 pm_parser_scope_pop(parser);
22877 statements = wrap_statements(parser, statements);
22879 flush_block_exits(parser, previous_block_exits);
22885 if (statements == NULL) {
22886 statements = pm_statements_node_create(parser, &((
pm_statements_t) { 0 }));
22889 return UP(pm_program_node_create(parser, &locals, statements));
22906pm_strnstr(
const char *big,
const char *little,
size_t big_length) {
22907 size_t little_length = strlen(little);
22909 for (
const char *max = big + big_length - little_length; big <= max; big++) {
22910 if (*big == *little && memcmp(big, little, little_length) == 0)
return big;
22917#define pm_parser_warn_shebang_carriage_return(parser, start, length) ((void) 0)
22925pm_parser_warn_shebang_carriage_return(
pm_parser_t *parser,
const uint8_t *start,
size_t length) {
22926 if (length > 2 && start[length - 2] ==
'\r' && start[length - 1] ==
'\n') {
22927 pm_parser_warn(parser, U32(start - parser->start), U32(length), PM_WARN_SHEBANG_CARRIAGE_RETURN);
22938 const char *switches = pm_strnstr(engine,
" -", length);
22939 if (switches == NULL)
return;
22942 options->shebang_callback(
22944 (
const uint8_t *) (switches + 1),
22945 length - ((
size_t) (switches - engine)) - 1,
22946 options->shebang_callback_data
22949 size_t encoding_length;
22950 if ((encoding_length = pm_string_length(&next_options.encoding)) > 0) {
22951 const uint8_t *encoding_source = pm_string_source(&next_options.encoding);
22952 parser_lex_magic_comment_encoding_value(parser, encoding_source, encoding_source + encoding_length);
22955 parser->command_line = next_options.command_line;
22956 parser->frozen_string_literal = next_options.frozen_string_literal;
22965#ifndef PM_CONSTANT_POOL_MIN_CAPACITY
22966#define PM_CONSTANT_POOL_MIN_CAPACITY 4
22975pm_size_sqrt(
size_t value) {
22977 size_t bit = ((size_t) 1) << (
sizeof(
size_t) * 8 - 2);
22979 while (bit > value) bit >>= 2;
22982 if (value >= result + bit) {
22983 value -= result + bit;
22984 result = (result >> 1) + bit;
23000 PRISM_ASSERT(arena != NULL);
23001 PRISM_ASSERT(source != NULL);
23005 .metadata_arena = { 0 },
23007 .lex_state = PM_LEX_STATE_BEG,
23008 .enclosure_nesting = 0,
23009 .lambda_enclosure_nesting = -1,
23010 .brace_nesting = 0,
23011 .do_loop_stack = { 0 },
23012 .accepts_block_stack = { 0 },
23014 .current = &parser->lex_modes.base,
23015 .base = { .mode = PM_LEX_DEFAULT },
23017 .node_chunks = { .arena = &parser->scratch_arena },
23019 .end = source + size,
23020 .previous = { .type = PM_TOKEN_EOF, .start = source, .end = source },
23021 .current = { .type = PM_TOKEN_EOF, .start = source, .end = source },
23022 .next_start = NULL,
23023 .heredoc_end = NULL,
23025 .comment_list = { 0 },
23026 .magic_comment_list = { 0 },
23027 .warning_list = { 0 },
23028 .error_list = { 0 },
23029 .current_scope = NULL,
23031 .current_context = NULL,
23032 .encoding = PM_ENCODING_UTF_8_ENTRY,
23033 .encoding_changed_callback = NULL,
23034 .encoding_comment_start = source,
23035 .lex_callback = { 0 },
23036 .filepath = PM_STRING_EMPTY,
23037 .constant_pool = { 0 },
23038 .line_offsets = { 0 },
23040 .current_string = PM_STRING_EMPTY,
23042 .explicit_encoding = NULL,
23044 .parsing_eval =
false,
23045 .partial_script =
false,
23046 .attach_comments =
false,
23047 .command_start =
true,
23048 .recovering =
false,
23049 .continuable =
true,
23050 .encoding_locked =
false,
23051 .encoding_changed =
false,
23052 .pattern_matching_newlines =
false,
23053 .in_keyword_arg =
false,
23054 .current_block_exits = NULL,
23056 .stack_budget = SIZE_MAX,
23057 .semantic_token_seen =
false,
23059 .warn_mismatched_indentation =
true
23071 if (size <= SIZE_MAX / 4) pm_arena_reserve(arena, size * 4);
23081 size_t constant_estimate = pm_size_sqrt(size) * 2;
23082 if (constant_estimate > ((
size_t) 1 << 30)) constant_estimate = (size_t) 1 << 30;
23084 uint32_t constant_size = (uint32_t) constant_estimate;
23085 if (constant_size < PM_CONSTANT_POOL_MIN_CAPACITY) constant_size = PM_CONSTANT_POOL_MIN_CAPACITY;
23088 size_t newline_size = size / 22;
23089 if (newline_size < 4) newline_size = 4;
23095 if (size <= SIZE_MAX / 2) {
23096 pm_arena_reserve(&parser->metadata_arena, pm_constant_pool_init_size(constant_size) + newline_size *
sizeof(uint32_t) + size / 2);
23099 pm_constant_pool_init(&parser->metadata_arena, &parser->constant_pool, constant_size);
23100 pm_line_offset_list_init(&parser->metadata_arena, &parser->line_offsets, newline_size);
23103 if (options != NULL) {
23105 if (pm_string_length(&options->filepath) > 0) {
23106 parser->filepath = options->filepath;
23110 parser->start_line = options->line;
23113 size_t encoding_length = pm_string_length(&options->encoding);
23114 if (encoding_length > 0) {
23115 const uint8_t *encoding_source = pm_string_source(&options->encoding);
23116 parser_lex_magic_comment_encoding_value(parser, encoding_source, encoding_source + encoding_length);
23120 parser->encoding_locked = options->encoding_locked;
23123 parser->frozen_string_literal = options->frozen_string_literal;
23126 parser->command_line = options->command_line;
23129 parser->version = options->version;
23132 parser->partial_script = options->partial_script;
23135 parser->attach_comments = options->attach_comments;
23138 parser->stack_budget = options->stack_budget;
23141 parser->parsing_eval = options->scopes_count > 0;
23142 if (parser->parsing_eval) parser->warn_mismatched_indentation =
false;
23144 for (
size_t scope_index = 0; scope_index < options->scopes_count; scope_index++) {
23146 pm_parser_scope_push(parser, scope_index == 0);
23150 parser->current_scope->parameters = ((pm_scope_parameters_t) scope->forwarding) | PM_SCOPE_PARAMETERS_IMPLICIT_DISALLOWED;
23152 for (
size_t local_index = 0; local_index < scope->locals_count; local_index++) {
23153 const pm_string_t *local = pm_options_scope_local(scope, local_index);
23155 const uint8_t *source = pm_string_source(local);
23156 size_t length = pm_string_length(local);
23158 uint8_t *allocated = PM_ARENA_ALLOC_ARRAY(&parser->metadata_arena, uint8_t, length);
23159 memcpy(allocated, source, length);
23160 pm_parser_local_add_owned(parser, allocated, length);
23167 if (parser->version == PM_OPTIONS_VERSION_UNSET) {
23168 parser->version = PM_OPTIONS_VERSION_LATEST;
23171 pm_accepts_block_stack_push(parser,
true);
23174 if (size >= 3 && source[0] == 0xef && source[1] == 0xbb && source[2] == 0xbf) {
23175 parser->current.end += 3;
23176 parser->encoding_comment_start += 3;
23178 if (parser->encoding != PM_ENCODING_UTF_8_ENTRY) {
23179 parser->encoding = PM_ENCODING_UTF_8_ENTRY;
23180 if (parser->encoding_changed_callback != NULL) parser->encoding_changed_callback(parser);
23187 bool search_shebang = PM_PARSER_COMMAND_LINE_OPTION_X(parser);
23204 const uint8_t *newline = next_newline(parser->current.end, parser->end - parser->current.end);
23205 size_t length = (size_t) ((newline != NULL ? newline : parser->end) - parser->current.end);
23207 if (length >= 2 && parser->current.end[0] ==
'#' && parser->current.end[1] ==
'!') {
23208 parser->encoding_comment_start = newline != NULL ? newline + 1 : parser->end;
23209 const char *engine;
23211 if ((engine = pm_strnstr((
const char *) parser->start,
"ruby", length)) != NULL) {
23212 if (newline != NULL) {
23213 if (options == NULL || options->main_script) {
23214 pm_parser_warn_shebang_carriage_return(parser, parser->start, length + 1);
23218 if (options != NULL && options->main_script && options->shebang_callback != NULL) {
23219 pm_parser_init_shebang(parser, options, engine, length - ((
size_t) (engine - (
const char *) parser->start)));
23222 search_shebang =
false;
23223 }
else if (length > 2 && options != NULL && options->main_script && !parser->parsing_eval) {
23224 search_shebang =
true;
23230 if (search_shebang) {
23233 bool found_shebang =
false;
23237 const uint8_t *cursor = parser->start;
23241 const uint8_t *newline = next_newline(cursor, parser->end - cursor);
23243 while (newline != NULL) {
23244 pm_line_offset_list_append(&parser->metadata_arena, &parser->line_offsets, U32(newline - parser->start + 1));
23246 cursor = newline + 1;
23247 newline = next_newline(cursor, parser->end - cursor);
23249 size_t length = (size_t) ((newline != NULL ? newline : parser->end) - cursor);
23250 if (length > 2 && cursor[0] ==
'#' && cursor[1] ==
'!') {
23251 const char *engine;
23252 if ((engine = pm_strnstr((
const char *) cursor,
"ruby", length)) != NULL) {
23253 found_shebang =
true;
23255 if (newline != NULL) {
23256 pm_parser_warn_shebang_carriage_return(parser, cursor, length + 1);
23257 parser->encoding_comment_start = newline + 1;
23260 if (options != NULL && options->shebang_callback != NULL) {
23261 pm_parser_init_shebang(parser, options, engine, length - ((
size_t) (engine - (
const char *) cursor)));
23269 if (found_shebang) {
23270 parser->previous = (
pm_token_t) { .type = PM_TOKEN_EOF, .start = cursor, .end = cursor };
23271 parser->current = (
pm_token_t) { .type = PM_TOKEN_EOF, .start = cursor, .end = cursor };
23273 pm_parser_err(parser, 0, 0, PM_ERR_SCRIPT_NOT_FOUND);
23274 pm_line_offset_list_clear(&parser->line_offsets);
23281 parser->encoding_comment_start += pm_strspn_inline_whitespace(parser->encoding_comment_start, parser->end - parser->encoding_comment_start);
23294 if (parser == NULL) PRISM_OOM();
23296 pm_parser_init(arena, parser, source, size, options);
23305 pm_arena_cleanup(&parser->metadata_arena);
23306 pm_arena_cleanup(&parser->scratch_arena);
23314 pm_parser_cleanup(parser);
23324pm_parse_err_is_fatal(pm_diagnostic_id_t diag_id) {
23326 case PM_ERR_ARRAY_EXPRESSION_AFTER_STAR:
23327 case PM_ERR_BEGIN_UPCASE_BRACE:
23328 case PM_ERR_CLASS_VARIABLE_BARE:
23329 case PM_ERR_END_UPCASE_BRACE:
23330 case PM_ERR_ESCAPE_INVALID_HEXADECIMAL:
23331 case PM_ERR_ESCAPE_INVALID_UNICODE_LIST:
23332 case PM_ERR_ESCAPE_INVALID_UNICODE_SHORT:
23333 case PM_ERR_EXPRESSION_NOT_WRITABLE:
23334 case PM_ERR_EXPRESSION_NOT_WRITABLE_SELF:
23335 case PM_ERR_GLOBAL_VARIABLE_BARE:
23336 case PM_ERR_HASH_KEY:
23337 case PM_ERR_HEREDOC_IDENTIFIER:
23338 case PM_ERR_INSTANCE_VARIABLE_BARE:
23339 case PM_ERR_INVALID_BLOCK_EXIT:
23340 case PM_ERR_INVALID_ENCODING_MAGIC_COMMENT:
23341 case PM_ERR_INVALID_FLOAT_EXPONENT:
23342 case PM_ERR_INVALID_NUMBER_BINARY:
23343 case PM_ERR_INVALID_NUMBER_DECIMAL:
23344 case PM_ERR_INVALID_NUMBER_HEXADECIMAL:
23345 case PM_ERR_INVALID_NUMBER_OCTAL:
23346 case PM_ERR_INVALID_NUMBER_UNDERSCORE_TRAILING:
23347 case PM_ERR_NO_LOCAL_VARIABLE:
23348 case PM_ERR_PARAMETER_ORDER:
23349 case PM_ERR_STACK_EXHAUSTED:
23350 case PM_ERR_STATEMENT_UNDEF:
23351 case PM_ERR_VOID_EXPRESSION:
23394 if (parser->error_list.size == 0) {
23395 parser->continuable =
false;
23399 if (!parser->continuable)
return;
23401 size_t source_length = (size_t) (parser->end - parser->start);
23404 bool has_non_stray_error =
false;
23406 if (error->diag_id != PM_ERR_UNEXPECTED_TOKEN_IGNORE && error->diag_id != PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT && !pm_parse_err_is_fatal(error->diag_id)) {
23407 has_non_stray_error =
true;
23415 size_t non_stray_min_start = SIZE_MAX;
23418 size_t error_start = (size_t) error->location.start;
23419 size_t error_end = error_start + (size_t) error->location.length;
23420 bool at_eof = error_end >= source_length;
23423 if (pm_parse_err_is_fatal(error->diag_id) && !at_eof) {
23424 parser->continuable =
false;
23429 if (error->diag_id != PM_ERR_UNEXPECTED_TOKEN_IGNORE &&
23430 error->diag_id != PM_ERR_UNEXPECTED_TOKEN_CLOSE_CONTEXT) {
23431 if (error_start < non_stray_min_start) non_stray_min_start = error_start;
23440 if (non_stray_min_start < error_start)
continue;
23447 if (at_eof && error_start > 0) {
23449 if (error->location.length == 1) {
23450 const uint8_t *
byte = parser->start + error_start;
23451 if (*
byte ==
')' || *
byte ==
']' || *
byte ==
'}') {
23452 parser->continuable =
false;
23462 if (has_non_stray_error)
continue;
23469 if (error->location.length == 1) {
23470 const uint8_t *
byte = parser->start + error_start;
23471 if (*
byte ==
'=' && (error_start == 0 || *(
byte - 1) ==
'\n'))
continue;
23475 parser->continuable =
false;
23486 pm_node_t *node = parse_program(parser);
23487 pm_parse_continuable(parser);
23488 if (parser->attach_comments) pm_comments_attach(parser, node);
23489 pm_arena_cleanup(&parser->scratch_arena);
23501 bool eof = pm_source_stream_read(source);
23508 while (!eof && tmp->data_loc.
length == 0) {
23509 eof = pm_source_stream_read(source);
23512 pm_arena_cleanup(arena);
23514 tmp =
pm_parser_new(arena, pm_source_source(source), pm_source_length(source), options);
23522#undef PM_CASE_KEYWORD
23523#undef PM_CASE_OPERATOR
23524#undef PM_CASE_WRITABLE
23525#undef PM_STRING_EMPTY
23530#ifndef PRISM_EXCLUDE_SERIALIZATION
23534 PM_BUFFER_APPEND_LITERAL(buffer,
"PRISM");
23538 pm_buffer_append_byte(buffer, PRISM_SERIALIZE_ONLY_SEMANTICS_FIELDS ? 1 : 0);
23546 pm_serialize_header(buffer);
23547 pm_serialize_content(parser, node, buffer);
23548 pm_buffer_append_byte(buffer,
'\0');
23556pm_serialize_parse(
pm_buffer_t *buffer,
const uint8_t *source,
size_t size,
const char *data) {
23558 pm_options_read(&options, data);
23562 pm_parser_init(&arena, &parser, source, size, &options);
23564 pm_node_t *node =
pm_parse(&parser);
23566 pm_serialize_header(buffer);
23567 pm_serialize_content(&parser, node, buffer);
23568 pm_buffer_append_byte(buffer,
'\0');
23570 pm_parser_cleanup(&parser);
23571 pm_arena_cleanup(&arena);
23572 pm_options_cleanup(&options);
23584 pm_options_read(&options, data);
23586 pm_node_t *node = pm_parse_stream(&parser, &arena, source, &options);
23587 pm_serialize_header(buffer);
23588 pm_serialize_content(parser, node, buffer);
23589 pm_buffer_append_byte(buffer,
'\0');
23592 pm_arena_cleanup(&arena);
23593 pm_options_cleanup(&options);
23607 pm_options_read(&options, data);
23611 pm_parser_init(&arena, &parser, source, size, &options);
23615 int8_t result = -1;
23616 if (parser.error_list.size > 0) {
23617 const char *encoding_name = parser.encoding->name;
23618 pm_buffer_append_string(buffer, encoding_name, strlen(encoding_name));
23619 pm_buffer_append_byte(buffer,
'\0');
23621 result = (int8_t) pm_errors_format(&parser, buffer, format_type);
23624 pm_parser_cleanup(&parser);
23625 pm_arena_cleanup(&arena);
23626 pm_options_cleanup(&options);
23635pm_serialize_parse_comments(
pm_buffer_t *buffer,
const uint8_t *source,
size_t size,
const char *data) {
23637 pm_options_read(&options, data);
23641 pm_parser_init(&arena, &parser, source, size, &options);
23644 pm_serialize_header(buffer);
23645 pm_serialize_encoding(parser.encoding, buffer);
23646 pm_buffer_append_varsint(buffer, parser.start_line);
23647 pm_buffer_append_uint64(buffer, pm_parser_checksum(&parser));
23648 pm_serialize_line_offset_list(&parser.line_offsets, buffer);
23649 pm_serialize_comment_list(&parser.comment_list, buffer);
23651 pm_parser_cleanup(&parser);
23652 pm_arena_cleanup(&arena);
23653 pm_options_cleanup(&options);
#define PRISM_ALIGNOF
Get the alignment requirement of a type.
#define PRISM_UNLIKELY(x)
The compiler should predicate that this branch will not be taken.
uint32_t pm_constant_id_t
A constant id is a unique identifier for a constant in the constant pool.
A header file that defines macros to exclude certain features of the prism library.
#define PRISM_FALLTHROUGH
We use -Wimplicit-fallthrough to guard potentially unintended fall-through between cases of a switch.
#define xmalloc
Old name of ruby_xmalloc.
int len
Length of the buffer.
#define PRISM_INLINE
Old Visual Studio versions do not support the inline keyword, so we need to define it to be __inline.
VALUE type(ANYARGS)
ANYARGS-ed function type.
T * cast(pm_node_t *node) noexcept
Cast the given node, which must not be null and must be of the given struct, to that struct.
static const uint8_t PM_OPTIONS_COMMAND_LINE_N
A bit representing whether or not the command line -n option was set.
#define PM_OPTIONS_FROZEN_STRING_LITERAL_DISABLED
String literals should not be frozen.
#define PM_OPTIONS_FROZEN_STRING_LITERAL_ENABLED
String literals should be made frozen.
#define PM_OPTIONS_FROZEN_STRING_LITERAL_UNSET
String literals may be frozen or mutable depending on the implementation default.
static const uint8_t PM_OPTIONS_COMMAND_LINE_P
A bit representing whether or not the command line -p option was set.
PRISM_NODISCARD PRISM_EXPORTED_FUNCTION pm_parser_t * pm_parser_new(pm_arena_t *arena, const uint8_t *source, size_t size, const pm_options_t *options) PRISM_NONNULL(1)
Allocate and initialize a parser with the given start and end pointers.
PRISM_EXPORTED_FUNCTION void pm_parser_free(pm_parser_t *parser) PRISM_NONNULL(1)
Free both the memory held by the given parser and the parser itself.
PRISM_EXPORTED_FUNCTION pm_node_t * pm_parse(pm_parser_t *parser) PRISM_NONNULL(1)
Initiate the parser with the given parser.
std::string_view constant(const pm_parser_t *parser PRISM_LIFETIMEBOUND, pm_constant_id_t constant_id) noexcept
The name of the constant with the given id, which must not be zero.
pm_visit_result_t
The value returned by a visitor callback, which determines where the walk goes next.
@ PM_VISIT_SKIP
Continue the walk without visiting this node's children.
@ PM_VISIT_DESCEND
Continue the walk by visiting this node's children.
#define PM_NODE_LIST_FOREACH(list, index, node)
Loop through each node in the node list, writing each node to the given pm_node_t pointer.
The version of the Prism library.
#define PRISM_VERSION
The version of the Prism library as a constant string.
#define PRISM_VERSION_PATCH
The patch version of the Prism library as an int.
#define PRISM_VERSION_MINOR
The minor version of the Prism library as an int.
#define PRISM_VERSION_MAJOR
The major version of the Prism library as an int.
PRISM_EXPORTED_FUNCTION const char * pm_version(void)
The prism version and the serialization format.
The functions related to serializing the AST to a binary format.
static PRISM_INLINE uintptr_t pm_stack_address(void)
Returns the current position of the C stack, for measuring how much of it has been consumed since an ...
Functions for parsing streams.
This is a special out parameter to the parse_arguments_list function that includes opening and closin...
pm_node_t * block
The optional block attached to the call.
bool has_forwarding
The flag indicating whether this arguments list has forwarding argument.
pm_location_t opening_loc
The optional location of the opening parenthesis or bracket.
pm_node_flags_t list_flags
The flags of the arguments node that depend on the arguments in list.
pm_node_list_t list
The open list of arguments while they are being parsed.
pm_location_t list_loc
The location covering the arguments in list.
pm_location_t closing_loc
The optional location of the closing parenthesis or bracket.
The elements of an ArrayNode node that is still being parsed.
pm_node_list_t nodes
The open list of elements.
PM_NODE_ALIGNAS struct pm_node * constant
ArrayPatternNode::constant.
pm_location_t opening_loc
ArrayPatternNode::opening_loc.
pm_location_t closing_loc
ArrayPatternNode::closing_loc.
PM_NODE_ALIGNAS struct pm_node * value
AssocNode::value.
PM_NODE_ALIGNAS struct pm_node * key
AssocNode::key.
PM_NODE_ALIGNAS struct pm_rescue_node * rescue_clause
BeginNode::rescue_clause.
pm_node_t base
The embedded base node.
This struct represents a set of binding powers used for a given token.
bool binary
Whether or not this token can be used as a binary operator.
pm_binding_power_t left
The left binding power.
bool nonassoc
Whether or not this token can be used as non-associative binary operator.
pm_binding_power_t right
The right binding power.
pm_location_t opening_loc
CallNode::opening_loc.
pm_location_t closing_loc
CallNode::closing_loc.
pm_constant_id_t name
CallNode::name.
PM_NODE_ALIGNAS struct pm_arguments_node * arguments
CallNode::arguments.
pm_location_t equal_loc
CallNode::equal_loc.
pm_location_t call_operator_loc
CallNode::call_operator_loc.
pm_location_t message_loc
CallNode::message_loc.
PM_NODE_ALIGNAS struct pm_node * block
CallNode::block.
PM_NODE_ALIGNAS struct pm_node * receiver
CallNode::receiver.
pm_location_t opening_loc
FindPatternNode::opening_loc.
PM_NODE_ALIGNAS struct pm_node * constant
FindPatternNode::constant.
pm_location_t closing_loc
FindPatternNode::closing_loc.
The elements of a HashNode or KeywordHashNode node that is still being parsed.
PM_NODE_ALIGNAS struct pm_node * constant
HashPatternNode::constant.
pm_location_t opening_loc
HashPatternNode::opening_loc.
pm_location_t closing_loc
HashPatternNode::closing_loc.
A Ruby keyword, along with the lex state that it transitions to and the token types that it produces.
uint32_t * offsets
The list of offsets.
size_t size
The number of offsets in the list.
uint32_t depth
LocalVariableReadNode::depth.
pm_constant_id_t name
LocalVariableReadNode::name.
This struct represents a slice in the source code, defined by an offset and a length.
uint32_t start
The offset of the location from the start of the source.
uint32_t length
The length of the location.
pm_location_t lparen_loc
MultiTargetNode::lparen_loc.
pm_location_t rparen_loc
MultiTargetNode::rparen_loc.
The targets of a MultiTargetNode node that is still being parsed, in source order.
uint32_t size
The number of nodes in the list.
struct pm_node ** nodes
The nodes in the list.
pm_node_type_t type
This represents the type of the node.
pm_location_t location
This is the location of the node in the source.
The parameters of a ParametersNode node that is still being parsed.
The token buffer for the content of a regular expression.
pm_regexp_offsets_t offsets
The places recorded so far.
pm_token_buffer_t base
The buffer of the content.
PM_NODE_ALIGNAS struct pm_rescue_node * subsequent
RescueNode::subsequent.
PM_NODE_ALIGNAS struct pm_node * expression
SplatNode::expression.
struct pm_node_list body
StatementsNode::body.
pm_node_t base
The embedded base node.
The body of a StatementsNode node that is still being parsed.
pm_string_t unescaped
StringNode::unescaped.
pm_location_t content_loc
StringNode::content_loc.
A view of a sequence of bytes.
size_t length
The length of the string in bytes of memory.
pm_location_t lparen_loc
SuperNode::lparen_loc.
PM_NODE_ALIGNAS struct pm_node * block
SuperNode::block.
pm_location_t content_loc
SymbolNode::content_loc.
pm_string_t unescaped
SymbolNode::unescaped.
When we're lexing certain types (strings, symbols, lists, etc.) we have string content associated wit...
pm_buffer_t buffer
The buffer that we're using to keep track of the string content.
const uint8_t * cursor
The cursor into the source string that points to how far we have currently copied into the buffer.
This struct represents a token in the Ruby source.
const uint8_t * end
A pointer to the end location of the token in the source.
const uint8_t * start
A pointer to the start location of the token in the source.
pm_token_type_t type
The type of the token.
#define PRISM_UNUSED
GCC will warn if you specify a function or parameter that is unused at runtime.