20#define PUSH_ADJUST(seq, location, label) \
21 ADD_ELEM((seq), (LINK_ELEMENT *) new_adjust_body(iseq, (label), (int) (location).line))
23#define PUSH_ADJUST_RESTORE(seq, label) \
24 ADD_ELEM((seq), (LINK_ELEMENT *) new_adjust_body(iseq, (label), -1))
26#define PUSH_INSN(seq, location, insn) \
27 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (int) (location).line, (int) (location).node_id, BIN(insn), 0))
29#define PUSH_INSN1(seq, location, insn, op1) \
30 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (int) (location).line, (int) (location).node_id, BIN(insn), 1, (VALUE)(op1)))
32#define PUSH_INSN2(seq, location, insn, op1, op2) \
33 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (int) (location).line, (int) (location).node_id, BIN(insn), 2, (VALUE)(op1), (VALUE)(op2)))
35#define PUSH_INSN3(seq, location, insn, op1, op2, op3) \
36 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_body(iseq, (int) (location).line, (int) (location).node_id, BIN(insn), 3, (VALUE)(op1), (VALUE)(op2), (VALUE)(op3)))
38#define PUSH_INSNL(seq, location, insn, label) \
39 (PUSH_INSN1(seq, location, insn, label), LABEL_REF(label))
41#define PUSH_LABEL(seq, label) \
42 ADD_ELEM((seq), (LINK_ELEMENT *) (label))
44#define PUSH_SEND_R(seq, location, id, argc, block, flag, keywords) \
45 ADD_ELEM((seq), (LINK_ELEMENT *) new_insn_send(iseq, (int) (location).line, (int) (location).node_id, (id), (VALUE)(argc), (block), (VALUE)(flag), (keywords)))
47#define PUSH_SEND(seq, location, id, argc) \
48 PUSH_SEND_R((seq), location, (id), (argc), NULL, (VALUE)INT2FIX(0), NULL)
50#define PUSH_SEND_WITH_FLAG(seq, location, id, argc, flag) \
51 PUSH_SEND_R((seq), location, (id), (argc), NULL, (VALUE)(flag), NULL)
53#define PUSH_SEND_WITH_BLOCK(seq, location, id, argc, block) \
54 PUSH_SEND_R((seq), location, (id), (argc), (block), (VALUE)INT2FIX(0), NULL)
56#define PUSH_CALL(seq, location, id, argc) \
57 PUSH_SEND_R((seq), location, (id), (argc), NULL, (VALUE)INT2FIX(VM_CALL_FCALL), NULL)
59#define PUSH_CALL_WITH_BLOCK(seq, location, id, argc, block) \
60 PUSH_SEND_R((seq), location, (id), (argc), (block), (VALUE)INT2FIX(VM_CALL_FCALL), NULL)
62#define PUSH_TRACE(seq, event) \
63 ADD_ELEM((seq), (LINK_ELEMENT *) new_trace_body(iseq, (event), 0))
65#define PUSH_CATCH_ENTRY(type, ls, le, iseqv, lc) \
66 ADD_CATCH_ENTRY((type), (ls), (le), (iseqv), (lc))
68#define PUSH_SEQ(seq1, seq2) \
69 APPEND_LIST((seq1), (seq2))
71#define PUSH_SYNTHETIC_PUTNIL(seq, iseq) \
73 int lineno = ISEQ_COMPILE_DATA(iseq)->last_line; \
74 if (lineno == 0) lineno = FIX2INT(rb_iseq_first_lineno(iseq)); \
75 ADD_SYNTHETIC_INSN(seq, lineno, -1, putnil); \
84pm_iseq_add_getlocal(
rb_iseq_t *iseq,
LINK_ANCHOR *
const seq,
int line,
int node_id,
int idx,
int level)
86 if (iseq_local_block_param_p(iseq, idx, level)) {
87 ADD_ELEM(seq, (
LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(getblockparam), 2,
INT2FIX((idx) + VM_ENV_DATA_SIZE - 1),
INT2FIX(level)));
90 ADD_ELEM(seq, (
LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(getlocal), 2,
INT2FIX((idx) + VM_ENV_DATA_SIZE - 1),
INT2FIX(level)));
92 if (level > 0) access_outer_variables(iseq, level, iseq_lvar_id(iseq, idx, level),
Qfalse);
96pm_iseq_add_setlocal(
rb_iseq_t *iseq,
LINK_ANCHOR *
const seq,
int line,
int node_id,
int idx,
int level)
98 if (iseq_local_block_param_p(iseq, idx, level)) {
99 ADD_ELEM(seq, (
LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(setblockparam), 2,
INT2FIX((idx) + VM_ENV_DATA_SIZE - 1),
INT2FIX(level)));
102 ADD_ELEM(seq, (
LINK_ELEMENT *) new_insn_body(iseq, line, node_id, BIN(setlocal), 2,
INT2FIX((idx) + VM_ENV_DATA_SIZE - 1),
INT2FIX(level)));
104 if (level > 0) access_outer_variables(iseq, level, iseq_lvar_id(iseq, idx, level),
Qtrue);
107#define PUSH_GETLOCAL(seq, location, idx, level) \
108 pm_iseq_add_getlocal(iseq, (seq), (int) (location).line, (int) (location).node_id, (idx), (level))
110#define PUSH_SETLOCAL(seq, location, idx, level) \
111 pm_iseq_add_setlocal(iseq, (seq), (int) (location).line, (int) (location).node_id, (idx), (level))
117#define OLD_ISEQ NEW_ISEQ
120#define NEW_ISEQ(node, name, type, line_no) \
121 pm_new_child_iseq(iseq, (node), rb_fstring(name), 0, (type), (line_no))
123#define OLD_CHILD_ISEQ NEW_CHILD_ISEQ
126#define NEW_CHILD_ISEQ(node, name, type, line_no) \
127 pm_new_child_iseq(iseq, (node), rb_fstring(name), iseq, (type), (line_no))
129#define PM_COMPILE(node) \
130 pm_compile_node(iseq, (node), ret, popped, scope_node)
132#define PM_COMPILE_INTO_ANCHOR(_ret, node) \
133 pm_compile_node(iseq, (node), _ret, popped, scope_node)
135#define PM_COMPILE_POPPED(node) \
136 pm_compile_node(iseq, (node), ret, true, scope_node)
138#define PM_COMPILE_NOT_POPPED(node) \
139 pm_compile_node(iseq, (node), ret, false, scope_node)
141#define PM_NODE_START_LOCATION(parser, node) \
142 ((pm_node_location_t) { .line = pm_newline_list_line(&(parser)->newline_list, ((const pm_node_t *) (node))->location.start, (parser)->start_line), .node_id = ((const pm_node_t *) (node))->node_id })
144#define PM_NODE_END_LOCATION(parser, node) \
145 ((pm_node_location_t) { .line = pm_newline_list_line(&(parser)->newline_list, ((const pm_node_t *) (node))->location.end, (parser)->start_line), .node_id = ((const pm_node_t *) (node))->node_id })
147#define PM_LOCATION_START_LOCATION(parser, location, id) \
148 ((pm_node_location_t) { .line = pm_newline_list_line(&(parser)->newline_list, (location)->start, (parser)->start_line), .node_id = id })
150#define PM_NODE_START_LINE_COLUMN(parser, node) \
151 pm_newline_list_line_column(&(parser)->newline_list, ((const pm_node_t *) (node))->location.start, (parser)->start_line)
153#define PM_NODE_END_LINE_COLUMN(parser, node) \
154 pm_newline_list_line_column(&(parser)->newline_list, ((const pm_node_t *) (node))->location.end, (parser)->start_line)
156#define PM_LOCATION_START_LINE_COLUMN(parser, location) \
157 pm_newline_list_line_column(&(parser)->newline_list, (location)->start, (parser)->start_line)
178 if (integer->
values == NULL) {
183 unsigned char *bytes = (
unsigned char *) RSTRING_PTR(
string);
185 size_t offset = integer->
length * 8;
186 for (
size_t value_index = 0; value_index < integer->
length; value_index++) {
187 uint32_t value = integer->
values[value_index];
189 for (
int index = 0; index < 8; index++) {
190 int byte = (value >> (4 * index)) & 0xf;
191 bytes[--offset] =
byte < 10 ?
byte +
'0' :
byte - 10 +
'a';
199 result =
rb_funcall(result, rb_intern(
"-@"), 0);
211 return parse_integer_value(&node->
value);
246 VALUE imaginary_part;
261 rb_bug(
"Unexpected numeric type on imaginary number %s\n", pm_node_type_to_str(
PM_NODE_TYPE(node->
numeric)));
264 return rb_complex_raw(
INT2FIX(0), imaginary_part);
270 return rb_enc_str_new((
const char *) pm_string_source(
string), pm_string_length(
string), scope_node->encoding);
284 encoding = rb_ascii8bit_encoding();
287 encoding = rb_utf8_encoding();
293 return rb_enc_str_new((
const char *) pm_string_source(
string), pm_string_length(
string), encoding);
302 encoding = rb_ascii8bit_encoding();
305 encoding = rb_utf8_encoding();
308 encoding = scope_node->encoding;
311 VALUE value = rb_enc_literal_str((
const char *) pm_string_source(
string), pm_string_length(
string), encoding);
314 if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal ||
RTEST(
ruby_debug)) {
315 int line_number = pm_node_line_number(scope_node->parser, node);
316 value = rb_str_with_debug_created_info(value, rb_iseq_path(iseq), line_number);
327 encoding = rb_utf8_encoding();
330 encoding = rb_ascii8bit_encoding();
333 encoding = rb_usascii_encoding();
336 encoding = scope_node->encoding;
339 return rb_intern3((
const char *) pm_string_source(&symbol->
unescaped), pm_string_length(&symbol->
unescaped), encoding);
343pm_optimizable_range_item_p(
const pm_node_t *node)
350parse_regexp_error(
rb_iseq_t *iseq, int32_t line_number,
const char *fmt, ...)
354 VALUE error = rb_syntax_error_append(
Qnil, rb_iseq_path(iseq), line_number, -1, NULL,
"%" PRIsVALUE, args);
366 if (explicit_regexp_encoding != NULL) {
367 encoding = explicit_regexp_encoding;
370 encoding = rb_ascii8bit_encoding();
373 encoding = rb_utf8_encoding();
376 encoding = implicit_regexp_encoding;
379 VALUE string = rb_enc_str_new((
const char *) pm_string_source(unescaped), pm_string_length(unescaped), encoding);
380 VALUE error = rb_reg_check_preprocess(
string);
382 if (error !=
Qnil) parse_regexp_error(iseq, pm_node_line_number(scope_node->parser, node),
"%" PRIsVALUE,
rb_obj_as_string(error));
391 for (
size_t index = 0; index < nodes->
size; index++) {
397 if (implicit_regexp_encoding != NULL) {
399 string = parse_regexp_string_part(iseq, scope_node, part, &((
const pm_string_node_t *) part)->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
402 string = parse_string_encoded(part, &((
const pm_string_node_t *) part)->unescaped, scope_node->encoding);
403 VALUE error = rb_reg_check_preprocess(
string);
404 if (error !=
Qnil) parse_regexp_error(iseq, pm_node_line_number(scope_node->parser, part),
"%" PRIsVALUE,
rb_obj_as_string(error));
408 string = parse_string_encoded(part, &((
const pm_string_node_t *) part)->unescaped, scope_node->encoding);
412 string = pm_static_literal_concat(iseq, &((
const pm_interpolated_string_node_t *) part)->parts, scope_node, implicit_regexp_encoding, explicit_regexp_encoding,
false);
416 string = pm_static_literal_concat(iseq, &cast->
statements->
body, scope_node, implicit_regexp_encoding, explicit_regexp_encoding,
false);
420 RUBY_ASSERT(
false &&
"unexpected node type in pm_static_literal_concat");
424 if (current !=
Qnil) {
432 return top ? rb_fstring(current) : current;
435#define RE_OPTION_ENCODING_SHIFT 8
436#define RE_OPTION_ENCODING(encoding) (((encoding) & 0xFF) << RE_OPTION_ENCODING_SHIFT)
437#define ARG_ENCODING_NONE 32
438#define ARG_ENCODING_FIXED 16
439#define ENC_ASCII8BIT 1
441#define ENC_Windows_31J 3
457 flags |= ARG_ENCODING_NONE;
461 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_EUC_JP));
465 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_Windows_31J));
469 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_UTF8));
473 flags |= ONIG_OPTION_IGNORECASE;
477 flags |= ONIG_OPTION_MULTILINE;
481 flags |= ONIG_OPTION_EXTEND;
487#undef RE_OPTION_ENCODING_SHIFT
488#undef RE_OPTION_ENCODING
489#undef ARG_ENCODING_FIXED
490#undef ARG_ENCODING_NONE
493#undef ENC_Windows_31J
500 return rb_ascii8bit_encoding();
503 return rb_utf8_encoding();
506 return rb_enc_get_from_index(ENCINDEX_EUC_JP);
509 return rb_enc_get_from_index(ENCINDEX_Windows_31J);
519 VALUE errinfo = rb_errinfo();
521 int32_t line_number = pm_node_line_number(scope_node->parser, node);
522 VALUE regexp = rb_reg_compile(
string, parse_regexp_flags(node), (
const char *) pm_string_source(&scope_node->parser->
filepath), line_number);
525 VALUE message = rb_attr_get(rb_errinfo(), idMesg);
526 rb_set_errinfo(errinfo);
528 parse_regexp_error(iseq, line_number,
"%" PRIsVALUE, message);
539 rb_encoding *regexp_encoding = parse_regexp_encoding(scope_node, node);
540 if (regexp_encoding == NULL) regexp_encoding = scope_node->encoding;
542 VALUE string = rb_enc_str_new((
const char *) pm_string_source(unescaped), pm_string_length(unescaped), regexp_encoding);
543 return parse_regexp(iseq, scope_node, node,
string);
549 rb_encoding *explicit_regexp_encoding = parse_regexp_encoding(scope_node, node);
550 rb_encoding *implicit_regexp_encoding = explicit_regexp_encoding != NULL ? explicit_regexp_encoding : scope_node->encoding;
552 VALUE string = pm_static_literal_concat(iseq, parts, scope_node, implicit_regexp_encoding, explicit_regexp_encoding,
false);
553 return parse_regexp(iseq, scope_node, node,
string);
562 size_t parts_size = parts->
size;
563 bool interpolated =
false;
565 if (parts_size > 0) {
569 for (
size_t index = 0; index < parts_size; index++) {
576 if (implicit_regexp_encoding == NULL) {
577 string_value = parse_string_encoded(part, &string_node->
unescaped, scope_node->encoding);
580 string_value = parse_regexp_string_part(iseq, scope_node, (
const pm_node_t *) string_node, &string_node->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
583 if (
RTEST(current_string)) {
584 current_string =
rb_str_concat(current_string, string_value);
587 current_string = string_value;
588 if (index != 0) current_location = PM_NODE_END_LOCATION(scope_node->parser, part);
603 if (implicit_regexp_encoding == NULL) {
604 string_value = parse_string_encoded(part, &string_node->
unescaped, scope_node->encoding);
607 string_value = parse_regexp_string_part(iseq, scope_node, (
const pm_node_t *) string_node, &string_node->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
610 if (
RTEST(current_string)) {
611 current_string =
rb_str_concat(current_string, string_value);
614 current_string = string_value;
615 current_location = PM_NODE_START_LOCATION(scope_node->parser, part);
619 if (!
RTEST(current_string)) {
622 if (implicit_regexp_encoding != NULL) {
623 if (explicit_regexp_encoding != NULL) {
624 encoding = explicit_regexp_encoding;
627 encoding = rb_ascii8bit_encoding();
630 encoding = implicit_regexp_encoding;
634 encoding = scope_node->encoding;
637 if (parts_size == 1) {
638 current_string = rb_enc_str_new(NULL, 0, encoding);
642 if (
RTEST(current_string)) {
643 VALUE operand = rb_fstring(current_string);
644 PUSH_INSN1(ret, current_location, putobject, operand);
648 PM_COMPILE_NOT_POPPED(part);
650 const pm_node_location_t current_location = PM_NODE_START_LOCATION(scope_node->parser, part);
651 PUSH_INSN(ret, current_location, dup);
654 const struct rb_callinfo *callinfo = new_callinfo(iseq, idTo_s, 0, VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE, NULL, FALSE);
655 PUSH_INSN1(ret, current_location, objtostring, callinfo);
658 PUSH_INSN(ret, current_location, anytostring);
660 current_string =
Qnil;
666 if (
RTEST(current_string)) {
667 current_string = rb_fstring(current_string);
669 if (stack_size == 0 && interpolated) {
670 PUSH_INSN1(ret, current_location, putstring, current_string);
673 PUSH_INSN1(ret, current_location, putobject, current_string);
676 current_string =
Qnil;
681 PUSH_INSN(ret, *node_location, putnil);
690 rb_encoding *explicit_regexp_encoding = parse_regexp_encoding(scope_node, node);
691 rb_encoding *implicit_regexp_encoding = explicit_regexp_encoding != NULL ? explicit_regexp_encoding : scope_node->encoding;
693 int length = pm_interpolated_node_compile(iseq, parts, node_location, ret, popped, scope_node, implicit_regexp_encoding, explicit_regexp_encoding);
694 PUSH_INSN2(ret, *node_location, toregexp,
INT2FIX(parse_regexp_flags(node) & 0xFF),
INT2FIX(length));
701 size_t length = pm_string_length(filepath);
705 return rb_enc_interned_str((
const char *) pm_string_source(filepath), length, filepath_encoding);
708 return rb_fstring_lit(
"<compiled>");
717pm_static_literal_string(
rb_iseq_t *iseq,
VALUE string,
int line_number)
719 if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal ||
RTEST(
ruby_debug)) {
720 return rb_str_with_debug_created_info(
string, rb_iseq_path(iseq), line_number);
723 return rb_fstring(
string);
744 VALUE value = rb_ary_hidden_new(elements->
size);
745 for (
size_t index = 0; index < elements->
size; index++) {
746 rb_ary_push(value, pm_static_literal_value(iseq, elements->
nodes[index], scope_node));
760 VALUE array = rb_ary_hidden_new(elements->
size * 2);
761 for (
size_t index = 0; index < elements->
size; index++) {
764 VALUE pair[2] = { pm_static_literal_value(iseq, cast->key, scope_node), pm_static_literal_value(iseq, cast->value, scope_node) };
765 rb_ary_cat(array, pair, 2);
768 VALUE value = rb_hash_new_with_size(elements->
size);
781 return parse_regexp_concat(iseq, scope_node, (
const pm_node_t *) cast, &cast->parts);
785 return parse_regexp_concat(iseq, scope_node, (
const pm_node_t *) cast, &cast->parts);
789 int line_number = pm_node_line_number(scope_node->parser, node);
790 return pm_static_literal_string(iseq,
string, line_number);
794 VALUE string = pm_static_literal_concat(iseq, &cast->
parts, scope_node, NULL, NULL,
true);
796 return ID2SYM(rb_intern_str(
string));
800 return parse_regexp_literal(iseq, scope_node, (
const pm_node_t *) cast, &cast->unescaped);
808 return parse_regexp_literal(iseq, scope_node, (
const pm_node_t *) cast, &cast->unescaped);
811 return rb_enc_from_encoding(scope_node->encoding);
814 return pm_source_file_value(cast, scope_node);
817 return INT2FIX(pm_node_line_number(scope_node->parser, node));
820 return parse_static_literal_string(iseq, scope_node, node, &cast->
unescaped);
827 rb_bug(
"Don't have a literal value for node type %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
838 const pm_line_column_t start_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, node);
839 const pm_line_column_t end_location = PM_NODE_END_LINE_COLUMN(scope_node->parser, node);
842 .beg_pos = { .lineno = start_location.
line, .column = start_location.
column },
843 .end_pos = { .lineno = end_location.
line, .column = end_location.
column }
852#define PM_BRANCH_COVERAGE_P(iseq) (ISEQ_COVERAGE(iseq) && ISEQ_BRANCH_COVERAGE(iseq))
866 if (!then_label) then_label = label;
867 else if (!else_label) else_label = label;
869 pm_compile_branch_condition(iseq, seq, cond, then_label, else_label, popped, scope_node);
871 if (LIST_INSN_SIZE_ONE(seq)) {
872 INSN *insn = (
INSN *) ELEM_FIRST_INSN(FIRST_ELEMENT(seq));
873 if (insn->insn_id == BIN(jump) && (
LABEL *)(insn->operands[0]) == label)
return;
876 if (!label->refcnt) {
877 if (popped) PUSH_INSN(ret, location, putnil);
880 PUSH_LABEL(seq, label);
893 PM_COMPILE_NOT_POPPED(node);
896 PUSH_INSN1(ret, location, getglobal, operand);
898 PUSH_SEND(ret, location, idEq,
INT2FIX(1));
899 if (popped) PUSH_INSN(ret, location, pop);
914 rb_num_t count = ISEQ_FLIP_CNT_INCREMENT(ISEQ_BODY(iseq)->local_iseq) + VM_SVAR_FLIPFLOP_START;
917 PUSH_INSN2(ret, location, getspecial, key,
INT2FIX(0));
918 PUSH_INSNL(ret, location, branchif, lend);
920 if (flip_flop_node->
left) {
921 pm_compile_flip_flop_bound(iseq, flip_flop_node->
left, ret, popped, scope_node);
924 PUSH_INSN(ret, location, putnil);
927 PUSH_INSNL(ret, location, branchunless, else_label);
928 PUSH_INSN1(ret, location, putobject,
Qtrue);
929 PUSH_INSN1(ret, location, setspecial, key);
931 PUSH_INSNL(ret, location, jump, then_label);
934 PUSH_LABEL(ret, lend);
935 if (flip_flop_node->
right) {
936 pm_compile_flip_flop_bound(iseq, flip_flop_node->
right, ret, popped, scope_node);
939 PUSH_INSN(ret, location, putnil);
942 PUSH_INSNL(ret, location, branchunless, then_label);
943 PUSH_INSN1(ret, location, putobject,
Qfalse);
944 PUSH_INSN1(ret, location, setspecial, key);
945 PUSH_INSNL(ret, location, jump, then_label);
959 pm_compile_logical(iseq, ret, cast->
left, NULL, else_label, popped, scope_node);
966 pm_compile_logical(iseq, ret, cast->
left, then_label, NULL, popped, scope_node);
973 PUSH_INSNL(ret, location, jump, else_label);
984 PUSH_INSNL(ret, location, jump, then_label);
987 pm_compile_flip_flop((
const pm_flip_flop_node_t *) cond, else_label, then_label, iseq, location.
line, ret, popped, scope_node);
991 pm_compile_defined_expr(iseq, cast->
value, &location, ret, popped, scope_node,
true);
995 DECL_ANCHOR(cond_seq);
996 pm_compile_node(iseq, cond, cond_seq,
false, scope_node);
998 if (LIST_INSN_SIZE_ONE(cond_seq)) {
999 INSN *insn = (
INSN *) ELEM_FIRST_INSN(FIRST_ELEMENT(cond_seq));
1001 if (insn->insn_id == BIN(putobject)) {
1002 if (
RTEST(insn->operands[0])) {
1003 PUSH_INSNL(ret, location, jump, then_label);
1008 PUSH_INSNL(ret, location, jump, else_label);
1014 PUSH_SEQ(ret, cond_seq);
1019 PUSH_INSNL(ret, location, branchunless, else_label);
1020 PUSH_INSNL(ret, location, jump, then_label);
1030 LABEL *then_label = NEW_LABEL(location.
line);
1031 LABEL *else_label = NEW_LABEL(location.
line);
1032 LABEL *end_label = NULL;
1034 DECL_ANCHOR(cond_seq);
1035 pm_compile_branch_condition(iseq, cond_seq, predicate, then_label, else_label,
false, scope_node);
1036 PUSH_SEQ(ret, cond_seq);
1041 if (then_label->refcnt && else_label->refcnt && PM_BRANCH_COVERAGE_P(iseq)) {
1042 conditional_location = pm_code_location(scope_node, node);
1043 branches = decl_branch_base(iseq, PTR2NUM(node), &conditional_location,
type ==
PM_IF_NODE ?
"if" :
"unless");
1046 if (then_label->refcnt) {
1047 PUSH_LABEL(ret, then_label);
1049 DECL_ANCHOR(then_seq);
1051 if (statements != NULL) {
1052 pm_compile_node(iseq, (
const pm_node_t *) statements, then_seq, popped, scope_node);
1055 PUSH_SYNTHETIC_PUTNIL(then_seq, iseq);
1058 if (else_label->refcnt) {
1060 if (PM_BRANCH_COVERAGE_P(iseq)) {
1063 if (statements != NULL) {
1064 branch_location = pm_code_location(scope_node, (
const pm_node_t *) statements);
1066 pm_line_column_t predicate_end = PM_NODE_END_LINE_COLUMN(scope_node->parser, predicate);
1068 .beg_pos = { .lineno = predicate_end.
line, .column = predicate_end.
column },
1069 .end_pos = { .lineno = predicate_end.
line, .column = predicate_end.
column }
1072 branch_location = conditional_location;
1075 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 0,
type ==
PM_IF_NODE ?
"then" :
"else", branches);
1078 end_label = NEW_LABEL(location.
line);
1079 PUSH_INSNL(then_seq, location, jump, end_label);
1080 if (!popped) PUSH_INSN(then_seq, location, pop);
1083 PUSH_SEQ(ret, then_seq);
1086 if (else_label->refcnt) {
1087 PUSH_LABEL(ret, else_label);
1089 DECL_ANCHOR(else_seq);
1091 if (subsequent != NULL) {
1092 pm_compile_node(iseq, subsequent, else_seq, popped, scope_node);
1095 PUSH_SYNTHETIC_PUTNIL(else_seq, iseq);
1099 if (then_label->refcnt && PM_BRANCH_COVERAGE_P(iseq)) {
1102 if (subsequent == NULL) {
1103 branch_location = conditional_location;
1108 branch_location = pm_code_location(scope_node, (
const pm_node_t *) subsequent);
1111 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 1,
type ==
PM_IF_NODE ?
"else" :
"then", branches);
1114 PUSH_SEQ(ret, else_seq);
1118 PUSH_LABEL(ret, end_label);
1132 LABEL *prev_start_label = ISEQ_COMPILE_DATA(iseq)->start_label;
1133 LABEL *prev_end_label = ISEQ_COMPILE_DATA(iseq)->end_label;
1134 LABEL *prev_redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label;
1136 LABEL *next_label = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(location.
line);
1137 LABEL *redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label = NEW_LABEL(location.
line);
1138 LABEL *break_label = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(location.
line);
1139 LABEL *end_label = NEW_LABEL(location.
line);
1140 LABEL *adjust_label = NEW_LABEL(location.
line);
1142 LABEL *next_catch_label = NEW_LABEL(location.
line);
1143 LABEL *tmp_label = NULL;
1149 push_ensure_entry(iseq, &enl, NULL, NULL);
1153 tmp_label = NEW_LABEL(location.
line);
1154 PUSH_INSNL(ret, location, jump, tmp_label);
1158 PUSH_INSNL(ret, location, jump, next_label);
1161 PUSH_LABEL(ret, adjust_label);
1162 PUSH_INSN(ret, location, putnil);
1163 PUSH_LABEL(ret, next_catch_label);
1164 PUSH_INSN(ret, location, pop);
1165 PUSH_INSNL(ret, location, jump, next_label);
1166 if (tmp_label) PUSH_LABEL(ret, tmp_label);
1168 PUSH_LABEL(ret, redo_label);
1171 if (PM_BRANCH_COVERAGE_P(iseq)) {
1173 VALUE branches = decl_branch_base(iseq, PTR2NUM(node), &loop_location,
type ==
PM_WHILE_NODE ?
"while" :
"until");
1175 rb_code_location_t branch_location = statements != NULL ? pm_code_location(scope_node, (
const pm_node_t *) statements) : loop_location;
1176 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 0,
"body", branches);
1179 if (statements != NULL) PM_COMPILE_POPPED((
const pm_node_t *) statements);
1180 PUSH_LABEL(ret, next_label);
1183 pm_compile_branch_condition(iseq, ret, predicate, redo_label, end_label, popped, scope_node);
1186 pm_compile_branch_condition(iseq, ret, predicate, end_label, redo_label, popped, scope_node);
1189 PUSH_LABEL(ret, end_label);
1190 PUSH_ADJUST_RESTORE(ret, adjust_label);
1191 PUSH_INSN(ret, location, putnil);
1193 PUSH_LABEL(ret, break_label);
1194 if (popped) PUSH_INSN(ret, location, pop);
1196 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, redo_label, break_label, NULL, break_label);
1197 PUSH_CATCH_ENTRY(CATCH_TYPE_NEXT, redo_label, break_label, NULL, next_catch_label);
1198 PUSH_CATCH_ENTRY(CATCH_TYPE_REDO, redo_label, break_label, NULL, ISEQ_COMPILE_DATA(iseq)->redo_label);
1200 ISEQ_COMPILE_DATA(iseq)->start_label = prev_start_label;
1201 ISEQ_COMPILE_DATA(iseq)->end_label = prev_end_label;
1202 ISEQ_COMPILE_DATA(iseq)->redo_label = prev_redo_label;
1203 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = ISEQ_COMPILE_DATA(iseq)->ensure_node_stack->prev;
1215 st_data_t local_index;
1218 for (level = 0; level < start_depth; level++) {
1219 scope_node = scope_node->previous;
1222 while (!st_lookup(scope_node->index_lookup_table, constant_id, &local_index)) {
1225 if (scope_node->previous) {
1226 scope_node = scope_node->previous;
1231 rb_bug(
"Local with constant_id %u does not exist", (
unsigned int) constant_id);
1235 lindex.level = level;
1236 lindex.index = scope_node->local_table_for_iseq_size - (int) local_index;
1250 rb_bug(
"constant_id out of range: %u", (
unsigned int)constant_id);
1252 return scope_node->constants[constant_id - 1];
1258 debugs(
"[new_child_iseq]> ---------------------------------------\n");
1259 int isolated_depth = ISEQ_COMPILE_DATA(iseq)->isolated_depth;
1261 rb_iseq_t *ret_iseq = pm_iseq_new_with_opt(node, name,
1262 rb_iseq_path(iseq), rb_iseq_realpath(iseq),
1264 isolated_depth ? isolated_depth + 1 : 0,
1265 type, ISEQ_COMPILE_DATA(iseq)->option, &error_state);
1269 rb_jump_tag(error_state);
1271 debugs(
"[new_child_iseq]< ---------------------------------------\n");
1284 return VM_DEFINECLASS_FLAG_SCOPED;
1288 PUSH_INSN1(ret, *node_location, putobject, rb_cObject);
1289 return VM_DEFINECLASS_FLAG_SCOPED;
1294 PUSH_INSN1(ret, *node_location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
1304pm_compile_call_and_or_write_node(
rb_iseq_t *iseq,
bool and_node,
const pm_node_t *receiver,
const pm_node_t *value,
pm_constant_id_t write_name,
pm_constant_id_t read_name,
bool safe_nav,
const pm_node_location_t *node_location,
LINK_ANCHOR *
const ret,
bool popped,
pm_scope_node_t *scope_node)
1308 LABEL *lcfin = NEW_LABEL(location.
line);
1309 LABEL *lskip = NULL;
1312 ID id_read_name = pm_constant_id_lookup(scope_node, read_name);
1314 PM_COMPILE_NOT_POPPED(receiver);
1316 lskip = NEW_LABEL(location.
line);
1317 PUSH_INSN(ret, location, dup);
1318 PUSH_INSNL(ret, location, branchnil, lskip);
1321 PUSH_INSN(ret, location, dup);
1322 PUSH_SEND_WITH_FLAG(ret, location, id_read_name,
INT2FIX(0),
INT2FIX(flag));
1323 if (!popped) PUSH_INSN(ret, location, dup);
1326 PUSH_INSNL(ret, location, branchunless, lcfin);
1329 PUSH_INSNL(ret, location, branchif, lcfin);
1332 if (!popped) PUSH_INSN(ret, location, pop);
1333 PM_COMPILE_NOT_POPPED(value);
1336 PUSH_INSN(ret, location, swap);
1337 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
1340 ID id_write_name = pm_constant_id_lookup(scope_node, write_name);
1341 PUSH_SEND_WITH_FLAG(ret, location, id_write_name,
INT2FIX(1),
INT2FIX(flag));
1342 PUSH_INSNL(ret, location, jump, lfin);
1344 PUSH_LABEL(ret, lcfin);
1345 if (!popped) PUSH_INSN(ret, location, swap);
1347 PUSH_LABEL(ret, lfin);
1349 if (lskip && popped) PUSH_LABEL(ret, lskip);
1350 PUSH_INSN(ret, location, pop);
1351 if (lskip && !popped) PUSH_LABEL(ret, lskip);
1364 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
1370 const int max_stack_length = 0x100;
1371 const unsigned int min_tmp_hash_length = 0x800;
1373 int stack_length = 0;
1374 bool first_chunk =
true;
1380 bool static_literal =
false;
1382 DECL_ANCHOR(anchor);
1385#define FLUSH_CHUNK \
1386 if (stack_length) { \
1387 if (first_chunk) { \
1388 PUSH_SEQ(ret, anchor); \
1389 PUSH_INSN1(ret, location, newhash, INT2FIX(stack_length)); \
1390 first_chunk = false; \
1393 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE)); \
1394 PUSH_INSN(ret, location, swap); \
1395 PUSH_SEQ(ret, anchor); \
1396 PUSH_SEND(ret, location, id_core_hash_merge_ptr, INT2FIX(stack_length + 1)); \
1398 INIT_ANCHOR(anchor); \
1402 for (
size_t index = 0; index < elements->
size; index++) {
1409 (shareability == 0) &&
1411 (!static_literal && ((index + min_tmp_hash_length) < elements->
size)) ||
1412 (first_chunk && stack_length == 0)
1417 while (index + count < elements->size &&
PM_NODE_FLAG_P(elements->
nodes[index + count], PM_NODE_FLAG_STATIC_LITERAL)) count++;
1419 if ((first_chunk && stack_length == 0) || count >= min_tmp_hash_length) {
1422 VALUE ary = rb_ary_hidden_new(count);
1425 for (
size_t tmp_end = index + count; index < tmp_end; index++) {
1429 pm_static_literal_value(iseq, assoc->key, scope_node),
1430 pm_static_literal_value(iseq, assoc->value, scope_node)
1433 rb_ary_cat(ary, elem, 2);
1445 PUSH_INSN1(ret, location, duphash, hash);
1446 first_chunk =
false;
1449 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1450 PUSH_INSN(ret, location, swap);
1451 PUSH_INSN1(ret, location, putobject, hash);
1452 PUSH_SEND(ret, location, id_core_hash_merge_kwd,
INT2FIX(2));
1458 static_literal =
true;
1462 static_literal =
false;
1467 if (shareability == 0) {
1468 pm_compile_node(iseq, element, anchor,
false, scope_node);
1472 pm_compile_shareable_constant_value(iseq, assoc->
key, shareability, path, ret, scope_node,
false);
1473 pm_compile_shareable_constant_value(iseq, assoc->
value, shareability, path, ret, scope_node,
false);
1476 if ((stack_length += 2) >= max_stack_length) FLUSH_CHUNK;
1483 bool empty_hash = assoc_splat->
value != NULL && (
1488 bool first_element = first_chunk && stack_length == 0;
1489 bool last_element = index == elements->
size - 1;
1490 bool only_element = first_element && last_element;
1493 if (only_element && argument) {
1500 PUSH_INSN(ret, location, putnil);
1502 else if (first_element) {
1505 PUSH_INSN1(ret, location, newhash,
INT2FIX(0));
1512 if (only_element && argument) {
1518 if (shareability == 0) {
1519 PM_COMPILE_NOT_POPPED(element);
1522 pm_compile_shareable_constant_value(iseq, element, shareability, path, ret, scope_node,
false);
1530 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1532 if (first_element) {
1533 PUSH_INSN1(ret, location, newhash,
INT2FIX(0));
1536 PUSH_INSN(ret, location, swap);
1539 if (shareability == 0) {
1540 PM_COMPILE_NOT_POPPED(element);
1543 pm_compile_shareable_constant_value(iseq, element, shareability, path, ret, scope_node,
false);
1546 PUSH_SEND(ret, location, id_core_hash_merge_kwd,
INT2FIX(2));
1550 first_chunk =
false;
1551 static_literal =
false;
1555 RUBY_ASSERT(
"Invalid node type for hash" &&
false);
1564#define SPLATARRAY_FALSE 0
1565#define SPLATARRAY_TRUE 1
1566#define DUP_SINGLE_KW_SPLAT 2
1575 bool has_splat =
false;
1576 bool has_keyword_splat =
false;
1578 if (arguments_node == NULL) {
1579 if (*flags & VM_CALL_FCALL) {
1580 *flags |= VM_CALL_VCALL;
1589 int post_splat_counter = 0;
1599 if (has_keyword_splat || has_splat) {
1600 *flags |= VM_CALL_KW_SPLAT;
1601 has_keyword_splat =
true;
1607 *flags |= VM_CALL_KW_SPLAT_MUT;
1608 pm_compile_hash_elements(iseq, argument, elements, 0,
Qundef,
true, ret, scope_node);
1610 else if (*dup_rest & DUP_SINGLE_KW_SPLAT) {
1611 *flags |= VM_CALL_KW_SPLAT_MUT;
1612 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1613 PUSH_INSN1(ret, location, newhash,
INT2FIX(0));
1614 pm_compile_hash_elements(iseq, argument, elements, 0,
Qundef,
true, ret, scope_node);
1615 PUSH_SEND(ret, location, id_core_hash_merge_kwd,
INT2FIX(2));
1618 pm_compile_hash_elements(iseq, argument, elements, 0,
Qundef,
true, ret, scope_node);
1629 VALUE stored_indices = rb_hash_new();
1630 VALUE keyword_indices = rb_ary_new_capa(elements->
size);
1633 for (
size_t element_index = 0; element_index < elements->
size; element_index++) {
1638 VALUE keyword = pm_static_literal_value(iseq, assoc->key, scope_node);
1639 VALUE stored_index = rb_hash_aref(stored_indices, keyword);
1644 if (!
NIL_P(stored_index)) {
1652 rb_hash_aset(stored_indices, keyword,
ULONG2NUM(element_index));
1653 rb_ary_store(keyword_indices, (
long) element_index,
Qtrue);
1658 *flags |= VM_CALL_KWARG;
1660 VALUE *keywords = (*kw_arg)->keywords;
1661 (*kw_arg)->references = 0;
1662 (*kw_arg)->keyword_len = (int) size;
1664 size_t keyword_index = 0;
1665 for (
size_t element_index = 0; element_index < elements->
size; element_index++) {
1669 if (rb_ary_entry(keyword_indices, (
long) element_index) ==
Qtrue) {
1670 keywords[keyword_index++] = pm_static_literal_value(iseq, assoc->key, scope_node);
1674 PM_COMPILE(assoc->value);
1683 *flags |= VM_CALL_KW_SPLAT;
1685 size_t size = elements->
size;
1690 *flags |= VM_CALL_KW_SPLAT_MUT;
1693 for (
size_t element_index = 0; element_index < size; element_index++) {
1695 PM_COMPILE_NOT_POPPED(assoc->key);
1696 PM_COMPILE_NOT_POPPED(assoc->value);
1699 PUSH_INSN1(ret, location, newhash,
INT2FIX(size * 2));
1705 *flags |= VM_CALL_ARGS_SPLAT;
1709 PM_COMPILE_NOT_POPPED(splat_node->
expression);
1712 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
1713 PUSH_GETLOCAL(ret, location, index.index, index.level);
1716 bool first_splat = !has_splat;
1724 if (index + 1 < arguments->
size || has_regular_blockarg) {
1725 PUSH_INSN1(ret, location, splatarray, (*dup_rest & SPLATARRAY_TRUE) ?
Qtrue :
Qfalse);
1726 if (*dup_rest & SPLATARRAY_TRUE) *dup_rest &= ~SPLATARRAY_TRUE;
1734 PUSH_INSN1(ret, location, splatarray,
Qfalse);
1744 PUSH_INSN(ret, location, concattoarray);
1748 post_splat_counter = 0;
1753 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
1755 if (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.flags.forwardable) {
1756 *flags |= VM_CALL_FORWARDING;
1758 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_DOT3, 0);
1759 PUSH_GETLOCAL(ret, location, mult_local.index, mult_local.level);
1766 *flags |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT | VM_CALL_ARGS_BLOCKARG | VM_CALL_KW_SPLAT;
1773 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
1774 PUSH_GETLOCAL(ret, location, mult_local.index, mult_local.level);
1775 PUSH_INSN1(ret, location, splatarray,
Qtrue);
1778 pm_local_index_t pow_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_POW, 0);
1779 PUSH_GETLOCAL(ret, location, pow_local.index, pow_local.level);
1782 pm_local_index_t and_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_AND, 0);
1783 PUSH_INSN2(ret, location, getblockparamproxy,
INT2FIX(and_local.index + VM_ENV_DATA_SIZE - 1),
INT2FIX(and_local.level));
1784 PUSH_INSN(ret, location, splatkw);
1789 post_splat_counter++;
1790 PM_COMPILE_NOT_POPPED(argument);
1810 if (index == arguments->
size - 1) {
1812 PUSH_INSN1(ret, location, pushtoarray,
INT2FIX(post_splat_counter));
1820 PUSH_INSN1(ret, location, newarray,
INT2FIX(post_splat_counter));
1821 PUSH_INSN(ret, location, concatarray);
1825 PUSH_INSN1(ret, location, newarray,
INT2FIX(post_splat_counter));
1826 PUSH_INSN(ret, location, concatarray);
1842 if (has_splat) orig_argc++;
1843 if (has_keyword_splat) orig_argc++;
1852pm_setup_args_dup_rest_p(
const pm_node_t *node)
1889 int dup_rest = SPLATARRAY_TRUE;
1892 size_t arguments_size;
1897 arguments_node != NULL &&
1898 (arguments = &arguments_node->
arguments, arguments_size = arguments->
size) >= 2 &&
1906 dup_rest = SPLATARRAY_FALSE;
1911 for (
size_t index = 0; dup_rest == SPLATARRAY_FALSE && index < elements->
size; index++) {
1917 if (pm_setup_args_dup_rest_p(assoc->
key) || pm_setup_args_dup_rest_p(assoc->
value)) dup_rest = SPLATARRAY_TRUE;
1922 if (assoc->
value != NULL && pm_setup_args_dup_rest_p(assoc->
value)) dup_rest = SPLATARRAY_TRUE;
1931 int initial_dup_rest = dup_rest;
1938 bool regular_block_arg =
true;
1941 if (block_expr && pm_setup_args_dup_rest_p(block_expr)) {
1942 dup_rest = SPLATARRAY_TRUE | DUP_SINGLE_KW_SPLAT;
1943 initial_dup_rest = dup_rest;
1946 DECL_ANCHOR(block_arg);
1947 pm_compile_node(iseq, block, block_arg,
false, scope_node);
1949 *flags |= VM_CALL_ARGS_BLOCKARG;
1951 if (LIST_INSN_SIZE_ONE(block_arg)) {
1953 if (IS_INSN(elem)) {
1955 if (iobj->insn_id == BIN(getblockparam)) {
1956 iobj->insn_id = BIN(getblockparamproxy);
1963 regular_block_arg =
false;
1967 argc = pm_setup_args_core(arguments_node, block, flags, regular_block_arg, kw_arg, &dup_rest, iseq, ret, scope_node, node_location);
1968 PUSH_SEQ(ret, block_arg);
1971 argc = pm_setup_args_core(arguments_node, block, flags,
false, kw_arg, &dup_rest, iseq, ret, scope_node, node_location);
1978 if (*flags & VM_CALL_ARGS_SPLAT && dup_rest != initial_dup_rest) {
1979 *flags |= VM_CALL_ARGS_SPLAT_MUT;
1999 if (!popped) PUSH_INSN(ret, location, putnil);
2001 PM_COMPILE_NOT_POPPED(node->
receiver);
2003 int boff = (node->
block == NULL ? 0 : 1);
2006 int argc = pm_setup_args(node->
arguments, (
const pm_node_t *) node->
block, &flag, &keywords, iseq, ret, scope_node, node_location);
2008 if ((argc > 0 || boff) && (flag & VM_CALL_KW_SPLAT)) {
2010 PUSH_INSN(ret, location, splatkw);
2013 PUSH_INSN(ret, location, dup);
2014 PUSH_INSN(ret, location, splatkw);
2015 PUSH_INSN(ret, location, pop);
2019 int dup_argn = argc + 1 + boff;
2020 int keyword_len = 0;
2023 keyword_len = keywords->keyword_len;
2024 dup_argn += keyword_len;
2027 PUSH_INSN1(ret, location, dupn,
INT2FIX(dup_argn));
2028 PUSH_SEND_R(ret, location, idAREF,
INT2FIX(argc), NULL,
INT2FIX(flag & ~(VM_CALL_ARGS_SPLAT_MUT | VM_CALL_KW_SPLAT_MUT)), keywords);
2029 PM_COMPILE_NOT_POPPED(node->
value);
2032 PUSH_SEND(ret, location, id_operator,
INT2FIX(1));
2035 PUSH_INSN1(ret, location, setn,
INT2FIX(dup_argn + 1));
2037 if (flag & VM_CALL_ARGS_SPLAT) {
2038 if (flag & VM_CALL_KW_SPLAT) {
2039 PUSH_INSN1(ret, location, topn,
INT2FIX(2 + boff));
2041 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2042 PUSH_INSN1(ret, location, splatarray,
Qtrue);
2043 flag |= VM_CALL_ARGS_SPLAT_MUT;
2046 PUSH_INSN(ret, location, swap);
2047 PUSH_INSN1(ret, location, pushtoarray,
INT2FIX(1));
2048 PUSH_INSN1(ret, location, setn,
INT2FIX(2 + boff));
2049 PUSH_INSN(ret, location, pop);
2053 PUSH_INSN1(ret, location, dupn,
INT2FIX(3));
2054 PUSH_INSN(ret, location, swap);
2055 PUSH_INSN(ret, location, pop);
2057 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2058 PUSH_INSN(ret, location, swap);
2059 PUSH_INSN1(ret, location, splatarray,
Qtrue);
2060 PUSH_INSN(ret, location, swap);
2061 flag |= VM_CALL_ARGS_SPLAT_MUT;
2063 PUSH_INSN1(ret, location, pushtoarray,
INT2FIX(1));
2065 PUSH_INSN1(ret, location, setn,
INT2FIX(3));
2066 PUSH_INSN(ret, location, pop);
2067 PUSH_INSN(ret, location, pop);
2071 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc), NULL,
INT2FIX(flag), keywords);
2073 else if (flag & VM_CALL_KW_SPLAT) {
2075 PUSH_INSN1(ret, location, topn,
INT2FIX(2));
2076 PUSH_INSN(ret, location, swap);
2077 PUSH_INSN1(ret, location, setn,
INT2FIX(3));
2078 PUSH_INSN(ret, location, pop);
2080 PUSH_INSN(ret, location, swap);
2081 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2083 else if (keyword_len) {
2084 PUSH_INSN(ret, location, dup);
2085 PUSH_INSN1(ret, location, opt_reverse,
INT2FIX(keyword_len + boff + 2));
2086 PUSH_INSN1(ret, location, opt_reverse,
INT2FIX(keyword_len + boff + 1));
2087 PUSH_INSN(ret, location, pop);
2088 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2092 PUSH_INSN(ret, location, swap);
2094 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2097 PUSH_INSN(ret, location, pop);
2116 if (!popped) PUSH_INSN(ret, location, putnil);
2117 PM_COMPILE_NOT_POPPED(receiver);
2119 int boff = (block == NULL ? 0 : 1);
2122 int argc = pm_setup_args(arguments, (
const pm_node_t *) block, &flag, &keywords, iseq, ret, scope_node, node_location);
2124 if ((argc > 0 || boff) && (flag & VM_CALL_KW_SPLAT)) {
2126 PUSH_INSN(ret, location, splatkw);
2129 PUSH_INSN(ret, location, dup);
2130 PUSH_INSN(ret, location, splatkw);
2131 PUSH_INSN(ret, location, pop);
2135 int dup_argn = argc + 1 + boff;
2136 int keyword_len = 0;
2139 keyword_len = keywords->keyword_len;
2140 dup_argn += keyword_len;
2143 PUSH_INSN1(ret, location, dupn,
INT2FIX(dup_argn));
2144 PUSH_SEND_R(ret, location, idAREF,
INT2FIX(argc), NULL,
INT2FIX(flag & ~(VM_CALL_ARGS_SPLAT_MUT | VM_CALL_KW_SPLAT_MUT)), keywords);
2146 LABEL *label = NEW_LABEL(location.
line);
2149 PUSH_INSN(ret, location, dup);
2151 PUSH_INSNL(ret, location, branchunless, label);
2154 PUSH_INSNL(ret, location, branchif, label);
2157 PUSH_INSN(ret, location, pop);
2158 PM_COMPILE_NOT_POPPED(value);
2161 PUSH_INSN1(ret, location, setn,
INT2FIX(dup_argn + 1));
2164 if (flag & VM_CALL_ARGS_SPLAT) {
2165 if (flag & VM_CALL_KW_SPLAT) {
2166 PUSH_INSN1(ret, location, topn,
INT2FIX(2 + boff));
2167 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2168 PUSH_INSN1(ret, location, splatarray,
Qtrue);
2169 flag |= VM_CALL_ARGS_SPLAT_MUT;
2172 PUSH_INSN(ret, location, swap);
2173 PUSH_INSN1(ret, location, pushtoarray,
INT2FIX(1));
2174 PUSH_INSN1(ret, location, setn,
INT2FIX(2 + boff));
2175 PUSH_INSN(ret, location, pop);
2179 PUSH_INSN1(ret, location, dupn,
INT2FIX(3));
2180 PUSH_INSN(ret, location, swap);
2181 PUSH_INSN(ret, location, pop);
2183 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2184 PUSH_INSN(ret, location, swap);
2185 PUSH_INSN1(ret, location, splatarray,
Qtrue);
2186 PUSH_INSN(ret, location, swap);
2187 flag |= VM_CALL_ARGS_SPLAT_MUT;
2189 PUSH_INSN1(ret, location, pushtoarray,
INT2FIX(1));
2191 PUSH_INSN1(ret, location, setn,
INT2FIX(3));
2192 PUSH_INSN(ret, location, pop);
2193 PUSH_INSN(ret, location, pop);
2197 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc), NULL,
INT2FIX(flag), keywords);
2199 else if (flag & VM_CALL_KW_SPLAT) {
2201 PUSH_INSN1(ret, location, topn,
INT2FIX(2));
2202 PUSH_INSN(ret, location, swap);
2203 PUSH_INSN1(ret, location, setn,
INT2FIX(3));
2204 PUSH_INSN(ret, location, pop);
2207 PUSH_INSN(ret, location, swap);
2208 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2210 else if (keyword_len) {
2211 PUSH_INSN1(ret, location, opt_reverse,
INT2FIX(keyword_len + boff + 1));
2212 PUSH_INSN1(ret, location, opt_reverse,
INT2FIX(keyword_len + boff + 0));
2213 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2217 PUSH_INSN(ret, location, swap);
2219 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2222 PUSH_INSN(ret, location, pop);
2223 PUSH_INSNL(ret, location, jump, lfin);
2224 PUSH_LABEL(ret, label);
2226 PUSH_INSN1(ret, location, setn,
INT2FIX(dup_argn + 1));
2228 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(dup_argn + 1));
2229 PUSH_LABEL(ret, lfin);
2238#define PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE 0
2239#define PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING 1
2240#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P 2
2241#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE 3
2242#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY 4
2247static int pm_compile_pattern(
rb_iseq_t *iseq,
pm_scope_node_t *scope_node,
const pm_node_t *node,
LINK_ANCHOR *
const ret,
LABEL *matched_label,
LABEL *unmatched_label,
bool in_single_pattern,
bool in_alternation_pattern,
bool use_deconstructed_cache,
unsigned int base_index);
2256 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2257 LABEL *match_succeeded_label = NEW_LABEL(location.
line);
2259 PUSH_INSN(ret, location, dup);
2260 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2262 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2263 PUSH_INSN1(ret, location, putobject, message);
2264 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2265 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(2));
2266 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2268 PUSH_INSN1(ret, location, putobject,
Qfalse);
2269 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2271 PUSH_INSN(ret, location, pop);
2272 PUSH_INSN(ret, location, pop);
2273 PUSH_LABEL(ret, match_succeeded_label);
2286 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2287 LABEL *match_succeeded_label = NEW_LABEL(location.
line);
2289 PUSH_INSN(ret, location, dup);
2290 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2292 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2293 PUSH_INSN1(ret, location, putobject, message);
2294 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2295 PUSH_INSN(ret, location, dup);
2296 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2297 PUSH_INSN1(ret, location, putobject, length);
2298 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(4));
2299 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2301 PUSH_INSN1(ret, location, putobject,
Qfalse);
2302 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2304 PUSH_INSN(ret, location, pop);
2305 PUSH_INSN(ret, location, pop);
2306 PUSH_LABEL(ret, match_succeeded_label);
2319 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2320 LABEL *match_succeeded_label = NEW_LABEL(location.
line);
2322 PUSH_INSN(ret, location, dup);
2323 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2324 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2326 VALUE operand = rb_fstring_lit(
"%p === %p does not return true");
2327 PUSH_INSN1(ret, location, putobject, operand);
2329 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2330 PUSH_INSN1(ret, location, topn,
INT2FIX(5));
2331 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(3));
2332 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2333 PUSH_INSN1(ret, location, putobject,
Qfalse);
2334 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2335 PUSH_INSN(ret, location, pop);
2336 PUSH_INSN(ret, location, pop);
2338 PUSH_LABEL(ret, match_succeeded_label);
2339 PUSH_INSN1(ret, location, setn,
INT2FIX(2));
2340 PUSH_INSN(ret, location, pop);
2341 PUSH_INSN(ret, location, pop);
2353pm_compile_pattern_match(
rb_iseq_t *iseq,
pm_scope_node_t *scope_node,
const pm_node_t *node,
LINK_ANCHOR *
const ret,
LABEL *unmatched_label,
bool in_single_pattern,
bool in_alternation_pattern,
bool use_deconstructed_cache,
unsigned int base_index)
2355 LABEL *matched_label = NEW_LABEL(pm_node_line_number(scope_node->parser, node));
2356 CHECK(pm_compile_pattern(iseq, scope_node, node, ret, matched_label, unmatched_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index));
2357 PUSH_LABEL(ret, matched_label);
2367pm_compile_pattern_deconstruct(
rb_iseq_t *iseq,
pm_scope_node_t *scope_node,
const pm_node_t *node,
LINK_ANCHOR *
const ret,
LABEL *deconstruct_label,
LABEL *match_failed_label,
LABEL *deconstructed_label,
LABEL *type_error_label,
bool in_single_pattern,
bool use_deconstructed_cache,
unsigned int base_index)
2369 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2371 if (use_deconstructed_cache) {
2372 PUSH_INSN1(ret, location, topn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2373 PUSH_INSNL(ret, location, branchnil, deconstruct_label);
2375 PUSH_INSN1(ret, location, topn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2376 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2378 PUSH_INSN(ret, location, pop);
2379 PUSH_INSN1(ret, location, topn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE - 1));
2380 PUSH_INSNL(ret, location, jump, deconstructed_label);
2383 PUSH_INSNL(ret, location, jump, deconstruct_label);
2386 PUSH_LABEL(ret, deconstruct_label);
2387 PUSH_INSN(ret, location, dup);
2390 PUSH_INSN1(ret, location, putobject, operand);
2391 PUSH_SEND(ret, location, idRespond_to,
INT2FIX(1));
2393 if (use_deconstructed_cache) {
2394 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE + 1));
2397 if (in_single_pattern) {
2398 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit(
"%p does not respond to #deconstruct"), base_index + 1));
2401 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2402 PUSH_SEND(ret, location, rb_intern(
"deconstruct"),
INT2FIX(0));
2404 if (use_deconstructed_cache) {
2405 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2408 PUSH_INSN(ret, location, dup);
2410 PUSH_INSNL(ret, location, branchunless, type_error_label);
2411 PUSH_LABEL(ret, deconstructed_label);
2423 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2425 PUSH_INSN(ret, location, dup);
2426 PM_COMPILE_NOT_POPPED(node);
2428 if (in_single_pattern) {
2429 PUSH_INSN1(ret, location, dupn,
INT2FIX(2));
2431 PUSH_INSN1(ret, location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_CASE));
2432 if (in_single_pattern) {
2433 CHECK(pm_compile_pattern_eqq_error(iseq, scope_node, node, ret, base_index + 3));
2435 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2446 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2447 LABEL *key_error_label = NEW_LABEL(location.
line);
2448 LABEL *cleanup_label = NEW_LABEL(location.
line);
2451 kw_arg->references = 0;
2452 kw_arg->keyword_len = 2;
2453 kw_arg->keywords[0] =
ID2SYM(rb_intern(
"matchee"));
2454 kw_arg->keywords[1] =
ID2SYM(rb_intern(
"key"));
2456 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2457 PUSH_INSN1(ret, location, topn,
INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2458 PUSH_INSNL(ret, location, branchif, key_error_label);
2461 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2464 VALUE operand = rb_fstring_lit(
"%p: %s");
2465 PUSH_INSN1(ret, location, putobject, operand);
2468 PUSH_INSN1(ret, location, topn,
INT2FIX(4));
2469 PUSH_INSN1(ret, location, topn,
INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 6));
2470 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(3));
2471 PUSH_SEND(ret, location, id_core_raise,
INT2FIX(2));
2472 PUSH_INSNL(ret, location, jump, cleanup_label);
2474 PUSH_LABEL(ret, key_error_label);
2476 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2479 VALUE operand = rb_fstring_lit(
"%p: %s");
2480 PUSH_INSN1(ret, location, putobject, operand);
2483 PUSH_INSN1(ret, location, topn,
INT2FIX(4));
2484 PUSH_INSN1(ret, location, topn,
INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 6));
2485 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(3));
2486 PUSH_INSN1(ret, location, topn,
INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE + 4));
2487 PUSH_INSN1(ret, location, topn,
INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY + 5));
2488 PUSH_SEND_R(ret, location, rb_intern(
"new"),
INT2FIX(1), NULL,
INT2FIX(VM_CALL_KWARG), kw_arg);
2489 PUSH_SEND(ret, location, id_core_raise,
INT2FIX(1));
2490 PUSH_LABEL(ret, cleanup_label);
2492 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(7));
2493 if (!popped) PUSH_INSN(ret, location, putnil);
2494 PUSH_INSNL(ret, location, jump, done_label);
2495 PUSH_INSN1(ret, location, dupn,
INT2FIX(5));
2496 if (popped) PUSH_INSN(ret, location, putnil);
2505 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2520 const size_t posts_size = cast->
posts.
size;
2521 const size_t minimum_size = requireds_size + posts_size;
2523 bool rest_named =
false;
2524 bool use_rest_size =
false;
2526 if (cast->
rest != NULL) {
2528 use_rest_size = (rest_named || (!rest_named && posts_size > 0));
2531 LABEL *match_failed_label = NEW_LABEL(location.
line);
2532 LABEL *type_error_label = NEW_LABEL(location.
line);
2533 LABEL *deconstruct_label = NEW_LABEL(location.
line);
2534 LABEL *deconstructed_label = NEW_LABEL(location.
line);
2536 if (use_rest_size) {
2537 PUSH_INSN1(ret, location, putobject,
INT2FIX(0));
2538 PUSH_INSN(ret, location, swap);
2543 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->
constant, ret, match_failed_label, in_single_pattern, base_index));
2546 CHECK(pm_compile_pattern_deconstruct(iseq, scope_node, node, ret, deconstruct_label, match_failed_label, deconstructed_label, type_error_label, in_single_pattern, use_deconstructed_cache, base_index));
2548 PUSH_INSN(ret, location, dup);
2549 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2550 PUSH_INSN1(ret, location, putobject,
INT2FIX(minimum_size));
2551 PUSH_SEND(ret, location, cast->
rest == NULL ? idEq : idGE,
INT2FIX(1));
2552 if (in_single_pattern) {
2553 VALUE message = cast->
rest == NULL ? rb_fstring_lit(
"%p length mismatch (given %p, expected %p)") : rb_fstring_lit(
"%p length mismatch (given %p, expected %p+)");
2554 CHECK(pm_compile_pattern_length_error(iseq, scope_node, node, ret, message,
INT2FIX(minimum_size), base_index + 1));
2556 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2558 for (
size_t index = 0; index < requireds_size; index++) {
2560 PUSH_INSN(ret, location, dup);
2561 PUSH_INSN1(ret, location, putobject,
INT2FIX(index));
2562 PUSH_SEND(ret, location, idAREF,
INT2FIX(1));
2563 CHECK(pm_compile_pattern_match(iseq, scope_node, required, ret, match_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 1));
2566 if (cast->
rest != NULL) {
2568 PUSH_INSN(ret, location, dup);
2569 PUSH_INSN1(ret, location, putobject,
INT2FIX(requireds_size));
2570 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
2571 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2572 PUSH_INSN1(ret, location, putobject,
INT2FIX(minimum_size));
2573 PUSH_SEND(ret, location, idMINUS,
INT2FIX(1));
2574 PUSH_INSN1(ret, location, setn,
INT2FIX(4));
2575 PUSH_SEND(ret, location, idAREF,
INT2FIX(2));
2576 CHECK(pm_compile_pattern_match(iseq, scope_node, ((
const pm_splat_node_t *) cast->
rest)->expression, ret, match_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 1));
2578 else if (posts_size > 0) {
2579 PUSH_INSN(ret, location, dup);
2580 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2581 PUSH_INSN1(ret, location, putobject,
INT2FIX(minimum_size));
2582 PUSH_SEND(ret, location, idMINUS,
INT2FIX(1));
2583 PUSH_INSN1(ret, location, setn,
INT2FIX(2));
2584 PUSH_INSN(ret, location, pop);
2588 for (
size_t index = 0; index < posts_size; index++) {
2590 PUSH_INSN(ret, location, dup);
2592 PUSH_INSN1(ret, location, putobject,
INT2FIX(requireds_size + index));
2593 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2594 PUSH_SEND(ret, location, idPLUS,
INT2FIX(1));
2595 PUSH_SEND(ret, location, idAREF,
INT2FIX(1));
2596 CHECK(pm_compile_pattern_match(iseq, scope_node, post, ret, match_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 1));
2599 PUSH_INSN(ret, location, pop);
2600 if (use_rest_size) {
2601 PUSH_INSN(ret, location, pop);
2604 PUSH_INSNL(ret, location, jump, matched_label);
2605 PUSH_INSN(ret, location, putnil);
2606 if (use_rest_size) {
2607 PUSH_INSN(ret, location, putnil);
2610 PUSH_LABEL(ret, type_error_label);
2611 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2615 VALUE operand = rb_fstring_lit(
"deconstruct must return Array");
2616 PUSH_INSN1(ret, location, putobject, operand);
2619 PUSH_SEND(ret, location, id_core_raise,
INT2FIX(2));
2620 PUSH_INSN(ret, location, pop);
2622 PUSH_LABEL(ret, match_failed_label);
2623 PUSH_INSN(ret, location, pop);
2624 if (use_rest_size) {
2625 PUSH_INSN(ret, location, pop);
2628 PUSH_INSNL(ret, location, jump, unmatched_label);
2643 LABEL *match_failed_label = NEW_LABEL(location.
line);
2644 LABEL *type_error_label = NEW_LABEL(location.
line);
2645 LABEL *deconstruct_label = NEW_LABEL(location.
line);
2646 LABEL *deconstructed_label = NEW_LABEL(location.
line);
2649 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->
constant, ret, match_failed_label, in_single_pattern, base_index));
2652 CHECK(pm_compile_pattern_deconstruct(iseq, scope_node, node, ret, deconstruct_label, match_failed_label, deconstructed_label, type_error_label, in_single_pattern, use_deconstructed_cache, base_index));
2654 PUSH_INSN(ret, location, dup);
2655 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2656 PUSH_INSN1(ret, location, putobject,
INT2FIX(size));
2657 PUSH_SEND(ret, location, idGE,
INT2FIX(1));
2658 if (in_single_pattern) {
2659 CHECK(pm_compile_pattern_length_error(iseq, scope_node, node, ret, rb_fstring_lit(
"%p length mismatch (given %p, expected %p+)"),
INT2FIX(size), base_index + 1));
2661 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2664 LABEL *while_begin_label = NEW_LABEL(location.
line);
2665 LABEL *next_loop_label = NEW_LABEL(location.
line);
2666 LABEL *find_succeeded_label = NEW_LABEL(location.
line);
2667 LABEL *find_failed_label = NEW_LABEL(location.
line);
2669 PUSH_INSN(ret, location, dup);
2670 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2672 PUSH_INSN(ret, location, dup);
2673 PUSH_INSN1(ret, location, putobject,
INT2FIX(size));
2674 PUSH_SEND(ret, location, idMINUS,
INT2FIX(1));
2675 PUSH_INSN1(ret, location, putobject,
INT2FIX(0));
2676 PUSH_LABEL(ret, while_begin_label);
2678 PUSH_INSN(ret, location, dup);
2679 PUSH_INSN1(ret, location, topn,
INT2FIX(2));
2680 PUSH_SEND(ret, location, idLE,
INT2FIX(1));
2681 PUSH_INSNL(ret, location, branchunless, find_failed_label);
2683 for (
size_t index = 0; index < size; index++) {
2684 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2685 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
2688 PUSH_INSN1(ret, location, putobject,
INT2FIX(index));
2689 PUSH_SEND(ret, location, idPLUS,
INT2FIX(1));
2692 PUSH_SEND(ret, location, idAREF,
INT2FIX(1));
2693 CHECK(pm_compile_pattern_match(iseq, scope_node, cast->
requireds.
nodes[index], ret, next_loop_label, in_single_pattern, in_alternation_pattern,
false, base_index + 4));
2699 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2700 PUSH_INSN1(ret, location, putobject,
INT2FIX(0));
2701 PUSH_INSN1(ret, location, topn,
INT2FIX(2));
2702 PUSH_SEND(ret, location, idAREF,
INT2FIX(2));
2703 CHECK(pm_compile_pattern_match(iseq, scope_node, left->
expression, ret, find_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 4));
2709 if (right->expression != NULL) {
2710 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2711 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
2712 PUSH_INSN1(ret, location, putobject,
INT2FIX(size));
2713 PUSH_SEND(ret, location, idPLUS,
INT2FIX(1));
2714 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2715 PUSH_SEND(ret, location, idAREF,
INT2FIX(2));
2716 pm_compile_pattern_match(iseq, scope_node, right->expression, ret, find_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 4);
2719 PUSH_INSNL(ret, location, jump, find_succeeded_label);
2721 PUSH_LABEL(ret, next_loop_label);
2722 PUSH_INSN1(ret, location, putobject,
INT2FIX(1));
2723 PUSH_SEND(ret, location, idPLUS,
INT2FIX(1));
2724 PUSH_INSNL(ret, location, jump, while_begin_label);
2726 PUSH_LABEL(ret, find_failed_label);
2727 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(3));
2728 if (in_single_pattern) {
2729 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2732 VALUE operand = rb_fstring_lit(
"%p does not match to find pattern");
2733 PUSH_INSN1(ret, location, putobject, operand);
2736 PUSH_INSN1(ret, location, topn,
INT2FIX(2));
2737 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(2));
2738 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2740 PUSH_INSN1(ret, location, putobject,
Qfalse);
2741 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2743 PUSH_INSN(ret, location, pop);
2744 PUSH_INSN(ret, location, pop);
2746 PUSH_INSNL(ret, location, jump, match_failed_label);
2747 PUSH_INSN1(ret, location, dupn,
INT2FIX(3));
2749 PUSH_LABEL(ret, find_succeeded_label);
2750 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(3));
2753 PUSH_INSN(ret, location, pop);
2754 PUSH_INSNL(ret, location, jump, matched_label);
2755 PUSH_INSN(ret, location, putnil);
2757 PUSH_LABEL(ret, type_error_label);
2758 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2762 VALUE operand = rb_fstring_lit(
"deconstruct must return Array");
2763 PUSH_INSN1(ret, location, putobject, operand);
2766 PUSH_SEND(ret, location, id_core_raise,
INT2FIX(2));
2767 PUSH_INSN(ret, location, pop);
2769 PUSH_LABEL(ret, match_failed_label);
2770 PUSH_INSN(ret, location, pop);
2771 PUSH_INSNL(ret, location, jump, unmatched_label);
2790 LABEL *match_failed_label = NEW_LABEL(location.
line);
2791 LABEL *type_error_label = NEW_LABEL(location.
line);
2794 if (has_keys && !has_rest) {
2797 for (
size_t index = 0; index < cast->
elements.
size; index++) {
2805 rb_ary_push(keys, symbol);
2810 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->
constant, ret, match_failed_label, in_single_pattern, base_index));
2813 PUSH_INSN(ret, location, dup);
2816 VALUE operand =
ID2SYM(rb_intern(
"deconstruct_keys"));
2817 PUSH_INSN1(ret, location, putobject, operand);
2820 PUSH_SEND(ret, location, idRespond_to,
INT2FIX(1));
2821 if (in_single_pattern) {
2822 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit(
"%p does not respond to #deconstruct_keys"), base_index + 1));
2824 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2827 PUSH_INSN(ret, location, putnil);
2830 PUSH_INSN1(ret, location, duparray, keys);
2833 PUSH_SEND(ret, location, rb_intern(
"deconstruct_keys"),
INT2FIX(1));
2835 PUSH_INSN(ret, location, dup);
2837 PUSH_INSNL(ret, location, branchunless, type_error_label);
2840 PUSH_SEND(ret, location, rb_intern(
"dup"),
INT2FIX(0));
2844 DECL_ANCHOR(match_values);
2846 for (
size_t index = 0; index < cast->
elements.
size; index++) {
2855 PUSH_INSN(ret, location, dup);
2856 PUSH_INSN1(ret, location, putobject, symbol);
2857 PUSH_SEND(ret, location, rb_intern(
"key?"),
INT2FIX(1));
2859 if (in_single_pattern) {
2860 LABEL *match_succeeded_label = NEW_LABEL(location.
line);
2862 PUSH_INSN(ret, location, dup);
2863 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2867 PUSH_INSN1(ret, location, putobject, operand);
2870 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 2));
2871 PUSH_INSN1(ret, location, putobject,
Qtrue);
2872 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 3));
2873 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2874 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE + 4));
2875 PUSH_INSN1(ret, location, putobject, symbol);
2876 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY + 5));
2878 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(4));
2879 PUSH_LABEL(ret, match_succeeded_label);
2882 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2883 PUSH_INSN(match_values, location, dup);
2884 PUSH_INSN1(match_values, location, putobject, symbol);
2885 PUSH_SEND(match_values, location, has_rest ? rb_intern(
"delete") : idAREF,
INT2FIX(1));
2892 CHECK(pm_compile_pattern_match(iseq, scope_node, value, match_values, match_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 1));
2895 PUSH_SEQ(ret, match_values);
2898 PUSH_INSN(ret, location, dup);
2899 PUSH_SEND(ret, location, idEmptyP,
INT2FIX(0));
2900 if (in_single_pattern) {
2901 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit(
"%p is not empty"), base_index + 1));
2903 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2909 PUSH_INSN(ret, location, dup);
2910 PUSH_SEND(ret, location, idEmptyP,
INT2FIX(0));
2911 if (in_single_pattern) {
2912 pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit(
"rest of %p is not empty"), base_index + 1);
2914 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2919 PUSH_INSN(ret, location, dup);
2920 pm_compile_pattern_match(iseq, scope_node, splat->value, ret, match_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 1);
2924 rb_bug(
"unreachable");
2929 PUSH_INSN(ret, location, pop);
2930 PUSH_INSNL(ret, location, jump, matched_label);
2931 PUSH_INSN(ret, location, putnil);
2933 PUSH_LABEL(ret, type_error_label);
2934 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2938 VALUE operand = rb_fstring_lit(
"deconstruct_keys must return Hash");
2939 PUSH_INSN1(ret, location, putobject, operand);
2942 PUSH_SEND(ret, location, id_core_raise,
INT2FIX(2));
2943 PUSH_INSN(ret, location, pop);
2945 PUSH_LABEL(ret, match_failed_label);
2946 PUSH_INSN(ret, location, pop);
2947 PUSH_INSNL(ret, location, jump, unmatched_label);
2962 LABEL *match_failed_label = NEW_LABEL(location.
line);
2964 PUSH_INSN(ret, location, dup);
2965 CHECK(pm_compile_pattern_match(iseq, scope_node, cast->
value, ret, match_failed_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index + 1));
2966 CHECK(pm_compile_pattern(iseq, scope_node, (
const pm_node_t *) cast->
target, ret, matched_label, match_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index));
2967 PUSH_INSN(ret, location, putnil);
2969 PUSH_LABEL(ret, match_failed_label);
2970 PUSH_INSN(ret, location, pop);
2971 PUSH_INSNL(ret, location, jump, unmatched_label);
2986 if (in_alternation_pattern) {
2987 ID id = pm_constant_id_lookup(scope_node, cast->
name);
2988 const char *name = rb_id2name(
id);
2990 if (name && strlen(name) > 0 && name[0] !=
'_') {
2991 COMPILE_ERROR(iseq, location.
line,
"illegal variable in alternative pattern (%"PRIsVALUE
")", rb_id2str(
id));
2996 PUSH_SETLOCAL(ret, location, index.index, index.level);
2997 PUSH_INSNL(ret, location, jump, matched_label);
3005 LABEL *matched_left_label = NEW_LABEL(location.
line);
3006 LABEL *unmatched_left_label = NEW_LABEL(location.
line);
3010 PUSH_INSN(ret, location, dup);
3011 CHECK(pm_compile_pattern(iseq, scope_node, cast->
left, ret, matched_left_label, unmatched_left_label, in_single_pattern,
true, use_deconstructed_cache, base_index + 1));
3016 PUSH_LABEL(ret, matched_left_label);
3017 PUSH_INSN(ret, location, pop);
3018 PUSH_INSNL(ret, location, jump, matched_label);
3019 PUSH_INSN(ret, location, putnil);
3023 PUSH_LABEL(ret, unmatched_left_label);
3024 CHECK(pm_compile_pattern(iseq, scope_node, cast->
right, ret, matched_label, unmatched_label, in_single_pattern,
true, use_deconstructed_cache, base_index));
3032 return pm_compile_pattern(iseq, scope_node, ((
const pm_parentheses_node_t *) node)->body, ret, matched_label, unmatched_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index);
3072 PM_COMPILE_NOT_POPPED(node);
3073 if (in_single_pattern) {
3074 PUSH_INSN1(ret, location, dupn,
INT2FIX(2));
3077 PUSH_INSN1(ret, location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_CASE));
3079 if (in_single_pattern) {
3080 pm_compile_pattern_eqq_error(iseq, scope_node, node, ret, base_index + 2);
3083 PUSH_INSNL(ret, location, branchif, matched_label);
3084 PUSH_INSNL(ret, location, jump, unmatched_label);
3093 CHECK(pm_compile_pattern(iseq, scope_node, cast->
variable, ret, matched_label, unmatched_label, in_single_pattern, in_alternation_pattern,
true, base_index));
3127 CHECK(pm_compile_pattern_match(iseq, scope_node, statement, ret, unmatched_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index));
3128 PM_COMPILE_NOT_POPPED(predicate);
3130 if (in_single_pattern) {
3131 LABEL *match_succeeded_label = NEW_LABEL(location.
line);
3133 PUSH_INSN(ret, location, dup);
3135 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
3138 PUSH_INSNL(ret, location, branchunless, match_succeeded_label);
3142 VALUE operand = rb_fstring_lit(
"guard clause does not return true");
3143 PUSH_INSN1(ret, location, putobject, operand);
3146 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
3147 PUSH_INSN1(ret, location, putobject,
Qfalse);
3148 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
3150 PUSH_INSN(ret, location, pop);
3151 PUSH_INSN(ret, location, pop);
3153 PUSH_LABEL(ret, match_succeeded_label);
3157 PUSH_INSNL(ret, location, branchunless, unmatched_label);
3160 PUSH_INSNL(ret, location, branchif, unmatched_label);
3163 PUSH_INSNL(ret, location, jump, matched_label);
3170 rb_bug(
"Unexpected node type in pattern matching expression: %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
3177#undef PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE
3178#undef PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING
3179#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P
3180#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE
3181#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY
3195 scope->previous = previous;
3199 scope->parser = previous->parser;
3200 scope->encoding = previous->encoding;
3202 scope->constants = previous->constants;
3203 scope->coverage_enabled = previous->coverage_enabled;
3210 scope->body = cast->
body;
3211 scope->locals = cast->
locals;
3217 scope->body = cast->
body;
3218 scope->locals = cast->
locals;
3224 scope->body = cast->body;
3225 scope->locals = cast->locals;
3252 scope->body = cast->
body;
3253 scope->locals = cast->
locals;
3265 scope->body = cast->
body;
3266 scope->locals = cast->
locals;
3277 scope->locals = cast->locals;
3292 scope->body = cast->
body;
3293 scope->locals = cast->
locals;
3302 rb_bug(
"unreachable");
3310 if (scope_node->index_lookup_table) {
3311 st_free_table(scope_node->index_lookup_table);
3331 iobj = IS_INSN(last_elem) ? (
INSN*) last_elem : (
INSN*) get_prev_insn((
INSN*) last_elem);
3332 while (!IS_INSN_ID(iobj, send) && !IS_INSN_ID(iobj, invokesuper) && !IS_INSN_ID(iobj, sendforward) && !IS_INSN_ID(iobj, invokesuperforward)) {
3333 iobj = (
INSN*) get_prev_insn(iobj);
3335 ELEM_INSERT_NEXT(&iobj->link, (
LINK_ELEMENT*) retry_end_l);
3340 if (&iobj->link == LAST_ELEMENT(ret)) {
3348 const char *name = rb_id2name(method_id);
3349 static const char prefix[] =
"__builtin_";
3350 const size_t prefix_len =
sizeof(prefix) - 1;
3352 if (receiver == NULL) {
3353 if (UNLIKELY(strncmp(prefix, name, prefix_len) == 0)) {
3355 return &name[prefix_len];
3382 if (arguments == NULL) {
3383 COMPILE_ERROR(iseq, node_location->
line,
"attr!: no argument");
3390 COMPILE_ERROR(iseq, node_location->
line,
"non symbol argument to attr!: %s", pm_node_type_to_str(
PM_NODE_TYPE(argument)));
3394 VALUE symbol = pm_static_literal_value(iseq, argument, scope_node);
3397 if (strcmp(RSTRING_PTR(
string),
"leaf") == 0) {
3398 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_LEAF;
3400 else if (strcmp(RSTRING_PTR(
string),
"inline_block") == 0) {
3401 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_INLINE_BLOCK;
3403 else if (strcmp(RSTRING_PTR(
string),
"use_block") == 0) {
3404 iseq_set_use_block(iseq);
3406 else if (strcmp(RSTRING_PTR(
string),
"c_trace") == 0) {
3408 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_C_TRACE;
3411 COMPILE_ERROR(iseq, node_location->
line,
"unknown argument to attr!: %s", RSTRING_PTR(
string));
3422 if (arguments == NULL) {
3423 COMPILE_ERROR(iseq, node_location->
line,
"arg!: no argument");
3428 COMPILE_ERROR(iseq, node_location->
line,
"arg!: too many argument");
3434 COMPILE_ERROR(iseq, node_location->
line,
"non symbol argument to arg!: %s", pm_node_type_to_str(
PM_NODE_TYPE(argument)));
3440 int index = ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->local_table_size - get_local_var_idx(iseq, name);
3442 debugs(
"id: %s idx: %d\n", rb_id2name(name), index);
3443 PUSH_GETLOCAL(ret, *node_location, index, get_lvar_level(iseq));
3452 const pm_node_t *ast_node = scope_node->ast_node;
3454 rb_bug(
"mandatory_only?: not in method definition");
3460 if (parameters_node == NULL) {
3461 rb_bug(
"mandatory_only?: in method definition with no parameters");
3467 rb_bug(
"mandatory_only?: not in method definition with plain statements");
3473 rb_bug(
"mandatory_only?: can't find mandatory node");
3484 .name = def_node->
name,
3486 .parameters = ¶meters,
3496 pm_scope_node_init(&def.base, &next_scope_node, scope_node);
3499 ISEQ_BODY(iseq)->mandatory_only_iseq = pm_iseq_new_with_opt(
3501 rb_iseq_base_label(iseq),
3503 rb_iseq_realpath(iseq),
3504 node_location->
line,
3508 ISEQ_COMPILE_DATA(iseq)->option,
3513 RUBY_ASSERT(ISEQ_BODY(iseq)->mandatory_only_iseq == NULL);
3514 rb_jump_tag(error_state);
3517 pm_scope_node_destroy(&next_scope_node);
3526 if (parent_block != NULL) {
3527 COMPILE_ERROR(iseq, node_location->
line,
"should not call builtins here.");
3531#define BUILTIN_INLINE_PREFIX "_bi"
3532 char inline_func[
sizeof(BUILTIN_INLINE_PREFIX) +
DECIMAL_SIZE_OF(
int)];
3533 bool cconst =
false;
3538 if (strcmp(
"cstmt!", builtin_func) == 0 || strcmp(
"cexpr!", builtin_func) == 0) {
3541 else if (strcmp(
"cconst!", builtin_func) == 0) {
3544 else if (strcmp(
"cinit!", builtin_func) == 0) {
3548 else if (strcmp(
"attr!", builtin_func) == 0) {
3549 return pm_compile_builtin_attr(iseq, scope_node, arguments, node_location);
3551 else if (strcmp(
"arg!", builtin_func) == 0) {
3552 return pm_compile_builtin_arg(iseq, ret, scope_node, arguments, node_location, popped);
3554 else if (strcmp(
"mandatory_only?", builtin_func) == 0) {
3556 rb_bug(
"mandatory_only? should be in if condition");
3558 else if (!LIST_INSN_SIZE_ZERO(ret)) {
3559 rb_bug(
"mandatory_only? should be put on top");
3562 PUSH_INSN1(ret, *node_location, putobject,
Qfalse);
3563 return pm_compile_builtin_mandatory_only_method(iseq, scope_node, call_node, node_location);
3566 rb_bug(
"can't find builtin function:%s", builtin_func);
3569 COMPILE_ERROR(iseq, node_location->
line,
"can't find builtin function:%s", builtin_func);
3573 int inline_index = node_location->
line;
3574 snprintf(inline_func,
sizeof(inline_func), BUILTIN_INLINE_PREFIX
"%d", inline_index);
3575 builtin_func = inline_func;
3581 typedef VALUE(*builtin_func0)(
void *,
VALUE);
3582 VALUE const_val = (*(builtin_func0)(uintptr_t)bf->func_ptr)(NULL,
Qnil);
3583 PUSH_INSN1(ret, *node_location, putobject, const_val);
3589 DECL_ANCHOR(args_seq);
3593 int argc = pm_setup_args(arguments, call_node->
block, &flags, &keywords, iseq, args_seq, scope_node, node_location);
3595 if (argc != bf->argc) {
3596 COMPILE_ERROR(iseq, node_location->
line,
"argc is not match for builtin function:%s (expect %d but %d)", builtin_func, bf->argc, argc);
3600 unsigned int start_index;
3601 if (delegate_call_p(iseq, argc, args_seq, &start_index)) {
3602 PUSH_INSN2(ret, *node_location, opt_invokebuiltin_delegate, bf,
INT2FIX(start_index));
3605 PUSH_SEQ(ret, args_seq);
3606 PUSH_INSN1(ret, *node_location, invokebuiltin, bf);
3609 if (popped) PUSH_INSN(ret, *node_location, pop);
3626 LABEL *else_label = NEW_LABEL(location.
line);
3627 LABEL *end_label = NEW_LABEL(location.
line);
3628 LABEL *retry_end_l = NEW_LABEL(location.
line);
3632 int node_id = location.
node_id;
3635 if (PM_BRANCH_COVERAGE_P(iseq)) {
3636 const uint8_t *cursors[3] = {
3642 const uint8_t *end_cursor = cursors[0];
3643 end_cursor = (end_cursor == NULL || cursors[1] == NULL) ? cursors[1] : (end_cursor > cursors[1] ? end_cursor : cursors[1]);
3644 end_cursor = (end_cursor == NULL || cursors[2] == NULL) ? cursors[2] : (end_cursor > cursors[2] ? end_cursor : cursors[2]);
3647 const pm_line_column_t start_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, call_node);
3651 .beg_pos = { .lineno = start_location.
line, .column = start_location.
column },
3652 .end_pos = { .lineno = end_location.
line, .column = end_location.
column }
3655 branches = decl_branch_base(iseq, PTR2NUM(call_node), &code_location,
"&.");
3658 PUSH_INSN(ret, location, dup);
3659 PUSH_INSNL(ret, location, branchnil, else_label);
3661 add_trace_branch_coverage(iseq, ret, &code_location, node_id, 0,
"then", branches);
3667 int orig_argc = pm_setup_args(call_node->
arguments, call_node->
block, &flags, &kw_arg, iseq, ret, scope_node, &location);
3668 const rb_iseq_t *previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
3674 pm_scope_node_init(call_node->
block, &next_scope_node, scope_node);
3676 block_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, pm_node_line_number(scope_node->parser, call_node->
block));
3677 pm_scope_node_destroy(&next_scope_node);
3678 ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq;
3682 flags |= VM_CALL_VCALL;
3686 flags |= VM_CALL_ARGS_SIMPLE;
3691 flags |= VM_CALL_FCALL;
3695 if (flags & VM_CALL_ARGS_BLOCKARG) {
3696 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
3697 if (flags & VM_CALL_ARGS_SPLAT) {
3698 PUSH_INSN1(ret, location, putobject,
INT2FIX(-1));
3699 PUSH_SEND_WITH_FLAG(ret, location, idAREF,
INT2FIX(1),
INT2FIX(0));
3701 PUSH_INSN1(ret, location, setn,
INT2FIX(orig_argc + 3));
3702 PUSH_INSN(ret, location, pop);
3704 else if (flags & VM_CALL_ARGS_SPLAT) {
3705 PUSH_INSN(ret, location, dup);
3706 PUSH_INSN1(ret, location, putobject,
INT2FIX(-1));
3707 PUSH_SEND_WITH_FLAG(ret, location, idAREF,
INT2FIX(1),
INT2FIX(0));
3708 PUSH_INSN1(ret, location, setn,
INT2FIX(orig_argc + 2));
3709 PUSH_INSN(ret, location, pop);
3712 PUSH_INSN1(ret, location, setn,
INT2FIX(orig_argc + 1));
3716 if ((flags & VM_CALL_KW_SPLAT) && (flags & VM_CALL_ARGS_BLOCKARG) && !(flags & VM_CALL_KW_SPLAT_MUT)) {
3717 PUSH_INSN(ret, location, splatkw);
3720 LABEL *not_basic_new = NEW_LABEL(location.
line);
3721 LABEL *not_basic_new_finish = NEW_LABEL(location.
line);
3723 bool inline_new = ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction &&
3724 method_id == rb_intern(
"new") &&
3725 call_node->
block == NULL;
3728 if (LAST_ELEMENT(ret) == opt_new_prelude) {
3729 PUSH_INSN(ret, location, putnil);
3730 PUSH_INSN(ret, location, swap);
3733 ELEM_INSERT_NEXT(opt_new_prelude, &new_insn_body(iseq, location.
line, location.
node_id, BIN(swap), 0)->link);
3734 ELEM_INSERT_NEXT(opt_new_prelude, &new_insn_body(iseq, location.
line, location.
node_id, BIN(putnil), 0)->link);
3739 if (flags & VM_CALL_FORWARDING) {
3740 ci = (
VALUE)new_callinfo(iseq, method_id, orig_argc + 1, flags, kw_arg, 0);
3743 ci = (
VALUE)new_callinfo(iseq, method_id, orig_argc, flags, kw_arg, 0);
3746 PUSH_INSN2(ret, location, opt_new, ci, not_basic_new);
3747 LABEL_REF(not_basic_new);
3749 PUSH_SEND_R(ret, location, rb_intern(
"initialize"),
INT2FIX(orig_argc), block_iseq,
INT2FIX(flags | VM_CALL_FCALL), kw_arg);
3750 PUSH_INSNL(ret, location, jump, not_basic_new_finish);
3752 PUSH_LABEL(ret, not_basic_new);
3754 PUSH_SEND_R(ret, location, method_id,
INT2FIX(orig_argc), block_iseq,
INT2FIX(flags), kw_arg);
3755 PUSH_INSN(ret, location, swap);
3757 PUSH_LABEL(ret, not_basic_new_finish);
3758 PUSH_INSN(ret, location, pop);
3761 PUSH_SEND_R(ret, location, method_id,
INT2FIX(orig_argc), block_iseq,
INT2FIX(flags), kw_arg);
3764 if (block_iseq && ISEQ_BODY(block_iseq)->catch_table) {
3765 pm_compile_retry_end_label(iseq, ret, retry_end_l);
3766 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, start, retry_end_l, block_iseq, retry_end_l);
3770 PUSH_INSNL(ret, location, jump, end_label);
3771 PUSH_LABEL(ret, else_label);
3772 add_trace_branch_coverage(iseq, ret, &code_location, node_id, 1,
"else", branches);
3773 PUSH_LABEL(ret, end_label);
3777 PUSH_INSN(ret, location, pop);
3780 if (popped) PUSH_INSN(ret, location, pop);
3781 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
3811#define PUSH_VAL(type) (in_condition ? Qtrue : rb_iseq_defined_string(type))
3814 enum defined_type dtype = DEFINED_NOT_DEFINED;
3822 dtype = DEFINED_NIL;
3829 ID name = pm_constant_id_lookup(scope_node, cast->
name);
3831 PUSH_INSN3(ret, location, definedivar,
ID2SYM(name), get_ivar_ic_value(iseq, name), PUSH_VAL(DEFINED_IVAR));
3842 dtype = DEFINED_LVAR;
3849 ID name = pm_constant_id_lookup(scope_node, cast->
name);
3851 PUSH_INSN(ret, location, putnil);
3852 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_GVAR),
ID2SYM(name), PUSH_VAL(DEFINED_GVAR));
3861 ID name = pm_constant_id_lookup(scope_node, cast->
name);
3863 PUSH_INSN(ret, location, putnil);
3864 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CVAR),
ID2SYM(name), PUSH_VAL(DEFINED_CVAR));
3873 ID name = pm_constant_id_lookup(scope_node, cast->
name);
3875 PUSH_INSN(ret, location, putnil);
3876 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CONST),
ID2SYM(name), PUSH_VAL(DEFINED_CONST));
3884 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
3886 PUSH_INSN(ret, location, putnil);
3887 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_YIELD), 0, PUSH_VAL(DEFINED_YIELD));
3897 dtype = DEFINED_EXPR;
3901 PUSH_INSN(ret, location, putnil);
3902 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_ZSUPER), 0, PUSH_VAL(DEFINED_ZSUPER));
3910 if (cast->
block != NULL) {
3911 dtype = DEFINED_EXPR;
3915 PUSH_INSN(ret, location, putnil);
3916 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_ZSUPER), 0, PUSH_VAL(DEFINED_ZSUPER));
3923 dtype = DEFINED_SELF;
3929 dtype = DEFINED_TRUE;
3935 dtype = DEFINED_FALSE;
4031 dtype = DEFINED_ASGN;
4175 dtype = DEFINED_EXPR;
4182 VALUE ref = pm_compile_back_reference_ref(cast);
4184 PUSH_INSN(ret, location, putnil);
4185 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_REF), ref, PUSH_VAL(DEFINED_GVAR));
4193 VALUE ref = pm_compile_numbered_reference_ref(cast);
4195 PUSH_INSN(ret, location, putnil);
4196 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_REF), ref, PUSH_VAL(DEFINED_GVAR));
4205 ID name = pm_constant_id_lookup(scope_node, cast->
name);
4207 if (cast->
parent != NULL) {
4208 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.
line);
4209 pm_compile_defined_expr0(iseq, cast->
parent, node_location, ret, popped, scope_node,
true, lfinish,
false);
4211 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4212 PM_COMPILE(cast->
parent);
4215 PUSH_INSN1(ret, location, putobject, rb_cObject);
4218 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CONST_FROM),
ID2SYM(name), PUSH_VAL(DEFINED_CONST));
4230 dtype = DEFINED_NIL;
4236 pm_compile_defined_expr0(iseq, cast->
statements->
body.
nodes[0], node_location, ret, popped, scope_node, in_condition, lfinish,
false);
4242 dtype = DEFINED_EXPR;
4247 dtype = DEFINED_EXPR;
4257 if (cast->
body == NULL) {
4259 dtype = DEFINED_NIL;
4264 pm_compile_defined_expr0(iseq, ((
const pm_statements_node_t *) cast->
body)->body.nodes[0], node_location, ret, popped, scope_node, in_condition, lfinish,
false);
4270 dtype = DEFINED_EXPR;
4281 lfinish[1] = NEW_LABEL(location.
line);
4284 for (
size_t index = 0; index < cast->
elements.
size; index++) {
4285 pm_compile_defined_expr0(iseq, cast->
elements.
nodes[index], node_location, ret, popped, scope_node,
true, lfinish,
false);
4286 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4289 dtype = DEFINED_EXPR;
4307 if (elements->
size > 0 && !lfinish[1]) {
4308 lfinish[1] = NEW_LABEL(location.
line);
4311 for (
size_t index = 0; index < elements->
size; index++) {
4312 pm_compile_defined_expr0(iseq, elements->
nodes[index], node_location, ret, popped, scope_node,
true, lfinish,
false);
4313 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4316 dtype = DEFINED_EXPR;
4324 pm_compile_defined_expr0(iseq, cast->
key, node_location, ret, popped, scope_node,
true, lfinish,
false);
4325 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4326 pm_compile_defined_expr0(iseq, cast->
value, node_location, ret, popped, scope_node,
true, lfinish,
false);
4335 if (cast->
value == NULL) {
4336 dtype = DEFINED_EXPR;
4340 pm_compile_defined_expr0(iseq, cast->
value, node_location, ret, popped, scope_node,
true, lfinish,
false);
4347 pm_compile_defined_expr0(iseq, cast->
value, node_location, ret, popped, scope_node, in_condition, lfinish,
false);
4351#define BLOCK_P(cast) ((cast)->block != NULL && PM_NODE_TYPE_P((cast)->block, PM_BLOCK_NODE))
4357 if (BLOCK_P(cast)) {
4358 dtype = DEFINED_EXPR;
4363 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.
line);
4364 if (!lfinish[2]) lfinish[2] = NEW_LABEL(location.
line);
4368 pm_compile_defined_expr0(iseq, (
const pm_node_t *) cast->
arguments, node_location, ret, popped, scope_node,
true, lfinish,
false);
4369 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4373 pm_compile_defined_expr0(iseq, cast->
block, node_location, ret, popped, scope_node,
true, lfinish,
false);
4374 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4381 pm_compile_defined_expr0(iseq, cast->
receiver, node_location, ret, popped, scope_node,
true, lfinish,
true);
4382 PUSH_INSNL(ret, location, branchunless, lfinish[2]);
4385 ID method_id = pm_constant_id_lookup(scope_node, receiver->name);
4387 pm_compile_call(iseq, receiver, ret, popped, scope_node, method_id, NULL);
4390 pm_compile_defined_expr0(iseq, cast->
receiver, node_location, ret, popped, scope_node,
true, lfinish,
false);
4391 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4395 ID method_id = pm_constant_id_lookup(scope_node, cast->
name);
4397 if (explicit_receiver) PUSH_INSN(ret, location, dup);
4398 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_METHOD),
rb_id2sym(method_id), PUSH_VAL(DEFINED_METHOD));
4401 ID method_id = pm_constant_id_lookup(scope_node, cast->
name);
4403 PUSH_INSN(ret, location, putself);
4404 if (explicit_receiver) PUSH_INSN(ret, location, dup);
4406 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_FUNC),
rb_id2sym(method_id), PUSH_VAL(DEFINED_METHOD));
4418 for (
size_t index = 0; index < cast->
arguments.
size; index++) {
4419 pm_compile_defined_expr0(iseq, cast->
arguments.
nodes[index], node_location, ret, popped, scope_node, in_condition, lfinish,
false);
4420 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4423 dtype = DEFINED_EXPR;
4429 dtype = DEFINED_EXPR;
4434 dtype = DEFINED_EXPR;
4442 dtype = DEFINED_EXPR;
4446 pm_compile_defined_expr0(iseq, cast->
expression, node_location, ret, popped, scope_node, in_condition, lfinish,
false);
4448 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.
line);
4449 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4451 dtype = DEFINED_EXPR;
4458 pm_compile_defined_expr0(iseq, ((
const pm_shareable_constant_node_t *) node)->write, node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
4509 rb_bug(
"Unreachable node in defined?: %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
4513 PUSH_INSN1(ret, location, putobject, PUSH_VAL(dtype));
4522 pm_compile_defined_expr0(iseq, node, node_location, ret, popped, scope_node, in_condition, lfinish,
false);
4525 LABEL *lstart = NEW_LABEL(node_location->
line);
4526 LABEL *lend = NEW_LABEL(node_location->
line);
4529 rb_iseq_new_with_callback_new_callback(build_defined_rescue_iseq, NULL);
4531 const rb_iseq_t *rescue = new_child_iseq_with_callback(
4540 lstart->rescued = LABEL_RESCUE_BEG;
4541 lend->rescued = LABEL_RESCUE_END;
4543 APPEND_LABEL(ret, lcur, lstart);
4544 PUSH_LABEL(ret, lend);
4545 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue, lfinish[1]);
4555 lfinish[0] = NEW_LABEL(node_location->
line);
4560 pm_defined_expr(iseq, node, node_location, ret, popped, scope_node, in_condition, lfinish);
4564 ELEM_INSERT_NEXT(last, &new_insn_body(iseq, node_location->
line, node_location->
node_id, BIN(putnil), 0)->link);
4565 PUSH_INSN(ret, *node_location, swap);
4567 if (lfinish[2]) PUSH_LABEL(ret, lfinish[2]);
4568 PUSH_INSN(ret, *node_location, pop);
4569 PUSH_LABEL(ret, lfinish[1]);
4573 PUSH_LABEL(ret, lfinish[0]);
4584 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack;
4586 DECL_ANCHOR(ensure);
4589 if (enlp->erange != NULL) {
4590 DECL_ANCHOR(ensure_part);
4591 LABEL *lstart = NEW_LABEL(0);
4592 LABEL *lend = NEW_LABEL(0);
4594 add_ensure_range(iseq, enlp->erange, lstart, lend);
4596 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enlp->prev;
4597 PUSH_LABEL(ensure_part, lstart);
4599 PM_COMPILE_INTO_ANCHOR(ensure_part, (
const pm_node_t *) enlp->ensure_node);
4600 PUSH_LABEL(ensure_part, lend);
4601 PUSH_SEQ(ensure, ensure_part);
4610 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = prev_enlp;
4611 PUSH_SEQ(ret, ensure);
4621pm_local_table_insert_func(st_data_t *key, st_data_t *value, st_data_t arg,
int existing)
4629 int local_index = ctx->local_index;
4631 ID local = pm_constant_id_lookup(scope_node, constant_id);
4632 local_table_for_iseq->ids[local_index] = local;
4634 *value = (st_data_t)local_index;
4650 RUBY_ASSERT((constant_id & PM_SPECIAL_CONSTANT_FLAG) == 0);
4652 ID local = pm_constant_id_lookup(scope_node, constant_id);
4653 local_table_for_iseq->ids[local_index] = local;
4654 st_insert(index_lookup_table, (st_data_t) constant_id, (st_data_t) local_index);
4664 local_table_for_iseq->ids[local_index] = local_name;
4665 st_insert(index_lookup_table, (st_data_t) (local_name | PM_SPECIAL_CONSTANT_FLAG), (st_data_t) local_index);
4677 for (
size_t index = 0; index < node->
lefts.
size; index++) {
4682 pm_insert_local_index(((
const pm_required_parameter_node_t *) left)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4688 local_index = pm_compile_destructured_param_locals((
const pm_multi_target_node_t *) left, index_lookup_table, local_table_for_iseq, scope_node, local_index);
4695 if (rest->expression != NULL) {
4699 pm_insert_local_index(((
const pm_required_parameter_node_t *) rest->expression)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4705 for (
size_t index = 0; index < node->
rights.
size; index++) {
4710 pm_insert_local_index(((
const pm_required_parameter_node_t *) right)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4716 local_index = pm_compile_destructured_param_locals((
const pm_multi_target_node_t *) right, index_lookup_table, local_table_for_iseq, scope_node, local_index);
4730 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4732 PUSH_SETLOCAL(ret, location, index.index, index.level);
4746 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4750 int flag = (has_rest || has_rights) ? 1 : 0;
4753 for (
size_t index = 0; index < node->
lefts.
size; index++) {
4781 for (
size_t index = 0; index < node->
rights.
size; index++) {
4848 node->stack_index = state->stack_size + 1;
4849 node->stack_size = stack_size;
4850 node->position = state->position;
4853 if (state->head == NULL) {
4858 state->tail->next = node;
4862 state->stack_size += stack_size;
4875 if (state->stack_size == 0)
return;
4880 while (current != NULL) {
4881 VALUE offset =
INT2FIX(state->stack_size - current->stack_index + current->position);
4882 current->topn->operands[0] = offset;
4888 if (current->stack_size > 1) {
4889 INSN *insn = current->topn;
4891 for (
size_t index = 1; index < current->stack_size; index += 1) {
4895 insn = (
INSN *) element;
4898 insn->operands[0] = offset;
4903 current = current->next;
4943 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4955 PUSH_SETLOCAL(writes, location, index.index, index.level);
4965 ID name = pm_constant_id_lookup(scope_node, cast->
name);
4968 PUSH_INSN2(writes, location, setclassvariable, operand, get_cvar_ic_value(iseq, name));
4978 ID name = pm_constant_id_lookup(scope_node, cast->
name);
4981 PUSH_INSN1(writes, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
4982 PUSH_INSN1(writes, location, setconstant, operand);
4992 ID name = pm_constant_id_lookup(scope_node, cast->
name);
4995 PUSH_INSN1(writes, location, setglobal, operand);
5005 ID name = pm_constant_id_lookup(scope_node, cast->
name);
5008 PUSH_INSN2(writes, location, setinstancevariable, operand, get_ivar_ic_value(iseq, name));
5021 ID name = pm_constant_id_lookup(scope_node, cast->
name);
5023 if (cast->
parent != NULL) {
5024 pm_compile_node(iseq, cast->
parent, parents,
false, scope_node);
5027 PUSH_INSN1(parents, location, putobject, rb_cObject);
5030 if (state == NULL) {
5031 PUSH_INSN(writes, location, swap);
5034 PUSH_INSN1(writes, location, topn,
INT2FIX(1));
5035 pm_multi_target_state_push(state, (
INSN *) LAST_ELEMENT(writes), 1);
5039 PUSH_INSN1(writes, location, setconstant, operand);
5041 if (state != NULL) {
5042 PUSH_INSN(cleanup, location, pop);
5057 ID method_id = pm_constant_id_lookup(scope_node, cast->
name);
5059 pm_compile_node(iseq, cast->
receiver, parents,
false, scope_node);
5061 LABEL *safe_label = NULL;
5063 safe_label = NEW_LABEL(location.
line);
5064 PUSH_INSN(parents, location, dup);
5065 PUSH_INSNL(parents, location, branchnil, safe_label);
5068 if (state != NULL) {
5069 PUSH_INSN1(writes, location, topn,
INT2FIX(1));
5070 pm_multi_target_state_push(state, (
INSN *) LAST_ELEMENT(writes), 1);
5071 PUSH_INSN(writes, location, swap);
5074 int flags = VM_CALL_ARGS_SIMPLE;
5077 PUSH_SEND_WITH_FLAG(writes, location, method_id,
INT2FIX(1),
INT2FIX(flags));
5078 if (safe_label != NULL && state == NULL) PUSH_LABEL(writes, safe_label);
5079 PUSH_INSN(writes, location, pop);
5080 if (safe_label != NULL && state != NULL) PUSH_LABEL(writes, safe_label);
5082 if (state != NULL) {
5083 PUSH_INSN(cleanup, location, pop);
5100 pm_compile_node(iseq, cast->
receiver, parents,
false, scope_node);
5104 int argc = pm_setup_args(cast->
arguments, (
const pm_node_t *) cast->
block, &flags, &kwargs, iseq, parents, scope_node, &location);
5106 if (state != NULL) {
5107 PUSH_INSN1(writes, location, topn,
INT2FIX(argc + 1));
5108 pm_multi_target_state_push(state, (
INSN *) LAST_ELEMENT(writes), argc + 1);
5111 PUSH_INSN(writes, location, swap);
5114 for (
int index = 0; index < argc; index++) {
5115 PUSH_INSN1(writes, location, topn,
INT2FIX(argc + 1));
5117 PUSH_INSN1(writes, location, topn,
INT2FIX(argc + 1));
5125 int ci_argc = argc + 1;
5126 if (flags & VM_CALL_ARGS_SPLAT) {
5128 PUSH_INSN1(writes, location, newarray,
INT2FIX(1));
5129 PUSH_INSN(writes, location, concatarray);
5132 PUSH_SEND_R(writes, location, idASET,
INT2NUM(ci_argc), NULL,
INT2FIX(flags), kwargs);
5133 PUSH_INSN(writes, location, pop);
5135 if (state != NULL) {
5137 PUSH_INSN(writes, location, pop);
5140 for (
int index = 0; index < argc + 1; index++) {
5141 PUSH_INSN(cleanup, location, pop);
5154 size_t before_position;
5155 if (state != NULL) {
5156 before_position = state->position;
5160 pm_compile_multi_target_node(iseq, node, parents, writes, cleanup, scope_node, state);
5161 if (state != NULL) state->position = before_position;
5166 rb_bug(
"Unexpected node type: %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
5179 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5187 lefts = &cast->
lefts;
5194 lefts = &cast->
lefts;
5200 rb_bug(
"Unsupported node %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
5205 bool has_posts = rights->
size > 0;
5210 PUSH_INSN2(writes, location, expandarray,
INT2FIX(lefts->
size),
INT2FIX((has_rest || has_posts) ? 1 : 0));
5216 if (state == NULL) state = &target_state;
5218 size_t base_position = state->position;
5219 size_t splat_position = (has_rest || has_posts) ? 1 : 0;
5222 for (
size_t index = 0; index < lefts->
size; index++) {
5224 state->position = lefts->
size - index + splat_position + base_position;
5225 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5231 state->position = 1 + rights->
size + base_position;
5237 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5242 if (!has_rest && rest != NULL) {
5246 for (
size_t index = 0; index < rights->
size; index++) {
5248 state->position = rights->
size - index + base_position;
5249 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
5262 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5268 PUSH_GETLOCAL(ret, location, 1, 0);
5269 pm_compile_target_node(iseq, node, ret, ret, ret, scope_node, NULL);
5282 DECL_ANCHOR(writes);
5283 DECL_ANCHOR(cleanup);
5287 pm_compile_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
5289 PUSH_GETLOCAL(ret, location, 1, 0);
5292 PUSH_SEQ(ret, writes);
5293 PUSH_SEQ(ret, cleanup);
5295 pm_multi_target_state_update(&state);
5299 DECL_ANCHOR(writes);
5300 DECL_ANCHOR(cleanup);
5302 pm_compile_target_node(iseq, node, ret, writes, cleanup, scope_node, NULL);
5304 LABEL *not_single = NEW_LABEL(location.
line);
5305 LABEL *not_ary = NEW_LABEL(location.
line);
5313 PUSH_GETLOCAL(ret, location, 1, 0);
5314 PUSH_INSN(ret, location, dup);
5315 PUSH_CALL(ret, location, idLength,
INT2FIX(0));
5316 PUSH_INSN1(ret, location, putobject,
INT2FIX(1));
5317 PUSH_CALL(ret, location, idEq,
INT2FIX(1));
5318 PUSH_INSNL(ret, location, branchunless, not_single);
5319 PUSH_INSN(ret, location, dup);
5320 PUSH_INSN1(ret, location, putobject,
INT2FIX(0));
5321 PUSH_CALL(ret, location, idAREF,
INT2FIX(1));
5322 PUSH_INSN1(ret, location, putobject,
rb_cArray);
5323 PUSH_INSN(ret, location, swap);
5324 PUSH_CALL(ret, location, rb_intern(
"try_convert"),
INT2FIX(1));
5325 PUSH_INSN(ret, location, dup);
5326 PUSH_INSNL(ret, location, branchunless, not_ary);
5327 PUSH_INSN(ret, location, swap);
5329 PUSH_LABEL(ret, not_ary);
5330 PUSH_INSN(ret, location, pop);
5332 PUSH_LABEL(ret, not_single);
5333 PUSH_SEQ(ret, writes);
5334 PUSH_SEQ(ret, cleanup);
5338 rb_bug(
"Unexpected node type for index in for node: %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
5348 LABEL *lstart = NEW_LABEL(node_location->
line);
5349 LABEL *lend = NEW_LABEL(node_location->
line);
5350 LABEL *lcont = NEW_LABEL(node_location->
line);
5355 rb_iseq_t *rescue_iseq = NEW_CHILD_ISEQ(
5362 pm_scope_node_destroy(&rescue_scope_node);
5364 lstart->rescued = LABEL_RESCUE_BEG;
5365 lend->rescued = LABEL_RESCUE_END;
5366 PUSH_LABEL(ret, lstart);
5368 bool prev_in_rescue = ISEQ_COMPILE_DATA(iseq)->in_rescue;
5369 ISEQ_COMPILE_DATA(iseq)->in_rescue =
true;
5376 PUSH_INSN(ret, location, putnil);
5379 ISEQ_COMPILE_DATA(iseq)->in_rescue = prev_in_rescue;
5380 PUSH_LABEL(ret, lend);
5383 if (!popped) PUSH_INSN(ret, *node_location, pop);
5387 PUSH_INSN(ret, *node_location, nop);
5388 PUSH_LABEL(ret, lcont);
5390 if (popped) PUSH_INSN(ret, *node_location, pop);
5391 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue_iseq, lcont);
5392 PUSH_CATCH_ENTRY(CATCH_TYPE_RETRY, lend, lcont, NULL, lstart);
5402 if (statements != NULL) {
5403 location = PM_NODE_START_LOCATION(parser, statements);
5406 location = *node_location;
5409 LABEL *lstart = NEW_LABEL(location.
line);
5411 LABEL *lcont = NEW_LABEL(location.
line);
5418 if (statements != NULL) {
5419 pm_compile_node(iseq, (
const pm_node_t *) statements, ensr,
true, scope_node);
5423 bool last_leave = last && IS_INSN(last) && IS_INSN_ID(last, leave);
5428 push_ensure_entry(iseq, &enl, &er, (
void *) cast->
ensure_clause);
5430 PUSH_LABEL(ret, lstart);
5432 pm_compile_rescue(iseq, cast, node_location, ret, popped | last_leave, scope_node);
5435 pm_compile_node(iseq, (
const pm_node_t *) cast->
statements, ret, popped | last_leave, scope_node);
5437 else if (!(popped | last_leave)) {
5438 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
5441 PUSH_LABEL(ret, lend);
5442 PUSH_SEQ(ret, ensr);
5443 if (!popped && last_leave) PUSH_INSN(ret, *node_location, putnil);
5444 PUSH_LABEL(ret, lcont);
5445 if (last_leave) PUSH_INSN(ret, *node_location, pop);
5457 pm_scope_node_destroy(&next_scope_node);
5459 erange = ISEQ_COMPILE_DATA(iseq)->ensure_node_stack->erange;
5460 if (lstart->link.next != &lend->link) {
5462 PUSH_CATCH_ENTRY(CATCH_TYPE_ENSURE, erange->begin, erange->end, child_iseq, lcont);
5463 erange = erange->next;
5466 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enl.prev;
5481 node->
block == NULL &&
5482 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5499 node->
block == NULL &&
5501 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5518 node->
block == NULL &&
5520 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5531 const pm_node_location_t location = PM_LOCATION_START_LOCATION(scope_node->parser, name_loc, node_id);
5533 if (ISEQ_COMPILE_DATA(iseq)->option->inline_const_cache) {
5534 ISEQ_BODY(iseq)->ic_size++;
5535 VALUE segments = rb_ary_new_from_args(1, name);
5536 PUSH_INSN1(ret, location, opt_getconstant_path, segments);
5539 PUSH_INSN(ret, location, putnil);
5540 PUSH_INSN1(ret, location, putobject,
Qtrue);
5541 PUSH_INSN1(ret, location, getconstant, name);
5552 VALUE parts = rb_ary_new();
5560 rb_ary_unshift(parts, name);
5567 rb_ary_unshift(parts, name);
5568 if (cast->
parent == NULL) {
5569 rb_ary_unshift(parts,
ID2SYM(idNULL));
5590 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5597 PUSH_INSN1(body, location, putobject,
Qtrue);
5598 PUSH_INSN1(body, location, getconstant, name);
5605 if (cast->
parent == NULL) {
5606 PUSH_INSN(body, location, pop);
5607 PUSH_INSN1(body, location, putobject, rb_cObject);
5608 PUSH_INSN1(body, location, putobject,
Qtrue);
5609 PUSH_INSN1(body, location, getconstant, name);
5612 pm_compile_constant_path(iseq, cast->
parent, prefix, body,
false, scope_node);
5613 PUSH_INSN1(body, location, putobject,
Qfalse);
5614 PUSH_INSN1(body, location, getconstant, name);
5619 PM_COMPILE_INTO_ANCHOR(prefix, node);
5642 return pm_static_literal_value(iseq, node, scope_node);
5644 return parse_static_literal_string(iseq, scope_node, node, &((
const pm_string_node_t *) node)->unescaped);
5651 for (
size_t index = 0; index < cast->
elements.
size; index++) {
5652 VALUE element = pm_compile_shareable_constant_literal(iseq, cast->
elements.
nodes[index], scope_node);
5655 rb_ary_push(result, element);
5664 for (
size_t index = 0; index < cast->
elements.
size; index++) {
5670 VALUE key = pm_compile_shareable_constant_literal(iseq, assoc->
key, scope_node);
5673 VALUE value = pm_compile_shareable_constant_literal(iseq, assoc->
value, scope_node);
5676 rb_hash_aset(result, key, value);
5693 VALUE literal = pm_compile_shareable_constant_literal(iseq, node, scope_node);
5695 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5696 PUSH_INSN1(ret, location, putobject, literal);
5700 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5706 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5709 for (
size_t index = 0; index < cast->
elements.
size; index++) {
5710 pm_compile_shareable_constant_value(iseq, cast->
elements.
nodes[index], shareability, path, ret, scope_node,
false);
5717 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2FIX(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5726 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5729 pm_compile_hash_elements(iseq, (
const pm_node_t *) cast, &cast->elements, shareability, path,
false, ret, scope_node);
5733 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2FIX(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5739 DECL_ANCHOR(value_seq);
5741 pm_compile_node(iseq, node, value_seq,
false, scope_node);
5743 PUSH_SEND_WITH_FLAG(value_seq, location, idUMinus,
INT2FIX(0),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5747 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5748 PUSH_SEQ(ret, value_seq);
5749 PUSH_INSN1(ret, location, putobject, path);
5750 PUSH_SEND_WITH_FLAG(ret, location, rb_intern(
"ensure_shareable"),
INT2FIX(2),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5753 if (top) PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5754 PUSH_SEQ(ret, value_seq);
5755 if (top) PUSH_SEND_WITH_FLAG(ret, location, rb_intern(
"make_shareable_copy"),
INT2FIX(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5758 if (top) PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5759 PUSH_SEQ(ret, value_seq);
5760 if (top) PUSH_SEND_WITH_FLAG(ret, location, rb_intern(
"make_shareable"),
INT2FIX(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5776 ID name_id = pm_constant_id_lookup(scope_node, node->
name);
5778 if (shareability != 0) {
5779 pm_compile_shareable_constant_value(iseq, node->
value, shareability, rb_id2str(name_id), ret, scope_node,
true);
5782 PM_COMPILE_NOT_POPPED(node->
value);
5785 if (!popped) PUSH_INSN(ret, location, dup);
5786 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5789 PUSH_INSN1(ret, location, setconstant, operand);
5802 LABEL *end_label = NEW_LABEL(location.
line);
5804 pm_compile_constant_read(iseq, name, &node->
name_loc, location.
node_id, ret, scope_node);
5805 if (!popped) PUSH_INSN(ret, location, dup);
5807 PUSH_INSNL(ret, location, branchunless, end_label);
5808 if (!popped) PUSH_INSN(ret, location, pop);
5810 if (shareability != 0) {
5811 pm_compile_shareable_constant_value(iseq, node->
value, shareability, name, ret, scope_node,
true);
5814 PM_COMPILE_NOT_POPPED(node->
value);
5817 if (!popped) PUSH_INSN(ret, location, dup);
5818 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5819 PUSH_INSN1(ret, location, setconstant, name);
5820 PUSH_LABEL(ret, end_label);
5833 LABEL *set_label = NEW_LABEL(location.
line);
5834 LABEL *end_label = NEW_LABEL(location.
line);
5836 PUSH_INSN(ret, location, putnil);
5837 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CONST), name,
Qtrue);
5838 PUSH_INSNL(ret, location, branchunless, set_label);
5840 pm_compile_constant_read(iseq, name, &node->
name_loc, location.
node_id, ret, scope_node);
5841 if (!popped) PUSH_INSN(ret, location, dup);
5843 PUSH_INSNL(ret, location, branchif, end_label);
5844 if (!popped) PUSH_INSN(ret, location, pop);
5845 PUSH_LABEL(ret, set_label);
5847 if (shareability != 0) {
5848 pm_compile_shareable_constant_value(iseq, node->
value, shareability, name, ret, scope_node,
true);
5851 PM_COMPILE_NOT_POPPED(node->
value);
5854 if (!popped) PUSH_INSN(ret, location, dup);
5855 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5856 PUSH_INSN1(ret, location, setconstant, name);
5857 PUSH_LABEL(ret, end_label);
5872 pm_compile_constant_read(iseq, name, &node->
name_loc, location.
node_id, ret, scope_node);
5874 if (shareability != 0) {
5875 pm_compile_shareable_constant_value(iseq, node->
value, shareability, name, ret, scope_node,
true);
5878 PM_COMPILE_NOT_POPPED(node->
value);
5881 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2NUM(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5882 if (!popped) PUSH_INSN(ret, location, dup);
5884 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5885 PUSH_INSN1(ret, location, setconstant, name);
5895 VALUE parts = rb_ary_new();
5896 rb_ary_push(parts, rb_id2str(pm_constant_id_lookup(scope_node, node->
name)));
5901 rb_ary_unshift(parts, rb_id2str(pm_constant_id_lookup(scope_node, cast->
name)));
5905 if (current == NULL) {
5906 rb_ary_unshift(parts, rb_id2str(idNULL));
5909 rb_ary_unshift(parts, rb_id2str(pm_constant_id_lookup(scope_node, ((
const pm_constant_read_node_t *) current)->name)));
5933 PUSH_INSN1(ret, location, putobject, rb_cObject);
5936 if (shareability != 0) {
5937 pm_compile_shareable_constant_value(iseq, node->
value, shareability, pm_constant_path_path(node->
target, scope_node), ret, scope_node,
true);
5940 PM_COMPILE_NOT_POPPED(node->
value);
5944 PUSH_INSN(ret, location, swap);
5945 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
5948 PUSH_INSN(ret, location, swap);
5949 PUSH_INSN1(ret, location, setconstant, name);
5966 PM_COMPILE_NOT_POPPED(target->
parent);
5969 PUSH_INSN1(ret, location, putobject, rb_cObject);
5972 PUSH_INSN(ret, location, dup);
5973 PUSH_INSN1(ret, location, putobject,
Qtrue);
5974 PUSH_INSN1(ret, location, getconstant, name);
5976 if (!popped) PUSH_INSN(ret, location, dup);
5977 PUSH_INSNL(ret, location, branchunless, lfin);
5979 if (!popped) PUSH_INSN(ret, location, pop);
5981 if (shareability != 0) {
5982 pm_compile_shareable_constant_value(iseq, node->
value, shareability, pm_constant_path_path(node->
target, scope_node), ret, scope_node,
true);
5985 PM_COMPILE_NOT_POPPED(node->
value);
5989 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
5992 PUSH_INSN1(ret, location, dupn,
INT2FIX(2));
5993 PUSH_INSN(ret, location, swap);
5996 PUSH_INSN1(ret, location, setconstant, name);
5997 PUSH_LABEL(ret, lfin);
5999 if (!popped) PUSH_INSN(ret, location, swap);
6000 PUSH_INSN(ret, location, pop);
6014 LABEL *lassign = NEW_LABEL(location.
line);
6018 PM_COMPILE_NOT_POPPED(target->
parent);
6021 PUSH_INSN1(ret, location, putobject, rb_cObject);
6024 PUSH_INSN(ret, location, dup);
6025 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CONST_FROM), name,
Qtrue);
6026 PUSH_INSNL(ret, location, branchunless, lassign);
6028 PUSH_INSN(ret, location, dup);
6029 PUSH_INSN1(ret, location, putobject,
Qtrue);
6030 PUSH_INSN1(ret, location, getconstant, name);
6032 if (!popped) PUSH_INSN(ret, location, dup);
6033 PUSH_INSNL(ret, location, branchif, lfin);
6035 if (!popped) PUSH_INSN(ret, location, pop);
6036 PUSH_LABEL(ret, lassign);
6038 if (shareability != 0) {
6039 pm_compile_shareable_constant_value(iseq, node->
value, shareability, pm_constant_path_path(node->
target, scope_node), ret, scope_node,
true);
6042 PM_COMPILE_NOT_POPPED(node->
value);
6046 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
6049 PUSH_INSN1(ret, location, dupn,
INT2FIX(2));
6050 PUSH_INSN(ret, location, swap);
6053 PUSH_INSN1(ret, location, setconstant, name);
6054 PUSH_LABEL(ret, lfin);
6056 if (!popped) PUSH_INSN(ret, location, swap);
6057 PUSH_INSN(ret, location, pop);
6074 PM_COMPILE_NOT_POPPED(target->
parent);
6077 PUSH_INSN1(ret, location, putobject, rb_cObject);
6080 PUSH_INSN(ret, location, dup);
6081 PUSH_INSN1(ret, location, putobject,
Qtrue);
6082 PUSH_INSN1(ret, location, getconstant, name);
6084 if (shareability != 0) {
6085 pm_compile_shareable_constant_value(iseq, node->
value, shareability, pm_constant_path_path(node->
target, scope_node), ret, scope_node,
true);
6088 PM_COMPILE_NOT_POPPED(node->
value);
6091 PUSH_CALL(ret, location, method_id,
INT2FIX(1));
6092 PUSH_INSN(ret, location, swap);
6095 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
6096 PUSH_INSN(ret, location, swap);
6099 PUSH_INSN1(ret, location, setconstant, name);
6108#define PM_CONTAINER_P(node) (PM_NODE_TYPE_P(node, PM_ARRAY_NODE) || PM_NODE_TYPE_P(node, PM_HASH_NODE) || PM_NODE_TYPE_P(node, PM_RANGE_NODE))
6127 bool trailing_comma =
false;
6133 if (scope_node->parameters != NULL) {
6137 parameters_node = cast->parameters;
6138 block_locals = &cast->locals;
6140 if (parameters_node) {
6142 trailing_comma =
true;
6153 body->
param.lead_num = maximum;
6154 body->
param.flags.ambiguous_param0 = maximum == 1;
6158 body->
param.lead_num = 1;
6159 body->
param.flags.ambiguous_param0 =
true;
6162 rb_bug(
"Unexpected node type for parameters: %s", pm_node_type_to_str(
PM_NODE_TYPE(scope_node->parameters)));
6166 struct rb_iseq_param_keyword *keyword = NULL;
6168 if (parameters_node) {
6169 optionals_list = ¶meters_node->
optionals;
6170 requireds_list = ¶meters_node->
requireds;
6171 keywords_list = ¶meters_node->
keywords;
6172 posts_list = ¶meters_node->
posts;
6175 body->
param.opt_num = 0;
6178 body->
param.lead_num = 0;
6179 body->
param.opt_num = 0;
6185 size_t locals_size = locals->
size;
6188 st_table *index_lookup_table = st_init_numtable();
6190 int table_size = (int) locals_size;
6196 if (keywords_list && keywords_list->
size) {
6200 if (requireds_list) {
6201 for (
size_t i = 0; i < requireds_list->
size; i++) {
6227 if (optionals_list && optionals_list->
size) {
6228 for (
size_t i = 0; i < optionals_list->
size; i++) {
6240 if (parameters_node) {
6241 if (parameters_node->
rest) {
6258 if (requireds_list->
size == 0 && optionals_list->
size == 0 && keywords_list->
size == 0) {
6259 ISEQ_BODY(iseq)->param.flags.use_block = TRUE;
6260 ISEQ_BODY(iseq)->param.flags.forwardable = TRUE;
6279 for (
size_t i = 0; i < posts_list->
size; i++) {
6290 if (keywords_list && keywords_list->
size) {
6291 for (
size_t i = 0; i < keywords_list->
size; i++) {
6299 if (parameters_node && parameters_node->
block) {
6310 local_table_for_iseq->size = table_size;
6330 int local_index = 0;
6337 if (requireds_list && requireds_list->
size) {
6338 for (
size_t i = 0; i < requireds_list->
size; i++, local_index++) {
6350 local = rb_make_temporary_id(local_index);
6351 local_table_for_iseq->ids[local_index] = local;
6360 ID local = pm_constant_id_lookup(scope_node, param->
name);
6361 local_table_for_iseq->ids[local_index] = local;
6364 pm_insert_local_index(param->
name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6370 rb_bug(
"Unsupported node in requireds in parameters %s", pm_node_type_to_str(
PM_NODE_TYPE(required)));
6374 body->
param.lead_num = (int) requireds_list->
size;
6375 body->
param.flags.has_lead =
true;
6379 ID local = rb_make_temporary_id(local_index);
6380 local_table_for_iseq->ids[local_index++] = local;
6385 if (optionals_list && optionals_list->
size) {
6386 body->
param.opt_num = (int) optionals_list->
size;
6387 body->
param.flags.has_opt =
true;
6389 for (
size_t i = 0; i < optionals_list->
size; i++, local_index++) {
6394 ID local = pm_constant_id_lookup(scope_node, name);
6395 local_table_for_iseq->ids[local_index] = local;
6398 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6405 if (parameters_node && parameters_node->
rest) {
6406 body->
param.rest_start = local_index;
6411 body->
param.flags.has_rest =
true;
6420 ID local = pm_constant_id_lookup(scope_node, name);
6421 local_table_for_iseq->ids[local_index] = local;
6424 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6430 body->
param.flags.anon_rest =
true;
6431 pm_insert_local_special(idMULT, local_index, index_lookup_table, local_table_for_iseq);
6440 if (posts_list && posts_list->
size) {
6441 body->
param.post_num = (int) posts_list->
size;
6442 body->
param.post_start = local_index;
6443 body->
param.flags.has_post =
true;
6445 for (
size_t i = 0; i < posts_list->
size; i++, local_index++) {
6457 local = rb_make_temporary_id(local_index);
6458 local_table_for_iseq->ids[local_index] = local;
6467 ID local = pm_constant_id_lookup(scope_node, param->
name);
6468 local_table_for_iseq->ids[local_index] = local;
6471 pm_insert_local_index(param->
name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6476 rb_bug(
"Unsupported node in posts in parameters %s", pm_node_type_to_str(
PM_NODE_TYPE(post_node)));
6484 if (keywords_list && keywords_list->
size) {
6485 keyword =
ZALLOC_N(
struct rb_iseq_param_keyword, 1);
6486 keyword->num = (int) keywords_list->
size;
6488 const VALUE default_values = rb_ary_hidden_new(1);
6491 for (
size_t i = 0; i < keywords_list->
size; i++) {
6499 keyword->required_num++;
6500 ID local = pm_constant_id_lookup(scope_node, name);
6503 local_table_for_iseq->ids[local_index] = local;
6506 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6512 for (
size_t i = 0; i < keywords_list->
size; i++) {
6524 if (
PM_NODE_FLAG_P(value, PM_NODE_FLAG_STATIC_LITERAL) && !PM_CONTAINER_P(value)) {
6525 rb_ary_push(default_values, pm_static_literal_value(iseq, value, scope_node));
6528 rb_ary_push(default_values, complex_mark);
6531 ID local = pm_constant_id_lookup(scope_node, name);
6533 local_table_for_iseq->ids[local_index] = local;
6536 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6546 for (
int i = 0; i <
RARRAY_LEN(default_values); i++) {
6548 if (dv == complex_mark) dv =
Qundef;
6552 keyword->default_values = dvs;
6556 keyword->bits_start = local_index;
6557 ID local = rb_make_temporary_id(local_index);
6558 local_table_for_iseq->ids[local_index] = local;
6561 body->
param.keyword = keyword;
6562 body->
param.flags.has_kw =
true;
6565 if (body->type == ISEQ_TYPE_BLOCK && local_index == 1 && requireds_list && requireds_list->
size == 1 && !trailing_comma) {
6566 body->
param.flags.ambiguous_param0 =
true;
6569 if (parameters_node) {
6577 body->
param.flags.accepts_no_kwarg =
true;
6584 if (!body->
param.flags.has_kw) {
6585 body->
param.keyword = keyword =
ZALLOC_N(
struct rb_iseq_param_keyword, 1);
6588 keyword->rest_start = local_index;
6589 body->
param.flags.has_kwrest =
true;
6594 ID local = pm_constant_id_lookup(scope_node, constant_id);
6595 local_table_for_iseq->ids[local_index] = local;
6598 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6602 body->
param.flags.anon_kwrest =
true;
6603 pm_insert_local_special(idPow, local_index, index_lookup_table, local_table_for_iseq);
6612 if (!ISEQ_BODY(iseq)->param.
flags.forwardable) {
6614 body->
param.rest_start = local_index;
6615 body->
param.flags.has_rest =
true;
6616 body->
param.flags.anon_rest =
true;
6617 pm_insert_local_special(idMULT, local_index++, index_lookup_table, local_table_for_iseq);
6621 body->
param.flags.has_kw =
false;
6622 body->
param.flags.has_kwrest =
true;
6623 body->
param.flags.anon_kwrest =
true;
6624 body->
param.keyword = keyword =
ZALLOC_N(
struct rb_iseq_param_keyword, 1);
6625 keyword->rest_start = local_index;
6626 pm_insert_local_special(idPow, local_index++, index_lookup_table, local_table_for_iseq);
6629 body->
param.block_start = local_index;
6630 body->
param.flags.has_block =
true;
6631 pm_insert_local_special(idAnd, local_index++, index_lookup_table, local_table_for_iseq);
6635 pm_insert_local_special(idDot3, local_index++, index_lookup_table, local_table_for_iseq);
6639 rb_bug(
"node type %s not expected as keyword_rest", pm_node_type_to_str(
PM_NODE_TYPE(parameters_node->
keyword_rest)));
6645 if (parameters_node->
block) {
6646 body->
param.block_start = local_index;
6647 body->
param.flags.has_block =
true;
6648 iseq_set_use_block(iseq);
6654 ID local = pm_constant_id_lookup(scope_node, name);
6655 local_table_for_iseq->ids[local_index] = local;
6658 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6662 pm_insert_local_special(idAnd, local_index, index_lookup_table, local_table_for_iseq);
6681 if (requireds_list && requireds_list->
size) {
6682 for (
size_t i = 0; i < requireds_list->
size; i++) {
6689 local_index = pm_compile_destructured_param_locals((
const pm_multi_target_node_t *) required, index_lookup_table, local_table_for_iseq, scope_node, local_index);
6695 if (posts_list && posts_list->
size) {
6696 for (
size_t i = 0; i < posts_list->
size; i++) {
6703 local_index = pm_compile_destructured_param_locals((
const pm_multi_target_node_t *) post, index_lookup_table, local_table_for_iseq, scope_node, local_index);
6711 body->
param.lead_num++;
6714 body->
param.rest_start = local_index;
6715 body->
param.flags.has_rest =
true;
6718 ID local = rb_make_temporary_id(local_index);
6719 local_table_for_iseq->ids[local_index] = local;
6727 for (
int i = 0; i < maximum; i++, local_index++) {
6728 const uint8_t param_name[] = {
'_',
'1' + i };
6730 RUBY_ASSERT(constant_id &&
"parser should fill in any gaps in numbered parameters");
6731 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6733 body->
param.lead_num = maximum;
6734 body->
param.flags.has_lead =
true;
6745 if (block_locals && block_locals->
size) {
6746 for (
size_t i = 0; i < block_locals->
size; i++, local_index++) {
6748 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6753 if (scope_node->locals.
size) {
6754 for (
size_t i = 0; i < scope_node->locals.
size; i++) {
6758 ctx.scope_node = scope_node;
6759 ctx.local_table_for_iseq = local_table_for_iseq;
6760 ctx.local_index = local_index;
6762 st_update(index_lookup_table, (st_data_t)constant_id, pm_local_table_insert_func, (st_data_t)&ctx);
6764 local_index = ctx.local_index;
6773 if (scope_node->index_lookup_table) {
6774 st_free_table(scope_node->index_lookup_table);
6776 scope_node->index_lookup_table = index_lookup_table;
6777 iseq_calc_param_size(iseq);
6779 if (ISEQ_BODY(iseq)->param.
flags.forwardable) {
6782 ISEQ_BODY(iseq)->param.size += 1;
6786 iseq_set_local_table(iseq, local_table_for_iseq, 0);
6787 scope_node->local_table_for_iseq_size = local_table_for_iseq->size;
6789 if (keyword != NULL) {
6790 size_t keyword_start_index = keyword->bits_start - keyword->num;
6791 keyword->table = (
ID *)&ISEQ_BODY(iseq)->local_table[keyword_start_index];
6796 if (optionals_list && optionals_list->
size) {
6804 for (
size_t i = 0; i < optionals_list->
size; i++) {
6805 label = NEW_LABEL(location.
line);
6806 opt_table[i] = label;
6807 PUSH_LABEL(ret, label);
6809 PM_COMPILE_NOT_POPPED(optional_node);
6813 label = NEW_LABEL(location.
line);
6814 opt_table[optionals_list->
size] = label;
6815 PUSH_LABEL(ret, label);
6817 body->
param.opt_table = (
const VALUE *) opt_table;
6820 if (keywords_list && keywords_list->
size) {
6821 size_t optional_index = 0;
6822 for (
size_t i = 0; i < keywords_list->
size; i++) {
6835 if (!
PM_NODE_FLAG_P(value, PM_NODE_FLAG_STATIC_LITERAL) || PM_CONTAINER_P(value)) {
6836 LABEL *end_label = NEW_LABEL(location.
line);
6839 int kw_bits_idx = table_size - body->
param.keyword->bits_start;
6840 PUSH_INSN2(ret, location, checkkeyword,
INT2FIX(kw_bits_idx + VM_ENV_DATA_SIZE - 1),
INT2FIX(optional_index));
6841 PUSH_INSNL(ret, location, branchif, end_label);
6843 PUSH_SETLOCAL(ret, location, index.index, index.level);
6844 PUSH_LABEL(ret, end_label);
6854 rb_bug(
"Unexpected keyword parameter node type %s", pm_node_type_to_str(
PM_NODE_TYPE(keyword_parameter_node)));
6859 if (requireds_list && requireds_list->
size) {
6860 for (
size_t i = 0; i < requireds_list->
size; i++) {
6867 PUSH_GETLOCAL(ret, location, table_size - (
int)i, 0);
6873 if (posts_list && posts_list->
size) {
6874 for (
size_t i = 0; i < posts_list->
size; i++) {
6881 PUSH_GETLOCAL(ret, location, table_size - body->
param.post_start - (
int) i, 0);
6887 switch (body->type) {
6888 case ISEQ_TYPE_PLAIN: {
6892 pm_compile_regexp_dynamic(iseq, (
const pm_node_t *) cast, &cast->parts, &location, ret, popped, scope_node);
6896 case ISEQ_TYPE_BLOCK: {
6897 LABEL *start = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(0);
6898 LABEL *end = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(0);
6901 start->rescued = LABEL_RESCUE_BEG;
6902 end->rescued = LABEL_RESCUE_END;
6909 pm_compile_for_node_index(iseq, ((
const pm_for_node_t *) scope_node->ast_node)->index, ret, scope_node);
6913 PUSH_INSN(ret, block_location, nop);
6914 PUSH_LABEL(ret, start);
6916 if (scope_node->body != NULL) {
6920 PUSH_INSN1(ret, block_location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
6924 pm_scope_node_init((
const pm_node_t *) cast->statements, &next_scope_node, scope_node);
6926 const rb_iseq_t *block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(body->parent_iseq), ISEQ_TYPE_BLOCK, location.
line);
6927 pm_scope_node_destroy(&next_scope_node);
6929 PUSH_CALL_WITH_BLOCK(ret, block_location, id_core_set_postexe,
INT2FIX(0), block);
6934 pm_compile_regexp_dynamic(iseq, (
const pm_node_t *) cast, &cast->parts, &location, ret, popped, scope_node);
6938 pm_compile_node(iseq, scope_node->body, ret, popped, scope_node);
6943 PUSH_INSN(ret, block_location, putnil);
6946 PUSH_LABEL(ret, end);
6948 ISEQ_COMPILE_DATA(iseq)->last_line = body->location.code_location.end_pos.lineno;
6951 PUSH_CATCH_ENTRY(CATCH_TYPE_REDO, start, end, NULL, start);
6952 PUSH_CATCH_ENTRY(CATCH_TYPE_NEXT, start, end, NULL, end);
6955 case ISEQ_TYPE_ENSURE: {
6956 const pm_node_location_t statements_location = (scope_node->body != NULL ? PM_NODE_START_LOCATION(scope_node->parser, scope_node->body) : location);
6957 iseq_set_exception_local_table(iseq);
6959 if (scope_node->body != NULL) {
6960 PM_COMPILE_POPPED((
const pm_node_t *) scope_node->body);
6963 PUSH_GETLOCAL(ret, statements_location, 1, 0);
6964 PUSH_INSN1(ret, statements_location,
throw,
INT2FIX(0));
6967 case ISEQ_TYPE_METHOD: {
6968 ISEQ_COMPILE_DATA(iseq)->root_node = (
const void *) scope_node->body;
6971 if (scope_node->body) {
6972 PM_COMPILE((
const pm_node_t *) scope_node->body);
6975 PUSH_INSN(ret, location, putnil);
6978 ISEQ_COMPILE_DATA(iseq)->root_node = (
const void *) scope_node->body;
6981 ISEQ_COMPILE_DATA(iseq)->last_line = body->location.code_location.end_pos.lineno;
6984 case ISEQ_TYPE_RESCUE: {
6985 iseq_set_exception_local_table(iseq);
6988 LABEL *rescue_end = NEW_LABEL(location.
line);
6989 PUSH_GETLOCAL(ret, location, LVAR_ERRINFO, 0);
6991 PUSH_INSN1(ret, location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
6992 PUSH_INSNL(ret, location, branchif, lab);
6993 PUSH_INSNL(ret, location, jump, rescue_end);
6994 PUSH_LABEL(ret, lab);
6996 PM_COMPILE((
const pm_node_t *) scope_node->body);
6997 PUSH_INSN(ret, location, leave);
6998 PUSH_LABEL(ret, rescue_end);
6999 PUSH_GETLOCAL(ret, location, LVAR_ERRINFO, 0);
7002 PM_COMPILE((
const pm_node_t *) scope_node->ast_node);
7004 PUSH_INSN1(ret, location,
throw,
INT2FIX(0));
7009 if (scope_node->body) {
7010 PM_COMPILE((
const pm_node_t *) scope_node->body);
7013 PUSH_INSN(ret, location, putnil);
7019 const pm_node_location_t end_location = PM_NODE_END_LOCATION(scope_node->parser, scope_node->ast_node);
7021 ISEQ_COMPILE_DATA(iseq)->last_line = end_location.
line;
7026 PUSH_INSN(ret, location, leave);
7035 PUSH_INSN1(ret, *location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7039 VALUE operand =
ID2SYM(rb_intern3((
const char *) name_loc->
start, name_loc->
end - name_loc->
start, scope_node->encoding));
7040 PUSH_INSN1(ret, *location, putobject, operand);
7045 VALUE operand =
ID2SYM(rb_intern3((
const char *) name_loc->
start, name_loc->
end - name_loc->
start, scope_node->encoding));
7046 PUSH_INSN1(ret, *location, putobject, operand);
7049 PUSH_SEND(ret, *location, id_core_set_variable_alias,
INT2FIX(2));
7050 if (popped) PUSH_INSN(ret, *location, pop);
7056 PUSH_INSN1(ret, *location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7057 PUSH_INSN1(ret, *location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CBASE));
7058 PM_COMPILE_NOT_POPPED(node->
new_name);
7059 PM_COMPILE_NOT_POPPED(node->
old_name);
7061 PUSH_SEND(ret, *location, id_core_set_method_alias,
INT2FIX(3));
7062 if (popped) PUSH_INSN(ret, *location, pop);
7068 LABEL *end_label = NEW_LABEL(location->
line);
7070 PM_COMPILE_NOT_POPPED(node->
left);
7071 if (!popped) PUSH_INSN(ret, *location, dup);
7072 PUSH_INSNL(ret, *location, branchunless, end_label);
7074 if (!popped) PUSH_INSN(ret, *location, pop);
7075 PM_COMPILE(node->
right);
7076 PUSH_LABEL(ret, end_label);
7089 if (elements->
size) {
7090 VALUE value = pm_static_literal_value(iseq, node, scope_node);
7091 PUSH_INSN1(ret, *location, duparray, value);
7094 PUSH_INSN1(ret, *location, newarray,
INT2FIX(0));
7112 const int max_new_array_size = 0x100;
7113 const unsigned int min_tmp_array_size = 0x40;
7115 int new_array_size = 0;
7116 bool first_chunk =
true;
7122 bool static_literal =
false;
7125#define FLUSH_CHUNK \
7126 if (new_array_size) { \
7127 if (first_chunk) PUSH_INSN1(ret, *location, newarray, INT2FIX(new_array_size)); \
7128 else PUSH_INSN1(ret, *location, pushtoarray, INT2FIX(new_array_size)); \
7129 first_chunk = false; \
7130 new_array_size = 0; \
7133 for (
size_t index = 0; index < elements->
size; index++) {
7141 PM_COMPILE_NOT_POPPED(splat_element->
expression);
7144 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
7145 PUSH_GETLOCAL(ret, *location, index.index, index.level);
7151 PUSH_INSN1(ret, *location, splatarray,
Qtrue);
7152 first_chunk =
false;
7155 PUSH_INSN(ret, *location, concattoarray);
7158 static_literal =
false;
7161 if (new_array_size == 0 && first_chunk) {
7162 PUSH_INSN1(ret, *location, newarray,
INT2FIX(0));
7163 first_chunk =
false;
7180 pm_compile_hash_elements(iseq, element, &keyword_hash->
elements, 0,
Qundef,
false, ret, scope_node);
7190 PUSH_INSN(ret, *location, pushtoarraykwsplat);
7198 !PM_CONTAINER_P(element) &&
7200 ((index + min_tmp_array_size) < elements->
size)
7205 size_t right_index = index + 1;
7207 right_index < elements->size &&
7209 !PM_CONTAINER_P(elements->
nodes[right_index])
7212 size_t tmp_array_size = right_index - index;
7213 if (tmp_array_size >= min_tmp_array_size) {
7214 VALUE tmp_array = rb_ary_hidden_new(tmp_array_size);
7217 for (; tmp_array_size; tmp_array_size--)
7218 rb_ary_push(tmp_array, pm_static_literal_value(iseq, elements->
nodes[index++], scope_node));
7226 PUSH_INSN1(ret, *location, duparray, tmp_array);
7227 first_chunk =
false;
7230 PUSH_INSN1(ret, *location, putobject, tmp_array);
7231 PUSH_INSN(ret, *location, concattoarray);
7235 PM_COMPILE_NOT_POPPED(element);
7236 if (++new_array_size >= max_new_array_size) FLUSH_CHUNK;
7237 static_literal =
true;
7240 PM_COMPILE_NOT_POPPED(element);
7241 if (++new_array_size >= max_new_array_size) FLUSH_CHUNK;
7242 static_literal =
false;
7247 if (popped) PUSH_INSN(ret, *location, pop);
7255 unsigned long throw_flag = 0;
7257 if (ISEQ_COMPILE_DATA(iseq)->redo_label != 0 && can_add_ensure_iseq(iseq)) {
7259 LABEL *splabel = NEW_LABEL(0);
7260 PUSH_LABEL(ret, splabel);
7261 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
7267 PUSH_INSN(ret, *location, putnil);
7270 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
7271 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->end_label);
7272 PUSH_ADJUST_RESTORE(ret, splabel);
7273 if (!popped) PUSH_INSN(ret, *location, putnil);
7279 if (!ISEQ_COMPILE_DATA(ip)) {
7284 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
7285 throw_flag = VM_THROW_NO_ESCAPE_FLAG;
7287 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_BLOCK) {
7290 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_EVAL) {
7291 COMPILE_ERROR(iseq, location->
line,
"Invalid break");
7295 ip = ISEQ_BODY(ip)->parent_iseq;
7304 PUSH_INSN(ret, *location, putnil);
7307 PUSH_INSN1(ret, *location,
throw,
INT2FIX(throw_flag | TAG_BREAK));
7308 if (popped) PUSH_INSN(ret, *location, pop);
7313 COMPILE_ERROR(iseq, location->
line,
"Invalid break");
7320 ID method_id = pm_constant_id_lookup(scope_node, node->
name);
7326 const char *builtin_func;
7328 if (UNLIKELY(iseq_has_builtin_function_table(iseq)) && (builtin_func = pm_iseq_builtin_function_name(scope_node, node->
receiver, method_id)) != NULL) {
7329 pm_compile_builtin_function_call(iseq, ret, scope_node, node, &location, popped, ISEQ_COMPILE_DATA(iseq)->current_block, builtin_func);
7333 LABEL *start = NEW_LABEL(location.
line);
7334 if (node->
block) PUSH_LABEL(ret, start);
7336 switch (method_id) {
7338 if (pm_opt_str_freeze_p(iseq, node)) {
7340 const struct rb_callinfo *callinfo = new_callinfo(iseq, idUMinus, 0, 0, NULL, FALSE);
7341 PUSH_INSN2(ret, location, opt_str_uminus, value, callinfo);
7342 if (popped) PUSH_INSN(ret, location, pop);
7348 if (pm_opt_str_freeze_p(iseq, node)) {
7350 const struct rb_callinfo *callinfo = new_callinfo(iseq, idFreeze, 0, 0, NULL, FALSE);
7351 PUSH_INSN2(ret, location, opt_str_freeze, value, callinfo);
7352 if (popped) PUSH_INSN(ret, location, pop);
7358 if (pm_opt_aref_with_p(iseq, node)) {
7360 VALUE value = parse_static_literal_string(iseq, scope_node, (
const pm_node_t *)
string, &string->unescaped);
7362 PM_COMPILE_NOT_POPPED(node->
receiver);
7364 const struct rb_callinfo *callinfo = new_callinfo(iseq, idAREF, 1, 0, NULL, FALSE);
7365 PUSH_INSN2(ret, location, opt_aref_with, value, callinfo);
7368 PUSH_INSN(ret, location, pop);
7376 if (pm_opt_aset_with_p(iseq, node)) {
7378 VALUE value = parse_static_literal_string(iseq, scope_node, (
const pm_node_t *)
string, &string->unescaped);
7380 PM_COMPILE_NOT_POPPED(node->
receiver);
7384 PUSH_INSN(ret, location, swap);
7385 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
7388 const struct rb_callinfo *callinfo = new_callinfo(iseq, idASET, 2, 0, NULL, FALSE);
7389 PUSH_INSN2(ret, location, opt_aset_with, value, callinfo);
7390 PUSH_INSN(ret, location, pop);
7398 PUSH_INSN(ret, location, putnil);
7402 PUSH_INSN(ret, location, putself);
7410 if (iseq_block_param_id_p(iseq, pm_constant_id_lookup(scope_node, read_node_cast->name), &idx, &level)) {
7411 ADD_ELEM(ret, (
LINK_ELEMENT *) new_insn_body(iseq, location.
line, node_id, BIN(getblockparamproxy), 2,
INT2FIX((idx) + VM_ENV_DATA_SIZE - 1),
INT2FIX(level)));
7414 PM_COMPILE_NOT_POPPED(node->
receiver);
7418 PM_COMPILE_NOT_POPPED(node->
receiver);
7422 pm_compile_call(iseq, node, ret, popped, scope_node, method_id, start);
7432 flag = VM_CALL_FCALL;
7435 PM_COMPILE_NOT_POPPED(node->
receiver);
7437 LABEL *safe_label = NULL;
7439 safe_label = NEW_LABEL(location->
line);
7440 PUSH_INSN(ret, *location, dup);
7441 PUSH_INSNL(ret, *location, branchnil, safe_label);
7444 PUSH_INSN(ret, *location, dup);
7446 ID id_read_name = pm_constant_id_lookup(scope_node, node->
read_name);
7447 PUSH_SEND_WITH_FLAG(ret, *location, id_read_name,
INT2FIX(0),
INT2FIX(flag));
7449 PM_COMPILE_NOT_POPPED(node->
value);
7451 PUSH_SEND(ret, *location, id_operator,
INT2FIX(1));
7454 PUSH_INSN(ret, *location, swap);
7455 PUSH_INSN1(ret, *location, topn,
INT2FIX(1));
7458 ID id_write_name = pm_constant_id_lookup(scope_node, node->
write_name);
7459 PUSH_SEND_WITH_FLAG(ret, *location, id_write_name,
INT2FIX(1),
INT2FIX(flag));
7461 if (safe_label != NULL && popped) PUSH_LABEL(ret, safe_label);
7462 PUSH_INSN(ret, *location, pop);
7463 if (safe_label != NULL && !popped) PUSH_LABEL(ret, safe_label);
7489 key = pm_static_literal_value(iseq, node, scope_node);
7493 key = (
FIXABLE(intptr) ?
LONG2FIX((
long) intptr) : rb_dbl2big(intptr));
7505 key = pm_static_literal_value(iseq, node, scope_node);
7509 key = parse_static_literal_string(iseq, scope_node, node, &cast->
unescaped);
7516 if (
NIL_P(rb_hash_lookup(dispatch, key))) {
7517 rb_hash_aset(dispatch, key, ((
VALUE) label) | 1);
7536 DECL_ANCHOR(cond_seq);
7541 DECL_ANCHOR(body_seq);
7545 LABEL *end_label = NEW_LABEL(location.
line);
7556 if (PM_BRANCH_COVERAGE_P(iseq)) {
7557 case_location = pm_code_location(scope_node, (
const pm_node_t *) cast);
7558 branches = decl_branch_base(iseq, PTR2NUM(cast), &case_location,
"case");
7564 for (
size_t clause_index = 0; clause_index < conditions->
size; clause_index++) {
7568 int clause_lineno = pm_node_line_number(parser, (
const pm_node_t *) clause);
7569 LABEL *label = NEW_LABEL(clause_lineno);
7570 PUSH_LABEL(body_seq, label);
7573 if (PM_BRANCH_COVERAGE_P(iseq)) {
7575 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++,
"when", branches);
7578 if (clause->statements != NULL) {
7579 pm_compile_node(iseq, (
const pm_node_t *) clause->statements, body_seq, popped, scope_node);
7582 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7585 PUSH_INSNL(body_seq, location, jump, end_label);
7590 for (
size_t condition_index = 0; condition_index < conditions->
size; condition_index++) {
7595 PUSH_INSN(cond_seq, cond_location, putnil);
7596 pm_compile_node(iseq, condition, cond_seq,
false, scope_node);
7597 PUSH_INSN1(cond_seq, cond_location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_WHEN | VM_CHECKMATCH_ARRAY));
7598 PUSH_INSNL(cond_seq, cond_location, branchif, label);
7601 LABEL *next_label = NEW_LABEL(pm_node_line_number(parser, condition));
7602 pm_compile_branch_condition(iseq, cond_seq, condition, label, next_label,
false, scope_node);
7603 PUSH_LABEL(cond_seq, next_label);
7610 if (PM_BRANCH_COVERAGE_P(iseq)) {
7614 branch_location = case_location;
7621 add_trace_branch_coverage(iseq, cond_seq, &branch_location, branch_location.beg_pos.column, branch_id,
"else", branches);
7629 PUSH_SYNTHETIC_PUTNIL(cond_seq, iseq);
7634 PUSH_INSNL(cond_seq, location, jump, end_label);
7635 PUSH_SEQ(ret, cond_seq);
7643 if (PM_BRANCH_COVERAGE_P(iseq)) {
7644 case_location = pm_code_location(scope_node, (
const pm_node_t *) cast);
7645 branches = decl_branch_base(iseq, PTR2NUM(cast), &case_location,
"case");
7650 LABEL *else_label = NEW_LABEL(location.
line);
7658 if (ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction) {
7659 dispatch = rb_hash_new();
7660 RHASH_TBL_RAW(dispatch)->type = &cdhash_type;
7671 for (
size_t clause_index = 0; clause_index < conditions->
size; clause_index++) {
7676 LABEL *label = NEW_LABEL(clause_location.
line);
7681 for (
size_t condition_index = 0; condition_index < conditions->
size; condition_index++) {
7683 const pm_node_location_t condition_location = PM_NODE_START_LOCATION(parser, condition);
7688 if (dispatch !=
Qundef) {
7689 dispatch = pm_compile_case_node_dispatch(iseq, dispatch, condition, label, scope_node);
7693 PUSH_INSN(cond_seq, condition_location, dup);
7694 pm_compile_node(iseq, condition, cond_seq,
false, scope_node);
7695 PUSH_INSN1(cond_seq, condition_location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_CASE | VM_CHECKMATCH_ARRAY));
7700 VALUE value = parse_static_literal_string(iseq, scope_node, condition, &string->
unescaped);
7701 PUSH_INSN1(cond_seq, condition_location, putobject, value);
7704 pm_compile_node(iseq, condition, cond_seq,
false, scope_node);
7707 PUSH_INSN1(cond_seq, condition_location, topn,
INT2FIX(1));
7708 PUSH_SEND_WITH_FLAG(cond_seq, condition_location, idEqq,
INT2NUM(1),
INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
7711 PUSH_INSNL(cond_seq, condition_location, branchif, label);
7718 PUSH_LABEL(body_seq, label);
7719 PUSH_INSN(body_seq, clause_location, pop);
7722 if (PM_BRANCH_COVERAGE_P(iseq)) {
7724 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++,
"when", branches);
7727 if (clause->statements != NULL) {
7728 pm_compile_node(iseq, (
const pm_node_t *) clause->statements, body_seq, popped, scope_node);
7731 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7734 PUSH_INSNL(body_seq, clause_location, jump, end_label);
7745 if (dispatch !=
Qundef) {
7746 PUSH_INSN(ret, location, dup);
7747 PUSH_INSN2(ret, location, opt_case_dispatch, dispatch, else_label);
7748 LABEL_REF(else_label);
7751 PUSH_SEQ(ret, cond_seq);
7755 PUSH_LABEL(ret, else_label);
7759 PUSH_INSN(ret, else_location, pop);
7762 if (PM_BRANCH_COVERAGE_P(iseq)) {
7764 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, branch_id,
"else", branches);
7768 PUSH_INSNL(ret, else_location, jump, end_label);
7771 PUSH_INSN(ret, location, pop);
7774 if (PM_BRANCH_COVERAGE_P(iseq)) {
7775 add_trace_branch_coverage(iseq, ret, &case_location, case_location.beg_pos.column, branch_id,
"else", branches);
7778 if (!popped) PUSH_INSN(ret, location, putnil);
7779 PUSH_INSNL(ret, location, jump, end_label);
7783 PUSH_SEQ(ret, body_seq);
7784 PUSH_LABEL(ret, end_label);
7793 DECL_ANCHOR(body_seq);
7798 DECL_ANCHOR(cond_seq);
7802 LABEL *end_label = NEW_LABEL(location->
line);
7807 LABEL *else_label = NEW_LABEL(location->
line);
7815 if (PM_BRANCH_COVERAGE_P(iseq)) {
7816 case_location = pm_code_location(scope_node, (
const pm_node_t *) node);
7817 branches = decl_branch_base(iseq, PTR2NUM(node), &case_location,
"case");
7827 if (in_single_pattern) {
7828 PUSH_INSN(ret, *location, putnil);
7829 PUSH_INSN(ret, *location, putnil);
7830 PUSH_INSN1(ret, *location, putobject,
Qfalse);
7831 PUSH_INSN(ret, *location, putnil);
7835 PUSH_INSN(ret, *location, putnil);
7847 const pm_node_location_t in_location = PM_NODE_START_LOCATION(scope_node->parser, in_node);
7851 PUSH_INSN(body_seq, in_location, putnil);
7854 LABEL *body_label = NEW_LABEL(in_location.
line);
7855 PUSH_LABEL(body_seq, body_label);
7856 PUSH_INSN1(body_seq, in_location, adjuststack,
INT2FIX(in_single_pattern ? 6 : 2));
7859 if (PM_BRANCH_COVERAGE_P(iseq)) {
7861 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++,
"in", branches);
7868 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7871 PUSH_INSNL(body_seq, in_location, jump, end_label);
7872 LABEL *next_pattern_label = NEW_LABEL(pattern_location.
line);
7874 PUSH_INSN(cond_seq, pattern_location, dup);
7875 pm_compile_pattern(iseq, scope_node, in_node->
pattern, cond_seq, body_label, next_pattern_label, in_single_pattern,
false,
true, 2);
7876 PUSH_LABEL(cond_seq, next_pattern_label);
7877 LABEL_UNREMOVABLE(next_pattern_label);
7886 PUSH_LABEL(cond_seq, else_label);
7887 PUSH_INSN(cond_seq, *location, pop);
7888 PUSH_INSN(cond_seq, *location, pop);
7891 if (PM_BRANCH_COVERAGE_P(iseq)) {
7893 add_trace_branch_coverage(iseq, cond_seq, &branch_location, branch_location.beg_pos.column, branch_id,
"else", branches);
7896 PM_COMPILE_INTO_ANCHOR(cond_seq, (
const pm_node_t *) else_node);
7897 PUSH_INSNL(cond_seq, *location, jump, end_label);
7898 PUSH_INSN(cond_seq, *location, putnil);
7899 if (popped) PUSH_INSN(cond_seq, *location, putnil);
7904 PUSH_LABEL(cond_seq, else_label);
7907 add_trace_branch_coverage(iseq, cond_seq, &case_location, case_location.beg_pos.column, branch_id,
"else", branches);
7909 if (in_single_pattern) {
7910 pm_compile_pattern_error_handler(iseq, scope_node, (
const pm_node_t *) node, cond_seq, end_label, popped);
7913 PUSH_INSN1(cond_seq, *location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7915 PUSH_INSN1(cond_seq, *location, topn,
INT2FIX(2));
7916 PUSH_SEND(cond_seq, *location, id_core_raise,
INT2FIX(2));
7918 PUSH_INSN1(cond_seq, *location, adjuststack,
INT2FIX(3));
7919 if (!popped) PUSH_INSN(cond_seq, *location, putnil);
7920 PUSH_INSNL(cond_seq, *location, jump, end_label);
7921 PUSH_INSN1(cond_seq, *location, dupn,
INT2FIX(1));
7922 if (popped) PUSH_INSN(cond_seq, *location, putnil);
7929 PUSH_SEQ(ret, cond_seq);
7930 PUSH_SEQ(ret, body_seq);
7931 PUSH_LABEL(ret, end_label);
7939 LABEL *retry_label = NULL;
7940 LABEL *retry_end_l = NULL;
7942 if (node->
block != NULL) {
7943 previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
7944 ISEQ_COMPILE_DATA(iseq)->current_block = NULL;
7946 retry_label = NEW_LABEL(location->
line);
7947 retry_end_l = NEW_LABEL(location->
line);
7949 PUSH_LABEL(ret, retry_label);
7952 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
7955 PUSH_INSN(ret, *location, putself);
7956 int flag = VM_CALL_ZSUPER | VM_CALL_SUPER | VM_CALL_FCALL;
7958 if (node->
block != NULL) {
7960 pm_scope_node_init((
const pm_node_t *) node->
block, &next_scope_node, scope_node);
7962 ISEQ_COMPILE_DATA(iseq)->current_block = block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location->
line);
7963 pm_scope_node_destroy(&next_scope_node);
7970 const rb_iseq_t *local_iseq = body->local_iseq;
7974 int depth = get_lvar_level(iseq);
7976 if (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->
param.flags.forwardable) {
7977 flag |= VM_CALL_FORWARDING;
7978 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_DOT3, 0);
7979 PUSH_GETLOCAL(ret, *location, mult_local.index, mult_local.level);
7981 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, 0, flag, NULL, block != NULL);
7982 PUSH_INSN2(ret, *location, invokesuperforward, callinfo, block);
7984 if (popped) PUSH_INSN(ret, *location, pop);
7986 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
7991 if (local_body->
param.flags.has_lead) {
7993 for (
int i = 0; i < local_body->
param.lead_num; i++) {
7994 int idx = local_body->local_table_size - i;
7995 PUSH_GETLOCAL(args, *location, idx, depth);
7997 argc += local_body->
param.lead_num;
8000 if (local_body->
param.flags.has_opt) {
8002 for (
int j = 0; j < local_body->
param.opt_num; j++) {
8003 int idx = local_body->local_table_size - (argc + j);
8004 PUSH_GETLOCAL(args, *location, idx, depth);
8006 argc += local_body->
param.opt_num;
8009 if (local_body->
param.flags.has_rest) {
8011 int idx = local_body->local_table_size - local_body->
param.rest_start;
8012 PUSH_GETLOCAL(args, *location, idx, depth);
8013 PUSH_INSN1(args, *location, splatarray,
Qfalse);
8015 argc = local_body->
param.rest_start + 1;
8016 flag |= VM_CALL_ARGS_SPLAT;
8019 if (local_body->
param.flags.has_post) {
8021 int post_len = local_body->
param.post_num;
8022 int post_start = local_body->
param.post_start;
8025 for (; j < post_len; j++) {
8026 int idx = local_body->local_table_size - (post_start + j);
8027 PUSH_GETLOCAL(args, *location, idx, depth);
8030 if (local_body->
param.flags.has_rest) {
8032 PUSH_INSN1(args, *location, newarray,
INT2FIX(j));
8033 PUSH_INSN(args, *location, concatarray);
8036 argc = post_len + post_start;
8040 const struct rb_iseq_param_keyword *
const local_keyword = local_body->
param.keyword;
8041 if (local_body->
param.flags.has_kw) {
8042 int local_size = local_body->local_table_size;
8045 PUSH_INSN1(args, *location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
8047 if (local_body->
param.flags.has_kwrest) {
8048 int idx = local_body->local_table_size - local_keyword->rest_start;
8049 PUSH_GETLOCAL(args, *location, idx, depth);
8051 PUSH_SEND(args, *location, rb_intern(
"dup"),
INT2FIX(0));
8054 PUSH_INSN1(args, *location, newhash,
INT2FIX(0));
8057 for (; i < local_keyword->num; ++i) {
8058 ID id = local_keyword->table[i];
8059 int idx = local_size - get_local_var_idx(local_iseq,
id);
8063 PUSH_INSN1(args, *location, putobject, operand);
8066 PUSH_GETLOCAL(args, *location, idx, depth);
8069 PUSH_SEND(args, *location, id_core_hash_merge_ptr,
INT2FIX(i * 2 + 1));
8070 flag |= VM_CALL_KW_SPLAT| VM_CALL_KW_SPLAT_MUT;
8072 else if (local_body->
param.flags.has_kwrest) {
8073 int idx = local_body->local_table_size - local_keyword->rest_start;
8074 PUSH_GETLOCAL(args, *location, idx, depth);
8076 flag |= VM_CALL_KW_SPLAT;
8079 PUSH_SEQ(ret, args);
8082 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flag, NULL, block != NULL);
8083 PUSH_INSN2(ret, *location, invokesuper, callinfo, block);
8086 if (node->
block != NULL) {
8087 pm_compile_retry_end_label(iseq, ret, retry_end_l);
8088 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, block, retry_end_l);
8089 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
8092 if (popped) PUSH_INSN(ret, *location, pop);
8098 LABEL *matched_label = NEW_LABEL(location->
line);
8099 LABEL *unmatched_label = NEW_LABEL(location->
line);
8100 LABEL *done_label = NEW_LABEL(location->
line);
8104 PUSH_INSN(ret, *location, putnil);
8105 PUSH_INSN(ret, *location, putnil);
8106 PUSH_INSN1(ret, *location, putobject,
Qfalse);
8107 PUSH_INSN(ret, *location, putnil);
8108 PUSH_INSN(ret, *location, putnil);
8112 PM_COMPILE_NOT_POPPED(node->
value);
8116 PUSH_INSN(ret, *location, dup);
8123 pm_compile_pattern(iseq, scope_node, node->
pattern, ret, matched_label, unmatched_label,
true,
false,
true, 2);
8128 PUSH_LABEL(ret, unmatched_label);
8129 pm_compile_pattern_error_handler(iseq, scope_node, (
const pm_node_t *) node, ret, done_label, popped);
8133 PUSH_LABEL(ret, matched_label);
8134 PUSH_INSN1(ret, *location, adjuststack,
INT2FIX(6));
8135 if (!popped) PUSH_INSN(ret, *location, putnil);
8136 PUSH_INSNL(ret, *location, jump, done_label);
8138 PUSH_LABEL(ret, done_label);
8144 LABEL *fail_label = NEW_LABEL(location->
line);
8145 LABEL *end_label = NEW_LABEL(location->
line);
8156 PUSH_INSN1(ret, *location, getglobal, operand);
8159 PUSH_INSN(ret, *location, dup);
8160 PUSH_INSNL(ret, *location, branchunless, fail_label);
8166 if (targets_count == 1) {
8175 PUSH_INSN1(ret, *location, putobject, operand);
8178 PUSH_SEND(ret, *location, idAREF,
INT2FIX(1));
8179 PUSH_LABEL(ret, fail_label);
8180 PUSH_SETLOCAL(ret, *location, index.index, index.level);
8181 if (popped) PUSH_INSN(ret, *location, pop);
8185 DECL_ANCHOR(fail_anchor);
8189 for (
size_t targets_index = 0; targets_index < targets_count; targets_index++) {
8196 if (((
size_t) targets_index) < (targets_count - 1)) {
8197 PUSH_INSN(ret, *location, dup);
8202 PUSH_INSN1(ret, *location, putobject, operand);
8205 PUSH_SEND(ret, *location, idAREF,
INT2FIX(1));
8206 PUSH_SETLOCAL(ret, *location, index.index, index.level);
8208 PUSH_INSN(fail_anchor, *location, putnil);
8209 PUSH_SETLOCAL(fail_anchor, *location, index.index, index.level);
8213 PUSH_INSNL(ret, *location, jump, end_label);
8217 PUSH_LABEL(ret, fail_label);
8218 PUSH_INSN(ret, *location, pop);
8219 PUSH_SEQ(ret, fail_anchor);
8222 PUSH_LABEL(ret, end_label);
8223 if (popped) PUSH_INSN(ret, *location, pop);
8229 if (ISEQ_COMPILE_DATA(iseq)->redo_label != 0 && can_add_ensure_iseq(iseq)) {
8230 LABEL *splabel = NEW_LABEL(0);
8231 PUSH_LABEL(ret, splabel);
8237 PUSH_INSN(ret, *location, putnil);
8239 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8241 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
8242 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->start_label);
8244 PUSH_ADJUST_RESTORE(ret, splabel);
8245 if (!popped) PUSH_INSN(ret, *location, putnil);
8247 else if (ISEQ_COMPILE_DATA(iseq)->end_label && can_add_ensure_iseq(iseq)) {
8248 LABEL *splabel = NEW_LABEL(0);
8250 PUSH_LABEL(ret, splabel);
8251 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->start_label);
8257 PUSH_INSN(ret, *location, putnil);
8260 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8261 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->end_label);
8262 PUSH_ADJUST_RESTORE(ret, splabel);
8263 splabel->unremovable = FALSE;
8265 if (!popped) PUSH_INSN(ret, *location, putnil);
8269 unsigned long throw_flag = 0;
8272 if (!ISEQ_COMPILE_DATA(ip)) {
8277 throw_flag = VM_THROW_NO_ESCAPE_FLAG;
8278 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
8282 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_BLOCK) {
8285 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_EVAL) {
8286 COMPILE_ERROR(iseq, location->
line,
"Invalid next");
8290 ip = ISEQ_BODY(ip)->parent_iseq;
8298 PUSH_INSN(ret, *location, putnil);
8301 PUSH_INSN1(ret, *location,
throw,
INT2FIX(throw_flag | TAG_NEXT));
8302 if (popped) PUSH_INSN(ret, *location, pop);
8305 COMPILE_ERROR(iseq, location->
line,
"Invalid next");
8313 if (ISEQ_COMPILE_DATA(iseq)->redo_label && can_add_ensure_iseq(iseq)) {
8314 LABEL *splabel = NEW_LABEL(0);
8316 PUSH_LABEL(ret, splabel);
8317 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
8318 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8320 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->redo_label);
8321 PUSH_ADJUST_RESTORE(ret, splabel);
8322 if (!popped) PUSH_INSN(ret, *location, putnil);
8324 else if (ISEQ_BODY(iseq)->
type != ISEQ_TYPE_EVAL && ISEQ_COMPILE_DATA(iseq)->start_label && can_add_ensure_iseq(iseq)) {
8325 LABEL *splabel = NEW_LABEL(0);
8327 PUSH_LABEL(ret, splabel);
8328 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
8329 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->start_label);
8331 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->start_label);
8332 PUSH_ADJUST_RESTORE(ret, splabel);
8333 if (!popped) PUSH_INSN(ret, *location, putnil);
8339 if (!ISEQ_COMPILE_DATA(ip)) {
8344 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
8347 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_BLOCK) {
8350 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_EVAL) {
8351 COMPILE_ERROR(iseq, location->
line,
"Invalid redo");
8355 ip = ISEQ_BODY(ip)->parent_iseq;
8359 PUSH_INSN(ret, *location, putnil);
8360 PUSH_INSN1(ret, *location,
throw,
INT2FIX(VM_THROW_NO_ESCAPE_FLAG | TAG_REDO));
8361 if (popped) PUSH_INSN(ret, *location, pop);
8364 COMPILE_ERROR(iseq, location->
line,
"Invalid redo");
8372 iseq_set_exception_local_table(iseq);
8376 LABEL *exception_match_label = NEW_LABEL(location->
line);
8377 LABEL *rescue_end_label = NEW_LABEL(location->
line);
8387 if (exceptions->
size > 0) {
8388 for (
size_t index = 0; index < exceptions->
size; index++) {
8389 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8390 PM_COMPILE(exceptions->
nodes[index]);
8391 int checkmatch_flags = VM_CHECKMATCH_TYPE_RESCUE;
8393 checkmatch_flags |= VM_CHECKMATCH_ARRAY;
8395 PUSH_INSN1(ret, *location, checkmatch,
INT2FIX(checkmatch_flags));
8396 PUSH_INSNL(ret, *location, branchif, exception_match_label);
8400 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8402 PUSH_INSN1(ret, *location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
8403 PUSH_INSNL(ret, *location, branchif, exception_match_label);
8408 PUSH_INSNL(ret, *location, jump, rescue_end_label);
8413 PUSH_LABEL(ret, exception_match_label);
8420 DECL_ANCHOR(writes);
8421 DECL_ANCHOR(cleanup);
8423 pm_compile_target_node(iseq, node->
reference, ret, writes, cleanup, scope_node, NULL);
8424 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8426 PUSH_SEQ(ret, writes);
8427 PUSH_SEQ(ret, cleanup);
8437 LABEL *prev_end = ISEQ_COMPILE_DATA(iseq)->end_label;
8438 ISEQ_COMPILE_DATA(iseq)->end_label = NULL;
8443 ISEQ_COMPILE_DATA(iseq)->end_label = prev_end;
8446 PUSH_INSN(ret, *location, putnil);
8449 PUSH_INSN(ret, *location, leave);
8455 PUSH_LABEL(ret, rescue_end_label);
8460 PUSH_GETLOCAL(ret, *location, 1, 0);
8468 enum rb_iseq_type
type = ISEQ_BODY(iseq)->type;
8472 enum rb_iseq_type parent_type = ISEQ_BODY(parent_iseq)->type;
8473 while (parent_type == ISEQ_TYPE_RESCUE || parent_type == ISEQ_TYPE_ENSURE) {
8474 if (!(parent_iseq = ISEQ_BODY(parent_iseq)->parent_iseq))
break;
8475 parent_type = ISEQ_BODY(parent_iseq)->type;
8478 switch (parent_type) {
8480 case ISEQ_TYPE_MAIN:
8482 rb_warn(
"argument of top-level return is ignored");
8484 if (parent_iseq == iseq) {
8485 type = ISEQ_TYPE_METHOD;
8492 if (
type == ISEQ_TYPE_METHOD) {
8493 splabel = NEW_LABEL(0);
8494 PUSH_LABEL(ret, splabel);
8495 PUSH_ADJUST(ret, *location, 0);
8498 if (arguments != NULL) {
8499 PM_COMPILE_NOT_POPPED((
const pm_node_t *) arguments);
8502 PUSH_INSN(ret, *location, putnil);
8505 if (
type == ISEQ_TYPE_METHOD && can_add_ensure_iseq(iseq)) {
8506 pm_add_ensure_iseq(ret, iseq, 1, scope_node);
8508 PUSH_INSN(ret, *location, leave);
8509 PUSH_ADJUST_RESTORE(ret, splabel);
8510 if (!popped) PUSH_INSN(ret, *location, putnil);
8513 PUSH_INSN1(ret, *location,
throw,
INT2FIX(TAG_RETURN));
8514 if (popped) PUSH_INSN(ret, *location, pop);
8523 LABEL *retry_label = NEW_LABEL(location->
line);
8524 LABEL *retry_end_l = NEW_LABEL(location->
line);
8526 const rb_iseq_t *previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
8528 ISEQ_COMPILE_DATA(iseq)->current_block = current_block = NULL;
8530 PUSH_LABEL(ret, retry_label);
8531 PUSH_INSN(ret, *location, putself);
8535 int argc = pm_setup_args(node->
arguments, node->
block, &flags, &keywords, iseq, ret, scope_node, location);
8537 flags |= VM_CALL_SUPER | VM_CALL_FCALL;
8541 pm_scope_node_init(node->
block, &next_scope_node, scope_node);
8543 ISEQ_COMPILE_DATA(iseq)->current_block = current_block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location->
line);
8544 pm_scope_node_destroy(&next_scope_node);
8548 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
8551 if ((flags & VM_CALL_ARGS_BLOCKARG) && (flags & VM_CALL_KW_SPLAT) && !(flags & VM_CALL_KW_SPLAT_MUT)) {
8552 PUSH_INSN(args, *location, splatkw);
8555 PUSH_SEQ(ret, args);
8556 if (is_forwardable && ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.
flags.forwardable) {
8557 flags |= VM_CALL_FORWARDING;
8560 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, current_block != NULL);
8561 PUSH_INSN2(ret, *location, invokesuperforward, callinfo, current_block);
8566 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, current_block != NULL);
8567 PUSH_INSN2(ret, *location, invokesuper, callinfo, current_block);
8572 pm_compile_retry_end_label(iseq, ret, retry_end_l);
8574 if (popped) PUSH_INSN(ret, *location, pop);
8575 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
8576 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, current_block, retry_end_l);
8582 switch (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->
type) {
8584 case ISEQ_TYPE_MAIN:
8585 case ISEQ_TYPE_CLASS:
8586 COMPILE_ERROR(iseq, location->
line,
"Invalid yield");
8596 argc = pm_setup_args(node->
arguments, NULL, &flags, &keywords, iseq, ret, scope_node, location);
8599 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, FALSE);
8600 PUSH_INSN1(ret, *location, invokeblock, callinfo);
8602 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
8603 if (popped) PUSH_INSN(ret, *location, pop);
8606 for (
const rb_iseq_t *tmp_iseq = iseq; tmp_iseq != ISEQ_BODY(iseq)->local_iseq; level++) {
8607 tmp_iseq = ISEQ_BODY(tmp_iseq)->parent_iseq;
8610 if (level > 0) access_outer_variables(iseq, level, rb_intern(
"yield"),
true);
8628 int lineno = (int) location.
line;
8635 lineno = (int) PM_NODE_START_LINE_COLUMN(parser, ((
const pm_begin_node_t *) node)->rescue_clause).line;
8644 ISEQ_COMPILE_DATA(iseq)->last_line = lineno;
8645 if (lineno > 0 && ISEQ_COVERAGE(iseq) && ISEQ_LINE_COVERAGE(iseq)) {
8646 event |= RUBY_EVENT_COVERAGE_LINE;
8648 PUSH_TRACE(ret, event);
8660 pm_compile_alias_method_node(iseq, (
const pm_alias_method_node_t *) node, &location, ret, popped, scope_node);
8665 pm_compile_and_node(iseq, (
const pm_and_node_t *) node, &location, ret, popped, scope_node);
8677 if (elements->
size == 1) {
8680 PM_COMPILE(elements->
nodes[0]);
8683 pm_compile_array_node(iseq, (
const pm_node_t *) cast, elements, &location, ret, popped, scope_node);
8691 pm_compile_array_node(iseq, (
const pm_node_t *) cast, &cast->elements, &location, ret, popped, scope_node);
8702 PM_COMPILE(cast->
key);
8703 PM_COMPILE(cast->
value);
8715 if (cast->
value != NULL) {
8716 PM_COMPILE(cast->
value);
8719 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_POW, 0);
8720 PUSH_GETLOCAL(ret, location, index.index, index.level);
8730 VALUE backref = pm_compile_back_reference_ref(cast);
8732 PUSH_INSN2(ret, location, getspecial,
INT2FIX(1), backref);
8744 pm_compile_ensure(iseq, cast, &location, ret, popped, scope_node);
8748 pm_compile_rescue(iseq, cast, &location, ret, popped, scope_node);
8757 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
8772 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_AND, 0);
8773 PUSH_INSN2(ret, location, getblockparamproxy,
INT2FIX(local_index.index + VM_ENV_DATA_SIZE - 1),
INT2FIX(local_index.level));
8783 pm_compile_break_node(iseq, (
const pm_break_node_t *) node, &location, ret, popped, scope_node);
8794 pm_compile_call_node(iseq, (
const pm_call_node_t *) node, ret, popped, scope_node);
8800 pm_compile_call_and_or_write_node(iseq,
true, cast->
receiver, cast->
value, cast->
write_name, cast->
read_name,
PM_NODE_FLAG_P(cast,
PM_CALL_NODE_FLAGS_SAFE_NAVIGATION), &location, ret, popped, scope_node);
8807 pm_compile_call_and_or_write_node(iseq,
false, cast->
receiver, cast->
value, cast->
write_name, cast->
read_name,
PM_NODE_FLAG_P(cast,
PM_CALL_NODE_FLAGS_SAFE_NAVIGATION), &location, ret, popped, scope_node);
8825 pm_compile_case_node(iseq, (
const pm_case_node_t *) node, &location, ret, popped, scope_node);
8836 pm_compile_case_match_node(iseq, (
const pm_case_match_node_t *) node, &location, ret, popped, scope_node);
8843 ID class_id = pm_constant_id_lookup(scope_node, cast->
name);
8844 VALUE class_name =
rb_str_freeze(rb_sprintf(
"<class:%"PRIsVALUE
">", rb_id2str(class_id)));
8847 pm_scope_node_init((
const pm_node_t *) cast, &next_scope_node, scope_node);
8849 const rb_iseq_t *class_iseq = NEW_CHILD_ISEQ(&next_scope_node, class_name, ISEQ_TYPE_CLASS, location.
line);
8850 pm_scope_node_destroy(&next_scope_node);
8853 const int flags = VM_DEFINECLASS_TYPE_CLASS |
8854 (cast->
superclass ? VM_DEFINECLASS_FLAG_HAS_SUPERCLASS : 0) |
8855 pm_compile_class_path(iseq, cast->
constant_path, &location, ret,
false, scope_node);
8861 PUSH_INSN(ret, location, putnil);
8866 PUSH_INSN3(ret, location, defineclass, operand, class_iseq,
INT2FIX(flags));
8870 if (popped) PUSH_INSN(ret, location, pop);
8877 LABEL *end_label = NEW_LABEL(location.
line);
8879 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
8882 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8883 if (!popped) PUSH_INSN(ret, location, dup);
8885 PUSH_INSNL(ret, location, branchunless, end_label);
8886 if (!popped) PUSH_INSN(ret, location, pop);
8888 PM_COMPILE_NOT_POPPED(cast->
value);
8889 if (!popped) PUSH_INSN(ret, location, dup);
8891 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8892 PUSH_LABEL(ret, end_label);
8901 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
8904 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8905 PM_COMPILE_NOT_POPPED(cast->
value);
8908 int flags = VM_CALL_ARGS_SIMPLE;
8909 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2NUM(1),
INT2FIX(flags));
8911 if (!popped) PUSH_INSN(ret, location, dup);
8912 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8920 LABEL *end_label = NEW_LABEL(location.
line);
8921 LABEL *start_label = NEW_LABEL(location.
line);
8923 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
8926 PUSH_INSN(ret, location, putnil);
8927 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CVAR), name,
Qtrue);
8928 PUSH_INSNL(ret, location, branchunless, start_label);
8930 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8931 if (!popped) PUSH_INSN(ret, location, dup);
8933 PUSH_INSNL(ret, location, branchif, end_label);
8934 if (!popped) PUSH_INSN(ret, location, pop);
8936 PUSH_LABEL(ret, start_label);
8937 PM_COMPILE_NOT_POPPED(cast->
value);
8938 if (!popped) PUSH_INSN(ret, location, dup);
8940 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8941 PUSH_LABEL(ret, end_label);
8950 ID name = pm_constant_id_lookup(scope_node, cast->
name);
8951 PUSH_INSN2(ret, location, getclassvariable,
ID2SYM(name), get_cvar_ic_value(iseq, name));
8959 PM_COMPILE_NOT_POPPED(cast->
value);
8960 if (!popped) PUSH_INSN(ret, location, dup);
8962 ID name = pm_constant_id_lookup(scope_node, cast->
name);
8963 PUSH_INSN2(ret, location, setclassvariable,
ID2SYM(name), get_cvar_ic_value(iseq, name));
8972 if (ISEQ_COMPILE_DATA(iseq)->option->inline_const_cache && ((parts = pm_constant_path_parts(node, scope_node)) !=
Qnil)) {
8973 ISEQ_BODY(iseq)->ic_size++;
8974 PUSH_INSN1(ret, location, opt_getconstant_path, parts);
8977 DECL_ANCHOR(prefix);
8980 pm_compile_constant_path(iseq, node, prefix, body, popped, scope_node);
8981 if (LIST_INSN_SIZE_ZERO(prefix)) {
8982 PUSH_INSN(ret, location, putnil);
8985 PUSH_SEQ(ret, prefix);
8988 PUSH_SEQ(ret, body);
8991 if (popped) PUSH_INSN(ret, location, pop);
8998 pm_compile_constant_path_and_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9005 pm_compile_constant_path_or_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9012 pm_compile_constant_path_operator_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9019 pm_compile_constant_path_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9028 pm_compile_constant_read(iseq, name, &cast->
base.
location, location.
node_id, ret, scope_node);
9029 if (popped) PUSH_INSN(ret, location, pop);
9037 pm_compile_constant_and_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9044 pm_compile_constant_or_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9051 pm_compile_constant_operator_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9058 pm_compile_constant_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
9068 ID method_name = pm_constant_id_lookup(scope_node, cast->
name);
9071 pm_scope_node_init((
const pm_node_t *) cast, &next_scope_node, scope_node);
9073 rb_iseq_t *method_iseq = NEW_ISEQ(&next_scope_node, rb_id2str(method_name), ISEQ_TYPE_METHOD, location.
line);
9074 pm_scope_node_destroy(&next_scope_node);
9077 PM_COMPILE_NOT_POPPED(cast->
receiver);
9078 PUSH_INSN2(ret, location, definesmethod,
ID2SYM(method_name), method_iseq);
9081 PUSH_INSN2(ret, location, definemethod,
ID2SYM(method_name), method_iseq);
9086 PUSH_INSN1(ret, location, putobject,
ID2SYM(method_name));
9095 pm_compile_defined_expr(iseq, cast->
value, &location, ret, popped, scope_node,
false);
9107 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
9110 if (popped) PUSH_INSN(ret, location, pop);
9124 PUSH_INSN1(ret, location, putobject,
Qfalse);
9146 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
9156 LABEL *final_label = NEW_LABEL(location.
line);
9157 LABEL *then_label = NEW_LABEL(location.
line);
9158 LABEL *else_label = NEW_LABEL(location.
line);
9160 pm_compile_flip_flop(cast, else_label, then_label, iseq, location.
line, ret, popped, scope_node);
9162 PUSH_LABEL(ret, then_label);
9163 PUSH_INSN1(ret, location, putobject,
Qtrue);
9164 PUSH_INSNL(ret, location, jump, final_label);
9165 PUSH_LABEL(ret, else_label);
9166 PUSH_INSN1(ret, location, putobject,
Qfalse);
9167 PUSH_LABEL(ret, final_label);
9176 PUSH_INSN1(ret, location, putobject, operand);
9185 LABEL *retry_label = NEW_LABEL(location.
line);
9186 LABEL *retry_end_l = NEW_LABEL(location.
line);
9189 PUSH_LABEL(ret, retry_label);
9195 pm_scope_node_init((
const pm_node_t *) cast, &next_scope_node, scope_node);
9197 const rb_iseq_t *child_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location.
line);
9198 pm_scope_node_destroy(&next_scope_node);
9200 const rb_iseq_t *prev_block = ISEQ_COMPILE_DATA(iseq)->current_block;
9201 ISEQ_COMPILE_DATA(iseq)->current_block = child_iseq;
9205 PUSH_SEND_WITH_BLOCK(ret, location, idEach,
INT2FIX(0), child_iseq);
9206 pm_compile_retry_end_label(iseq, ret, retry_end_l);
9208 if (popped) PUSH_INSN(ret, location, pop);
9209 ISEQ_COMPILE_DATA(iseq)->current_block = prev_block;
9210 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, child_iseq, retry_end_l);
9214 rb_bug(
"Cannot compile a ForwardingArgumentsNode directly\n");
9228 LABEL *end_label = NEW_LABEL(location.
line);
9231 PUSH_INSN1(ret, location, getglobal, name);
9232 if (!popped) PUSH_INSN(ret, location, dup);
9234 PUSH_INSNL(ret, location, branchunless, end_label);
9235 if (!popped) PUSH_INSN(ret, location, pop);
9237 PM_COMPILE_NOT_POPPED(cast->
value);
9238 if (!popped) PUSH_INSN(ret, location, dup);
9240 PUSH_INSN1(ret, location, setglobal, name);
9241 PUSH_LABEL(ret, end_label);
9251 PUSH_INSN1(ret, location, getglobal, name);
9252 PM_COMPILE_NOT_POPPED(cast->
value);
9255 int flags = VM_CALL_ARGS_SIMPLE;
9256 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2NUM(1),
INT2FIX(flags));
9258 if (!popped) PUSH_INSN(ret, location, dup);
9259 PUSH_INSN1(ret, location, setglobal, name);
9267 LABEL *set_label = NEW_LABEL(location.
line);
9268 LABEL *end_label = NEW_LABEL(location.
line);
9270 PUSH_INSN(ret, location, putnil);
9273 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_GVAR), name,
Qtrue);
9274 PUSH_INSNL(ret, location, branchunless, set_label);
9276 PUSH_INSN1(ret, location, getglobal, name);
9277 if (!popped) PUSH_INSN(ret, location, dup);
9279 PUSH_INSNL(ret, location, branchif, end_label);
9280 if (!popped) PUSH_INSN(ret, location, pop);
9282 PUSH_LABEL(ret, set_label);
9283 PM_COMPILE_NOT_POPPED(cast->
value);
9284 if (!popped) PUSH_INSN(ret, location, dup);
9286 PUSH_INSN1(ret, location, setglobal, name);
9287 PUSH_LABEL(ret, end_label);
9297 PUSH_INSN1(ret, location, getglobal, name);
9298 if (popped) PUSH_INSN(ret, location, pop);
9306 PM_COMPILE_NOT_POPPED(cast->
value);
9307 if (!popped) PUSH_INSN(ret, location, dup);
9309 ID name = pm_constant_id_lookup(scope_node, cast->
name);
9310 PUSH_INSN1(ret, location, setglobal,
ID2SYM(name));
9328 PUSH_INSN1(ret, location, newhash,
INT2FIX(0));
9331 VALUE value = pm_static_literal_value(iseq, node, scope_node);
9332 PUSH_INSN1(ret, location, duphash, value);
9353 for (
size_t index = 0; index < elements->
size; index++) {
9354 PM_COMPILE_POPPED(elements->
nodes[index]);
9358 pm_compile_hash_elements(iseq, node, elements, 0,
Qundef,
false, ret, scope_node);
9374 pm_compile_conditional(iseq, &location,
PM_IF_NODE, (
const pm_node_t *) cast, cast->statements, cast->subsequent, cast->predicate, ret, popped, scope_node);
9382 PUSH_INSN1(ret, location, putobject, operand);
9396 PM_COMPILE(cast->
value);
9402 rb_bug(
"Should not ever enter an in node directly");
9409 pm_compile_index_operator_write_node(iseq, cast, &location, ret, popped, scope_node);
9416 pm_compile_index_control_flow_write_node(iseq, node, cast->
receiver, cast->
arguments, cast->
block, cast->
value, &location, ret, popped, scope_node);
9423 pm_compile_index_control_flow_write_node(iseq, node, cast->
receiver, cast->
arguments, cast->
block, cast->
value, &location, ret, popped, scope_node);
9430 LABEL *end_label = NEW_LABEL(location.
line);
9432 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
9435 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9436 if (!popped) PUSH_INSN(ret, location, dup);
9438 PUSH_INSNL(ret, location, branchunless, end_label);
9439 if (!popped) PUSH_INSN(ret, location, pop);
9441 PM_COMPILE_NOT_POPPED(cast->
value);
9442 if (!popped) PUSH_INSN(ret, location, dup);
9444 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9445 PUSH_LABEL(ret, end_label);
9454 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
9457 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9458 PM_COMPILE_NOT_POPPED(cast->
value);
9461 int flags = VM_CALL_ARGS_SIMPLE;
9462 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2NUM(1),
INT2FIX(flags));
9464 if (!popped) PUSH_INSN(ret, location, dup);
9465 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9473 LABEL *end_label = NEW_LABEL(location.
line);
9475 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
9478 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9479 if (!popped) PUSH_INSN(ret, location, dup);
9481 PUSH_INSNL(ret, location, branchif, end_label);
9482 if (!popped) PUSH_INSN(ret, location, pop);
9484 PM_COMPILE_NOT_POPPED(cast->
value);
9485 if (!popped) PUSH_INSN(ret, location, dup);
9487 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9488 PUSH_LABEL(ret, end_label);
9497 ID name = pm_constant_id_lookup(scope_node, cast->
name);
9498 PUSH_INSN2(ret, location, getinstancevariable,
ID2SYM(name), get_ivar_ic_value(iseq, name));
9506 PM_COMPILE_NOT_POPPED(cast->
value);
9507 if (!popped) PUSH_INSN(ret, location, dup);
9509 ID name = pm_constant_id_lookup(scope_node, cast->
name);
9510 PUSH_INSN2(ret, location, setinstancevariable,
ID2SYM(name), get_ivar_ic_value(iseq, name));
9519 PUSH_INSN1(ret, location, putobject, operand);
9528 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9529 PUSH_INSN1(ret, location, putobject, regexp);
9536 PUSH_INSN1(ret, location, getglobal,
rb_id2sym(idLASTLINE));
9537 PUSH_SEND(ret, location, idEqTilde,
INT2NUM(1));
9538 if (popped) PUSH_INSN(ret, location, pop);
9546 const rb_iseq_t *prevblock = ISEQ_COMPILE_DATA(iseq)->current_block;
9548 int ise_index = ISEQ_BODY(iseq)->ise_size++;
9551 pm_scope_node_init(node, &next_scope_node, scope_node);
9553 block_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_PLAIN, location.
line);
9554 pm_scope_node_destroy(&next_scope_node);
9556 ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq;
9557 PUSH_INSN2(ret, location, once, block_iseq,
INT2FIX(ise_index));
9558 ISEQ_COMPILE_DATA(iseq)->current_block = prevblock;
9560 if (popped) PUSH_INSN(ret, location, pop);
9566 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9567 PUSH_INSN1(ret, location, putobject, regexp);
9572 if (popped) PUSH_INSN(ret, location, pop);
9582 VALUE string = pm_static_literal_value(iseq, node, scope_node);
9585 PUSH_INSN1(ret, location, putobject,
string);
9588 PUSH_INSN1(ret, location, putstring,
string);
9591 PUSH_INSN1(ret, location, putchilledstring,
string);
9597 int length = pm_interpolated_node_compile(iseq, &cast->
parts, &location, ret, popped, scope_node, NULL, NULL);
9598 if (length > 1) PUSH_INSN1(ret, location, concatstrings,
INT2FIX(length));
9599 if (popped) PUSH_INSN(ret, location, pop);
9608 int length = pm_interpolated_node_compile(iseq, &cast->
parts, &location, ret, popped, scope_node, NULL, NULL);
9611 PUSH_INSN1(ret, location, concatstrings,
INT2FIX(length));
9615 PUSH_INSN(ret, location, intern);
9618 PUSH_INSN(ret, location, pop);
9628 PUSH_INSN(ret, location, putself);
9630 int length = pm_interpolated_node_compile(iseq, &cast->
parts, &location, ret,
false, scope_node, NULL, NULL);
9631 if (length > 1) PUSH_INSN1(ret, location, concatstrings,
INT2FIX(length));
9633 PUSH_SEND_WITH_FLAG(ret, location, idBackquote,
INT2NUM(1),
INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
9634 if (popped) PUSH_INSN(ret, location, pop);
9642 PUSH_GETLOCAL(ret, location, scope_node->local_table_for_iseq_size, 0);
9655 PM_COMPILE(element);
9658 if (!popped) PUSH_INSN1(ret, location, newhash,
INT2FIX(elements->
size * 2));
9667 pm_scope_node_init(node, &next_scope_node, scope_node);
9669 int opening_lineno = pm_location_line_number(parser, &cast->
opening_loc);
9670 const rb_iseq_t *block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, opening_lineno);
9671 pm_scope_node_destroy(&next_scope_node);
9674 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
9675 PUSH_CALL_WITH_BLOCK(ret, location, idLambda, argc, block);
9678 if (popped) PUSH_INSN(ret, location, pop);
9685 LABEL *end_label = NEW_LABEL(location.
line);
9688 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9689 if (!popped) PUSH_INSN(ret, location, dup);
9691 PUSH_INSNL(ret, location, branchunless, end_label);
9692 if (!popped) PUSH_INSN(ret, location, pop);
9694 PM_COMPILE_NOT_POPPED(cast->
value);
9695 if (!popped) PUSH_INSN(ret, location, dup);
9697 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9698 PUSH_LABEL(ret, end_label);
9708 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9710 PM_COMPILE_NOT_POPPED(cast->
value);
9713 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2NUM(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
9715 if (!popped) PUSH_INSN(ret, location, dup);
9716 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9725 LABEL *set_label = NEW_LABEL(location.
line);
9726 LABEL *end_label = NEW_LABEL(location.
line);
9728 PUSH_INSN1(ret, location, putobject,
Qtrue);
9729 PUSH_INSNL(ret, location, branchunless, set_label);
9732 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9733 if (!popped) PUSH_INSN(ret, location, dup);
9735 PUSH_INSNL(ret, location, branchif, end_label);
9736 if (!popped) PUSH_INSN(ret, location, pop);
9738 PUSH_LABEL(ret, set_label);
9739 PM_COMPILE_NOT_POPPED(cast->
value);
9740 if (!popped) PUSH_INSN(ret, location, dup);
9742 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9743 PUSH_LABEL(ret, end_label);
9753 PUSH_GETLOCAL(ret, location, index.index, index.level);
9762 PM_COMPILE_NOT_POPPED(cast->
value);
9763 if (!popped) PUSH_INSN(ret, location, dup);
9766 PUSH_SETLOCAL(ret, location, index.index, index.level);
9772 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9774 PUSH_INSN1(ret, location, putobject, regexp);
9776 PUSH_SEND(ret, location, idEqTilde,
INT2NUM(1));
9777 if (popped) PUSH_INSN(ret, location, pop);
9788 PUSH_INSN(ret, location, putnil);
9791 PM_COMPILE_NOT_POPPED(cast->
value);
9792 PUSH_INSN(ret, location, dup);
9796 LABEL *matched_label = NEW_LABEL(location.
line);
9797 LABEL *unmatched_label = NEW_LABEL(location.
line);
9798 LABEL *done_label = NEW_LABEL(location.
line);
9799 pm_compile_pattern(iseq, scope_node, cast->
pattern, ret, matched_label, unmatched_label,
false,
false,
true, 2);
9803 PUSH_LABEL(ret, unmatched_label);
9804 PUSH_INSN(ret, location, pop);
9805 PUSH_INSN(ret, location, pop);
9807 if (!popped) PUSH_INSN1(ret, location, putobject,
Qfalse);
9808 PUSH_INSNL(ret, location, jump, done_label);
9809 PUSH_INSN(ret, location, putnil);
9813 PUSH_LABEL(ret, matched_label);
9814 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(2));
9815 if (!popped) PUSH_INSN1(ret, location, putobject,
Qtrue);
9816 PUSH_INSNL(ret, location, jump, done_label);
9818 PUSH_LABEL(ret, done_label);
9844 pm_compile_match_write_node(iseq, (
const pm_match_write_node_t *) node, &location, ret, popped, scope_node);
9847 rb_bug(
"A pm_missing_node_t should not exist in prism's AST.");
9854 ID module_id = pm_constant_id_lookup(scope_node, cast->
name);
9855 VALUE module_name =
rb_str_freeze(rb_sprintf(
"<module:%"PRIsVALUE
">", rb_id2str(module_id)));
9858 pm_scope_node_init((
const pm_node_t *) cast, &next_scope_node, scope_node);
9860 const rb_iseq_t *module_iseq = NEW_CHILD_ISEQ(&next_scope_node, module_name, ISEQ_TYPE_CLASS, location.
line);
9861 pm_scope_node_destroy(&next_scope_node);
9863 const int flags = VM_DEFINECLASS_TYPE_MODULE | pm_compile_class_path(iseq, cast->
constant_path, &location, ret,
false, scope_node);
9864 PUSH_INSN(ret, location, putnil);
9865 PUSH_INSN3(ret, location, defineclass,
ID2SYM(module_id), module_iseq,
INT2FIX(flags));
9868 if (popped) PUSH_INSN(ret, location, pop);
9877 PUSH_SETLOCAL(ret, location, index.index, index.level);
9891 DECL_ANCHOR(writes);
9892 DECL_ANCHOR(cleanup);
9895 state.position = popped ? 0 : 1;
9896 pm_compile_multi_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
9898 PM_COMPILE_NOT_POPPED(cast->
value);
9899 if (!popped) PUSH_INSN(ret, location, dup);
9901 PUSH_SEQ(ret, writes);
9902 if (!popped && state.stack_size >= 1) {
9905 PUSH_INSN1(ret, location, setn,
INT2FIX(state.stack_size));
9910 pm_multi_target_state_update(&state);
9912 PUSH_SEQ(ret, cleanup);
9921 pm_compile_next_node(iseq, (
const pm_next_node_t *) node, &location, ret, popped, scope_node);
9927 PUSH_INSN(ret, location, putnil);
9935 ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg = TRUE;
9945 VALUE ref = pm_compile_numbered_reference_ref(cast);
9946 PUSH_INSN2(ret, location, getspecial,
INT2FIX(1), ref);
9949 PUSH_INSN(ret, location, putnil);
9960 LABEL *end_label = NEW_LABEL(location.
line);
9961 PM_COMPILE_NOT_POPPED(cast->
left);
9963 if (!popped) PUSH_INSN(ret, location, dup);
9964 PUSH_INSNL(ret, location, branchif, end_label);
9966 if (!popped) PUSH_INSN(ret, location, pop);
9967 PM_COMPILE(cast->
right);
9968 PUSH_LABEL(ret, end_label);
9976 PM_COMPILE_NOT_POPPED(cast->
value);
9979 PUSH_SETLOCAL(ret, location, index.index, index.level);
9991 if (cast->
body != NULL) {
9992 PM_COMPILE(cast->
body);
9995 PUSH_INSN(ret, location, putnil);
10012 DECL_ANCHOR(inner_pre);
10015 DECL_ANCHOR(inner_body);
10020 for (
size_t index = 0; index < body->
size; index++) {
10021 pm_compile_node(iseq, body->
nodes[index], inner_body,
true, scope_node);
10026 PUSH_INSN(inner_body, location, putnil);
10032 PUSH_SEQ(outer_pre, inner_pre);
10033 PUSH_SEQ(outer_pre, inner_body);
10042 const rb_iseq_t *prevblock = ISEQ_COMPILE_DATA(iseq)->current_block;
10045 pm_scope_node_init(node, &next_scope_node, scope_node);
10046 child_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, lineno);
10047 pm_scope_node_destroy(&next_scope_node);
10049 ISEQ_COMPILE_DATA(iseq)->current_block = child_iseq;
10051 int is_index = ISEQ_BODY(iseq)->ise_size++;
10052 PUSH_INSN2(ret, location, once, child_iseq,
INT2FIX(is_index));
10054 if (popped) PUSH_INSN(ret, location, pop);
10056 ISEQ_COMPILE_DATA(iseq)->current_block = prevblock;
10066 if (pm_optimizable_range_item_p(cast->
left) && pm_optimizable_range_item_p(cast->
right)) {
10077 PUSH_INSN1(ret, location, putobject, val);
10081 if (cast->
left != NULL) {
10082 PM_COMPILE(cast->
left);
10084 else if (!popped) {
10085 PUSH_INSN(ret, location, putnil);
10088 if (cast->
right != NULL) {
10089 PM_COMPILE(cast->
right);
10091 else if (!popped) {
10092 PUSH_INSN(ret, location, putnil);
10096 PUSH_INSN1(ret, location, newrange,
INT2FIX(exclude_end ? 1 : 0));
10105 PUSH_INSN1(ret, location, putobject, parse_rational((
const pm_rational_node_t *) node));
10112 pm_compile_redo_node(iseq, &location, ret, popped, scope_node);
10118 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
10119 PUSH_INSN1(ret, location, putobject, regexp);
10126 pm_compile_rescue_node(iseq, (
const pm_rescue_node_t *) node, &location, ret, popped, scope_node);
10134 pm_scope_node_init((
const pm_node_t *) cast, &rescue_scope_node, scope_node);
10136 rb_iseq_t *rescue_iseq = NEW_CHILD_ISEQ(
10137 &rescue_scope_node,
10143 pm_scope_node_destroy(&rescue_scope_node);
10145 LABEL *lstart = NEW_LABEL(location.
line);
10146 LABEL *lend = NEW_LABEL(location.
line);
10147 LABEL *lcont = NEW_LABEL(location.
line);
10149 lstart->rescued = LABEL_RESCUE_BEG;
10150 lend->rescued = LABEL_RESCUE_END;
10152 PUSH_LABEL(ret, lstart);
10154 PUSH_LABEL(ret, lend);
10156 PUSH_INSN(ret, location, nop);
10157 PUSH_LABEL(ret, lcont);
10158 if (popped) PUSH_INSN(ret, location, pop);
10160 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue_iseq, lcont);
10161 PUSH_CATCH_ENTRY(CATCH_TYPE_RETRY, lend, lcont, NULL, lstart);
10170 pm_compile_return_node(iseq, (
const pm_return_node_t *) node, &location, ret, popped, scope_node);
10175 if (ISEQ_BODY(iseq)->
type == ISEQ_TYPE_RESCUE) {
10176 PUSH_INSN(ret, location, putnil);
10177 PUSH_INSN1(ret, location,
throw,
INT2FIX(TAG_RETRY));
10178 if (popped) PUSH_INSN(ret, location, pop);
10181 COMPILE_ERROR(iseq, location.
line,
"Invalid retry");
10187 pm_compile_scope_node(iseq, (
pm_scope_node_t *) node, &location, ret, popped);
10193 PUSH_INSN(ret, location, putself);
10229 rb_bug(
"Unexpected node type for shareable constant write: %s", pm_node_type_to_str(
PM_NODE_TYPE(cast->
write)));
10241 pm_scope_node_init((
const pm_node_t *) cast, &next_scope_node, scope_node);
10242 const rb_iseq_t *child_iseq = NEW_ISEQ(&next_scope_node, rb_fstring_lit(
"singleton class"), ISEQ_TYPE_CLASS, location.
line);
10243 pm_scope_node_destroy(&next_scope_node);
10246 PUSH_INSN(ret, location, putnil);
10249 CONST_ID(singletonclass,
"singletonclass");
10250 PUSH_INSN3(ret, location, defineclass,
ID2SYM(singletonclass), child_iseq,
INT2FIX(VM_DEFINECLASS_TYPE_SINGLETON_CLASS));
10252 if (popped) PUSH_INSN(ret, location, pop);
10261 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10262 PUSH_INSN1(ret, location, putobject, value);
10271 VALUE string = pm_source_file_value(cast, scope_node);
10274 PUSH_INSN1(ret, location, putobject,
string);
10277 PUSH_INSN1(ret, location, putstring,
string);
10280 PUSH_INSN1(ret, location, putchilledstring,
string);
10289 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10290 PUSH_INSN1(ret, location, putobject, value);
10303 PUSH_INSN1(ret, location, splatarray,
Qtrue);
10312 if (body->
size > 0) {
10313 for (
size_t index = 0; index < body->
size - 1; index++) {
10314 PM_COMPILE_POPPED(body->
nodes[index]);
10316 PM_COMPILE(body->
nodes[body->
size - 1]);
10319 PUSH_INSN(ret, location, putnil);
10328 VALUE value = parse_static_literal_string(iseq, scope_node, node, &cast->
unescaped);
10331 PUSH_INSN1(ret, location, putobject, value);
10334 PUSH_INSN1(ret, location, putstring, value);
10337 PUSH_INSN1(ret, location, putchilledstring, value);
10346 pm_compile_super_node(iseq, (
const pm_super_node_t *) node, &location, ret, popped, scope_node);
10352 VALUE value = pm_static_literal_value(iseq, node, scope_node);
10353 PUSH_INSN1(ret, location, putobject, value);
10361 PUSH_INSN1(ret, location, putobject,
Qtrue);
10371 for (
size_t index = 0; index < names->
size; index++) {
10372 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
10373 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CBASE));
10375 PM_COMPILE_NOT_POPPED(names->
nodes[index]);
10376 PUSH_SEND(ret, location, id_core_undef_method,
INT2NUM(2));
10378 if (index < names->size - 1) {
10379 PUSH_INSN(ret, location, pop);
10383 if (popped) PUSH_INSN(ret, location, pop);
10398 pm_compile_conditional(iseq, &location,
PM_UNLESS_NODE, (
const pm_node_t *) cast, statements, (
const pm_node_t *) cast->statements, cast->predicate, ret, popped, scope_node);
10408 pm_compile_loop(iseq, &location, cast->
base.
flags,
PM_UNTIL_NODE, (
const pm_node_t *) cast, cast->statements, cast->predicate, ret, popped, scope_node);
10418 pm_compile_loop(iseq, &location, cast->
base.
flags,
PM_WHILE_NODE, (
const pm_node_t *) cast, cast->statements, cast->predicate, ret, popped, scope_node);
10425 VALUE value = parse_static_literal_string(iseq, scope_node, node, &cast->
unescaped);
10427 PUSH_INSN(ret, location, putself);
10428 PUSH_INSN1(ret, location, putobject, value);
10429 PUSH_SEND_WITH_FLAG(ret, location, idBackquote,
INT2NUM(1),
INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
10430 if (popped) PUSH_INSN(ret, location, pop);
10440 pm_compile_yield_node(iseq, (
const pm_yield_node_t *) node, &location, ret, popped, scope_node);
10448#undef PM_CONTAINER_P
10452pm_iseq_pre_execution_p(
rb_iseq_t *iseq)
10454 switch (ISEQ_BODY(iseq)->
type) {
10455 case ISEQ_TYPE_TOP:
10456 case ISEQ_TYPE_EVAL:
10457 case ISEQ_TYPE_MAIN:
10476 if (pm_iseq_pre_execution_p(iseq)) {
10488 pm_compile_node(iseq, (
const pm_node_t *) node, body,
false, node);
10492 PUSH_SEQ(ret, pre);
10493 PUSH_SEQ(ret, body);
10498 pm_compile_node(iseq, (
const pm_node_t *) node, ret,
false, node);
10501 CHECK(iseq_setup_insn(iseq, ret));
10502 return iseq_setup(iseq, ret);
10512 if (result->
node.ast_node != NULL) {
10513 pm_node_destroy(&result->
parser, result->
node.ast_node);
10518 pm_scope_node_destroy(&result->
node);
10521 pm_parser_free(&result->
parser);
10522 pm_string_free(&result->
input);
10523 pm_options_free(&result->
options);
10559#define PM_COLOR_BOLD "\033[1m"
10560#define PM_COLOR_GRAY "\033[2m"
10561#define PM_COLOR_RED "\033[1;31m"
10562#define PM_COLOR_RESET "\033[m"
10563#define PM_ERROR_TRUNCATE 30
10568 if (errors == NULL)
return NULL;
10572 pm_line_column_t start = pm_newline_list_line_column(newline_list, error->location.
start, start_line);
10573 pm_line_column_t end = pm_newline_list_line_column(newline_list, error->location.end, start_line);
10581 (index < error_list->size) &&
10582 (errors[index].error != NULL) &&
10584 (errors[index].line < start.
line) ||
10591 if (index + 1 < error_list->
size) {
10592 memmove(&errors[index + 1], &errors[index],
sizeof(
pm_parse_error_t) * (error_list->
size - index - 1));
10596 uint32_t column_end;
10598 column_end = end.
column;
10600 column_end = (uint32_t) (newline_list->
offsets[start.
line - start_line + 1] - newline_list->
offsets[start.
line - start_line] - 1);
10604 if (start.
column == column_end) column_end++;
10608 .line = start.
line,
10609 .column_start = start.
column,
10610 .column_end = column_end
10618#define pm_buffer_append_literal(buffer, str) pm_buffer_append_string(buffer, str, rb_strlen_lit(str))
10621pm_parse_errors_format_line(
const pm_parser_t *parser,
const pm_newline_list_t *newline_list,
const char *number_prefix, int32_t line, uint32_t column_start, uint32_t column_end,
pm_buffer_t *buffer) {
10622 int32_t line_delta = line - parser->
start_line;
10623 assert(line_delta >= 0);
10625 size_t index = (size_t) line_delta;
10626 assert(index < newline_list->size);
10628 const uint8_t *start = &parser->
start[newline_list->
offsets[index]];
10629 const uint8_t *end;
10631 if (index >= newline_list->
size - 1) {
10634 end = &parser->
start[newline_list->
offsets[index + 1]];
10637 pm_buffer_append_format(buffer, number_prefix, line);
10640 bool truncate_end =
false;
10641 if ((column_end != 0) && ((end - (start + column_end)) >= PM_ERROR_TRUNCATE)) {
10642 end = start + column_end + PM_ERROR_TRUNCATE;
10643 truncate_end =
true;
10647 if (column_start >= PM_ERROR_TRUNCATE) {
10648 pm_buffer_append_string(buffer,
"... ", 4);
10649 start += column_start;
10652 pm_buffer_append_string(buffer, (
const char *) start, (
size_t) (end - start));
10654 if (truncate_end) {
10655 pm_buffer_append_string(buffer,
" ...\n", 5);
10656 }
else if (end == parser->
end && end[-1] !=
'\n') {
10657 pm_buffer_append_string(buffer,
"\n", 1);
10666 assert(error_list->
size != 0);
10670 const int32_t start_line = parser->
start_line;
10673 pm_parse_error_t *errors = pm_parse_errors_format_sort(parser, error_list, newline_list);
10674 if (errors == NULL)
return;
10680 int32_t first_line_number = errors[0].
line;
10681 int32_t last_line_number = errors[error_list->
size - 1].
line;
10686 if (first_line_number < 0) first_line_number = (-first_line_number) * 10;
10687 if (last_line_number < 0) last_line_number = (-last_line_number) * 10;
10688 int32_t max_line_number = first_line_number > last_line_number ? first_line_number : last_line_number;
10690 if (max_line_number < 10) {
10691 if (highlight > 0) {
10693 .
number_prefix = PM_COLOR_GRAY
"%1" PRIi32
" | " PM_COLOR_RESET,
10694 .blank_prefix = PM_COLOR_GRAY
" | " PM_COLOR_RESET,
10695 .divider = PM_COLOR_GRAY
" ~~~~~" PM_COLOR_RESET
"\n"
10700 .blank_prefix =
" | ",
10701 .divider =
" ~~~~~\n"
10704 }
else if (max_line_number < 100) {
10705 if (highlight > 0) {
10707 .
number_prefix = PM_COLOR_GRAY
"%2" PRIi32
" | " PM_COLOR_RESET,
10708 .blank_prefix = PM_COLOR_GRAY
" | " PM_COLOR_RESET,
10709 .divider = PM_COLOR_GRAY
" ~~~~~~" PM_COLOR_RESET
"\n"
10714 .blank_prefix =
" | ",
10715 .divider =
" ~~~~~~\n"
10718 }
else if (max_line_number < 1000) {
10719 if (highlight > 0) {
10721 .
number_prefix = PM_COLOR_GRAY
"%3" PRIi32
" | " PM_COLOR_RESET,
10722 .blank_prefix = PM_COLOR_GRAY
" | " PM_COLOR_RESET,
10723 .divider = PM_COLOR_GRAY
" ~~~~~~~" PM_COLOR_RESET
"\n"
10728 .blank_prefix =
" | ",
10729 .divider =
" ~~~~~~~\n"
10732 }
else if (max_line_number < 10000) {
10733 if (highlight > 0) {
10735 .
number_prefix = PM_COLOR_GRAY
"%4" PRIi32
" | " PM_COLOR_RESET,
10736 .blank_prefix = PM_COLOR_GRAY
" | " PM_COLOR_RESET,
10737 .divider = PM_COLOR_GRAY
" ~~~~~~~~" PM_COLOR_RESET
"\n"
10742 .blank_prefix =
" | ",
10743 .divider =
" ~~~~~~~~\n"
10747 if (highlight > 0) {
10749 .
number_prefix = PM_COLOR_GRAY
"%5" PRIi32
" | " PM_COLOR_RESET,
10750 .blank_prefix = PM_COLOR_GRAY
" | " PM_COLOR_RESET,
10751 .divider = PM_COLOR_GRAY
" ~~~~~~~~" PM_COLOR_RESET
"\n"
10756 .blank_prefix =
" | ",
10757 .divider =
" ~~~~~~~~\n"
10771 uint32_t last_column_start = 0;
10774 for (
size_t index = 0; index < error_list->
size; index++) {
10779 if (error->
line - last_line > 1) {
10780 if (error->
line - last_line > 2) {
10781 if ((index != 0) && (error->
line - last_line > 3)) {
10785 pm_buffer_append_string(buffer,
" ", 2);
10786 pm_parse_errors_format_line(parser, newline_list, error_format.
number_prefix, error->
line - 2, 0, 0, buffer);
10789 pm_buffer_append_string(buffer,
" ", 2);
10790 pm_parse_errors_format_line(parser, newline_list, error_format.
number_prefix, error->
line - 1, 0, 0, buffer);
10795 if ((index == 0) || (error->
line != last_line)) {
10796 if (highlight > 1) {
10797 pm_buffer_append_literal(buffer, PM_COLOR_RED
"> " PM_COLOR_RESET);
10798 }
else if (highlight > 0) {
10799 pm_buffer_append_literal(buffer, PM_COLOR_BOLD
"> " PM_COLOR_RESET);
10801 pm_buffer_append_literal(buffer,
"> ");
10808 for (
size_t next_index = index + 1; next_index < error_list->
size; next_index++) {
10809 if (errors[next_index].line != error->
line)
break;
10810 if (errors[next_index].column_end > column_end) column_end = errors[next_index].
column_end;
10816 const uint8_t *start = &parser->
start[newline_list->
offsets[error->
line - start_line]];
10817 if (start == parser->
end) pm_buffer_append_byte(buffer,
'\n');
10828 pm_buffer_append_string(buffer,
" ", 2);
10832 if (last_column_start >= PM_ERROR_TRUNCATE) {
10833 pm_buffer_append_string(buffer,
" ", 4);
10834 column = last_column_start;
10837 while (column < error->column_start) {
10838 pm_buffer_append_byte(buffer,
' ');
10840 size_t char_width = encoding->
char_width(start + column, parser->
end - (start + column));
10841 column += (char_width == 0 ? 1 : char_width);
10844 if (highlight > 1) pm_buffer_append_literal(buffer, PM_COLOR_RED);
10845 else if (highlight > 0) pm_buffer_append_literal(buffer, PM_COLOR_BOLD);
10846 pm_buffer_append_byte(buffer,
'^');
10848 size_t char_width = encoding->
char_width(start + column, parser->
end - (start + column));
10849 column += (char_width == 0 ? 1 : char_width);
10851 while (column < error->column_end) {
10852 pm_buffer_append_byte(buffer,
'~');
10854 size_t char_width = encoding->
char_width(start + column, parser->
end - (start + column));
10855 column += (char_width == 0 ? 1 : char_width);
10858 if (highlight > 0) pm_buffer_append_literal(buffer, PM_COLOR_RESET);
10860 if (inline_messages) {
10861 pm_buffer_append_byte(buffer,
' ');
10862 assert(error->
error != NULL);
10865 pm_buffer_append_string(buffer, message, strlen(message));
10868 pm_buffer_append_byte(buffer,
'\n');
10872 last_line = error->
line;
10875 if (index == error_list->
size - 1) {
10876 next_line = (((int32_t) newline_list->
size) + parser->
start_line);
10885 next_line = errors[index + 1].
line;
10888 if (next_line - last_line > 1) {
10889 pm_buffer_append_string(buffer,
" ", 2);
10890 pm_parse_errors_format_line(parser, newline_list, error_format.
number_prefix, ++last_line, 0, 0, buffer);
10893 if (next_line - last_line > 1) {
10894 pm_buffer_append_string(buffer,
" ", 2);
10895 pm_parse_errors_format_line(parser, newline_list, error_format.
number_prefix, ++last_line, 0, 0, buffer);
10903#undef PM_ERROR_TRUNCATE
10904#undef PM_COLOR_GRAY
10906#undef PM_COLOR_RESET
10917 const size_t start_line = pm_newline_list_line_column(&parser->
newline_list, location->
start, 1).
line;
10918 const size_t end_line = pm_newline_list_line_column(&parser->
newline_list, location->
end, 1).
line;
10921 const uint8_t *end = ((end_line == parser->
newline_list.
size) ? parser->
end : (parser->start + parser->newline_list.offsets[end_line]));
10924 while (start < end) {
10925 if ((width = pm_encoding_utf_8_char_width(start, end - start)) == 0)
return false;
10941 bool valid_utf8 =
true;
10946 int highlight = rb_stderr_tty_p();
10948 const char *no_color = getenv(
"NO_COLOR");
10949 highlight = (no_color == NULL || no_color[0] ==
'\0') ? 2 : 1;
10953 switch (error->level) {
10960 if (valid_utf8 && !pm_parse_process_error_utf8_p(parser, &error->location)) {
10961 valid_utf8 =
false;
10968 int32_t line_number = (int32_t) pm_location_line_number(parser, &error->location);
10970 pm_buffer_append_format(
10972 "%.*s:%" PRIi32
": %s",
10973 (
int) pm_string_length(filepath),
10974 pm_string_source(filepath),
10979 if (pm_parse_process_error_utf8_p(parser, &error->location)) {
10980 pm_buffer_append_byte(&buffer,
'\n');
10983 pm_list_t error_list = { .
size = 1, .head = list_node, .tail = list_node };
10985 pm_parse_errors_format(parser, &error_list, &buffer, highlight,
false);
10988 VALUE value =
rb_exc_new(rb_eArgError, pm_buffer_value(&buffer), pm_buffer_length(&buffer));
10989 pm_buffer_free(&buffer);
11005 pm_buffer_append_format(
11007 "%.*s:%" PRIi32
": syntax error%s found\n",
11008 (
int) pm_string_length(filepath),
11009 pm_string_source(filepath),
11010 (int32_t) pm_location_line_number(parser, &head->location),
11015 pm_parse_errors_format(parser, &parser->
error_list, &buffer, highlight,
true);
11019 if (error != head) pm_buffer_append_byte(&buffer,
'\n');
11020 pm_buffer_append_format(&buffer,
"%.*s:%" PRIi32
": %s", (
int) pm_string_length(filepath), pm_string_source(filepath), (int32_t) pm_location_line_number(parser, &error->location), error->message);
11024 VALUE message = rb_enc_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer), result->
node.encoding);
11028 VALUE path = rb_enc_str_new((
const char *) pm_string_source(filepath), pm_string_length(filepath), filepath_encoding);
11031 pm_buffer_free(&buffer);
11050 int coverage_enabled = scope_node->coverage_enabled;
11052 pm_scope_node_init(node, scope_node, NULL);
11055 scope_node->encoding = rb_enc_find(parser->
encoding->
name);
11056 if (!scope_node->encoding) rb_bug(
"Encoding not found %s!", parser->
encoding->
name);
11058 scope_node->coverage_enabled = coverage_enabled;
11062 if (script_lines != NULL) {
11068 rb_ary_push(*script_lines, rb_enc_str_new((
const char *) parser->
start + offset, length, scope_node->encoding));
11076 const char *warning_filepath = (
const char *) pm_string_source(&parser->
filepath);
11079 int line = pm_location_line_number(parser, &warning->
location);
11082 rb_enc_compile_warning(scope_node->encoding, warning_filepath, line,
"%s", warning->
message);
11085 rb_enc_compile_warn(scope_node->encoding, warning_filepath, line,
"%s", warning->
message);
11091 VALUE error = pm_parse_process_error(result);
11100 scope_node->parser = parser;
11105 scope_node->constants[index] = rb_intern3((
const char *) constant->
start, constant->
length, scope_node->encoding);
11108 scope_node->index_lookup_table = st_init_numtable();
11110 for (
size_t index = 0; index < locals->
size; index++) {
11111 st_insert(scope_node->index_lookup_table, locals->
ids[index], index);
11125pm_options_frozen_string_literal_init(
pm_options_t *options)
11127 int frozen_string_literal = rb_iseq_opt_frozen_string_literal();
11129 switch (frozen_string_literal) {
11130 case ISEQ_FROZEN_STRING_LITERAL_UNSET:
11132 case ISEQ_FROZEN_STRING_LITERAL_DISABLED:
11133 pm_options_frozen_string_literal_set(options,
false);
11135 case ISEQ_FROZEN_STRING_LITERAL_ENABLED:
11136 pm_options_frozen_string_literal_set(options,
true);
11139 rb_bug(
"pm_options_frozen_string_literal_init: invalid frozen_string_literal=%d", frozen_string_literal);
11152 const char *start = (
const char *) parser->
start;
11153 const char *end = (
const char *) parser->
end;
11158 size_t last_offset = newline_list->
offsets[newline_list->
size - 1];
11159 bool last_push = start + last_offset != end;
11162 VALUE lines = rb_ary_new_capa(newline_list->
size - (last_push ? 0 : 1));
11164 for (
size_t index = 0; index < newline_list->
size - 1; index++) {
11165 size_t offset = newline_list->
offsets[index];
11166 size_t length = newline_list->
offsets[index + 1] - offset;
11168 rb_ary_push(lines, rb_enc_str_new(start + offset, length, scope_node->encoding));
11173 rb_ary_push(lines, rb_enc_str_new(start + last_offset, end - (start + last_offset), scope_node->encoding));
11183pm_read_file(
pm_string_t *
string,
const char *filepath)
11187 int length = MultiByteToWideChar(CP_UTF8, 0, filepath, -1, NULL, 0);
11190 WCHAR *wfilepath =
xmalloc(
sizeof(WCHAR) * ((
size_t) length));
11191 if ((wfilepath == NULL) || (MultiByteToWideChar(CP_UTF8, 0, filepath, -1, wfilepath, length) == 0)) {
11196 HANDLE file = CreateFileW(wfilepath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
11197 if (file == INVALID_HANDLE_VALUE) {
11200 if (GetLastError() == ERROR_ACCESS_DENIED) {
11201 DWORD attributes = GetFileAttributesW(wfilepath);
11202 if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
11212 DWORD file_size = GetFileSize(file, NULL);
11213 if (file_size == INVALID_FILE_SIZE) {
11221 if (file_size == 0) {
11224 const uint8_t source[] =
"";
11225 *
string = (
pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
11230 HANDLE mapping = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
11231 if (mapping == NULL) {
11238 uint8_t *source = (uint8_t *) MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
11239 CloseHandle(mapping);
11243 if (source == NULL) {
11247 *
string = (
pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = (size_t) file_size };
11249#elif defined(_POSIX_MAPPED_FILES)
11251 const int open_mode = O_RDONLY | O_NONBLOCK;
11252 int fd = open(filepath, open_mode);
11259 if (fstat(fd, &sb) == -1) {
11265 if (S_ISDIR(sb.st_mode)) {
11273 if (S_ISFIFO(sb.st_mode) || S_ISCHR(sb.st_mode)) {
11282 long len = RSTRING_LEN(contents);
11287 size_t length = (size_t)
len;
11288 uint8_t *source = malloc(length);
11289 memcpy(source, RSTRING_PTR(contents), length);
11290 *
string = (
pm_string_t) { .type = PM_STRING_OWNED, .source = source, .length = length };
11296 size_t size = (size_t) sb.st_size;
11297 uint8_t *source = NULL;
11301 const uint8_t source[] =
"";
11302 *
string = (
pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
11306 source = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
11307 if (source == MAP_FAILED) {
11313 *
string = (
pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = size };
11316 return pm_string_file_init(
string, filepath);
11330 pm_options_frozen_string_literal_init(&result->
options);
11339 err = rb_w32_map_errno(GetLastError());
11371 pm_options_filepath_set(&result->
options, RSTRING_PTR(filepath));
11374 pm_parser_init(&result->
parser, pm_string_source(&result->
input), pm_string_length(&result->
input), &result->
options);
11377 VALUE error = pm_parse_process(result, node, script_lines);
11382 ID id_script_lines = rb_intern(
"SCRIPT_LINES__");
11388 rb_hash_aset(constant_script_lines, filepath, pm_parse_file_script_lines(&result->
node, &result->
parser));
11402 VALUE error = pm_load_file(result, filepath,
false);
11403 if (
NIL_P(error)) {
11404 error = pm_parse_file(result, filepath, script_lines);
11420 if (!rb_enc_asciicompat(encoding)) {
11424 pm_options_frozen_string_literal_init(&result->
options);
11425 pm_string_constant_init(&result->
input, RSTRING_PTR(source), RSTRING_LEN(source));
11426 pm_options_encoding_set(&result->
options, rb_enc_name(encoding));
11429 pm_options_filepath_set(&result->
options, RSTRING_PTR(filepath));
11432 pm_parser_init(&result->
parser, pm_string_source(&result->
input), pm_string_length(&result->
input), &result->
options);
11435 return pm_parse_process(result, node, script_lines);
11442pm_parse_stdin_fgets(
char *
string,
int size,
void *stream)
11451 const char *cstr = RSTRING_PTR(line);
11452 long length = RSTRING_LEN(line);
11454 memcpy(
string, cstr, length);
11455 string[length] =
'\0';
11461void rb_reset_argf_lineno(
long n);
11471 pm_options_frozen_string_literal_init(&result->
options);
11479 pm_string_owned_init(&result->
input, (uint8_t *) pm_buffer_value(&buffer), pm_buffer_length(&buffer));
11483 rb_reset_argf_lineno(0);
11485 return pm_parse_process(result, node, NULL);
11489#define NEW_ISEQ OLD_ISEQ
11491#undef NEW_CHILD_ISEQ
11492#define NEW_CHILD_ISEQ OLD_CHILD_ISEQ
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
@ PM_INTERPOLATED_STRING_NODE_FLAGS_MUTABLE
mutable by virtue of a frozen_string_literal: false comment or --disable-frozen-string-literal; only ...
@ PM_INTERPOLATED_STRING_NODE_FLAGS_FROZEN
frozen by virtue of a frozen_string_literal: true comment or --enable-frozen-string-literal; only for...
@ PM_RANGE_FLAGS_EXCLUDE_END
... operator
pm_node_type
This enum represents every type of node in the Ruby syntax tree.
@ PM_DEFINED_NODE
DefinedNode.
@ PM_PRE_EXECUTION_NODE
PreExecutionNode.
@ PM_RETRY_NODE
RetryNode.
@ PM_CONSTANT_PATH_WRITE_NODE
ConstantPathWriteNode.
@ PM_INDEX_AND_WRITE_NODE
IndexAndWriteNode.
@ PM_SOURCE_LINE_NODE
SourceLineNode.
@ PM_UNLESS_NODE
UnlessNode.
@ PM_EMBEDDED_VARIABLE_NODE
EmbeddedVariableNode.
@ PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE
GlobalVariableOperatorWriteNode.
@ PM_GLOBAL_VARIABLE_READ_NODE
GlobalVariableReadNode.
@ PM_RATIONAL_NODE
RationalNode.
@ PM_YIELD_NODE
YieldNode.
@ PM_LOCAL_VARIABLE_AND_WRITE_NODE
LocalVariableAndWriteNode.
@ PM_CONSTANT_AND_WRITE_NODE
ConstantAndWriteNode.
@ PM_CLASS_NODE
ClassNode.
@ PM_FIND_PATTERN_NODE
FindPatternNode.
@ PM_CALL_OPERATOR_WRITE_NODE
CallOperatorWriteNode.
@ PM_MATCH_WRITE_NODE
MatchWriteNode.
@ PM_ARRAY_NODE
ArrayNode.
@ PM_CONSTANT_PATH_TARGET_NODE
ConstantPathTargetNode.
@ PM_PROGRAM_NODE
ProgramNode.
@ PM_MULTI_WRITE_NODE
MultiWriteNode.
@ PM_IMPLICIT_NODE
ImplicitNode.
@ PM_ARGUMENTS_NODE
ArgumentsNode.
@ PM_FORWARDING_SUPER_NODE
ForwardingSuperNode.
@ PM_WHILE_NODE
WhileNode.
@ PM_INTERPOLATED_STRING_NODE
InterpolatedStringNode.
@ PM_FALSE_NODE
FalseNode.
@ PM_FORWARDING_PARAMETER_NODE
ForwardingParameterNode.
@ PM_BLOCK_LOCAL_VARIABLE_NODE
BlockLocalVariableNode.
@ PM_UNTIL_NODE
UntilNode.
@ PM_MATCH_PREDICATE_NODE
MatchPredicateNode.
@ PM_X_STRING_NODE
XStringNode.
@ PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE
LocalVariableOperatorWriteNode.
@ PM_LOCAL_VARIABLE_OR_WRITE_NODE
LocalVariableOrWriteNode.
@ PM_INSTANCE_VARIABLE_AND_WRITE_NODE
InstanceVariableAndWriteNode.
@ PM_GLOBAL_VARIABLE_TARGET_NODE
GlobalVariableTargetNode.
@ PM_CONSTANT_TARGET_NODE
ConstantTargetNode.
@ PM_IT_LOCAL_VARIABLE_READ_NODE
ItLocalVariableReadNode.
@ PM_CONSTANT_PATH_AND_WRITE_NODE
ConstantPathAndWriteNode.
@ PM_BLOCK_PARAMETER_NODE
BlockParameterNode.
@ PM_CAPTURE_PATTERN_NODE
CapturePatternNode.
@ PM_SOURCE_FILE_NODE
SourceFileNode.
@ PM_NO_KEYWORDS_PARAMETER_NODE
NoKeywordsParameterNode.
@ PM_CONSTANT_PATH_OPERATOR_WRITE_NODE
ConstantPathOperatorWriteNode.
@ PM_MULTI_TARGET_NODE
MultiTargetNode.
@ PM_SPLAT_NODE
SplatNode.
@ PM_LAMBDA_NODE
LambdaNode.
@ PM_CLASS_VARIABLE_READ_NODE
ClassVariableReadNode.
@ PM_REQUIRED_KEYWORD_PARAMETER_NODE
RequiredKeywordParameterNode.
@ PM_CALL_TARGET_NODE
CallTargetNode.
@ PM_INTERPOLATED_MATCH_LAST_LINE_NODE
InterpolatedMatchLastLineNode.
@ PM_NUMBERED_PARAMETERS_NODE
NumberedParametersNode.
@ PM_SYMBOL_NODE
SymbolNode.
@ PM_RESCUE_MODIFIER_NODE
RescueModifierNode.
@ PM_ALIAS_METHOD_NODE
AliasMethodNode.
@ PM_MATCH_REQUIRED_NODE
MatchRequiredNode.
@ PM_FORWARDING_ARGUMENTS_NODE
ForwardingArgumentsNode.
@ PM_BACK_REFERENCE_READ_NODE
BackReferenceReadNode.
@ PM_SCOPE_NODE
A special kind of node used for compilation.
@ PM_BLOCK_ARGUMENT_NODE
BlockArgumentNode.
@ PM_MISSING_NODE
MissingNode.
@ PM_IMPLICIT_REST_NODE
ImplicitRestNode.
@ PM_ASSOC_SPLAT_NODE
AssocSplatNode.
@ PM_CLASS_VARIABLE_AND_WRITE_NODE
ClassVariableAndWriteNode.
@ PM_RANGE_NODE
RangeNode.
@ PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE
InstanceVariableOperatorWriteNode.
@ PM_LOCAL_VARIABLE_READ_NODE
LocalVariableReadNode.
@ PM_SHAREABLE_CONSTANT_NODE
ShareableConstantNode.
@ PM_INSTANCE_VARIABLE_OR_WRITE_NODE
InstanceVariableOrWriteNode.
@ PM_REGULAR_EXPRESSION_NODE
RegularExpressionNode.
@ PM_CLASS_VARIABLE_OR_WRITE_NODE
ClassVariableOrWriteNode.
@ PM_BLOCK_PARAMETERS_NODE
BlockParametersNode.
@ PM_CONSTANT_WRITE_NODE
ConstantWriteNode.
@ PM_HASH_PATTERN_NODE
HashPatternNode.
@ PM_INDEX_OPERATOR_WRITE_NODE
IndexOperatorWriteNode.
@ PM_UNDEF_NODE
UndefNode.
@ PM_ALTERNATION_PATTERN_NODE
AlternationPatternNode.
@ PM_ENSURE_NODE
EnsureNode.
@ PM_LOCAL_VARIABLE_WRITE_NODE
LocalVariableWriteNode.
@ PM_SINGLETON_CLASS_NODE
SingletonClassNode.
@ PM_KEYWORD_HASH_NODE
KeywordHashNode.
@ PM_PARENTHESES_NODE
ParenthesesNode.
@ PM_CLASS_VARIABLE_WRITE_NODE
ClassVariableWriteNode.
@ PM_POST_EXECUTION_NODE
PostExecutionNode.
@ PM_CONSTANT_OPERATOR_WRITE_NODE
ConstantOperatorWriteNode.
@ PM_RETURN_NODE
ReturnNode.
@ PM_MODULE_NODE
ModuleNode.
@ PM_ARRAY_PATTERN_NODE
ArrayPatternNode.
@ PM_SUPER_NODE
SuperNode.
@ PM_MATCH_LAST_LINE_NODE
MatchLastLineNode.
@ PM_CONSTANT_PATH_NODE
ConstantPathNode.
@ PM_INTERPOLATED_SYMBOL_NODE
InterpolatedSymbolNode.
@ PM_CALL_AND_WRITE_NODE
CallAndWriteNode.
@ PM_OPTIONAL_KEYWORD_PARAMETER_NODE
OptionalKeywordParameterNode.
@ PM_CLASS_VARIABLE_TARGET_NODE
ClassVariableTargetNode.
@ PM_CASE_MATCH_NODE
CaseMatchNode.
@ PM_BREAK_NODE
BreakNode.
@ PM_CALL_OR_WRITE_NODE
CallOrWriteNode.
@ PM_IMAGINARY_NODE
ImaginaryNode.
@ PM_CONSTANT_READ_NODE
ConstantReadNode.
@ PM_GLOBAL_VARIABLE_WRITE_NODE
GlobalVariableWriteNode.
@ PM_SOURCE_ENCODING_NODE
SourceEncodingNode.
@ PM_BEGIN_NODE
BeginNode.
@ PM_INTERPOLATED_X_STRING_NODE
InterpolatedXStringNode.
@ PM_INSTANCE_VARIABLE_READ_NODE
InstanceVariableReadNode.
@ PM_FLIP_FLOP_NODE
FlipFlopNode.
@ PM_PINNED_VARIABLE_NODE
PinnedVariableNode.
@ PM_REQUIRED_PARAMETER_NODE
RequiredParameterNode.
@ PM_INSTANCE_VARIABLE_WRITE_NODE
InstanceVariableWriteNode.
@ PM_INSTANCE_VARIABLE_TARGET_NODE
InstanceVariableTargetNode.
@ PM_GLOBAL_VARIABLE_AND_WRITE_NODE
GlobalVariableAndWriteNode.
@ PM_RESCUE_NODE
RescueNode.
@ PM_FLOAT_NODE
FloatNode.
@ PM_ASSOC_NODE
AssocNode.
@ PM_IT_PARAMETERS_NODE
ItParametersNode.
@ PM_INTEGER_NODE
IntegerNode.
@ PM_LOCAL_VARIABLE_TARGET_NODE
LocalVariableTargetNode.
@ PM_STRING_NODE
StringNode.
@ PM_INDEX_OR_WRITE_NODE
IndexOrWriteNode.
@ PM_ALIAS_GLOBAL_VARIABLE_NODE
AliasGlobalVariableNode.
@ PM_PARAMETERS_NODE
ParametersNode.
@ PM_NUMBERED_REFERENCE_READ_NODE
NumberedReferenceReadNode.
@ PM_CONSTANT_PATH_OR_WRITE_NODE
ConstantPathOrWriteNode.
@ PM_GLOBAL_VARIABLE_OR_WRITE_NODE
GlobalVariableOrWriteNode.
@ PM_CONSTANT_OR_WRITE_NODE
ConstantOrWriteNode.
@ PM_STATEMENTS_NODE
StatementsNode.
@ PM_OPTIONAL_PARAMETER_NODE
OptionalParameterNode.
@ PM_PINNED_EXPRESSION_NODE
PinnedExpressionNode.
@ PM_BLOCK_NODE
BlockNode.
@ PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE
ClassVariableOperatorWriteNode.
@ PM_REST_PARAMETER_NODE
RestParameterNode.
@ PM_EMBEDDED_STATEMENTS_NODE
EmbeddedStatementsNode.
@ PM_INTERPOLATED_REGULAR_EXPRESSION_NODE
InterpolatedRegularExpressionNode.
@ PM_INDEX_TARGET_NODE
IndexTargetNode.
@ PM_KEYWORD_REST_PARAMETER_NODE
KeywordRestParameterNode.
static const pm_node_flags_t PM_NODE_FLAG_NEWLINE
We store the flags enum in every node in the tree.
@ PM_SYMBOL_FLAGS_FORCED_UTF8_ENCODING
internal bytes forced the encoding to UTF-8
@ PM_SYMBOL_FLAGS_FORCED_US_ASCII_ENCODING
internal bytes forced the encoding to US-ASCII
@ PM_SYMBOL_FLAGS_FORCED_BINARY_ENCODING
internal bytes forced the encoding to binary
@ PM_STRING_FLAGS_FROZEN
frozen by virtue of a frozen_string_literal: true comment or --enable-frozen-string-literal
@ PM_STRING_FLAGS_FORCED_BINARY_ENCODING
internal bytes forced the encoding to binary
@ PM_STRING_FLAGS_MUTABLE
mutable by virtue of a frozen_string_literal: false comment or --disable-frozen-string-literal
@ PM_STRING_FLAGS_FORCED_UTF8_ENCODING
internal bytes forced the encoding to UTF-8
@ PM_ARGUMENTS_NODE_FLAGS_CONTAINS_SPLAT
if the arguments contain a splat
@ PM_ARGUMENTS_NODE_FLAGS_CONTAINS_FORWARDING
if the arguments contain forwarding
@ PM_ARGUMENTS_NODE_FLAGS_CONTAINS_KEYWORD_SPLAT
if the arguments contain a keyword splat
@ PM_ARGUMENTS_NODE_FLAGS_CONTAINS_MULTIPLE_SPLATS
if the arguments contain multiple splats
#define PM_NODE_FLAG_P(node, flag)
Return true if the given flag is set on the given node.
#define PM_NODE_TYPE_P(node, type)
Return true if the type of the given node matches the given type.
#define PM_NODE_TYPE(node)
Cast the type to an enum to allow the compiler to provide exhaustiveness checking.
@ PM_PARENTHESES_NODE_FLAGS_MULTIPLE_STATEMENTS
parentheses that contain multiple potentially void statements
@ PM_CALL_NODE_FLAGS_IGNORE_VISIBILITY
a call that ignores method visibility
@ PM_CALL_NODE_FLAGS_SAFE_NAVIGATION
&.
@ PM_CALL_NODE_FLAGS_ATTRIBUTE_WRITE
a call that is an attribute write, so the value being written should be returned
@ PM_CALL_NODE_FLAGS_VARIABLE_CALL
a call that could have been a local variable
@ PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_EVERYTHING
constant writes that should be modified with shareable constant value experimental everything
@ PM_SHAREABLE_CONSTANT_NODE_FLAGS_LITERAL
constant writes that should be modified with shareable constant value literal
@ PM_SHAREABLE_CONSTANT_NODE_FLAGS_EXPERIMENTAL_COPY
constant writes that should be modified with shareable constant value experimental copy
uint16_t pm_node_type_t
This is the type of node embedded in the node struct.
@ PM_KEYWORD_HASH_NODE_FLAGS_SYMBOL_KEYS
a keyword hash which only has AssocNode elements all with symbol keys, which means the elements can b...
@ PM_REGULAR_EXPRESSION_FLAGS_FORCED_BINARY_ENCODING
internal bytes forced the encoding to binary
@ PM_REGULAR_EXPRESSION_FLAGS_EUC_JP
e - forces the EUC-JP encoding
@ PM_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE
i - ignores the case of characters when matching
@ PM_REGULAR_EXPRESSION_FLAGS_ASCII_8BIT
n - forces the ASCII-8BIT encoding
@ PM_REGULAR_EXPRESSION_FLAGS_MULTI_LINE
m - allows $ to match the end of lines within strings
@ PM_REGULAR_EXPRESSION_FLAGS_EXTENDED
x - ignores whitespace and allows comments in regular expressions
@ PM_REGULAR_EXPRESSION_FLAGS_ONCE
o - only interpolates values into the regular expression once
@ PM_REGULAR_EXPRESSION_FLAGS_WINDOWS_31J
s - forces the Windows-31J encoding
@ PM_REGULAR_EXPRESSION_FLAGS_UTF_8
u - forces the UTF-8 encoding
uint16_t pm_node_flags_t
These are the flags embedded in the node struct.
@ PM_PARAMETER_FLAGS_REPEATED_PARAMETER
a parameter name that has been repeated in the method signature
@ PM_ENCODING_FLAGS_FORCED_BINARY_ENCODING
internal bytes forced the encoding to binary
@ PM_ENCODING_FLAGS_FORCED_UTF8_ENCODING
internal bytes forced the encoding to UTF-8
@ PM_LOOP_FLAGS_BEGIN_MODIFIER
a loop after a begin statement, so the body is executed first before the condition
@ PM_WARNING_LEVEL_VERBOSE
For warnings which should be emitted if $VERBOSE == true.
@ PM_ERROR_LEVEL_ARGUMENT
For errors that should raise an argument error.
@ PM_ERROR_LEVEL_LOAD
For errors that should raise a load error.
@ PM_ERROR_LEVEL_SYNTAX
For errors that should raise a syntax error.
#define RUBY_EVENT_END
Encountered an end of a class clause.
#define RUBY_EVENT_B_RETURN
Encountered a next statement.
#define RUBY_EVENT_CLASS
Encountered a new class.
#define RUBY_EVENT_LINE
Encountered a new line.
#define RUBY_EVENT_RETURN
Encountered a return statement.
#define RUBY_EVENT_B_CALL
Encountered an yield statement.
#define RUBY_EVENT_CALL
A method, written in Ruby, is called.
#define RUBY_EVENT_RESCUE
Encountered a rescue statement.
#define rb_str_new2
Old name of rb_str_new_cstr.
#define ALLOCV
Old name of RB_ALLOCV.
#define ALLOC
Old name of RB_ALLOC.
#define RFLOAT_VALUE
Old name of rb_float_value.
#define T_STRING
Old name of RUBY_T_STRING.
#define xfree
Old name of ruby_xfree.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define rb_str_cat2
Old name of rb_str_cat_cstr.
#define ID2SYM
Old name of RB_ID2SYM.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define ULONG2NUM
Old name of RB_ULONG2NUM.
#define FIXABLE
Old name of RB_FIXABLE.
#define xmalloc
Old name of ruby_xmalloc.
#define LONG2FIX
Old name of RB_INT2FIX.
#define ZALLOC_N
Old name of RB_ZALLOC_N.
#define T_HASH
Old name of RUBY_T_HASH.
#define ALLOC_N
Old name of RB_ALLOC_N.
#define rb_exc_new3
Old name of rb_exc_new_str.
#define Qtrue
Old name of RUBY_Qtrue.
#define INT2NUM
Old name of RB_INT2NUM.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define NIL_P
Old name of RB_NIL_P.
#define DBL2NUM
Old name of rb_float_new.
#define xcalloc
Old name of ruby_xcalloc.
#define NUM2LONG
Old name of RB_NUM2LONG.
#define UINT2NUM
Old name of RB_UINT2NUM.
#define CONST_ID
Old name of RUBY_CONST_ID.
#define ruby_debug
This variable controls whether the interpreter is in debug mode.
VALUE rb_eNotImpError
NotImplementedError exception.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
VALUE rb_eStandardError
StandardError exception.
VALUE rb_eLoadError
LoadError exception.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eNoMatchingPatternError
NoMatchingPatternError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
VALUE rb_exc_new(VALUE etype, const char *ptr, long len)
Creates an instance of the passed exception class.
VALUE rb_eNoMatchingPatternKeyError
NoMatchingPatternKeyError exception.
VALUE rb_exc_new_str(VALUE etype, VALUE str)
Identical to rb_exc_new_cstr(), except it takes a Ruby's string instead of C's.
VALUE rb_eSyntaxError
SyntaxError exception.
VALUE rb_syserr_new(int n, const char *mesg)
Creates an exception object that represents the given C errno.
VALUE rb_cArray
Array class.
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
VALUE rb_stdin
STDIN constant.
VALUE rb_obj_freeze(VALUE obj)
Just calls rb_obj_freeze_inline() inside.
#define RB_OBJ_WRITTEN(old, oldv, young)
Identical to RB_OBJ_WRITE(), except it doesn't write any values, but only a WB declaration.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
int rb_enc_str_coderange(VALUE str)
Scans the passed string to collect its code range.
VALUE rb_enc_interned_str(const char *ptr, long len, rb_encoding *enc)
Identical to rb_enc_str_new(), except it returns a "f"string.
VALUE rb_enc_str_new_cstr(const char *ptr, rb_encoding *enc)
Identical to rb_enc_str_new(), except it assumes the passed pointer is a pointer to a C string.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
VALUE rb_io_fdopen(int fd, int flags, const char *path)
Creates an IO instance whose backend is the given file descriptor.
VALUE rb_range_new(VALUE beg, VALUE end, int excl)
Creates a new Range.
VALUE rb_rational_new(VALUE num, VALUE den)
Constructs a Rational, with reduction.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
VALUE rb_str_tmp_new(long len)
Allocates a "temporary" string.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
#define rb_exc_new_cstr(exc, str)
Identical to rb_exc_new(), except it assumes the passed pointer is a pointer to a C string.
#define rb_str_buf_new_cstr(str)
Identical to rb_str_new_cstr, except done differently.
VALUE rb_str_concat(VALUE dst, VALUE src)
Identical to rb_str_append(), except it also accepts an integer as a codepoint.
VALUE rb_str_freeze(VALUE str)
This is the implementation of String#freeze.
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
VALUE rb_obj_as_string(VALUE obj)
Try converting an object to its stringised representation using its to_s method, if any.
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
VALUE rb_const_get_at(VALUE space, ID name)
Identical to rb_const_defined_at(), except it returns the actual defined value.
int rb_const_defined_at(VALUE space, ID name)
Identical to rb_const_defined(), except it doesn't look for parent classes.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
VALUE rb_id2sym(ID id)
Allocates an instance of rb_cSymbol that has the given id.
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
@ RUBY_IO_READABLE
IO::READABLE
VALUE rb_io_wait(VALUE io, VALUE events, VALUE timeout)
Blocks until the passed IO is ready for the passed events.
int len
Length of the buffer.
VALUE rb_ractor_make_shareable(VALUE obj)
Destructively transforms the passed object so that multiple Ractors can share it.
#define DECIMAL_SIZE_OF(expr)
An approximation of decimal representation size.
#define RB_INT2NUM
Just another name of rb_int2num_inline.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
VALUE type(ANYARGS)
ANYARGS-ed function type.
uint32_t pm_constant_id_t
A constant id is a unique identifier for a constant in the constant pool.
pm_string_init_result_t
Represents the result of calling pm_string_mapped_init or pm_string_file_init.
@ PM_STRING_INIT_SUCCESS
Indicates that the string was successfully initialized.
@ PM_STRING_INIT_ERROR_GENERIC
Indicates a generic error from a string_*_init function, where the type of error should be read from ...
@ PM_STRING_INIT_ERROR_DIRECTORY
Indicates that the file that was attempted to be opened was a directory.
#define PM_ENCODING_US_ASCII_ENTRY
This is the US-ASCII encoding.
#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 main header file for the prism parser.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY_AREF(a, i)
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
#define errno
Ractor-aware version of errno.
#define RTEST
This is an old name of RB_TEST.
struct pm_node * old_name
AliasGlobalVariableNode::old_name.
struct pm_node * new_name
AliasGlobalVariableNode::new_name.
struct pm_node * old_name
AliasMethodNode::old_name.
struct pm_node * new_name
AliasMethodNode::new_name.
struct pm_node * left
AlternationPatternNode::left.
struct pm_node * right
AlternationPatternNode::right.
struct pm_node * left
AndNode::left.
struct pm_node * right
AndNode::right.
pm_node_t base
The embedded base node.
struct pm_node_list arguments
ArgumentsNode::arguments.
struct pm_node_list elements
ArrayNode::elements.
struct pm_node_list requireds
ArrayPatternNode::requireds.
struct pm_node * rest
ArrayPatternNode::rest.
struct pm_node * constant
ArrayPatternNode::constant.
struct pm_node_list posts
ArrayPatternNode::posts.
struct pm_node * value
AssocNode::value.
struct pm_node * key
AssocNode::key.
struct pm_node * value
AssocSplatNode::value.
pm_node_t base
The embedded base node.
struct pm_ensure_node * ensure_clause
BeginNode::ensure_clause.
struct pm_rescue_node * rescue_clause
BeginNode::rescue_clause.
struct pm_statements_node * statements
BeginNode::statements.
struct pm_else_node * else_clause
BeginNode::else_clause.
struct pm_node * expression
BlockArgumentNode::expression.
struct pm_node * parameters
BlockNode::parameters.
struct pm_node * body
BlockNode::body.
pm_constant_id_list_t locals
BlockNode::locals.
struct pm_arguments_node * arguments
BreakNode::arguments.
A pm_buffer_t is a simple memory buffer that stores data in a contiguous block of memory.
struct pm_node * value
CallAndWriteNode::value.
pm_constant_id_t read_name
CallAndWriteNode::read_name.
pm_constant_id_t write_name
CallAndWriteNode::write_name.
struct pm_node * receiver
CallAndWriteNode::receiver.
pm_location_t closing_loc
CallNode::closing_loc.
struct pm_node * receiver
CallNode::receiver.
pm_constant_id_t name
CallNode::name.
pm_node_t base
The embedded base node.
pm_location_t message_loc
CallNode::message_loc.
struct pm_arguments_node * arguments
CallNode::arguments.
struct pm_node * block
CallNode::block.
pm_constant_id_t read_name
CallOperatorWriteNode::read_name.
pm_constant_id_t binary_operator
CallOperatorWriteNode::binary_operator.
struct pm_node * receiver
CallOperatorWriteNode::receiver.
pm_constant_id_t write_name
CallOperatorWriteNode::write_name.
struct pm_node * value
CallOperatorWriteNode::value.
struct pm_node * receiver
CallOrWriteNode::receiver.
struct pm_node * value
CallOrWriteNode::value.
pm_constant_id_t write_name
CallOrWriteNode::write_name.
pm_constant_id_t read_name
CallOrWriteNode::read_name.
pm_constant_id_t name
CallTargetNode::name.
struct pm_node * receiver
CallTargetNode::receiver.
struct pm_local_variable_target_node * target
CapturePatternNode::target.
struct pm_node * value
CapturePatternNode::value.
struct pm_node_list conditions
CaseMatchNode::conditions.
struct pm_else_node * else_clause
CaseMatchNode::else_clause.
struct pm_node * predicate
CaseMatchNode::predicate.
struct pm_node * predicate
CaseNode::predicate.
struct pm_else_node * else_clause
CaseNode::else_clause.
struct pm_node_list conditions
CaseNode::conditions.
struct pm_node * constant_path
ClassNode::constant_path.
pm_constant_id_list_t locals
ClassNode::locals.
pm_constant_id_t name
ClassNode::name.
struct pm_node * body
ClassNode::body.
struct pm_node * superclass
ClassNode::superclass.
ClassVariableAndWriteNode.
struct pm_node * value
ClassVariableAndWriteNode::value.
pm_constant_id_t name
ClassVariableAndWriteNode::name.
ClassVariableOperatorWriteNode.
pm_constant_id_t name
ClassVariableOperatorWriteNode::name.
pm_constant_id_t binary_operator
ClassVariableOperatorWriteNode::binary_operator.
struct pm_node * value
ClassVariableOperatorWriteNode::value.
ClassVariableOrWriteNode.
pm_constant_id_t name
ClassVariableOrWriteNode::name.
struct pm_node * value
ClassVariableOrWriteNode::value.
pm_constant_id_t name
ClassVariableReadNode::name.
pm_constant_id_t name
ClassVariableTargetNode::name.
struct pm_node * value
ClassVariableWriteNode::value.
pm_constant_id_t name
ClassVariableWriteNode::name.
pm_location_t name_loc
ConstantAndWriteNode::name_loc.
pm_constant_id_t name
ConstantAndWriteNode::name.
struct pm_node * value
ConstantAndWriteNode::value.
size_t size
The number of constant ids in the list.
size_t capacity
The number of constant ids that have been allocated in the list.
pm_constant_id_t * ids
The constant ids in the list.
ConstantOperatorWriteNode.
pm_constant_id_t name
ConstantOperatorWriteNode::name.
pm_location_t name_loc
ConstantOperatorWriteNode::name_loc.
pm_constant_id_t binary_operator
ConstantOperatorWriteNode::binary_operator.
struct pm_node * value
ConstantOperatorWriteNode::value.
pm_location_t name_loc
ConstantOrWriteNode::name_loc.
pm_constant_id_t name
ConstantOrWriteNode::name.
struct pm_node * value
ConstantOrWriteNode::value.
ConstantPathAndWriteNode.
struct pm_constant_path_node * target
ConstantPathAndWriteNode::target.
struct pm_node * value
ConstantPathAndWriteNode::value.
pm_constant_id_t name
ConstantPathNode::name.
struct pm_node * parent
ConstantPathNode::parent.
ConstantPathOperatorWriteNode.
struct pm_constant_path_node * target
ConstantPathOperatorWriteNode::target.
struct pm_node * value
ConstantPathOperatorWriteNode::value.
pm_constant_id_t binary_operator
ConstantPathOperatorWriteNode::binary_operator.
struct pm_node * value
ConstantPathOrWriteNode::value.
struct pm_constant_path_node * target
ConstantPathOrWriteNode::target.
struct pm_node * parent
ConstantPathTargetNode::parent.
pm_constant_id_t name
ConstantPathTargetNode::name.
struct pm_constant_path_node * target
ConstantPathWriteNode::target.
struct pm_node * value
ConstantPathWriteNode::value.
uint32_t size
The number of buckets in the hash map.
pm_constant_t * constants
The constants that are stored in the buckets.
pm_node_t base
The embedded base node.
pm_constant_id_t name
ConstantReadNode::name.
A constant in the pool which effectively stores a string.
size_t length
The length of the string.
const uint8_t * start
A pointer to the start of the string.
pm_constant_id_t name
ConstantTargetNode::name.
struct pm_node * value
ConstantWriteNode::value.
pm_constant_id_t name
ConstantWriteNode::name.
struct pm_parameters_node * parameters
DefNode::parameters.
pm_constant_id_t name
DefNode::name.
struct pm_node * body
DefNode::body.
struct pm_node * receiver
DefNode::receiver.
pm_node_t base
The embedded base node.
pm_constant_id_list_t locals
DefNode::locals.
struct pm_node * value
DefinedNode::value.
This struct represents a diagnostic generated during parsing.
pm_location_t location
The location of the diagnostic in the source.
const char * message
The message associated with the diagnostic.
pm_list_node_t node
The embedded base node.
uint8_t level
The level of the diagnostic, see pm_error_level_t and pm_warning_level_t for possible values.
struct pm_statements_node * statements
ElseNode::statements.
struct pm_statements_node * statements
EmbeddedStatementsNode::statements.
struct pm_node * variable
EmbeddedVariableNode::variable.
This struct defines the functions necessary to implement the encoding interface so we can determine h...
size_t(* char_width)(const uint8_t *b, ptrdiff_t n)
Return the number of bytes that the next character takes if it is valid in the encoding.
const char * name
The name of the encoding.
struct pm_statements_node * statements
EnsureNode::statements.
struct pm_node * constant
FindPatternNode::constant.
struct pm_node * right
FindPatternNode::right.
struct pm_node_list requireds
FindPatternNode::requireds.
struct pm_splat_node * left
FindPatternNode::left.
pm_node_t base
The embedded base node.
struct pm_node * left
FlipFlopNode::left.
struct pm_node * right
FlipFlopNode::right.
double value
FloatNode::value.
struct pm_statements_node * statements
ForNode::statements.
struct pm_node * collection
ForNode::collection.
struct pm_block_node * block
ForwardingSuperNode::block.
GlobalVariableAndWriteNode.
struct pm_node * value
GlobalVariableAndWriteNode::value.
pm_constant_id_t name
GlobalVariableAndWriteNode::name.
GlobalVariableOperatorWriteNode.
pm_constant_id_t name
GlobalVariableOperatorWriteNode::name.
pm_constant_id_t binary_operator
GlobalVariableOperatorWriteNode::binary_operator.
struct pm_node * value
GlobalVariableOperatorWriteNode::value.
GlobalVariableOrWriteNode.
pm_constant_id_t name
GlobalVariableOrWriteNode::name.
struct pm_node * value
GlobalVariableOrWriteNode::value.
pm_constant_id_t name
GlobalVariableReadNode::name.
GlobalVariableTargetNode.
pm_constant_id_t name
GlobalVariableTargetNode::name.
struct pm_node * value
GlobalVariableWriteNode::value.
pm_constant_id_t name
GlobalVariableWriteNode::name.
struct pm_node_list elements
HashNode::elements.
struct pm_node_list elements
HashPatternNode::elements.
struct pm_node * rest
HashPatternNode::rest.
struct pm_node * constant
HashPatternNode::constant.
struct pm_node * predicate
IfNode::predicate.
struct pm_statements_node * statements
IfNode::statements.
struct pm_node * numeric
ImaginaryNode::numeric.
struct pm_node * value
ImplicitNode::value.
struct pm_statements_node * statements
InNode::statements.
struct pm_node * pattern
InNode::pattern.
struct pm_arguments_node * arguments
IndexAndWriteNode::arguments.
struct pm_node * receiver
IndexAndWriteNode::receiver.
struct pm_block_argument_node * block
IndexAndWriteNode::block.
struct pm_node * value
IndexAndWriteNode::value.
struct pm_block_argument_node * block
IndexOperatorWriteNode::block.
struct pm_node * value
IndexOperatorWriteNode::value.
struct pm_arguments_node * arguments
IndexOperatorWriteNode::arguments.
pm_constant_id_t binary_operator
IndexOperatorWriteNode::binary_operator.
struct pm_node * receiver
IndexOperatorWriteNode::receiver.
struct pm_block_argument_node * block
IndexOrWriteNode::block.
struct pm_node * receiver
IndexOrWriteNode::receiver.
struct pm_node * value
IndexOrWriteNode::value.
struct pm_arguments_node * arguments
IndexOrWriteNode::arguments.
struct pm_node * receiver
IndexTargetNode::receiver.
struct pm_arguments_node * arguments
IndexTargetNode::arguments.
struct pm_block_argument_node * block
IndexTargetNode::block.
InstanceVariableAndWriteNode.
struct pm_node * value
InstanceVariableAndWriteNode::value.
pm_constant_id_t name
InstanceVariableAndWriteNode::name.
InstanceVariableOperatorWriteNode.
struct pm_node * value
InstanceVariableOperatorWriteNode::value.
pm_constant_id_t binary_operator
InstanceVariableOperatorWriteNode::binary_operator.
pm_constant_id_t name
InstanceVariableOperatorWriteNode::name.
InstanceVariableOrWriteNode.
struct pm_node * value
InstanceVariableOrWriteNode::value.
pm_constant_id_t name
InstanceVariableOrWriteNode::name.
InstanceVariableReadNode.
pm_constant_id_t name
InstanceVariableReadNode::name.
InstanceVariableTargetNode.
pm_constant_id_t name
InstanceVariableTargetNode::name.
InstanceVariableWriteNode.
pm_constant_id_t name
InstanceVariableWriteNode::name.
struct pm_node * value
InstanceVariableWriteNode::value.
pm_integer_t value
IntegerNode::value.
A structure represents an arbitrary-sized integer.
size_t length
The number of allocated values.
uint32_t value
Embedded value for small integer.
uint32_t * values
List of 32-bit integers.
bool negative
Whether or not the integer is negative.
InterpolatedMatchLastLineNode.
InterpolatedRegularExpressionNode.
struct pm_node_list parts
InterpolatedStringNode::parts.
struct pm_node_list parts
InterpolatedSymbolNode::parts.
struct pm_node_list parts
InterpolatedXStringNode::parts.
struct pm_node_list elements
KeywordHashNode::elements.
KeywordRestParameterNode.
struct pm_node * body
LambdaNode::body.
pm_location_t opening_loc
LambdaNode::opening_loc.
struct pm_node * parameters
LambdaNode::parameters.
pm_location_t operator_loc
LambdaNode::operator_loc.
pm_constant_id_list_t locals
LambdaNode::locals.
A line and column in a string.
uint32_t column
The column number.
int32_t line
The line number.
This struct represents an abstract linked list that provides common functionality.
struct pm_list_node * next
A pointer to the next node in the list.
This represents the overall linked list.
pm_list_node_t * head
A pointer to the head of the list.
size_t size
The size of the list.
the getlocal and setlocal instructions require two parameters.
LocalVariableAndWriteNode.
pm_constant_id_t name
LocalVariableAndWriteNode::name.
uint32_t depth
LocalVariableAndWriteNode::depth.
struct pm_node * value
LocalVariableAndWriteNode::value.
LocalVariableOperatorWriteNode.
uint32_t depth
LocalVariableOperatorWriteNode::depth.
pm_constant_id_t binary_operator
LocalVariableOperatorWriteNode::binary_operator.
struct pm_node * value
LocalVariableOperatorWriteNode::value.
pm_constant_id_t name
LocalVariableOperatorWriteNode::name.
LocalVariableOrWriteNode.
uint32_t depth
LocalVariableOrWriteNode::depth.
struct pm_node * value
LocalVariableOrWriteNode::value.
pm_constant_id_t name
LocalVariableOrWriteNode::name.
uint32_t depth
LocalVariableReadNode::depth.
pm_constant_id_t name
LocalVariableReadNode::name.
uint32_t depth
LocalVariableTargetNode::depth.
pm_constant_id_t name
LocalVariableTargetNode::name.
struct pm_node * value
LocalVariableWriteNode::value.
uint32_t depth
LocalVariableWriteNode::depth.
pm_constant_id_t name
LocalVariableWriteNode::name.
This represents a range of bytes in the source string to which a node or token corresponds.
const uint8_t * start
A pointer to the start location of the range in the source.
const uint8_t * end
A pointer to the end location of the range in the source.
struct pm_node * pattern
MatchPredicateNode::pattern.
struct pm_node * value
MatchPredicateNode::value.
struct pm_node * value
MatchRequiredNode::value.
struct pm_node * pattern
MatchRequiredNode::pattern.
struct pm_node_list targets
MatchWriteNode::targets.
struct pm_call_node * call
MatchWriteNode::call.
struct pm_node * constant_path
ModuleNode::constant_path.
struct pm_node * body
ModuleNode::body.
pm_constant_id_list_t locals
ModuleNode::locals.
pm_constant_id_t name
ModuleNode::name.
struct pm_node_list lefts
MultiTargetNode::lefts.
struct pm_node * rest
MultiTargetNode::rest.
struct pm_node_list rights
MultiTargetNode::rights.
This is a node in the multi target state linked list.
As we're compiling a multi target, we need to track additional information whenever there is a parent...
struct pm_node * value
MultiWriteNode::value.
struct pm_node * rest
MultiWriteNode::rest.
struct pm_node_list rights
MultiWriteNode::rights.
struct pm_node_list lefts
MultiWriteNode::lefts.
A list of offsets of newlines in a string.
const uint8_t * start
A pointer to the start of the source string.
size_t * offsets
The list of offsets.
size_t size
The number of offsets in the list.
struct pm_arguments_node * arguments
NextNode::arguments.
A list of nodes in the source, most often used for lists of children.
size_t size
The number of nodes in the list.
struct pm_node ** nodes
The nodes in the list.
This compiler defines its own concept of the location of a node.
int32_t line
This is the line number of a node.
uint32_t node_id
This is a unique identifier for the node.
This is the base structure that represents a node in the syntax tree.
pm_node_type_t type
This represents the type of the node.
uint32_t node_id
The unique identifier for this node, which is deterministic based on the source.
pm_node_flags_t flags
This represents any flags on the node.
pm_location_t location
This is the location of the node in the source.
NumberedReferenceReadNode.
uint32_t number
NumberedReferenceReadNode::number.
OptionalKeywordParameterNode.
pm_constant_id_t name
OptionalKeywordParameterNode::name.
struct pm_node * value
OptionalKeywordParameterNode::value.
struct pm_node * value
OptionalParameterNode::value.
pm_constant_id_t name
OptionalParameterNode::name.
The options that can be passed to the parser.
struct pm_node * left
OrNode::left.
struct pm_node * right
OrNode::right.
struct pm_node * rest
ParametersNode::rest.
struct pm_node_list requireds
ParametersNode::requireds.
struct pm_block_parameter_node * block
ParametersNode::block.
struct pm_node_list optionals
ParametersNode::optionals.
struct pm_node_list posts
ParametersNode::posts.
pm_node_t base
The embedded base node.
struct pm_node * keyword_rest
ParametersNode::keyword_rest.
struct pm_node_list keywords
ParametersNode::keywords.
struct pm_node * body
ParenthesesNode::body.
An error that is going to be formatted into the output.
pm_diagnostic_t * error
A pointer to the diagnostic that was generated during parsing.
uint32_t column_end
The column end of the diagnostic message.
int32_t line
The start line of the diagnostic message.
uint32_t column_start
The column start of the diagnostic message.
bool parsed
Whether or not this parse result has performed its parsing yet.
pm_scope_node_t node
The resulting scope node that will hold the generated AST.
pm_string_t input
The input that represents the source to be parsed.
pm_parser_t parser
The parser that will do the actual parsing.
pm_options_t options
The options that will be passed to the parser.
This struct represents the overall parser.
const pm_encoding_t * encoding
The encoding functions for the current file is attached to the parser as it's parsing so that it can ...
const uint8_t * end
The pointer to the end of the source.
pm_constant_pool_t constant_pool
This constant pool keeps all of the constants defined throughout the file so that we can reference th...
const uint8_t * start
The pointer to the start of the source.
pm_list_t error_list
The list of errors that have been found while parsing.
pm_list_t warning_list
The list of warnings that have been found while parsing.
int32_t start_line
The line number at the start of the parse.
pm_string_t filepath
This is the path of the file being parsed.
pm_newline_list_t newline_list
This is the list of newline offsets in the source file.
struct pm_node * variable
PinnedVariableNode::variable.
struct pm_statements_node * statements
PostExecutionNode::statements.
struct pm_statements_node * statements
PreExecutionNode::statements.
struct pm_statements_node * statements
ProgramNode::statements.
struct pm_node * right
RangeNode::right.
struct pm_node * left
RangeNode::left.
pm_integer_t denominator
RationalNode::denominator.
pm_integer_t numerator
RationalNode::numerator.
RequiredKeywordParameterNode.
pm_constant_id_t name
RequiredParameterNode::name.
struct pm_node * rescue_expression
RescueModifierNode::rescue_expression.
struct pm_node * expression
RescueModifierNode::expression.
struct pm_rescue_node * subsequent
RescueNode::subsequent.
struct pm_node * reference
RescueNode::reference.
struct pm_node_list exceptions
RescueNode::exceptions.
struct pm_statements_node * statements
RescueNode::statements.
struct pm_arguments_node * arguments
ReturnNode::arguments.
rb_encoding * filepath_encoding
This is the encoding of the actual filepath object that will be used when a FILE node is compiled or ...
struct iseq_link_anchor * pre_execution_anchor
This will only be set on the top-level scope node.
VALUE * script_lines
This is a pointer to the list of script lines for the ISEQs that will be associated with this scope n...
struct pm_node * write
ShareableConstantNode::write.
pm_node_t base
The embedded base node.
pm_constant_id_list_t locals
SingletonClassNode::locals.
struct pm_node * expression
SingletonClassNode::expression.
struct pm_node * body
SingletonClassNode::body.
pm_string_t filepath
SourceFileNode::filepath.
struct pm_node * expression
SplatNode::expression.
struct pm_node_list body
StatementsNode::body.
pm_node_t base
The embedded base node.
pm_string_t unescaped
StringNode::unescaped.
A generic string type that can have various ownership semantics.
struct pm_arguments_node * arguments
SuperNode::arguments.
struct pm_node * block
SuperNode::block.
pm_string_t unescaped
SymbolNode::unescaped.
pm_node_t base
The embedded base node.
struct pm_node_list names
UndefNode::names.
struct pm_statements_node * statements
UnlessNode::statements.
struct pm_node * predicate
UnlessNode::predicate.
struct pm_else_node * else_clause
UnlessNode::else_clause.
pm_node_t base
The embedded base node.
pm_node_t base
The embedded base node.
pm_string_t unescaped
XStringNode::unescaped.
struct pm_arguments_node * arguments
YieldNode::arguments.
struct rb_iseq_constant_body::@155 param
parameter information
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.