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_SPECIAL_CONSTANT_FLAG ((pm_constant_id_t)(1 << 31))
142#define PM_CONSTANT_AND ((pm_constant_id_t)(idAnd | PM_SPECIAL_CONSTANT_FLAG))
143#define PM_CONSTANT_DOT3 ((pm_constant_id_t)(idDot3 | PM_SPECIAL_CONSTANT_FLAG))
144#define PM_CONSTANT_MULT ((pm_constant_id_t)(idMULT | PM_SPECIAL_CONSTANT_FLAG))
145#define PM_CONSTANT_POW ((pm_constant_id_t)(idPow | PM_SPECIAL_CONSTANT_FLAG))
147#define PM_NODE_START_LOCATION(parser, node) \
148 ((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 })
150#define PM_NODE_END_LOCATION(parser, node) \
151 ((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 })
153#define PM_LOCATION_START_LOCATION(parser, location, id) \
154 ((pm_node_location_t) { .line = pm_newline_list_line(&(parser)->newline_list, (location)->start, (parser)->start_line), .node_id = id })
156#define PM_NODE_START_LINE_COLUMN(parser, node) \
157 pm_newline_list_line_column(&(parser)->newline_list, ((const pm_node_t *) (node))->location.start, (parser)->start_line)
159#define PM_NODE_END_LINE_COLUMN(parser, node) \
160 pm_newline_list_line_column(&(parser)->newline_list, ((const pm_node_t *) (node))->location.end, (parser)->start_line)
162#define PM_LOCATION_START_LINE_COLUMN(parser, location) \
163 pm_newline_list_line_column(&(parser)->newline_list, (location)->start, (parser)->start_line)
184 if (integer->
values == NULL) {
189 unsigned char *bytes = (
unsigned char *) RSTRING_PTR(
string);
191 size_t offset = integer->
length * 8;
192 for (
size_t value_index = 0; value_index < integer->
length; value_index++) {
193 uint32_t value = integer->
values[value_index];
195 for (
int index = 0; index < 8; index++) {
196 int byte = (value >> (4 * index)) & 0xf;
197 bytes[--offset] =
byte < 10 ?
byte +
'0' :
byte - 10 +
'a';
205 result =
rb_funcall(result, rb_intern(
"-@"), 0);
217 return parse_integer_value(&node->
value);
252 VALUE imaginary_part;
267 rb_bug(
"Unexpected numeric type on imaginary number %s\n", pm_node_type_to_str(
PM_NODE_TYPE(node->
numeric)));
270 return rb_complex_raw(
INT2FIX(0), imaginary_part);
274parse_string(
const pm_scope_node_t *scope_node,
const pm_string_t *
string)
276 return rb_enc_str_new((
const char *) pm_string_source(
string), pm_string_length(
string), scope_node->encoding);
287 rb_encoding *encoding;
290 encoding = rb_ascii8bit_encoding();
293 encoding = rb_utf8_encoding();
299 return rb_enc_str_new((
const char *) pm_string_source(
string), pm_string_length(
string), encoding);
303parse_static_literal_string(rb_iseq_t *iseq,
const pm_scope_node_t *scope_node,
const pm_node_t *node,
const pm_string_t *
string)
305 rb_encoding *encoding;
308 encoding = rb_ascii8bit_encoding();
311 encoding = rb_utf8_encoding();
314 encoding = scope_node->encoding;
317 VALUE value = rb_enc_literal_str((
const char *) pm_string_source(
string), pm_string_length(
string), encoding);
320 if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal ||
RTEST(
ruby_debug)) {
321 int line_number = pm_node_line_number(scope_node->parser, node);
322 value = rb_str_with_debug_created_info(value, rb_iseq_path(iseq), line_number);
329parse_string_symbol(
const pm_scope_node_t *scope_node,
const pm_symbol_node_t *symbol)
331 rb_encoding *encoding;
333 encoding = rb_utf8_encoding();
336 encoding = rb_ascii8bit_encoding();
339 encoding = rb_usascii_encoding();
342 encoding = scope_node->encoding;
345 return rb_intern3((
const char *) pm_string_source(&symbol->
unescaped), pm_string_length(&symbol->
unescaped), encoding);
349pm_optimizable_range_item_p(
const pm_node_t *node)
356parse_regexp_error(rb_iseq_t *iseq, int32_t line_number,
const char *fmt, ...)
360 VALUE error = rb_syntax_error_append(
Qnil, rb_iseq_path(iseq), line_number, -1, NULL,
"%" PRIsVALUE, args);
366parse_regexp_string_part(rb_iseq_t *iseq,
const pm_scope_node_t *scope_node,
const pm_node_t *node,
const pm_string_t *unescaped, rb_encoding *implicit_regexp_encoding, rb_encoding *explicit_regexp_encoding)
370 rb_encoding *encoding;
372 if (explicit_regexp_encoding != NULL) {
373 encoding = explicit_regexp_encoding;
376 encoding = rb_ascii8bit_encoding();
379 encoding = rb_utf8_encoding();
382 encoding = implicit_regexp_encoding;
385 VALUE string = rb_enc_str_new((
const char *) pm_string_source(unescaped), pm_string_length(unescaped), encoding);
386 VALUE error = rb_reg_check_preprocess(
string);
388 if (error !=
Qnil) parse_regexp_error(iseq, pm_node_line_number(scope_node->parser, node),
"%" PRIsVALUE, rb_obj_as_string(error));
393pm_static_literal_concat(rb_iseq_t *iseq,
const pm_node_list_t *nodes,
const pm_scope_node_t *scope_node, rb_encoding *implicit_regexp_encoding, rb_encoding *explicit_regexp_encoding,
bool top)
397 for (
size_t index = 0; index < nodes->
size; index++) {
403 if (implicit_regexp_encoding != NULL) {
405 string = parse_regexp_string_part(iseq, scope_node, part, &((
const pm_string_node_t *) part)->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
408 string = parse_string_encoded(part, &((
const pm_string_node_t *) part)->unescaped, scope_node->encoding);
409 VALUE error = rb_reg_check_preprocess(
string);
410 if (error !=
Qnil) parse_regexp_error(iseq, pm_node_line_number(scope_node->parser, part),
"%" PRIsVALUE, rb_obj_as_string(error));
414 string = parse_string_encoded(part, &((
const pm_string_node_t *) part)->unescaped, scope_node->encoding);
418 string = pm_static_literal_concat(iseq, &((
const pm_interpolated_string_node_t *) part)->parts, scope_node, implicit_regexp_encoding, explicit_regexp_encoding,
false);
422 string = pm_static_literal_concat(iseq, &cast->
statements->
body, scope_node, implicit_regexp_encoding, explicit_regexp_encoding,
false);
426 RUBY_ASSERT(
false &&
"unexpected node type in pm_static_literal_concat");
430 if (current !=
Qnil) {
438 return top ? rb_fstring(current) : current;
441#define RE_OPTION_ENCODING_SHIFT 8
442#define RE_OPTION_ENCODING(encoding) (((encoding) & 0xFF) << RE_OPTION_ENCODING_SHIFT)
443#define ARG_ENCODING_NONE 32
444#define ARG_ENCODING_FIXED 16
445#define ENC_ASCII8BIT 1
447#define ENC_Windows_31J 3
463 flags |= ARG_ENCODING_NONE;
467 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_EUC_JP));
471 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_Windows_31J));
475 flags |= (ARG_ENCODING_FIXED | RE_OPTION_ENCODING(ENC_UTF8));
479 flags |= ONIG_OPTION_IGNORECASE;
483 flags |= ONIG_OPTION_MULTILINE;
487 flags |= ONIG_OPTION_EXTEND;
493#undef RE_OPTION_ENCODING_SHIFT
494#undef RE_OPTION_ENCODING
495#undef ARG_ENCODING_FIXED
496#undef ARG_ENCODING_NONE
499#undef ENC_Windows_31J
503parse_regexp_encoding(
const pm_scope_node_t *scope_node,
const pm_node_t *node)
506 return rb_ascii8bit_encoding();
509 return rb_utf8_encoding();
512 return rb_enc_get_from_index(ENCINDEX_EUC_JP);
515 return rb_enc_get_from_index(ENCINDEX_Windows_31J);
523parse_regexp(rb_iseq_t *iseq,
const pm_scope_node_t *scope_node,
const pm_node_t *node,
VALUE string)
525 VALUE errinfo = rb_errinfo();
527 int32_t line_number = pm_node_line_number(scope_node->parser, node);
528 VALUE regexp = rb_reg_compile(
string, parse_regexp_flags(node), (
const char *) pm_string_source(&scope_node->parser->
filepath), line_number);
531 VALUE message = rb_attr_get(rb_errinfo(), idMesg);
532 rb_set_errinfo(errinfo);
534 parse_regexp_error(iseq, line_number,
"%" PRIsVALUE, message);
543parse_regexp_literal(rb_iseq_t *iseq,
const pm_scope_node_t *scope_node,
const pm_node_t *node,
const pm_string_t *unescaped)
545 rb_encoding *regexp_encoding = parse_regexp_encoding(scope_node, node);
546 if (regexp_encoding == NULL) regexp_encoding = scope_node->encoding;
548 VALUE string = rb_enc_str_new((
const char *) pm_string_source(unescaped), pm_string_length(unescaped), regexp_encoding);
549 return parse_regexp(iseq, scope_node, node,
string);
553parse_regexp_concat(rb_iseq_t *iseq,
const pm_scope_node_t *scope_node,
const pm_node_t *node,
const pm_node_list_t *parts)
555 rb_encoding *explicit_regexp_encoding = parse_regexp_encoding(scope_node, node);
556 rb_encoding *implicit_regexp_encoding = explicit_regexp_encoding != NULL ? explicit_regexp_encoding : scope_node->encoding;
558 VALUE string = pm_static_literal_concat(iseq, parts, scope_node, implicit_regexp_encoding, explicit_regexp_encoding,
false);
559 return parse_regexp(iseq, scope_node, node,
string);
562static void pm_compile_node(rb_iseq_t *iseq,
const pm_node_t *node, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node);
565pm_interpolated_node_compile(rb_iseq_t *iseq,
const pm_node_list_t *parts,
const pm_node_location_t *node_location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node, rb_encoding *implicit_regexp_encoding, rb_encoding *explicit_regexp_encoding)
568 size_t parts_size = parts->
size;
569 bool interpolated =
false;
571 if (parts_size > 0) {
575 for (
size_t index = 0; index < parts_size; index++) {
582 if (implicit_regexp_encoding == NULL) {
583 string_value = parse_string_encoded(part, &string_node->
unescaped, scope_node->encoding);
586 string_value = parse_regexp_string_part(iseq, scope_node, (
const pm_node_t *) string_node, &string_node->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
589 if (
RTEST(current_string)) {
590 current_string =
rb_str_concat(current_string, string_value);
593 current_string = string_value;
594 if (index != 0) current_location = PM_NODE_END_LOCATION(scope_node->parser, part);
609 if (implicit_regexp_encoding == NULL) {
610 string_value = parse_string_encoded(part, &string_node->
unescaped, scope_node->encoding);
613 string_value = parse_regexp_string_part(iseq, scope_node, (
const pm_node_t *) string_node, &string_node->unescaped, implicit_regexp_encoding, explicit_regexp_encoding);
616 if (
RTEST(current_string)) {
617 current_string =
rb_str_concat(current_string, string_value);
620 current_string = string_value;
621 current_location = PM_NODE_START_LOCATION(scope_node->parser, part);
625 if (!
RTEST(current_string)) {
626 rb_encoding *encoding;
628 if (implicit_regexp_encoding != NULL) {
629 if (explicit_regexp_encoding != NULL) {
630 encoding = explicit_regexp_encoding;
633 encoding = rb_ascii8bit_encoding();
636 encoding = implicit_regexp_encoding;
640 encoding = scope_node->encoding;
643 if (parts_size == 1) {
644 current_string = rb_enc_str_new(NULL, 0, encoding);
648 if (
RTEST(current_string)) {
649 VALUE operand = rb_fstring(current_string);
650 PUSH_INSN1(ret, current_location, putobject, operand);
654 PM_COMPILE_NOT_POPPED(part);
656 const pm_node_location_t current_location = PM_NODE_START_LOCATION(scope_node->parser, part);
657 PUSH_INSN(ret, current_location, dup);
660 const struct rb_callinfo *callinfo = new_callinfo(iseq, idTo_s, 0, VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE, NULL, FALSE);
661 PUSH_INSN1(ret, current_location, objtostring, callinfo);
664 PUSH_INSN(ret, current_location, anytostring);
666 current_string =
Qnil;
672 if (
RTEST(current_string)) {
673 current_string = rb_fstring(current_string);
675 if (stack_size == 0 && interpolated) {
676 PUSH_INSN1(ret, current_location, putstring, current_string);
679 PUSH_INSN1(ret, current_location, putobject, current_string);
682 current_string =
Qnil;
687 PUSH_INSN(ret, *node_location, putnil);
696 rb_encoding *explicit_regexp_encoding = parse_regexp_encoding(scope_node, node);
697 rb_encoding *implicit_regexp_encoding = explicit_regexp_encoding != NULL ? explicit_regexp_encoding : scope_node->encoding;
699 int length = pm_interpolated_node_compile(iseq, parts, node_location, ret, popped, scope_node, implicit_regexp_encoding, explicit_regexp_encoding);
700 PUSH_INSN2(ret, *node_location, toregexp,
INT2FIX(parse_regexp_flags(node) & 0xFF),
INT2FIX(length));
707 size_t length = pm_string_length(filepath);
711 return rb_enc_interned_str((
const char *) pm_string_source(filepath), length, filepath_encoding);
714 return rb_fstring_lit(
"<compiled>");
723pm_static_literal_string(rb_iseq_t *iseq,
VALUE string,
int line_number)
725 if (ISEQ_COMPILE_DATA(iseq)->option->debug_frozen_string_literal ||
RTEST(
ruby_debug)) {
726 return rb_str_with_debug_created_info(
string, rb_iseq_path(iseq), line_number);
729 return rb_fstring(
string);
739pm_static_literal_value(rb_iseq_t *iseq,
const pm_node_t *node,
const pm_scope_node_t *scope_node)
750 VALUE value = rb_ary_hidden_new(elements->
size);
751 for (
size_t index = 0; index < elements->
size; index++) {
752 rb_ary_push(value, pm_static_literal_value(iseq, elements->
nodes[index], scope_node));
766 VALUE array = rb_ary_hidden_new(elements->
size * 2);
767 for (
size_t index = 0; index < elements->
size; index++) {
770 VALUE pair[2] = { pm_static_literal_value(iseq, cast->key, scope_node), pm_static_literal_value(iseq, cast->value, scope_node) };
771 rb_ary_cat(array, pair, 2);
774 VALUE value = rb_hash_new_with_size(elements->
size);
787 return parse_regexp_concat(iseq, scope_node, (
const pm_node_t *) cast, &cast->parts);
791 return parse_regexp_concat(iseq, scope_node, (
const pm_node_t *) cast, &cast->parts);
795 int line_number = pm_node_line_number(scope_node->parser, node);
796 return pm_static_literal_string(iseq,
string, line_number);
800 VALUE string = pm_static_literal_concat(iseq, &cast->
parts, scope_node, NULL, NULL,
true);
802 return ID2SYM(rb_intern_str(
string));
806 return parse_regexp_literal(iseq, scope_node, (
const pm_node_t *) cast, &cast->unescaped);
814 return parse_regexp_literal(iseq, scope_node, (
const pm_node_t *) cast, &cast->unescaped);
817 return rb_enc_from_encoding(scope_node->encoding);
820 return pm_source_file_value(cast, scope_node);
823 return INT2FIX(pm_node_line_number(scope_node->parser, node));
826 return parse_static_literal_string(iseq, scope_node, node, &cast->
unescaped);
833 rb_bug(
"Don't have a literal value for node type %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
841static rb_code_location_t
842pm_code_location(
const pm_scope_node_t *scope_node,
const pm_node_t *node)
844 const pm_line_column_t start_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, node);
845 const pm_line_column_t end_location = PM_NODE_END_LINE_COLUMN(scope_node->parser, node);
847 return (rb_code_location_t) {
848 .beg_pos = { .lineno = start_location.
line, .column = start_location.
column },
849 .end_pos = { .lineno = end_location.
line, .column = end_location.
column }
858#define PM_BRANCH_COVERAGE_P(iseq) (ISEQ_COVERAGE(iseq) && ISEQ_BRANCH_COVERAGE(iseq))
861pm_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *
const ret,
const pm_node_t *cond,
862 LABEL *then_label, LABEL *else_label,
bool popped, pm_scope_node_t *scope_node);
865pm_compile_logical(rb_iseq_t *iseq, LINK_ANCHOR *
const ret,
pm_node_t *cond, LABEL *then_label, LABEL *else_label,
bool popped, pm_scope_node_t *scope_node)
871 LABEL *label = NEW_LABEL(location.
line);
872 if (!then_label) then_label = label;
873 else if (!else_label) else_label = label;
875 pm_compile_branch_condition(iseq, seq, cond, then_label, else_label, popped, scope_node);
877 if (LIST_INSN_SIZE_ONE(seq)) {
878 INSN *insn = (INSN *) ELEM_FIRST_INSN(FIRST_ELEMENT(seq));
879 if (insn->insn_id == BIN(jump) && (LABEL *)(insn->operands[0]) == label)
return;
882 if (!label->refcnt) {
883 if (popped) PUSH_INSN(ret, location, putnil);
886 PUSH_LABEL(seq, label);
894pm_compile_flip_flop_bound(rb_iseq_t *iseq,
const pm_node_t *node, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
896 const pm_node_location_t location = { .line = ISEQ_BODY(iseq)->location.first_lineno, .node_id = -1 };
899 PM_COMPILE_NOT_POPPED(node);
902 PUSH_INSN1(ret, location, getglobal, operand);
904 PUSH_SEND(ret, location, idEq,
INT2FIX(1));
905 if (popped) PUSH_INSN(ret, location, pop);
913pm_compile_flip_flop(
const pm_flip_flop_node_t *flip_flop_node, LABEL *else_label, LABEL *then_label, rb_iseq_t *iseq,
const int lineno, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
915 const pm_node_location_t location = { .line = ISEQ_BODY(iseq)->location.first_lineno, .node_id = -1 };
916 LABEL *lend = NEW_LABEL(location.
line);
920 rb_num_t count = ISEQ_FLIP_CNT_INCREMENT(ISEQ_BODY(iseq)->local_iseq) + VM_SVAR_FLIPFLOP_START;
923 PUSH_INSN2(ret, location, getspecial, key,
INT2FIX(0));
924 PUSH_INSNL(ret, location, branchif, lend);
926 if (flip_flop_node->
left) {
927 pm_compile_flip_flop_bound(iseq, flip_flop_node->
left, ret, popped, scope_node);
930 PUSH_INSN(ret, location, putnil);
933 PUSH_INSNL(ret, location, branchunless, else_label);
934 PUSH_INSN1(ret, location, putobject,
Qtrue);
935 PUSH_INSN1(ret, location, setspecial, key);
937 PUSH_INSNL(ret, location, jump, then_label);
940 PUSH_LABEL(ret, lend);
941 if (flip_flop_node->
right) {
942 pm_compile_flip_flop_bound(iseq, flip_flop_node->
right, ret, popped, scope_node);
945 PUSH_INSN(ret, location, putnil);
948 PUSH_INSNL(ret, location, branchunless, then_label);
949 PUSH_INSN1(ret, location, putobject,
Qfalse);
950 PUSH_INSN1(ret, location, setspecial, key);
951 PUSH_INSNL(ret, location, jump, then_label);
954static void pm_compile_defined_expr(rb_iseq_t *iseq,
const pm_node_t *node,
const pm_node_location_t *node_location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node,
bool in_condition);
957pm_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *
const ret,
const pm_node_t *cond, LABEL *then_label, LABEL *else_label,
bool popped, pm_scope_node_t *scope_node)
965 pm_compile_logical(iseq, ret, cast->
left, NULL, else_label, popped, scope_node);
972 pm_compile_logical(iseq, ret, cast->
left, then_label, NULL, popped, scope_node);
979 PUSH_INSNL(ret, location, jump, else_label);
990 PUSH_INSNL(ret, location, jump, then_label);
993 pm_compile_flip_flop((
const pm_flip_flop_node_t *) cond, else_label, then_label, iseq, location.
line, ret, popped, scope_node);
997 pm_compile_defined_expr(iseq, cast->
value, &location, ret, popped, scope_node,
true);
1001 DECL_ANCHOR(cond_seq);
1002 pm_compile_node(iseq, cond, cond_seq,
false, scope_node);
1004 if (LIST_INSN_SIZE_ONE(cond_seq)) {
1005 INSN *insn = (INSN *) ELEM_FIRST_INSN(FIRST_ELEMENT(cond_seq));
1007 if (insn->insn_id == BIN(putobject)) {
1008 if (
RTEST(insn->operands[0])) {
1009 PUSH_INSNL(ret, location, jump, then_label);
1014 PUSH_INSNL(ret, location, jump, else_label);
1020 PUSH_SEQ(ret, cond_seq);
1025 PUSH_INSNL(ret, location, branchunless, else_label);
1026 PUSH_INSNL(ret, location, jump, then_label);
1036 LABEL *then_label = NEW_LABEL(location.
line);
1037 LABEL *else_label = NEW_LABEL(location.
line);
1038 LABEL *end_label = NULL;
1040 DECL_ANCHOR(cond_seq);
1041 pm_compile_branch_condition(iseq, cond_seq, predicate, then_label, else_label,
false, scope_node);
1042 PUSH_SEQ(ret, cond_seq);
1044 rb_code_location_t conditional_location = { 0 };
1047 if (then_label->refcnt && else_label->refcnt && PM_BRANCH_COVERAGE_P(iseq)) {
1048 conditional_location = pm_code_location(scope_node, node);
1049 branches = decl_branch_base(iseq, PTR2NUM(node), &conditional_location,
type ==
PM_IF_NODE ?
"if" :
"unless");
1052 if (then_label->refcnt) {
1053 PUSH_LABEL(ret, then_label);
1055 DECL_ANCHOR(then_seq);
1057 if (statements != NULL) {
1058 pm_compile_node(iseq, (
const pm_node_t *) statements, then_seq, popped, scope_node);
1061 PUSH_SYNTHETIC_PUTNIL(then_seq, iseq);
1064 if (else_label->refcnt) {
1066 if (PM_BRANCH_COVERAGE_P(iseq)) {
1067 rb_code_location_t branch_location;
1069 if (statements != NULL) {
1070 branch_location = pm_code_location(scope_node, (
const pm_node_t *) statements);
1072 pm_line_column_t predicate_end = PM_NODE_END_LINE_COLUMN(scope_node->parser, predicate);
1073 branch_location = (rb_code_location_t) {
1074 .beg_pos = { .lineno = predicate_end.
line, .column = predicate_end.
column },
1075 .end_pos = { .lineno = predicate_end.
line, .column = predicate_end.
column }
1078 branch_location = conditional_location;
1081 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 0,
type ==
PM_IF_NODE ?
"then" :
"else", branches);
1084 end_label = NEW_LABEL(location.
line);
1085 PUSH_INSNL(then_seq, location, jump, end_label);
1086 if (!popped) PUSH_INSN(then_seq, location, pop);
1089 PUSH_SEQ(ret, then_seq);
1092 if (else_label->refcnt) {
1093 PUSH_LABEL(ret, else_label);
1095 DECL_ANCHOR(else_seq);
1097 if (subsequent != NULL) {
1098 pm_compile_node(iseq, subsequent, else_seq, popped, scope_node);
1101 PUSH_SYNTHETIC_PUTNIL(else_seq, iseq);
1105 if (then_label->refcnt && PM_BRANCH_COVERAGE_P(iseq)) {
1106 rb_code_location_t branch_location;
1108 if (subsequent == NULL) {
1109 branch_location = conditional_location;
1114 branch_location = pm_code_location(scope_node, (
const pm_node_t *) subsequent);
1117 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 1,
type ==
PM_IF_NODE ?
"else" :
"then", branches);
1120 PUSH_SEQ(ret, else_seq);
1124 PUSH_LABEL(ret, end_label);
1138 LABEL *prev_start_label = ISEQ_COMPILE_DATA(iseq)->start_label;
1139 LABEL *prev_end_label = ISEQ_COMPILE_DATA(iseq)->end_label;
1140 LABEL *prev_redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label;
1142 LABEL *next_label = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(location.
line);
1143 LABEL *redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label = NEW_LABEL(location.
line);
1144 LABEL *break_label = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(location.
line);
1145 LABEL *end_label = NEW_LABEL(location.
line);
1146 LABEL *adjust_label = NEW_LABEL(location.
line);
1148 LABEL *next_catch_label = NEW_LABEL(location.
line);
1149 LABEL *tmp_label = NULL;
1155 push_ensure_entry(iseq, &enl, NULL, NULL);
1159 tmp_label = NEW_LABEL(location.
line);
1160 PUSH_INSNL(ret, location, jump, tmp_label);
1164 PUSH_INSNL(ret, location, jump, next_label);
1167 PUSH_LABEL(ret, adjust_label);
1168 PUSH_INSN(ret, location, putnil);
1169 PUSH_LABEL(ret, next_catch_label);
1170 PUSH_INSN(ret, location, pop);
1171 PUSH_INSNL(ret, location, jump, next_label);
1172 if (tmp_label) PUSH_LABEL(ret, tmp_label);
1174 PUSH_LABEL(ret, redo_label);
1177 if (PM_BRANCH_COVERAGE_P(iseq)) {
1178 rb_code_location_t loop_location = pm_code_location(scope_node, node);
1179 VALUE branches = decl_branch_base(iseq, PTR2NUM(node), &loop_location,
type ==
PM_WHILE_NODE ?
"while" :
"until");
1181 rb_code_location_t branch_location = statements != NULL ? pm_code_location(scope_node, (
const pm_node_t *) statements) : loop_location;
1182 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, 0,
"body", branches);
1185 if (statements != NULL) PM_COMPILE_POPPED((
const pm_node_t *) statements);
1186 PUSH_LABEL(ret, next_label);
1189 pm_compile_branch_condition(iseq, ret, predicate, redo_label, end_label, popped, scope_node);
1192 pm_compile_branch_condition(iseq, ret, predicate, end_label, redo_label, popped, scope_node);
1195 PUSH_LABEL(ret, end_label);
1196 PUSH_ADJUST_RESTORE(ret, adjust_label);
1197 PUSH_INSN(ret, location, putnil);
1199 PUSH_LABEL(ret, break_label);
1200 if (popped) PUSH_INSN(ret, location, pop);
1202 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, redo_label, break_label, NULL, break_label);
1203 PUSH_CATCH_ENTRY(CATCH_TYPE_NEXT, redo_label, break_label, NULL, next_catch_label);
1204 PUSH_CATCH_ENTRY(CATCH_TYPE_REDO, redo_label, break_label, NULL, ISEQ_COMPILE_DATA(iseq)->redo_label);
1206 ISEQ_COMPILE_DATA(iseq)->start_label = prev_start_label;
1207 ISEQ_COMPILE_DATA(iseq)->end_label = prev_end_label;
1208 ISEQ_COMPILE_DATA(iseq)->redo_label = prev_redo_label;
1209 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = ISEQ_COMPILE_DATA(iseq)->ensure_node_stack->prev;
1217static pm_local_index_t
1218pm_lookup_local_index(rb_iseq_t *iseq,
const pm_scope_node_t *scope_node,
pm_constant_id_t constant_id,
int start_depth)
1220 pm_local_index_t lindex = { 0 };
1221 st_data_t local_index;
1224 for (level = 0; level < start_depth; level++) {
1225 scope_node = scope_node->previous;
1228 while (!st_lookup(scope_node->index_lookup_table, constant_id, &local_index)) {
1231 if (scope_node->previous) {
1232 scope_node = scope_node->previous;
1237 rb_bug(
"Local with constant_id %u does not exist", (
unsigned int) constant_id);
1241 lindex.level = level;
1242 lindex.index = scope_node->local_table_for_iseq_size - (int) local_index;
1253pm_constant_id_lookup(
const pm_scope_node_t *scope_node,
pm_constant_id_t constant_id)
1256 rb_bug(
"constant_id out of range: %u", (
unsigned int)constant_id);
1258 return scope_node->constants[constant_id - 1];
1262pm_new_child_iseq(rb_iseq_t *iseq, pm_scope_node_t *node,
VALUE name,
const rb_iseq_t *parent,
enum rb_iseq_type
type,
int line_no)
1264 debugs(
"[new_child_iseq]> ---------------------------------------\n");
1265 int isolated_depth = ISEQ_COMPILE_DATA(iseq)->isolated_depth;
1267 rb_iseq_t *ret_iseq = pm_iseq_new_with_opt(node, name,
1268 rb_iseq_path(iseq), rb_iseq_realpath(iseq),
1270 isolated_depth ? isolated_depth + 1 : 0,
1271 type, ISEQ_COMPILE_DATA(iseq)->option, &error_state);
1275 rb_jump_tag(error_state);
1277 debugs(
"[new_child_iseq]< ---------------------------------------\n");
1282pm_compile_class_path(rb_iseq_t *iseq,
const pm_node_t *node,
const pm_node_location_t *node_location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
1290 return VM_DEFINECLASS_FLAG_SCOPED;
1294 PUSH_INSN1(ret, *node_location, putobject, rb_cObject);
1295 return VM_DEFINECLASS_FLAG_SCOPED;
1300 PUSH_INSN1(ret, *node_location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
1310pm_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)
1313 LABEL *lfin = NEW_LABEL(location.
line);
1314 LABEL *lcfin = NEW_LABEL(location.
line);
1315 LABEL *lskip = NULL;
1318 ID id_read_name = pm_constant_id_lookup(scope_node, read_name);
1320 PM_COMPILE_NOT_POPPED(receiver);
1322 lskip = NEW_LABEL(location.
line);
1323 PUSH_INSN(ret, location, dup);
1324 PUSH_INSNL(ret, location, branchnil, lskip);
1327 PUSH_INSN(ret, location, dup);
1328 PUSH_SEND_WITH_FLAG(ret, location, id_read_name,
INT2FIX(0),
INT2FIX(flag));
1329 if (!popped) PUSH_INSN(ret, location, dup);
1332 PUSH_INSNL(ret, location, branchunless, lcfin);
1335 PUSH_INSNL(ret, location, branchif, lcfin);
1338 if (!popped) PUSH_INSN(ret, location, pop);
1339 PM_COMPILE_NOT_POPPED(value);
1342 PUSH_INSN(ret, location, swap);
1343 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
1346 ID id_write_name = pm_constant_id_lookup(scope_node, write_name);
1347 PUSH_SEND_WITH_FLAG(ret, location, id_write_name,
INT2FIX(1),
INT2FIX(flag));
1348 PUSH_INSNL(ret, location, jump, lfin);
1350 PUSH_LABEL(ret, lcfin);
1351 if (!popped) PUSH_INSN(ret, location, swap);
1353 PUSH_LABEL(ret, lfin);
1355 if (lskip && popped) PUSH_LABEL(ret, lskip);
1356 PUSH_INSN(ret, location, pop);
1357 if (lskip && !popped) PUSH_LABEL(ret, lskip);
1360static void pm_compile_shareable_constant_value(rb_iseq_t *iseq,
const pm_node_t *node,
const pm_node_flags_t shareability,
VALUE path, LINK_ANCHOR *
const ret, pm_scope_node_t *scope_node,
bool top);
1368pm_compile_hash_elements(rb_iseq_t *iseq,
const pm_node_t *node,
const pm_node_list_t *elements,
const pm_node_flags_t shareability,
VALUE path,
bool argument, LINK_ANCHOR *
const ret, pm_scope_node_t *scope_node)
1370 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
1376 const int max_stack_length = 0x100;
1377 const unsigned int min_tmp_hash_length = 0x800;
1379 int stack_length = 0;
1380 bool first_chunk =
true;
1386 bool static_literal =
false;
1388 DECL_ANCHOR(anchor);
1391#define FLUSH_CHUNK \
1392 if (stack_length) { \
1393 if (first_chunk) { \
1394 PUSH_SEQ(ret, anchor); \
1395 PUSH_INSN1(ret, location, newhash, INT2FIX(stack_length)); \
1396 first_chunk = false; \
1399 PUSH_INSN1(ret, location, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE)); \
1400 PUSH_INSN(ret, location, swap); \
1401 PUSH_SEQ(ret, anchor); \
1402 PUSH_SEND(ret, location, id_core_hash_merge_ptr, INT2FIX(stack_length + 1)); \
1404 INIT_ANCHOR(anchor); \
1408 for (
size_t index = 0; index < elements->
size; index++) {
1415 (shareability == 0) &&
1417 (!static_literal && ((index + min_tmp_hash_length) < elements->
size)) ||
1418 (first_chunk && stack_length == 0)
1423 while (index + count < elements->size &&
PM_NODE_FLAG_P(elements->
nodes[index + count], PM_NODE_FLAG_STATIC_LITERAL)) count++;
1425 if ((first_chunk && stack_length == 0) || count >= min_tmp_hash_length) {
1428 VALUE ary = rb_ary_hidden_new(count);
1431 for (
size_t tmp_end = index + count; index < tmp_end; index++) {
1435 pm_static_literal_value(iseq, assoc->key, scope_node),
1436 pm_static_literal_value(iseq, assoc->value, scope_node)
1439 rb_ary_cat(ary, elem, 2);
1451 PUSH_INSN1(ret, location, duphash, hash);
1452 first_chunk =
false;
1455 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1456 PUSH_INSN(ret, location, swap);
1457 PUSH_INSN1(ret, location, putobject, hash);
1458 PUSH_SEND(ret, location, id_core_hash_merge_kwd,
INT2FIX(2));
1464 static_literal =
true;
1468 static_literal =
false;
1473 if (shareability == 0) {
1474 pm_compile_node(iseq, element, anchor,
false, scope_node);
1478 pm_compile_shareable_constant_value(iseq, assoc->
key, shareability, path, ret, scope_node,
false);
1479 pm_compile_shareable_constant_value(iseq, assoc->
value, shareability, path, ret, scope_node,
false);
1482 if ((stack_length += 2) >= max_stack_length) FLUSH_CHUNK;
1489 bool empty_hash = assoc_splat->
value != NULL && (
1494 bool first_element = first_chunk && stack_length == 0;
1495 bool last_element = index == elements->
size - 1;
1496 bool only_element = first_element && last_element;
1499 if (only_element && argument) {
1506 PUSH_INSN(ret, location, putnil);
1508 else if (first_element) {
1511 PUSH_INSN1(ret, location, newhash,
INT2FIX(0));
1518 if (only_element && argument) {
1524 if (shareability == 0) {
1525 PM_COMPILE_NOT_POPPED(element);
1528 pm_compile_shareable_constant_value(iseq, element, shareability, path, ret, scope_node,
false);
1536 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1538 if (first_element) {
1539 PUSH_INSN1(ret, location, newhash,
INT2FIX(0));
1542 PUSH_INSN(ret, location, swap);
1545 if (shareability == 0) {
1546 PM_COMPILE_NOT_POPPED(element);
1549 pm_compile_shareable_constant_value(iseq, element, shareability, path, ret, scope_node,
false);
1552 PUSH_SEND(ret, location, id_core_hash_merge_kwd,
INT2FIX(2));
1556 first_chunk =
false;
1557 static_literal =
false;
1561 RUBY_ASSERT(
"Invalid node type for hash" &&
false);
1570#define SPLATARRAY_FALSE 0
1571#define SPLATARRAY_TRUE 1
1572#define DUP_SINGLE_KW_SPLAT 2
1581 bool has_splat =
false;
1582 bool has_keyword_splat =
false;
1584 if (arguments_node == NULL) {
1585 if (*flags & VM_CALL_FCALL) {
1586 *flags |= VM_CALL_VCALL;
1595 int post_splat_counter = 0;
1605 if (has_keyword_splat || has_splat) {
1606 *flags |= VM_CALL_KW_SPLAT;
1607 has_keyword_splat =
true;
1613 *flags |= VM_CALL_KW_SPLAT_MUT;
1614 pm_compile_hash_elements(iseq, argument, elements, 0,
Qundef,
true, ret, scope_node);
1616 else if (*dup_rest & DUP_SINGLE_KW_SPLAT) {
1617 *flags |= VM_CALL_KW_SPLAT_MUT;
1618 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
1619 PUSH_INSN1(ret, location, newhash,
INT2FIX(0));
1620 pm_compile_hash_elements(iseq, argument, elements, 0,
Qundef,
true, ret, scope_node);
1621 PUSH_SEND(ret, location, id_core_hash_merge_kwd,
INT2FIX(2));
1624 pm_compile_hash_elements(iseq, argument, elements, 0,
Qundef,
true, ret, scope_node);
1635 VALUE stored_indices = rb_hash_new();
1636 VALUE keyword_indices = rb_ary_new_capa(elements->
size);
1639 for (
size_t element_index = 0; element_index < elements->
size; element_index++) {
1644 VALUE keyword = pm_static_literal_value(iseq, assoc->key, scope_node);
1645 VALUE stored_index = rb_hash_aref(stored_indices, keyword);
1650 if (!
NIL_P(stored_index)) {
1658 rb_hash_aset(stored_indices, keyword,
ULONG2NUM(element_index));
1659 rb_ary_store(keyword_indices, (
long) element_index,
Qtrue);
1664 *flags |= VM_CALL_KWARG;
1666 VALUE *keywords = (*kw_arg)->keywords;
1667 (*kw_arg)->references = 0;
1668 (*kw_arg)->keyword_len = (int) size;
1670 size_t keyword_index = 0;
1671 for (
size_t element_index = 0; element_index < elements->
size; element_index++) {
1675 if (rb_ary_entry(keyword_indices, (
long) element_index) ==
Qtrue) {
1676 keywords[keyword_index++] = pm_static_literal_value(iseq, assoc->key, scope_node);
1680 PM_COMPILE(assoc->value);
1689 *flags |= VM_CALL_KW_SPLAT;
1691 size_t size = elements->
size;
1696 *flags |= VM_CALL_KW_SPLAT_MUT;
1699 for (
size_t element_index = 0; element_index < size; element_index++) {
1701 PM_COMPILE_NOT_POPPED(assoc->key);
1702 PM_COMPILE_NOT_POPPED(assoc->value);
1705 PUSH_INSN1(ret, location, newhash,
INT2FIX(size * 2));
1711 *flags |= VM_CALL_ARGS_SPLAT;
1715 PM_COMPILE_NOT_POPPED(splat_node->
expression);
1718 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
1719 PUSH_GETLOCAL(ret, location, index.index, index.level);
1722 bool first_splat = !has_splat;
1730 if (index + 1 < arguments->
size || has_regular_blockarg) {
1731 PUSH_INSN1(ret, location, splatarray, (*dup_rest & SPLATARRAY_TRUE) ?
Qtrue :
Qfalse);
1732 if (*dup_rest & SPLATARRAY_TRUE) *dup_rest &= ~SPLATARRAY_TRUE;
1740 PUSH_INSN1(ret, location, splatarray,
Qfalse);
1750 PUSH_INSN(ret, location, concattoarray);
1754 post_splat_counter = 0;
1759 if (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.flags.forwardable) {
1760 *flags |= VM_CALL_FORWARDING;
1762 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_DOT3, 0);
1763 PUSH_GETLOCAL(ret, location, mult_local.index, mult_local.level);
1770 *flags |= VM_CALL_ARGS_SPLAT | VM_CALL_ARGS_SPLAT_MUT | VM_CALL_ARGS_BLOCKARG | VM_CALL_KW_SPLAT;
1777 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
1778 PUSH_GETLOCAL(ret, location, mult_local.index, mult_local.level);
1779 PUSH_INSN1(ret, location, splatarray,
Qtrue);
1782 pm_local_index_t pow_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_POW, 0);
1783 PUSH_GETLOCAL(ret, location, pow_local.index, pow_local.level);
1786 pm_local_index_t and_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_AND, 0);
1787 PUSH_INSN2(ret, location, getblockparamproxy,
INT2FIX(and_local.index + VM_ENV_DATA_SIZE - 1),
INT2FIX(and_local.level));
1788 PUSH_INSN(ret, location, splatkw);
1793 post_splat_counter++;
1794 PM_COMPILE_NOT_POPPED(argument);
1814 if (index == arguments->
size - 1) {
1816 PUSH_INSN1(ret, location, pushtoarray,
INT2FIX(post_splat_counter));
1824 PUSH_INSN1(ret, location, newarray,
INT2FIX(post_splat_counter));
1825 PUSH_INSN(ret, location, concatarray);
1829 PUSH_INSN1(ret, location, newarray,
INT2FIX(post_splat_counter));
1830 PUSH_INSN(ret, location, concatarray);
1846 if (has_splat) orig_argc++;
1847 if (has_keyword_splat) orig_argc++;
1856pm_setup_args_dup_rest_p(
const pm_node_t *node)
1893 int dup_rest = SPLATARRAY_TRUE;
1896 size_t arguments_size;
1901 arguments_node != NULL &&
1902 (arguments = &arguments_node->
arguments, arguments_size = arguments->
size) >= 2 &&
1910 dup_rest = SPLATARRAY_FALSE;
1915 for (
size_t index = 0; dup_rest == SPLATARRAY_FALSE && index < elements->
size; index++) {
1921 if (pm_setup_args_dup_rest_p(assoc->
key) || pm_setup_args_dup_rest_p(assoc->
value)) dup_rest = SPLATARRAY_TRUE;
1926 if (assoc->
value != NULL && pm_setup_args_dup_rest_p(assoc->
value)) dup_rest = SPLATARRAY_TRUE;
1935 int initial_dup_rest = dup_rest;
1942 bool regular_block_arg =
true;
1945 if (block_expr && pm_setup_args_dup_rest_p(block_expr)) {
1946 dup_rest = SPLATARRAY_TRUE | DUP_SINGLE_KW_SPLAT;
1947 initial_dup_rest = dup_rest;
1950 DECL_ANCHOR(block_arg);
1951 pm_compile_node(iseq, block, block_arg,
false, scope_node);
1953 *flags |= VM_CALL_ARGS_BLOCKARG;
1955 if (LIST_INSN_SIZE_ONE(block_arg)) {
1956 LINK_ELEMENT *elem = FIRST_ELEMENT(block_arg);
1957 if (IS_INSN(elem)) {
1958 INSN *iobj = (INSN *) elem;
1959 if (iobj->insn_id == BIN(getblockparam)) {
1960 iobj->insn_id = BIN(getblockparamproxy);
1967 regular_block_arg =
false;
1971 argc = pm_setup_args_core(arguments_node, block, flags, regular_block_arg, kw_arg, &dup_rest, iseq, ret, scope_node, node_location);
1972 PUSH_SEQ(ret, block_arg);
1975 argc = pm_setup_args_core(arguments_node, block, flags,
false, kw_arg, &dup_rest, iseq, ret, scope_node, node_location);
1982 if (*flags & VM_CALL_ARGS_SPLAT && dup_rest != initial_dup_rest) {
1983 *flags |= VM_CALL_ARGS_SPLAT_MUT;
2003 if (!popped) PUSH_INSN(ret, location, putnil);
2005 PM_COMPILE_NOT_POPPED(node->
receiver);
2007 int boff = (node->
block == NULL ? 0 : 1);
2010 int argc = pm_setup_args(node->
arguments, (
const pm_node_t *) node->
block, &flag, &keywords, iseq, ret, scope_node, node_location);
2012 if ((argc > 0 || boff) && (flag & VM_CALL_KW_SPLAT)) {
2014 PUSH_INSN(ret, location, splatkw);
2017 PUSH_INSN(ret, location, dup);
2018 PUSH_INSN(ret, location, splatkw);
2019 PUSH_INSN(ret, location, pop);
2023 int dup_argn = argc + 1 + boff;
2024 int keyword_len = 0;
2027 keyword_len = keywords->keyword_len;
2028 dup_argn += keyword_len;
2031 PUSH_INSN1(ret, location, dupn,
INT2FIX(dup_argn));
2032 PUSH_SEND_R(ret, location, idAREF,
INT2FIX(argc), NULL,
INT2FIX(flag & ~(VM_CALL_ARGS_SPLAT_MUT | VM_CALL_KW_SPLAT_MUT)), keywords);
2033 PM_COMPILE_NOT_POPPED(node->
value);
2036 PUSH_SEND(ret, location, id_operator,
INT2FIX(1));
2039 PUSH_INSN1(ret, location, setn,
INT2FIX(dup_argn + 1));
2041 if (flag & VM_CALL_ARGS_SPLAT) {
2042 if (flag & VM_CALL_KW_SPLAT) {
2043 PUSH_INSN1(ret, location, topn,
INT2FIX(2 + boff));
2045 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2046 PUSH_INSN1(ret, location, splatarray,
Qtrue);
2047 flag |= VM_CALL_ARGS_SPLAT_MUT;
2050 PUSH_INSN(ret, location, swap);
2051 PUSH_INSN1(ret, location, pushtoarray,
INT2FIX(1));
2052 PUSH_INSN1(ret, location, setn,
INT2FIX(2 + boff));
2053 PUSH_INSN(ret, location, pop);
2057 PUSH_INSN1(ret, location, dupn,
INT2FIX(3));
2058 PUSH_INSN(ret, location, swap);
2059 PUSH_INSN(ret, location, pop);
2061 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2062 PUSH_INSN(ret, location, swap);
2063 PUSH_INSN1(ret, location, splatarray,
Qtrue);
2064 PUSH_INSN(ret, location, swap);
2065 flag |= VM_CALL_ARGS_SPLAT_MUT;
2067 PUSH_INSN1(ret, location, pushtoarray,
INT2FIX(1));
2069 PUSH_INSN1(ret, location, setn,
INT2FIX(3));
2070 PUSH_INSN(ret, location, pop);
2071 PUSH_INSN(ret, location, pop);
2075 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc), NULL,
INT2FIX(flag), keywords);
2077 else if (flag & VM_CALL_KW_SPLAT) {
2079 PUSH_INSN1(ret, location, topn,
INT2FIX(2));
2080 PUSH_INSN(ret, location, swap);
2081 PUSH_INSN1(ret, location, setn,
INT2FIX(3));
2082 PUSH_INSN(ret, location, pop);
2084 PUSH_INSN(ret, location, swap);
2085 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2087 else if (keyword_len) {
2088 PUSH_INSN(ret, location, dup);
2089 PUSH_INSN1(ret, location, opt_reverse,
INT2FIX(keyword_len + boff + 2));
2090 PUSH_INSN1(ret, location, opt_reverse,
INT2FIX(keyword_len + boff + 1));
2091 PUSH_INSN(ret, location, pop);
2092 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2096 PUSH_INSN(ret, location, swap);
2098 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2101 PUSH_INSN(ret, location, pop);
2120 if (!popped) PUSH_INSN(ret, location, putnil);
2121 PM_COMPILE_NOT_POPPED(receiver);
2123 int boff = (block == NULL ? 0 : 1);
2126 int argc = pm_setup_args(arguments, (
const pm_node_t *) block, &flag, &keywords, iseq, ret, scope_node, node_location);
2128 if ((argc > 0 || boff) && (flag & VM_CALL_KW_SPLAT)) {
2130 PUSH_INSN(ret, location, splatkw);
2133 PUSH_INSN(ret, location, dup);
2134 PUSH_INSN(ret, location, splatkw);
2135 PUSH_INSN(ret, location, pop);
2139 int dup_argn = argc + 1 + boff;
2140 int keyword_len = 0;
2143 keyword_len = keywords->keyword_len;
2144 dup_argn += keyword_len;
2147 PUSH_INSN1(ret, location, dupn,
INT2FIX(dup_argn));
2148 PUSH_SEND_R(ret, location, idAREF,
INT2FIX(argc), NULL,
INT2FIX(flag & ~(VM_CALL_ARGS_SPLAT_MUT | VM_CALL_KW_SPLAT_MUT)), keywords);
2150 LABEL *label = NEW_LABEL(location.
line);
2151 LABEL *lfin = NEW_LABEL(location.
line);
2153 PUSH_INSN(ret, location, dup);
2155 PUSH_INSNL(ret, location, branchunless, label);
2158 PUSH_INSNL(ret, location, branchif, label);
2161 PUSH_INSN(ret, location, pop);
2162 PM_COMPILE_NOT_POPPED(value);
2165 PUSH_INSN1(ret, location, setn,
INT2FIX(dup_argn + 1));
2168 if (flag & VM_CALL_ARGS_SPLAT) {
2169 if (flag & VM_CALL_KW_SPLAT) {
2170 PUSH_INSN1(ret, location, topn,
INT2FIX(2 + boff));
2171 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2172 PUSH_INSN1(ret, location, splatarray,
Qtrue);
2173 flag |= VM_CALL_ARGS_SPLAT_MUT;
2176 PUSH_INSN(ret, location, swap);
2177 PUSH_INSN1(ret, location, pushtoarray,
INT2FIX(1));
2178 PUSH_INSN1(ret, location, setn,
INT2FIX(2 + boff));
2179 PUSH_INSN(ret, location, pop);
2183 PUSH_INSN1(ret, location, dupn,
INT2FIX(3));
2184 PUSH_INSN(ret, location, swap);
2185 PUSH_INSN(ret, location, pop);
2187 if (!(flag & VM_CALL_ARGS_SPLAT_MUT)) {
2188 PUSH_INSN(ret, location, swap);
2189 PUSH_INSN1(ret, location, splatarray,
Qtrue);
2190 PUSH_INSN(ret, location, swap);
2191 flag |= VM_CALL_ARGS_SPLAT_MUT;
2193 PUSH_INSN1(ret, location, pushtoarray,
INT2FIX(1));
2195 PUSH_INSN1(ret, location, setn,
INT2FIX(3));
2196 PUSH_INSN(ret, location, pop);
2197 PUSH_INSN(ret, location, pop);
2201 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc), NULL,
INT2FIX(flag), keywords);
2203 else if (flag & VM_CALL_KW_SPLAT) {
2205 PUSH_INSN1(ret, location, topn,
INT2FIX(2));
2206 PUSH_INSN(ret, location, swap);
2207 PUSH_INSN1(ret, location, setn,
INT2FIX(3));
2208 PUSH_INSN(ret, location, pop);
2211 PUSH_INSN(ret, location, swap);
2212 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2214 else if (keyword_len) {
2215 PUSH_INSN1(ret, location, opt_reverse,
INT2FIX(keyword_len + boff + 1));
2216 PUSH_INSN1(ret, location, opt_reverse,
INT2FIX(keyword_len + boff + 0));
2217 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2221 PUSH_INSN(ret, location, swap);
2223 PUSH_SEND_R(ret, location, idASET,
INT2FIX(argc + 1), NULL,
INT2FIX(flag), keywords);
2226 PUSH_INSN(ret, location, pop);
2227 PUSH_INSNL(ret, location, jump, lfin);
2228 PUSH_LABEL(ret, label);
2230 PUSH_INSN1(ret, location, setn,
INT2FIX(dup_argn + 1));
2232 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(dup_argn + 1));
2233 PUSH_LABEL(ret, lfin);
2242#define PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE 0
2243#define PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING 1
2244#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P 2
2245#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE 3
2246#define PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY 4
2251static 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);
2258pm_compile_pattern_generic_error(rb_iseq_t *iseq, pm_scope_node_t *scope_node,
const pm_node_t *node, LINK_ANCHOR *
const ret,
VALUE message,
unsigned int base_index)
2260 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2261 LABEL *match_succeeded_label = NEW_LABEL(location.
line);
2263 PUSH_INSN(ret, location, dup);
2264 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2266 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2267 PUSH_INSN1(ret, location, putobject, message);
2268 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2269 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(2));
2270 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2272 PUSH_INSN1(ret, location, putobject,
Qfalse);
2273 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2275 PUSH_INSN(ret, location, pop);
2276 PUSH_INSN(ret, location, pop);
2277 PUSH_LABEL(ret, match_succeeded_label);
2288pm_compile_pattern_length_error(rb_iseq_t *iseq, pm_scope_node_t *scope_node,
const pm_node_t *node, LINK_ANCHOR *
const ret,
VALUE message,
VALUE length,
unsigned int base_index)
2290 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2291 LABEL *match_succeeded_label = NEW_LABEL(location.
line);
2293 PUSH_INSN(ret, location, dup);
2294 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2296 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2297 PUSH_INSN1(ret, location, putobject, message);
2298 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2299 PUSH_INSN(ret, location, dup);
2300 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2301 PUSH_INSN1(ret, location, putobject, length);
2302 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(4));
2303 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2305 PUSH_INSN1(ret, location, putobject,
Qfalse);
2306 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2308 PUSH_INSN(ret, location, pop);
2309 PUSH_INSN(ret, location, pop);
2310 PUSH_LABEL(ret, match_succeeded_label);
2321pm_compile_pattern_eqq_error(rb_iseq_t *iseq, pm_scope_node_t *scope_node,
const pm_node_t *node, LINK_ANCHOR *
const ret,
unsigned int base_index)
2323 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2324 LABEL *match_succeeded_label = NEW_LABEL(location.
line);
2326 PUSH_INSN(ret, location, dup);
2327 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2328 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2330 VALUE operand = rb_fstring_lit(
"%p === %p does not return true");
2331 PUSH_INSN1(ret, location, putobject, operand);
2333 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2334 PUSH_INSN1(ret, location, topn,
INT2FIX(5));
2335 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(3));
2336 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2337 PUSH_INSN1(ret, location, putobject,
Qfalse);
2338 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2339 PUSH_INSN(ret, location, pop);
2340 PUSH_INSN(ret, location, pop);
2342 PUSH_LABEL(ret, match_succeeded_label);
2343 PUSH_INSN1(ret, location, setn,
INT2FIX(2));
2344 PUSH_INSN(ret, location, pop);
2345 PUSH_INSN(ret, location, pop);
2357pm_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)
2359 LABEL *matched_label = NEW_LABEL(pm_node_line_number(scope_node->parser, node));
2360 CHECK(pm_compile_pattern(iseq, scope_node, node, ret, matched_label, unmatched_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index));
2361 PUSH_LABEL(ret, matched_label);
2371pm_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)
2373 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2375 if (use_deconstructed_cache) {
2376 PUSH_INSN1(ret, location, topn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2377 PUSH_INSNL(ret, location, branchnil, deconstruct_label);
2379 PUSH_INSN1(ret, location, topn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2380 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2382 PUSH_INSN(ret, location, pop);
2383 PUSH_INSN1(ret, location, topn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE - 1));
2384 PUSH_INSNL(ret, location, jump, deconstructed_label);
2387 PUSH_INSNL(ret, location, jump, deconstruct_label);
2390 PUSH_LABEL(ret, deconstruct_label);
2391 PUSH_INSN(ret, location, dup);
2394 PUSH_INSN1(ret, location, putobject, operand);
2395 PUSH_SEND(ret, location, idRespond_to,
INT2FIX(1));
2397 if (use_deconstructed_cache) {
2398 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE + 1));
2401 if (in_single_pattern) {
2402 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit(
"%p does not respond to #deconstruct"), base_index + 1));
2405 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2406 PUSH_SEND(ret, location, rb_intern(
"deconstruct"),
INT2FIX(0));
2408 if (use_deconstructed_cache) {
2409 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE));
2412 PUSH_INSN(ret, location, dup);
2414 PUSH_INSNL(ret, location, branchunless, type_error_label);
2415 PUSH_LABEL(ret, deconstructed_label);
2425pm_compile_pattern_constant(rb_iseq_t *iseq, pm_scope_node_t *scope_node,
const pm_node_t *node, LINK_ANCHOR *
const ret, LABEL *match_failed_label,
bool in_single_pattern,
unsigned int base_index)
2427 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2429 PUSH_INSN(ret, location, dup);
2430 PM_COMPILE_NOT_POPPED(node);
2432 if (in_single_pattern) {
2433 PUSH_INSN1(ret, location, dupn,
INT2FIX(2));
2435 PUSH_INSN1(ret, location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_CASE));
2436 if (in_single_pattern) {
2437 CHECK(pm_compile_pattern_eqq_error(iseq, scope_node, node, ret, base_index + 3));
2439 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2448pm_compile_pattern_error_handler(rb_iseq_t *iseq,
const pm_scope_node_t *scope_node,
const pm_node_t *node, LINK_ANCHOR *
const ret, LABEL *done_label,
bool popped)
2450 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2451 LABEL *key_error_label = NEW_LABEL(location.
line);
2452 LABEL *cleanup_label = NEW_LABEL(location.
line);
2455 kw_arg->references = 0;
2456 kw_arg->keyword_len = 2;
2457 kw_arg->keywords[0] =
ID2SYM(rb_intern(
"matchee"));
2458 kw_arg->keywords[1] =
ID2SYM(rb_intern(
"key"));
2460 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2461 PUSH_INSN1(ret, location, topn,
INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2462 PUSH_INSNL(ret, location, branchif, key_error_label);
2465 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2468 VALUE operand = rb_fstring_lit(
"%p: %s");
2469 PUSH_INSN1(ret, location, putobject, operand);
2472 PUSH_INSN1(ret, location, topn,
INT2FIX(4));
2473 PUSH_INSN1(ret, location, topn,
INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 6));
2474 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(3));
2475 PUSH_SEND(ret, location, id_core_raise,
INT2FIX(2));
2476 PUSH_INSNL(ret, location, jump, cleanup_label);
2478 PUSH_LABEL(ret, key_error_label);
2480 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2483 VALUE operand = rb_fstring_lit(
"%p: %s");
2484 PUSH_INSN1(ret, location, putobject, operand);
2487 PUSH_INSN1(ret, location, topn,
INT2FIX(4));
2488 PUSH_INSN1(ret, location, topn,
INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 6));
2489 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(3));
2490 PUSH_INSN1(ret, location, topn,
INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE + 4));
2491 PUSH_INSN1(ret, location, topn,
INT2FIX(PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY + 5));
2492 PUSH_SEND_R(ret, location, rb_intern(
"new"),
INT2FIX(1), NULL,
INT2FIX(VM_CALL_KWARG), kw_arg);
2493 PUSH_SEND(ret, location, id_core_raise,
INT2FIX(1));
2494 PUSH_LABEL(ret, cleanup_label);
2496 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(7));
2497 if (!popped) PUSH_INSN(ret, location, putnil);
2498 PUSH_INSNL(ret, location, jump, done_label);
2499 PUSH_INSN1(ret, location, dupn,
INT2FIX(5));
2500 if (popped) PUSH_INSN(ret, location, putnil);
2507pm_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)
2509 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
2524 const size_t posts_size = cast->
posts.
size;
2525 const size_t minimum_size = requireds_size + posts_size;
2527 bool rest_named =
false;
2528 bool use_rest_size =
false;
2530 if (cast->
rest != NULL) {
2532 use_rest_size = (rest_named || (!rest_named && posts_size > 0));
2535 LABEL *match_failed_label = NEW_LABEL(location.
line);
2536 LABEL *type_error_label = NEW_LABEL(location.
line);
2537 LABEL *deconstruct_label = NEW_LABEL(location.
line);
2538 LABEL *deconstructed_label = NEW_LABEL(location.
line);
2540 if (use_rest_size) {
2541 PUSH_INSN1(ret, location, putobject,
INT2FIX(0));
2542 PUSH_INSN(ret, location, swap);
2547 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->
constant, ret, match_failed_label, in_single_pattern, base_index));
2550 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));
2552 PUSH_INSN(ret, location, dup);
2553 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2554 PUSH_INSN1(ret, location, putobject,
INT2FIX(minimum_size));
2555 PUSH_SEND(ret, location, cast->
rest == NULL ? idEq : idGE,
INT2FIX(1));
2556 if (in_single_pattern) {
2557 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+)");
2558 CHECK(pm_compile_pattern_length_error(iseq, scope_node, node, ret, message,
INT2FIX(minimum_size), base_index + 1));
2560 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2562 for (
size_t index = 0; index < requireds_size; index++) {
2564 PUSH_INSN(ret, location, dup);
2565 PUSH_INSN1(ret, location, putobject,
INT2FIX(index));
2566 PUSH_SEND(ret, location, idAREF,
INT2FIX(1));
2567 CHECK(pm_compile_pattern_match(iseq, scope_node, required, ret, match_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 1));
2570 if (cast->
rest != NULL) {
2572 PUSH_INSN(ret, location, dup);
2573 PUSH_INSN1(ret, location, putobject,
INT2FIX(requireds_size));
2574 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
2575 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2576 PUSH_INSN1(ret, location, putobject,
INT2FIX(minimum_size));
2577 PUSH_SEND(ret, location, idMINUS,
INT2FIX(1));
2578 PUSH_INSN1(ret, location, setn,
INT2FIX(4));
2579 PUSH_SEND(ret, location, idAREF,
INT2FIX(2));
2580 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));
2582 else if (posts_size > 0) {
2583 PUSH_INSN(ret, location, dup);
2584 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2585 PUSH_INSN1(ret, location, putobject,
INT2FIX(minimum_size));
2586 PUSH_SEND(ret, location, idMINUS,
INT2FIX(1));
2587 PUSH_INSN1(ret, location, setn,
INT2FIX(2));
2588 PUSH_INSN(ret, location, pop);
2592 for (
size_t index = 0; index < posts_size; index++) {
2594 PUSH_INSN(ret, location, dup);
2596 PUSH_INSN1(ret, location, putobject,
INT2FIX(requireds_size + index));
2597 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2598 PUSH_SEND(ret, location, idPLUS,
INT2FIX(1));
2599 PUSH_SEND(ret, location, idAREF,
INT2FIX(1));
2600 CHECK(pm_compile_pattern_match(iseq, scope_node, post, ret, match_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 1));
2603 PUSH_INSN(ret, location, pop);
2604 if (use_rest_size) {
2605 PUSH_INSN(ret, location, pop);
2608 PUSH_INSNL(ret, location, jump, matched_label);
2609 PUSH_INSN(ret, location, putnil);
2610 if (use_rest_size) {
2611 PUSH_INSN(ret, location, putnil);
2614 PUSH_LABEL(ret, type_error_label);
2615 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2619 VALUE operand = rb_fstring_lit(
"deconstruct must return Array");
2620 PUSH_INSN1(ret, location, putobject, operand);
2623 PUSH_SEND(ret, location, id_core_raise,
INT2FIX(2));
2624 PUSH_INSN(ret, location, pop);
2626 PUSH_LABEL(ret, match_failed_label);
2627 PUSH_INSN(ret, location, pop);
2628 if (use_rest_size) {
2629 PUSH_INSN(ret, location, pop);
2632 PUSH_INSNL(ret, location, jump, unmatched_label);
2647 LABEL *match_failed_label = NEW_LABEL(location.
line);
2648 LABEL *type_error_label = NEW_LABEL(location.
line);
2649 LABEL *deconstruct_label = NEW_LABEL(location.
line);
2650 LABEL *deconstructed_label = NEW_LABEL(location.
line);
2653 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->
constant, ret, match_failed_label, in_single_pattern, base_index));
2656 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));
2658 PUSH_INSN(ret, location, dup);
2659 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2660 PUSH_INSN1(ret, location, putobject,
INT2FIX(size));
2661 PUSH_SEND(ret, location, idGE,
INT2FIX(1));
2662 if (in_single_pattern) {
2663 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));
2665 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2668 LABEL *while_begin_label = NEW_LABEL(location.
line);
2669 LABEL *next_loop_label = NEW_LABEL(location.
line);
2670 LABEL *find_succeeded_label = NEW_LABEL(location.
line);
2671 LABEL *find_failed_label = NEW_LABEL(location.
line);
2673 PUSH_INSN(ret, location, dup);
2674 PUSH_SEND(ret, location, idLength,
INT2FIX(0));
2676 PUSH_INSN(ret, location, dup);
2677 PUSH_INSN1(ret, location, putobject,
INT2FIX(size));
2678 PUSH_SEND(ret, location, idMINUS,
INT2FIX(1));
2679 PUSH_INSN1(ret, location, putobject,
INT2FIX(0));
2680 PUSH_LABEL(ret, while_begin_label);
2682 PUSH_INSN(ret, location, dup);
2683 PUSH_INSN1(ret, location, topn,
INT2FIX(2));
2684 PUSH_SEND(ret, location, idLE,
INT2FIX(1));
2685 PUSH_INSNL(ret, location, branchunless, find_failed_label);
2687 for (
size_t index = 0; index < size; index++) {
2688 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2689 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
2692 PUSH_INSN1(ret, location, putobject,
INT2FIX(index));
2693 PUSH_SEND(ret, location, idPLUS,
INT2FIX(1));
2696 PUSH_SEND(ret, location, idAREF,
INT2FIX(1));
2697 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));
2703 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2704 PUSH_INSN1(ret, location, putobject,
INT2FIX(0));
2705 PUSH_INSN1(ret, location, topn,
INT2FIX(2));
2706 PUSH_SEND(ret, location, idAREF,
INT2FIX(2));
2707 CHECK(pm_compile_pattern_match(iseq, scope_node, left->
expression, ret, find_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 4));
2713 if (right->expression != NULL) {
2714 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2715 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
2716 PUSH_INSN1(ret, location, putobject,
INT2FIX(size));
2717 PUSH_SEND(ret, location, idPLUS,
INT2FIX(1));
2718 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2719 PUSH_SEND(ret, location, idAREF,
INT2FIX(2));
2720 pm_compile_pattern_match(iseq, scope_node, right->expression, ret, find_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 4);
2723 PUSH_INSNL(ret, location, jump, find_succeeded_label);
2725 PUSH_LABEL(ret, next_loop_label);
2726 PUSH_INSN1(ret, location, putobject,
INT2FIX(1));
2727 PUSH_SEND(ret, location, idPLUS,
INT2FIX(1));
2728 PUSH_INSNL(ret, location, jump, while_begin_label);
2730 PUSH_LABEL(ret, find_failed_label);
2731 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(3));
2732 if (in_single_pattern) {
2733 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2736 VALUE operand = rb_fstring_lit(
"%p does not match to find pattern");
2737 PUSH_INSN1(ret, location, putobject, operand);
2740 PUSH_INSN1(ret, location, topn,
INT2FIX(2));
2741 PUSH_SEND(ret, location, id_core_sprintf,
INT2FIX(2));
2742 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
2744 PUSH_INSN1(ret, location, putobject,
Qfalse);
2745 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
2747 PUSH_INSN(ret, location, pop);
2748 PUSH_INSN(ret, location, pop);
2750 PUSH_INSNL(ret, location, jump, match_failed_label);
2751 PUSH_INSN1(ret, location, dupn,
INT2FIX(3));
2753 PUSH_LABEL(ret, find_succeeded_label);
2754 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(3));
2757 PUSH_INSN(ret, location, pop);
2758 PUSH_INSNL(ret, location, jump, matched_label);
2759 PUSH_INSN(ret, location, putnil);
2761 PUSH_LABEL(ret, type_error_label);
2762 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2766 VALUE operand = rb_fstring_lit(
"deconstruct must return Array");
2767 PUSH_INSN1(ret, location, putobject, operand);
2770 PUSH_SEND(ret, location, id_core_raise,
INT2FIX(2));
2771 PUSH_INSN(ret, location, pop);
2773 PUSH_LABEL(ret, match_failed_label);
2774 PUSH_INSN(ret, location, pop);
2775 PUSH_INSNL(ret, location, jump, unmatched_label);
2794 LABEL *match_failed_label = NEW_LABEL(location.
line);
2795 LABEL *type_error_label = NEW_LABEL(location.
line);
2798 if (has_keys && !has_rest) {
2801 for (
size_t index = 0; index < cast->
elements.
size; index++) {
2809 rb_ary_push(keys, symbol);
2814 CHECK(pm_compile_pattern_constant(iseq, scope_node, cast->
constant, ret, match_failed_label, in_single_pattern, base_index));
2817 PUSH_INSN(ret, location, dup);
2820 VALUE operand =
ID2SYM(rb_intern(
"deconstruct_keys"));
2821 PUSH_INSN1(ret, location, putobject, operand);
2824 PUSH_SEND(ret, location, idRespond_to,
INT2FIX(1));
2825 if (in_single_pattern) {
2826 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit(
"%p does not respond to #deconstruct_keys"), base_index + 1));
2828 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2831 PUSH_INSN(ret, location, putnil);
2834 PUSH_INSN1(ret, location, duparray, keys);
2837 PUSH_SEND(ret, location, rb_intern(
"deconstruct_keys"),
INT2FIX(1));
2839 PUSH_INSN(ret, location, dup);
2841 PUSH_INSNL(ret, location, branchunless, type_error_label);
2844 PUSH_SEND(ret, location, rb_intern(
"dup"),
INT2FIX(0));
2848 DECL_ANCHOR(match_values);
2850 for (
size_t index = 0; index < cast->
elements.
size; index++) {
2859 PUSH_INSN(ret, location, dup);
2860 PUSH_INSN1(ret, location, putobject, symbol);
2861 PUSH_SEND(ret, location, rb_intern(
"key?"),
INT2FIX(1));
2863 if (in_single_pattern) {
2864 LABEL *match_succeeded_label = NEW_LABEL(location.
line);
2866 PUSH_INSN(ret, location, dup);
2867 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
2871 PUSH_INSN1(ret, location, putobject, operand);
2874 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 2));
2875 PUSH_INSN1(ret, location, putobject,
Qtrue);
2876 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 3));
2877 PUSH_INSN1(ret, location, topn,
INT2FIX(3));
2878 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE + 4));
2879 PUSH_INSN1(ret, location, putobject, symbol);
2880 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY + 5));
2882 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(4));
2883 PUSH_LABEL(ret, match_succeeded_label);
2886 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2887 PUSH_INSN(match_values, location, dup);
2888 PUSH_INSN1(match_values, location, putobject, symbol);
2889 PUSH_SEND(match_values, location, has_rest ? rb_intern(
"delete") : idAREF,
INT2FIX(1));
2896 CHECK(pm_compile_pattern_match(iseq, scope_node, value, match_values, match_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 1));
2899 PUSH_SEQ(ret, match_values);
2902 PUSH_INSN(ret, location, dup);
2903 PUSH_SEND(ret, location, idEmptyP,
INT2FIX(0));
2904 if (in_single_pattern) {
2905 CHECK(pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit(
"%p is not empty"), base_index + 1));
2907 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2913 PUSH_INSN(ret, location, dup);
2914 PUSH_SEND(ret, location, idEmptyP,
INT2FIX(0));
2915 if (in_single_pattern) {
2916 pm_compile_pattern_generic_error(iseq, scope_node, node, ret, rb_fstring_lit(
"rest of %p is not empty"), base_index + 1);
2918 PUSH_INSNL(ret, location, branchunless, match_failed_label);
2923 PUSH_INSN(ret, location, dup);
2924 pm_compile_pattern_match(iseq, scope_node, splat->value, ret, match_failed_label, in_single_pattern, in_alternation_pattern,
false, base_index + 1);
2928 rb_bug(
"unreachable");
2933 PUSH_INSN(ret, location, pop);
2934 PUSH_INSNL(ret, location, jump, matched_label);
2935 PUSH_INSN(ret, location, putnil);
2937 PUSH_LABEL(ret, type_error_label);
2938 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
2942 VALUE operand = rb_fstring_lit(
"deconstruct_keys must return Hash");
2943 PUSH_INSN1(ret, location, putobject, operand);
2946 PUSH_SEND(ret, location, id_core_raise,
INT2FIX(2));
2947 PUSH_INSN(ret, location, pop);
2949 PUSH_LABEL(ret, match_failed_label);
2950 PUSH_INSN(ret, location, pop);
2951 PUSH_INSNL(ret, location, jump, unmatched_label);
2966 LABEL *match_failed_label = NEW_LABEL(location.
line);
2968 PUSH_INSN(ret, location, dup);
2969 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));
2970 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));
2971 PUSH_INSN(ret, location, putnil);
2973 PUSH_LABEL(ret, match_failed_label);
2974 PUSH_INSN(ret, location, pop);
2975 PUSH_INSNL(ret, location, jump, unmatched_label);
2984 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->
name, cast->
depth);
2990 if (in_alternation_pattern) {
2991 ID id = pm_constant_id_lookup(scope_node, cast->
name);
2992 const char *name = rb_id2name(
id);
2994 if (name && strlen(name) > 0 && name[0] !=
'_') {
2995 COMPILE_ERROR(iseq, location.
line,
"illegal variable in alternative pattern (%"PRIsVALUE
")", rb_id2str(
id));
3000 PUSH_SETLOCAL(ret, location, index.index, index.level);
3001 PUSH_INSNL(ret, location, jump, matched_label);
3009 LABEL *matched_left_label = NEW_LABEL(location.
line);
3010 LABEL *unmatched_left_label = NEW_LABEL(location.
line);
3014 PUSH_INSN(ret, location, dup);
3015 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));
3020 PUSH_LABEL(ret, matched_left_label);
3021 PUSH_INSN(ret, location, pop);
3022 PUSH_INSNL(ret, location, jump, matched_label);
3023 PUSH_INSN(ret, location, putnil);
3027 PUSH_LABEL(ret, unmatched_left_label);
3028 CHECK(pm_compile_pattern(iseq, scope_node, cast->
right, ret, matched_label, unmatched_label, in_single_pattern,
true, use_deconstructed_cache, base_index));
3036 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);
3076 PM_COMPILE_NOT_POPPED(node);
3077 if (in_single_pattern) {
3078 PUSH_INSN1(ret, location, dupn,
INT2FIX(2));
3081 PUSH_INSN1(ret, location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_CASE));
3083 if (in_single_pattern) {
3084 pm_compile_pattern_eqq_error(iseq, scope_node, node, ret, base_index + 2);
3087 PUSH_INSNL(ret, location, branchif, matched_label);
3088 PUSH_INSNL(ret, location, jump, unmatched_label);
3097 CHECK(pm_compile_pattern(iseq, scope_node, cast->
variable, ret, matched_label, unmatched_label, in_single_pattern, in_alternation_pattern,
true, base_index));
3131 CHECK(pm_compile_pattern_match(iseq, scope_node, statement, ret, unmatched_label, in_single_pattern, in_alternation_pattern, use_deconstructed_cache, base_index));
3132 PM_COMPILE_NOT_POPPED(predicate);
3134 if (in_single_pattern) {
3135 LABEL *match_succeeded_label = NEW_LABEL(location.
line);
3137 PUSH_INSN(ret, location, dup);
3139 PUSH_INSNL(ret, location, branchif, match_succeeded_label);
3142 PUSH_INSNL(ret, location, branchunless, match_succeeded_label);
3146 VALUE operand = rb_fstring_lit(
"guard clause does not return true");
3147 PUSH_INSN1(ret, location, putobject, operand);
3150 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING + 1));
3151 PUSH_INSN1(ret, location, putobject,
Qfalse);
3152 PUSH_INSN1(ret, location, setn,
INT2FIX(base_index + PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P + 2));
3154 PUSH_INSN(ret, location, pop);
3155 PUSH_INSN(ret, location, pop);
3157 PUSH_LABEL(ret, match_succeeded_label);
3161 PUSH_INSNL(ret, location, branchunless, unmatched_label);
3164 PUSH_INSNL(ret, location, branchif, unmatched_label);
3167 PUSH_INSNL(ret, location, jump, matched_label);
3174 rb_bug(
"Unexpected node type in pattern matching expression: %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
3181#undef PM_PATTERN_BASE_INDEX_OFFSET_DECONSTRUCTED_CACHE
3182#undef PM_PATTERN_BASE_INDEX_OFFSET_ERROR_STRING
3183#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_P
3184#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_MATCHEE
3185#undef PM_PATTERN_BASE_INDEX_OFFSET_KEY_ERROR_KEY
3189pm_scope_node_init(
const pm_node_t *node, pm_scope_node_t *scope, pm_scope_node_t *previous)
3193 memset(scope, 0,
sizeof(pm_scope_node_t));
3199 scope->previous = previous;
3203 scope->parser = previous->parser;
3204 scope->encoding = previous->encoding;
3206 scope->constants = previous->constants;
3207 scope->coverage_enabled = previous->coverage_enabled;
3214 scope->body = cast->
body;
3215 scope->locals = cast->
locals;
3221 scope->body = cast->
body;
3222 scope->locals = cast->
locals;
3228 scope->body = cast->body;
3229 scope->locals = cast->locals;
3256 scope->body = cast->
body;
3257 scope->locals = cast->
locals;
3269 scope->body = cast->
body;
3270 scope->locals = cast->
locals;
3281 scope->locals = cast->locals;
3296 scope->body = cast->
body;
3297 scope->locals = cast->
locals;
3306 rb_bug(
"unreachable");
3312pm_scope_node_destroy(pm_scope_node_t *scope_node)
3314 if (scope_node->index_lookup_table) {
3315 st_free_table(scope_node->index_lookup_table);
3331pm_compile_retry_end_label(rb_iseq_t *iseq, LINK_ANCHOR *
const ret, LABEL *retry_end_l)
3334 LINK_ELEMENT *last_elem = LAST_ELEMENT(ret);
3335 iobj = IS_INSN(last_elem) ? (INSN*) last_elem : (INSN*) get_prev_insn((INSN*) last_elem);
3336 while (!IS_INSN_ID(iobj, send) && !IS_INSN_ID(iobj, invokesuper) && !IS_INSN_ID(iobj, sendforward) && !IS_INSN_ID(iobj, invokesuperforward)) {
3337 iobj = (INSN*) get_prev_insn(iobj);
3339 ELEM_INSERT_NEXT(&iobj->link, (LINK_ELEMENT*) retry_end_l);
3344 if (&iobj->link == LAST_ELEMENT(ret)) {
3345 ret->last = (LINK_ELEMENT*) retry_end_l;
3350pm_iseq_builtin_function_name(
const pm_scope_node_t *scope_node,
const pm_node_t *receiver,
ID method_id)
3352 const char *name = rb_id2name(method_id);
3353 static const char prefix[] =
"__builtin_";
3354 const size_t prefix_len =
sizeof(prefix) - 1;
3356 if (receiver == NULL) {
3357 if (UNLIKELY(strncmp(prefix, name, prefix_len) == 0)) {
3359 return &name[prefix_len];
3386 if (arguments == NULL) {
3387 COMPILE_ERROR(iseq, node_location->
line,
"attr!: no argument");
3394 COMPILE_ERROR(iseq, node_location->
line,
"non symbol argument to attr!: %s", pm_node_type_to_str(
PM_NODE_TYPE(argument)));
3398 VALUE symbol = pm_static_literal_value(iseq, argument, scope_node);
3401 if (strcmp(RSTRING_PTR(
string),
"leaf") == 0) {
3402 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_LEAF;
3404 else if (strcmp(RSTRING_PTR(
string),
"inline_block") == 0) {
3405 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_INLINE_BLOCK;
3407 else if (strcmp(RSTRING_PTR(
string),
"use_block") == 0) {
3408 iseq_set_use_block(iseq);
3410 else if (strcmp(RSTRING_PTR(
string),
"c_trace") == 0) {
3412 ISEQ_BODY(iseq)->builtin_attrs |= BUILTIN_ATTR_C_TRACE;
3415 COMPILE_ERROR(iseq, node_location->
line,
"unknown argument to attr!: %s", RSTRING_PTR(
string));
3424pm_compile_builtin_arg(rb_iseq_t *iseq, LINK_ANCHOR *
const ret,
const pm_scope_node_t *scope_node,
const pm_arguments_node_t *arguments,
const pm_node_location_t *node_location,
int popped)
3426 if (arguments == NULL) {
3427 COMPILE_ERROR(iseq, node_location->
line,
"arg!: no argument");
3432 COMPILE_ERROR(iseq, node_location->
line,
"arg!: too many argument");
3438 COMPILE_ERROR(iseq, node_location->
line,
"non symbol argument to arg!: %s", pm_node_type_to_str(
PM_NODE_TYPE(argument)));
3444 int index = ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->local_table_size - get_local_var_idx(iseq, name);
3446 debugs(
"id: %s idx: %d\n", rb_id2name(name), index);
3447 PUSH_GETLOCAL(ret, *node_location, index, get_lvar_level(iseq));
3454pm_compile_builtin_mandatory_only_method(rb_iseq_t *iseq, pm_scope_node_t *scope_node,
const pm_call_node_t *call_node,
const pm_node_location_t *node_location)
3456 const pm_node_t *ast_node = scope_node->ast_node;
3458 rb_bug(
"mandatory_only?: not in method definition");
3464 if (parameters_node == NULL) {
3465 rb_bug(
"mandatory_only?: in method definition with no parameters");
3471 rb_bug(
"mandatory_only?: not in method definition with plain statements");
3477 rb_bug(
"mandatory_only?: can't find mandatory node");
3482 .base = parameters_node->
base,
3487 .base = def_node->
base,
3488 .name = def_node->
name,
3490 .parameters = ¶meters,
3499 pm_scope_node_t next_scope_node;
3500 pm_scope_node_init(&def.base, &next_scope_node, scope_node);
3503 ISEQ_BODY(iseq)->mandatory_only_iseq = pm_iseq_new_with_opt(
3505 rb_iseq_base_label(iseq),
3507 rb_iseq_realpath(iseq),
3508 node_location->
line,
3512 ISEQ_COMPILE_DATA(iseq)->option,
3517 RUBY_ASSERT(ISEQ_BODY(iseq)->mandatory_only_iseq == NULL);
3518 rb_jump_tag(error_state);
3521 pm_scope_node_destroy(&next_scope_node);
3526pm_compile_builtin_function_call(rb_iseq_t *iseq, LINK_ANCHOR *
const ret, pm_scope_node_t *scope_node,
const pm_call_node_t *call_node,
const pm_node_location_t *node_location,
int popped,
const rb_iseq_t *parent_block,
const char *builtin_func)
3530 if (parent_block != NULL) {
3531 COMPILE_ERROR(iseq, node_location->
line,
"should not call builtins here.");
3535#define BUILTIN_INLINE_PREFIX "_bi"
3536 char inline_func[
sizeof(BUILTIN_INLINE_PREFIX) +
DECIMAL_SIZE_OF(
int)];
3537 bool cconst =
false;
3542 if (strcmp(
"cstmt!", builtin_func) == 0 || strcmp(
"cexpr!", builtin_func) == 0) {
3545 else if (strcmp(
"cconst!", builtin_func) == 0) {
3548 else if (strcmp(
"cinit!", builtin_func) == 0) {
3552 else if (strcmp(
"attr!", builtin_func) == 0) {
3553 return pm_compile_builtin_attr(iseq, scope_node, arguments, node_location);
3555 else if (strcmp(
"arg!", builtin_func) == 0) {
3556 return pm_compile_builtin_arg(iseq, ret, scope_node, arguments, node_location, popped);
3558 else if (strcmp(
"mandatory_only?", builtin_func) == 0) {
3560 rb_bug(
"mandatory_only? should be in if condition");
3562 else if (!LIST_INSN_SIZE_ZERO(ret)) {
3563 rb_bug(
"mandatory_only? should be put on top");
3566 PUSH_INSN1(ret, *node_location, putobject,
Qfalse);
3567 return pm_compile_builtin_mandatory_only_method(iseq, scope_node, call_node, node_location);
3570 rb_bug(
"can't find builtin function:%s", builtin_func);
3573 COMPILE_ERROR(iseq, node_location->
line,
"can't find builtin function:%s", builtin_func);
3577 int inline_index = node_location->
line;
3578 snprintf(inline_func,
sizeof(inline_func), BUILTIN_INLINE_PREFIX
"%d", inline_index);
3579 builtin_func = inline_func;
3585 typedef VALUE(*builtin_func0)(
void *,
VALUE);
3586 VALUE const_val = (*(builtin_func0)(uintptr_t)bf->func_ptr)(NULL,
Qnil);
3587 PUSH_INSN1(ret, *node_location, putobject, const_val);
3593 DECL_ANCHOR(args_seq);
3597 int argc = pm_setup_args(arguments, call_node->
block, &flags, &keywords, iseq, args_seq, scope_node, node_location);
3599 if (argc != bf->argc) {
3600 COMPILE_ERROR(iseq, node_location->
line,
"argc is not match for builtin function:%s (expect %d but %d)", builtin_func, bf->argc, argc);
3604 unsigned int start_index;
3605 if (delegate_call_p(iseq, argc, args_seq, &start_index)) {
3606 PUSH_INSN2(ret, *node_location, opt_invokebuiltin_delegate, bf,
INT2FIX(start_index));
3609 PUSH_SEQ(ret, args_seq);
3610 PUSH_INSN1(ret, *node_location, invokebuiltin, bf);
3613 if (popped) PUSH_INSN(ret, *node_location, pop);
3621pm_compile_call(rb_iseq_t *iseq,
const pm_call_node_t *call_node, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node,
ID method_id, LABEL *start)
3627 LABEL *else_label = NEW_LABEL(location.
line);
3628 LABEL *end_label = NEW_LABEL(location.
line);
3629 LABEL *retry_end_l = NEW_LABEL(location.
line);
3632 rb_code_location_t code_location = { 0 };
3633 int node_id = location.
node_id;
3636 if (PM_BRANCH_COVERAGE_P(iseq)) {
3637 const uint8_t *cursors[3] = {
3643 const uint8_t *end_cursor = cursors[0];
3644 end_cursor = (end_cursor == NULL || cursors[1] == NULL) ? cursors[1] : (end_cursor > cursors[1] ? end_cursor : cursors[1]);
3645 end_cursor = (end_cursor == NULL || cursors[2] == NULL) ? cursors[2] : (end_cursor > cursors[2] ? end_cursor : cursors[2]);
3648 const pm_line_column_t start_location = PM_NODE_START_LINE_COLUMN(scope_node->parser, call_node);
3651 code_location = (rb_code_location_t) {
3652 .beg_pos = { .lineno = start_location.line, .column = start_location.column },
3653 .end_pos = { .lineno = end_location.line, .column = end_location.column }
3656 branches = decl_branch_base(iseq, PTR2NUM(call_node), &code_location,
"&.");
3659 PUSH_INSN(ret, location, dup);
3660 PUSH_INSNL(ret, location, branchnil, else_label);
3662 add_trace_branch_coverage(iseq, ret, &code_location, node_id, 0,
"then", branches);
3668 int orig_argc = pm_setup_args(call_node->
arguments, call_node->
block, &flags, &kw_arg, iseq, ret, scope_node, &location);
3669 const rb_iseq_t *previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
3670 const rb_iseq_t *block_iseq = NULL;
3674 pm_scope_node_t next_scope_node;
3675 pm_scope_node_init(call_node->
block, &next_scope_node, scope_node);
3677 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));
3678 pm_scope_node_destroy(&next_scope_node);
3679 ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq;
3683 flags |= VM_CALL_VCALL;
3687 flags |= VM_CALL_ARGS_SIMPLE;
3692 flags |= VM_CALL_FCALL;
3696 if (flags & VM_CALL_ARGS_BLOCKARG) {
3697 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
3698 if (flags & VM_CALL_ARGS_SPLAT) {
3699 PUSH_INSN1(ret, location, putobject,
INT2FIX(-1));
3700 PUSH_SEND_WITH_FLAG(ret, location, idAREF,
INT2FIX(1),
INT2FIX(0));
3702 PUSH_INSN1(ret, location, setn,
INT2FIX(orig_argc + 3));
3703 PUSH_INSN(ret, location, pop);
3705 else if (flags & VM_CALL_ARGS_SPLAT) {
3706 PUSH_INSN(ret, location, dup);
3707 PUSH_INSN1(ret, location, putobject,
INT2FIX(-1));
3708 PUSH_SEND_WITH_FLAG(ret, location, idAREF,
INT2FIX(1),
INT2FIX(0));
3709 PUSH_INSN1(ret, location, setn,
INT2FIX(orig_argc + 2));
3710 PUSH_INSN(ret, location, pop);
3713 PUSH_INSN1(ret, location, setn,
INT2FIX(orig_argc + 1));
3717 if ((flags & VM_CALL_KW_SPLAT) && (flags & VM_CALL_ARGS_BLOCKARG) && !(flags & VM_CALL_KW_SPLAT_MUT)) {
3718 PUSH_INSN(ret, location, splatkw);
3721 PUSH_SEND_R(ret, location, method_id,
INT2FIX(orig_argc), block_iseq,
INT2FIX(flags), kw_arg);
3723 if (block_iseq && ISEQ_BODY(block_iseq)->catch_table) {
3724 pm_compile_retry_end_label(iseq, ret, retry_end_l);
3725 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, start, retry_end_l, block_iseq, retry_end_l);
3729 PUSH_INSNL(ret, location, jump, end_label);
3730 PUSH_LABEL(ret, else_label);
3731 add_trace_branch_coverage(iseq, ret, &code_location, node_id, 1,
"else", branches);
3732 PUSH_LABEL(ret, end_label);
3736 PUSH_INSN(ret, location, pop);
3739 if (popped) PUSH_INSN(ret, location, pop);
3740 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
3744pm_compile_defined_expr0(rb_iseq_t *iseq,
const pm_node_t *node,
const pm_node_location_t *node_location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node,
bool in_condition, LABEL **lfinish,
bool explicit_receiver)
3747 enum defined_type dtype = DEFINED_NOT_DEFINED;
3754 for (
size_t idx = 0; idx < arguments->
size; idx++) {
3756 pm_compile_defined_expr0(iseq, argument, node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
3759 lfinish[1] = NEW_LABEL(location.
line);
3761 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
3763 dtype = DEFINED_TRUE;
3767 dtype = DEFINED_NIL;
3772 if (cast->
body == NULL) {
3774 dtype = DEFINED_NIL;
3779 pm_compile_defined_expr0(iseq, ((
const pm_statements_node_t *) cast->
body)->body.nodes[0], node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
3785 dtype = DEFINED_EXPR;
3791 dtype = DEFINED_SELF;
3794 dtype = DEFINED_TRUE;
3797 dtype = DEFINED_FALSE;
3803 lfinish[1] = NEW_LABEL(location.
line);
3806 for (
size_t index = 0; index < cast->
elements.
size; index++) {
3807 pm_compile_defined_expr0(iseq, cast->
elements.
nodes[index], node_location, ret, popped, scope_node,
true, lfinish,
false);
3808 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
3811 dtype = DEFINED_EXPR;
3825 if (elements->
size > 0 && !lfinish[1]) {
3826 lfinish[1] = NEW_LABEL(location.
line);
3829 for (
size_t index = 0; index < elements->
size; index++) {
3836 pm_compile_defined_expr0(iseq, assoc->
key, node_location, ret, popped, scope_node,
true, lfinish,
false);
3837 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
3839 pm_compile_defined_expr0(iseq, assoc->
value, node_location, ret, popped, scope_node,
true, lfinish,
false);
3840 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
3847 pm_compile_defined_expr0(iseq, assoc_splat->
value, node_location, ret, popped, scope_node,
true, lfinish,
false);
3848 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
3853 rb_bug(
"unexpected node type in hash node: %s", pm_node_type_to_str(
PM_NODE_TYPE(element)));
3858 dtype = DEFINED_EXPR;
3863 pm_compile_defined_expr0(iseq, cast->
expression, node_location, ret, popped, scope_node, in_condition, lfinish,
false);
3866 lfinish[1] = NEW_LABEL(location.
line);
3869 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
3870 dtype = DEFINED_EXPR;
3875 pm_compile_defined_expr0(iseq, cast->
value, node_location, ret, popped, scope_node, in_condition, lfinish, explicit_receiver);
3918 dtype = DEFINED_EXPR;
3921 dtype = DEFINED_LVAR;
3924#define PUSH_VAL(type) (in_condition ? Qtrue : rb_iseq_defined_string(type))
3929 ID name = pm_constant_id_lookup(scope_node, cast->
name);
3930 PUSH_INSN3(ret, location, definedivar,
ID2SYM(name), get_ivar_ic_value(iseq, name), PUSH_VAL(DEFINED_IVAR));
3935 const char *char_ptr = (
const char *) (node->
location.
start + 1);
3936 ID backref_val =
INT2FIX(rb_intern2(char_ptr, 1)) << 1 | 1;
3938 PUSH_INSN(ret, location, putnil);
3939 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_REF), backref_val, PUSH_VAL(DEFINED_GVAR));
3946 PUSH_INSN(ret, location, putnil);
3947 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_REF),
INT2FIX(reference_number << 1), PUSH_VAL(DEFINED_GVAR));
3955 PUSH_INSN(ret, location, putnil);
3956 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_GVAR), name, PUSH_VAL(DEFINED_GVAR));
3964 PUSH_INSN(ret, location, putnil);
3965 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CVAR), name, PUSH_VAL(DEFINED_CVAR));
3973 PUSH_INSN(ret, location, putnil);
3974 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CONST), name, PUSH_VAL(DEFINED_CONST));
3982 if (cast->
parent != NULL) {
3983 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.
line);
3984 pm_compile_defined_expr0(iseq, cast->
parent, node_location, ret, popped, scope_node,
true, lfinish,
false);
3986 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
3987 PM_COMPILE(cast->
parent);
3990 PUSH_INSN1(ret, location, putobject, rb_cObject);
3993 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CONST_FROM), name, PUSH_VAL(DEFINED_CONST));
4000 dtype = DEFINED_EXPR;
4004 ID method_id = pm_constant_id_lookup(scope_node, cast->
name);
4007 if (!lfinish[1]) lfinish[1] = NEW_LABEL(location.
line);
4008 if (!lfinish[2]) lfinish[2] = NEW_LABEL(location.
line);
4012 pm_compile_defined_expr0(iseq, (
const pm_node_t *) cast->
arguments, node_location, ret, popped, scope_node,
true, lfinish,
false);
4013 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4017 pm_compile_defined_expr0(iseq, cast->
receiver, node_location, ret, popped, scope_node,
true, lfinish,
true);
4020 PUSH_INSNL(ret, location, branchunless, lfinish[2]);
4023 ID method_id = pm_constant_id_lookup(scope_node, receiver->name);
4024 pm_compile_call(iseq, receiver, ret, popped, scope_node, method_id, NULL);
4027 PUSH_INSNL(ret, location, branchunless, lfinish[1]);
4031 if (explicit_receiver) PUSH_INSN(ret, location, dup);
4032 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_METHOD),
rb_id2sym(method_id), PUSH_VAL(DEFINED_METHOD));
4035 PUSH_INSN(ret, location, putself);
4036 if (explicit_receiver) PUSH_INSN(ret, location, dup);
4037 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_FUNC),
rb_id2sym(method_id), PUSH_VAL(DEFINED_METHOD));
4043 PUSH_INSN(ret, location, putnil);
4044 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_YIELD), 0, PUSH_VAL(DEFINED_YIELD));
4045 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
4049 PUSH_INSN(ret, location, putnil);
4050 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_ZSUPER), 0, PUSH_VAL(DEFINED_ZSUPER));
4091 dtype = DEFINED_ASGN;
4094 rb_bug(
"Unsupported node %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
4098 PUSH_INSN1(ret, location, putobject, PUSH_VAL(dtype));
4103pm_defined_expr(rb_iseq_t *iseq,
const pm_node_t *node,
const pm_node_location_t *node_location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node,
bool in_condition, LABEL **lfinish,
bool explicit_receiver)
4105 LINK_ELEMENT *lcur = ret->last;
4106 pm_compile_defined_expr0(iseq, node, node_location, ret, popped, scope_node, in_condition, lfinish,
false);
4109 LABEL *lstart = NEW_LABEL(node_location->
line);
4110 LABEL *lend = NEW_LABEL(node_location->
line);
4113 rb_iseq_new_with_callback_new_callback(build_defined_rescue_iseq, NULL);
4115 const rb_iseq_t *rescue = new_child_iseq_with_callback(
4124 lstart->rescued = LABEL_RESCUE_BEG;
4125 lend->rescued = LABEL_RESCUE_END;
4127 APPEND_LABEL(ret, lcur, lstart);
4128 PUSH_LABEL(ret, lend);
4129 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue, lfinish[1]);
4134pm_compile_defined_expr(rb_iseq_t *iseq,
const pm_node_t *node,
const pm_node_location_t *node_location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node,
bool in_condition)
4137 LINK_ELEMENT *last = ret->last;
4139 lfinish[0] = NEW_LABEL(node_location->
line);
4144 pm_defined_expr(iseq, node, node_location, ret, popped, scope_node, in_condition, lfinish,
false);
4148 ELEM_INSERT_NEXT(last, &new_insn_body(iseq, node_location->
line, node_location->
node_id, BIN(putnil), 0)->link);
4149 PUSH_INSN(ret, *node_location, swap);
4151 if (lfinish[2]) PUSH_LABEL(ret, lfinish[2]);
4152 PUSH_INSN(ret, *node_location, pop);
4153 PUSH_LABEL(ret, lfinish[1]);
4157 PUSH_LABEL(ret, lfinish[0]);
4163pm_add_ensure_iseq(LINK_ANCHOR *
const ret, rb_iseq_t *iseq,
int is_return, pm_scope_node_t *scope_node)
4168 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack;
4170 DECL_ANCHOR(ensure);
4173 if (enlp->erange != NULL) {
4174 DECL_ANCHOR(ensure_part);
4175 LABEL *lstart = NEW_LABEL(0);
4176 LABEL *lend = NEW_LABEL(0);
4178 add_ensure_range(iseq, enlp->erange, lstart, lend);
4180 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enlp->prev;
4181 PUSH_LABEL(ensure_part, lstart);
4183 PM_COMPILE_INTO_ANCHOR(ensure_part, (
const pm_node_t *) enlp->ensure_node);
4184 PUSH_LABEL(ensure_part, lend);
4185 PUSH_SEQ(ensure, ensure_part);
4194 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = prev_enlp;
4195 PUSH_SEQ(ret, ensure);
4199 pm_scope_node_t *scope_node;
4200 rb_ast_id_table_t *local_table_for_iseq;
4205pm_local_table_insert_func(st_data_t *key, st_data_t *value, st_data_t arg,
int existing)
4211 pm_scope_node_t *scope_node = ctx->scope_node;
4212 rb_ast_id_table_t *local_table_for_iseq = ctx->local_table_for_iseq;
4213 int local_index = ctx->local_index;
4215 ID local = pm_constant_id_lookup(scope_node, constant_id);
4216 local_table_for_iseq->ids[local_index] = local;
4218 *value = (st_data_t)local_index;
4232pm_insert_local_index(
pm_constant_id_t constant_id,
int local_index, st_table *index_lookup_table, rb_ast_id_table_t *local_table_for_iseq, pm_scope_node_t *scope_node)
4234 RUBY_ASSERT((constant_id & PM_SPECIAL_CONSTANT_FLAG) == 0);
4236 ID local = pm_constant_id_lookup(scope_node, constant_id);
4237 local_table_for_iseq->ids[local_index] = local;
4238 st_insert(index_lookup_table, (st_data_t) constant_id, (st_data_t) local_index);
4246pm_insert_local_special(
ID local_name,
int local_index, st_table *index_lookup_table, rb_ast_id_table_t *local_table_for_iseq)
4248 local_table_for_iseq->ids[local_index] = local_name;
4249 st_insert(index_lookup_table, (st_data_t) (local_name | PM_SPECIAL_CONSTANT_FLAG), (st_data_t) local_index);
4259pm_compile_destructured_param_locals(
const pm_multi_target_node_t *node, st_table *index_lookup_table, rb_ast_id_table_t *local_table_for_iseq, pm_scope_node_t *scope_node,
int local_index)
4261 for (
size_t index = 0; index < node->
lefts.
size; index++) {
4266 pm_insert_local_index(((
const pm_required_parameter_node_t *) left)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4272 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);
4279 if (rest->expression != NULL) {
4283 pm_insert_local_index(((
const pm_required_parameter_node_t *) rest->expression)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4289 for (
size_t index = 0; index < node->
rights.
size; index++) {
4294 pm_insert_local_index(((
const pm_required_parameter_node_t *) right)->name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
4300 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);
4312pm_compile_destructured_param_write(rb_iseq_t *iseq,
const pm_required_parameter_node_t *node, LINK_ANCHOR *
const ret,
const pm_scope_node_t *scope_node)
4314 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4315 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, node->
name, 0);
4316 PUSH_SETLOCAL(ret, location, index.index, index.level);
4328pm_compile_destructured_param_writes(rb_iseq_t *iseq,
const pm_multi_target_node_t *node, LINK_ANCHOR *
const ret,
const pm_scope_node_t *scope_node)
4330 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4334 int flag = (has_rest || has_rights) ? 1 : 0;
4337 for (
size_t index = 0; index < node->
lefts.
size; index++) {
4365 for (
size_t index = 0; index < node->
rights.
size; index++) {
4400} pm_multi_target_state_node_t;
4418 pm_multi_target_state_node_t *head;
4421 pm_multi_target_state_node_t *tail;
4430 pm_multi_target_state_node_t *node =
ALLOC(pm_multi_target_state_node_t);
4432 node->stack_index = state->stack_size + 1;
4433 node->stack_size = stack_size;
4434 node->position = state->position;
4437 if (state->head == NULL) {
4442 state->tail->next = node;
4446 state->stack_size += stack_size;
4459 if (state->stack_size == 0)
return;
4461 pm_multi_target_state_node_t *current = state->head;
4462 pm_multi_target_state_node_t *previous;
4464 while (current != NULL) {
4465 VALUE offset =
INT2FIX(state->stack_size - current->stack_index + current->position);
4466 current->topn->operands[0] = offset;
4472 if (current->stack_size > 1) {
4473 INSN *insn = current->topn;
4475 for (
size_t index = 1; index < current->stack_size; index += 1) {
4476 LINK_ELEMENT *element = get_next_insn(insn);
4479 insn = (INSN *) element;
4482 insn->operands[0] = offset;
4487 current = current->next;
4494pm_compile_multi_target_node(rb_iseq_t *iseq,
const pm_node_t *node, LINK_ANCHOR *
const parents, LINK_ANCHOR *
const writes, LINK_ANCHOR *
const cleanup, pm_scope_node_t *scope_node,
pm_multi_target_state_t *state);
4525pm_compile_target_node(rb_iseq_t *iseq,
const pm_node_t *node, LINK_ANCHOR *
const parents, LINK_ANCHOR *
const writes, LINK_ANCHOR *
const cleanup, pm_scope_node_t *scope_node,
pm_multi_target_state_t *state)
4527 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4537 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->
name, cast->
depth);
4539 PUSH_SETLOCAL(writes, location, index.index, index.level);
4549 ID name = pm_constant_id_lookup(scope_node, cast->
name);
4552 PUSH_INSN2(writes, location, setclassvariable, operand, get_cvar_ic_value(iseq, name));
4562 ID name = pm_constant_id_lookup(scope_node, cast->
name);
4565 PUSH_INSN1(writes, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
4566 PUSH_INSN1(writes, location, setconstant, operand);
4576 ID name = pm_constant_id_lookup(scope_node, cast->
name);
4579 PUSH_INSN1(writes, location, setglobal, operand);
4589 ID name = pm_constant_id_lookup(scope_node, cast->
name);
4592 PUSH_INSN2(writes, location, setinstancevariable, operand, get_ivar_ic_value(iseq, name));
4605 ID name = pm_constant_id_lookup(scope_node, cast->
name);
4607 if (cast->
parent != NULL) {
4608 pm_compile_node(iseq, cast->
parent, parents,
false, scope_node);
4611 PUSH_INSN1(parents, location, putobject, rb_cObject);
4614 if (state == NULL) {
4615 PUSH_INSN(writes, location, swap);
4618 PUSH_INSN1(writes, location, topn,
INT2FIX(1));
4619 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), 1);
4623 PUSH_INSN1(writes, location, setconstant, operand);
4625 if (state != NULL) {
4626 PUSH_INSN(cleanup, location, pop);
4641 ID method_id = pm_constant_id_lookup(scope_node, cast->
name);
4643 pm_compile_node(iseq, cast->
receiver, parents,
false, scope_node);
4645 LABEL *safe_label = NULL;
4647 safe_label = NEW_LABEL(location.
line);
4648 PUSH_INSN(parents, location, dup);
4649 PUSH_INSNL(parents, location, branchnil, safe_label);
4652 if (state != NULL) {
4653 PUSH_INSN1(writes, location, topn,
INT2FIX(1));
4654 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), 1);
4655 PUSH_INSN(writes, location, swap);
4658 int flags = VM_CALL_ARGS_SIMPLE;
4661 PUSH_SEND_WITH_FLAG(writes, location, method_id,
INT2FIX(1),
INT2FIX(flags));
4662 if (safe_label != NULL && state == NULL) PUSH_LABEL(writes, safe_label);
4663 PUSH_INSN(writes, location, pop);
4664 if (safe_label != NULL && state != NULL) PUSH_LABEL(writes, safe_label);
4666 if (state != NULL) {
4667 PUSH_INSN(cleanup, location, pop);
4684 pm_compile_node(iseq, cast->
receiver, parents,
false, scope_node);
4688 int argc = pm_setup_args(cast->
arguments, (
const pm_node_t *) cast->
block, &flags, &kwargs, iseq, parents, scope_node, &location);
4690 if (state != NULL) {
4691 PUSH_INSN1(writes, location, topn,
INT2FIX(argc + 1));
4692 pm_multi_target_state_push(state, (INSN *) LAST_ELEMENT(writes), argc + 1);
4695 PUSH_INSN(writes, location, swap);
4698 for (
int index = 0; index < argc; index++) {
4699 PUSH_INSN1(writes, location, topn,
INT2FIX(argc + 1));
4701 PUSH_INSN1(writes, location, topn,
INT2FIX(argc + 1));
4709 int ci_argc = argc + 1;
4710 if (flags & VM_CALL_ARGS_SPLAT) {
4712 PUSH_INSN1(writes, location, newarray,
INT2FIX(1));
4713 PUSH_INSN(writes, location, concatarray);
4716 PUSH_SEND_R(writes, location, idASET,
INT2NUM(ci_argc), NULL,
INT2FIX(flags), kwargs);
4717 PUSH_INSN(writes, location, pop);
4719 if (state != NULL) {
4721 PUSH_INSN(writes, location, pop);
4724 for (
int index = 0; index < argc + 1; index++) {
4725 PUSH_INSN(cleanup, location, pop);
4738 size_t before_position;
4739 if (state != NULL) {
4740 before_position = state->position;
4744 pm_compile_multi_target_node(iseq, node, parents, writes, cleanup, scope_node, state);
4745 if (state != NULL) state->position = before_position;
4750 rb_bug(
"Unexpected node type: %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
4761pm_compile_multi_target_node(rb_iseq_t *iseq,
const pm_node_t *node, LINK_ANCHOR *
const parents, LINK_ANCHOR *
const writes, LINK_ANCHOR *
const cleanup, pm_scope_node_t *scope_node,
pm_multi_target_state_t *state)
4763 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4771 lefts = &cast->
lefts;
4778 lefts = &cast->
lefts;
4784 rb_bug(
"Unsupported node %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
4789 bool has_posts = rights->
size > 0;
4794 PUSH_INSN2(writes, location, expandarray,
INT2FIX(lefts->
size),
INT2FIX((has_rest || has_posts) ? 1 : 0));
4800 if (state == NULL) state = &target_state;
4802 size_t base_position = state->position;
4803 size_t splat_position = (has_rest || has_posts) ? 1 : 0;
4806 for (
size_t index = 0; index < lefts->
size; index++) {
4808 state->position = lefts->
size - index + splat_position + base_position;
4809 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
4815 state->position = 1 + rights->
size + base_position;
4821 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
4826 if (!has_rest && rest != NULL) {
4830 for (
size_t index = 0; index < rights->
size; index++) {
4832 state->position = rights->
size - index + base_position;
4833 pm_compile_target_node(iseq, target, parents, writes, cleanup, scope_node, state);
4844pm_compile_for_node_index(rb_iseq_t *iseq,
const pm_node_t *node, LINK_ANCHOR *
const ret, pm_scope_node_t *scope_node)
4846 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
4852 PUSH_GETLOCAL(ret, location, 1, 0);
4853 pm_compile_target_node(iseq, node, ret, ret, ret, scope_node, NULL);
4866 DECL_ANCHOR(writes);
4867 DECL_ANCHOR(cleanup);
4871 pm_compile_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
4873 PUSH_GETLOCAL(ret, location, 1, 0);
4876 PUSH_SEQ(ret, writes);
4877 PUSH_SEQ(ret, cleanup);
4879 pm_multi_target_state_update(&state);
4883 DECL_ANCHOR(writes);
4884 DECL_ANCHOR(cleanup);
4886 pm_compile_target_node(iseq, node, ret, writes, cleanup, scope_node, NULL);
4888 LABEL *not_single = NEW_LABEL(location.
line);
4889 LABEL *not_ary = NEW_LABEL(location.
line);
4897 PUSH_GETLOCAL(ret, location, 1, 0);
4898 PUSH_INSN(ret, location, dup);
4899 PUSH_CALL(ret, location, idLength,
INT2FIX(0));
4900 PUSH_INSN1(ret, location, putobject,
INT2FIX(1));
4901 PUSH_CALL(ret, location, idEq,
INT2FIX(1));
4902 PUSH_INSNL(ret, location, branchunless, not_single);
4903 PUSH_INSN(ret, location, dup);
4904 PUSH_INSN1(ret, location, putobject,
INT2FIX(0));
4905 PUSH_CALL(ret, location, idAREF,
INT2FIX(1));
4906 PUSH_INSN1(ret, location, putobject,
rb_cArray);
4907 PUSH_INSN(ret, location, swap);
4908 PUSH_CALL(ret, location, rb_intern(
"try_convert"),
INT2FIX(1));
4909 PUSH_INSN(ret, location, dup);
4910 PUSH_INSNL(ret, location, branchunless, not_ary);
4911 PUSH_INSN(ret, location, swap);
4913 PUSH_LABEL(ret, not_ary);
4914 PUSH_INSN(ret, location, pop);
4916 PUSH_LABEL(ret, not_single);
4917 PUSH_SEQ(ret, writes);
4918 PUSH_SEQ(ret, cleanup);
4922 rb_bug(
"Unexpected node type for index in for node: %s", pm_node_type_to_str(
PM_NODE_TYPE(node)));
4928pm_compile_rescue(rb_iseq_t *iseq,
const pm_begin_node_t *cast,
const pm_node_location_t *node_location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
4932 LABEL *lstart = NEW_LABEL(node_location->
line);
4933 LABEL *lend = NEW_LABEL(node_location->
line);
4934 LABEL *lcont = NEW_LABEL(node_location->
line);
4936 pm_scope_node_t rescue_scope_node;
4939 rb_iseq_t *rescue_iseq = NEW_CHILD_ISEQ(
4946 pm_scope_node_destroy(&rescue_scope_node);
4948 lstart->rescued = LABEL_RESCUE_BEG;
4949 lend->rescued = LABEL_RESCUE_END;
4950 PUSH_LABEL(ret, lstart);
4952 bool prev_in_rescue = ISEQ_COMPILE_DATA(iseq)->in_rescue;
4953 ISEQ_COMPILE_DATA(iseq)->in_rescue =
true;
4960 PUSH_INSN(ret, location, putnil);
4963 ISEQ_COMPILE_DATA(iseq)->in_rescue = prev_in_rescue;
4964 PUSH_LABEL(ret, lend);
4967 if (!popped) PUSH_INSN(ret, *node_location, pop);
4971 PUSH_INSN(ret, *node_location, nop);
4972 PUSH_LABEL(ret, lcont);
4974 if (popped) PUSH_INSN(ret, *node_location, pop);
4975 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue_iseq, lcont);
4976 PUSH_CATCH_ENTRY(CATCH_TYPE_RETRY, lend, lcont, NULL, lstart);
4980pm_compile_ensure(rb_iseq_t *iseq,
const pm_begin_node_t *cast,
const pm_node_location_t *node_location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
4986 if (statements != NULL) {
4987 location = PM_NODE_START_LOCATION(parser, statements);
4990 location = *node_location;
4993 LABEL *lstart = NEW_LABEL(location.
line);
4994 LABEL *lend = NEW_LABEL(location.
line);
4995 LABEL *lcont = NEW_LABEL(location.
line);
5002 if (statements != NULL) {
5003 pm_compile_node(iseq, (
const pm_node_t *) statements, ensr,
true, scope_node);
5006 LINK_ELEMENT *last = ensr->last;
5007 bool last_leave = last && IS_INSN(last) && IS_INSN_ID(last, leave);
5012 push_ensure_entry(iseq, &enl, &er, (
void *) cast->
ensure_clause);
5014 PUSH_LABEL(ret, lstart);
5016 pm_compile_rescue(iseq, cast, node_location, ret, popped | last_leave, scope_node);
5019 pm_compile_node(iseq, (
const pm_node_t *) cast->
statements, ret, popped | last_leave, scope_node);
5021 else if (!(popped | last_leave)) {
5022 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
5025 PUSH_LABEL(ret, lend);
5026 PUSH_SEQ(ret, ensr);
5027 if (!popped && last_leave) PUSH_INSN(ret, *node_location, putnil);
5028 PUSH_LABEL(ret, lcont);
5029 if (last_leave) PUSH_INSN(ret, *node_location, pop);
5031 pm_scope_node_t next_scope_node;
5034 rb_iseq_t *child_iseq = NEW_CHILD_ISEQ(
5041 pm_scope_node_destroy(&next_scope_node);
5043 erange = ISEQ_COMPILE_DATA(iseq)->ensure_node_stack->erange;
5044 if (lstart->link.next != &lend->link) {
5046 PUSH_CATCH_ENTRY(CATCH_TYPE_ENSURE, erange->begin, erange->end, child_iseq, lcont);
5047 erange = erange->next;
5050 ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enl.prev;
5058pm_opt_str_freeze_p(
const rb_iseq_t *iseq,
const pm_call_node_t *node)
5065 node->
block == NULL &&
5066 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5075pm_opt_aref_with_p(
const rb_iseq_t *iseq,
const pm_call_node_t *node)
5083 node->
block == NULL &&
5085 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5094pm_opt_aset_with_p(
const rb_iseq_t *iseq,
const pm_call_node_t *node)
5102 node->
block == NULL &&
5104 ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction
5113pm_compile_constant_read(rb_iseq_t *iseq,
VALUE name,
const pm_location_t *name_loc, uint32_t node_id, LINK_ANCHOR *
const ret,
const pm_scope_node_t *scope_node)
5115 const pm_node_location_t location = PM_LOCATION_START_LOCATION(scope_node->parser, name_loc, node_id);
5117 if (ISEQ_COMPILE_DATA(iseq)->option->inline_const_cache) {
5118 ISEQ_BODY(iseq)->ic_size++;
5119 VALUE segments = rb_ary_new_from_args(1, name);
5120 PUSH_INSN1(ret, location, opt_getconstant_path, segments);
5123 PUSH_INSN(ret, location, putnil);
5124 PUSH_INSN1(ret, location, putobject,
Qtrue);
5125 PUSH_INSN1(ret, location, getconstant, name);
5134pm_constant_path_parts(
const pm_node_t *node,
const pm_scope_node_t *scope_node)
5136 VALUE parts = rb_ary_new();
5144 rb_ary_unshift(parts, name);
5151 rb_ary_unshift(parts, name);
5152 if (cast->
parent == NULL) {
5153 rb_ary_unshift(parts,
ID2SYM(idNULL));
5172pm_compile_constant_path(rb_iseq_t *iseq,
const pm_node_t *node, LINK_ANCHOR *
const prefix, LINK_ANCHOR *
const body,
bool popped, pm_scope_node_t *scope_node)
5174 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5181 PUSH_INSN1(body, location, putobject,
Qtrue);
5182 PUSH_INSN1(body, location, getconstant, name);
5189 if (cast->
parent == NULL) {
5190 PUSH_INSN(body, location, pop);
5191 PUSH_INSN1(body, location, putobject, rb_cObject);
5192 PUSH_INSN1(body, location, putobject,
Qtrue);
5193 PUSH_INSN1(body, location, getconstant, name);
5196 pm_compile_constant_path(iseq, cast->
parent, prefix, body,
false, scope_node);
5197 PUSH_INSN1(body, location, putobject,
Qfalse);
5198 PUSH_INSN1(body, location, getconstant, name);
5203 PM_COMPILE_INTO_ANCHOR(prefix, node);
5212pm_compile_shareable_constant_literal(rb_iseq_t *iseq,
const pm_node_t *node,
const pm_scope_node_t *scope_node)
5226 return pm_static_literal_value(iseq, node, scope_node);
5228 return parse_static_literal_string(iseq, scope_node, node, &((
const pm_string_node_t *) node)->unescaped);
5235 for (
size_t index = 0; index < cast->
elements.
size; index++) {
5236 VALUE element = pm_compile_shareable_constant_literal(iseq, cast->
elements.
nodes[index], scope_node);
5239 rb_ary_push(result, element);
5248 for (
size_t index = 0; index < cast->
elements.
size; index++) {
5254 VALUE key = pm_compile_shareable_constant_literal(iseq, assoc->
key, scope_node);
5257 VALUE value = pm_compile_shareable_constant_literal(iseq, assoc->
value, scope_node);
5260 rb_hash_aset(result, key, value);
5275pm_compile_shareable_constant_value(rb_iseq_t *iseq,
const pm_node_t *node,
const pm_node_flags_t shareability,
VALUE path, LINK_ANCHOR *
const ret, pm_scope_node_t *scope_node,
bool top)
5277 VALUE literal = pm_compile_shareable_constant_literal(iseq, node, scope_node);
5279 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5280 PUSH_INSN1(ret, location, putobject, literal);
5284 const pm_node_location_t location = PM_NODE_START_LOCATION(scope_node->parser, node);
5290 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5293 for (
size_t index = 0; index < cast->
elements.
size; index++) {
5294 pm_compile_shareable_constant_value(iseq, cast->
elements.
nodes[index], shareability, path, ret, scope_node,
false);
5301 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2FIX(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5310 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5313 pm_compile_hash_elements(iseq, (
const pm_node_t *) cast, &cast->elements, shareability, path,
false, ret, scope_node);
5317 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2FIX(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5323 DECL_ANCHOR(value_seq);
5325 pm_compile_node(iseq, node, value_seq,
false, scope_node);
5327 PUSH_SEND_WITH_FLAG(value_seq, location, idUMinus,
INT2FIX(0),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5331 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5332 PUSH_SEQ(ret, value_seq);
5333 PUSH_INSN1(ret, location, putobject, path);
5334 PUSH_SEND_WITH_FLAG(ret, location, rb_intern(
"ensure_shareable"),
INT2FIX(2),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5337 if (top) PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5338 PUSH_SEQ(ret, value_seq);
5339 if (top) PUSH_SEND_WITH_FLAG(ret, location, rb_intern(
"make_shareable_copy"),
INT2FIX(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5342 if (top) PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
5343 PUSH_SEQ(ret, value_seq);
5344 if (top) PUSH_SEND_WITH_FLAG(ret, location, rb_intern(
"make_shareable"),
INT2FIX(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5360 ID name_id = pm_constant_id_lookup(scope_node, node->
name);
5362 if (shareability != 0) {
5363 pm_compile_shareable_constant_value(iseq, node->
value, shareability, rb_id2str(name_id), ret, scope_node,
true);
5366 PM_COMPILE_NOT_POPPED(node->
value);
5369 if (!popped) PUSH_INSN(ret, location, dup);
5370 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5373 PUSH_INSN1(ret, location, setconstant, operand);
5386 LABEL *end_label = NEW_LABEL(location.
line);
5388 pm_compile_constant_read(iseq, name, &node->
name_loc, location.
node_id, ret, scope_node);
5389 if (!popped) PUSH_INSN(ret, location, dup);
5391 PUSH_INSNL(ret, location, branchunless, end_label);
5392 if (!popped) PUSH_INSN(ret, location, pop);
5394 if (shareability != 0) {
5395 pm_compile_shareable_constant_value(iseq, node->
value, shareability, name, ret, scope_node,
true);
5398 PM_COMPILE_NOT_POPPED(node->
value);
5401 if (!popped) PUSH_INSN(ret, location, dup);
5402 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5403 PUSH_INSN1(ret, location, setconstant, name);
5404 PUSH_LABEL(ret, end_label);
5417 LABEL *set_label = NEW_LABEL(location.
line);
5418 LABEL *end_label = NEW_LABEL(location.
line);
5420 PUSH_INSN(ret, location, putnil);
5421 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CONST), name,
Qtrue);
5422 PUSH_INSNL(ret, location, branchunless, set_label);
5424 pm_compile_constant_read(iseq, name, &node->
name_loc, location.
node_id, ret, scope_node);
5425 if (!popped) PUSH_INSN(ret, location, dup);
5427 PUSH_INSNL(ret, location, branchif, end_label);
5428 if (!popped) PUSH_INSN(ret, location, pop);
5429 PUSH_LABEL(ret, set_label);
5431 if (shareability != 0) {
5432 pm_compile_shareable_constant_value(iseq, node->
value, shareability, name, ret, scope_node,
true);
5435 PM_COMPILE_NOT_POPPED(node->
value);
5438 if (!popped) PUSH_INSN(ret, location, dup);
5439 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5440 PUSH_INSN1(ret, location, setconstant, name);
5441 PUSH_LABEL(ret, end_label);
5456 pm_compile_constant_read(iseq, name, &node->
name_loc, location.
node_id, ret, scope_node);
5458 if (shareability != 0) {
5459 pm_compile_shareable_constant_value(iseq, node->
value, shareability, name, ret, scope_node,
true);
5462 PM_COMPILE_NOT_POPPED(node->
value);
5465 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2NUM(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
5466 if (!popped) PUSH_INSN(ret, location, dup);
5468 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE));
5469 PUSH_INSN1(ret, location, setconstant, name);
5479 VALUE parts = rb_ary_new();
5480 rb_ary_push(parts, rb_id2str(pm_constant_id_lookup(scope_node, node->
name)));
5485 rb_ary_unshift(parts, rb_id2str(pm_constant_id_lookup(scope_node, cast->
name)));
5489 if (current == NULL) {
5490 rb_ary_unshift(parts, rb_id2str(idNULL));
5493 rb_ary_unshift(parts, rb_id2str(pm_constant_id_lookup(scope_node, ((
const pm_constant_read_node_t *) current)->name)));
5517 PUSH_INSN1(ret, location, putobject, rb_cObject);
5520 if (shareability != 0) {
5521 pm_compile_shareable_constant_value(iseq, node->
value, shareability, pm_constant_path_path(node->
target, scope_node), ret, scope_node,
true);
5524 PM_COMPILE_NOT_POPPED(node->
value);
5528 PUSH_INSN(ret, location, swap);
5529 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
5532 PUSH_INSN(ret, location, swap);
5533 PUSH_INSN1(ret, location, setconstant, name);
5547 LABEL *lfin = NEW_LABEL(location.
line);
5550 PM_COMPILE_NOT_POPPED(target->
parent);
5553 PUSH_INSN1(ret, location, putobject, rb_cObject);
5556 PUSH_INSN(ret, location, dup);
5557 PUSH_INSN1(ret, location, putobject,
Qtrue);
5558 PUSH_INSN1(ret, location, getconstant, name);
5560 if (!popped) PUSH_INSN(ret, location, dup);
5561 PUSH_INSNL(ret, location, branchunless, lfin);
5563 if (!popped) PUSH_INSN(ret, location, pop);
5565 if (shareability != 0) {
5566 pm_compile_shareable_constant_value(iseq, node->
value, shareability, pm_constant_path_path(node->
target, scope_node), ret, scope_node,
true);
5569 PM_COMPILE_NOT_POPPED(node->
value);
5573 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
5576 PUSH_INSN1(ret, location, dupn,
INT2FIX(2));
5577 PUSH_INSN(ret, location, swap);
5580 PUSH_INSN1(ret, location, setconstant, name);
5581 PUSH_LABEL(ret, lfin);
5583 if (!popped) PUSH_INSN(ret, location, swap);
5584 PUSH_INSN(ret, location, pop);
5598 LABEL *lassign = NEW_LABEL(location.
line);
5599 LABEL *lfin = NEW_LABEL(location.
line);
5602 PM_COMPILE_NOT_POPPED(target->
parent);
5605 PUSH_INSN1(ret, location, putobject, rb_cObject);
5608 PUSH_INSN(ret, location, dup);
5609 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CONST_FROM), name,
Qtrue);
5610 PUSH_INSNL(ret, location, branchunless, lassign);
5612 PUSH_INSN(ret, location, dup);
5613 PUSH_INSN1(ret, location, putobject,
Qtrue);
5614 PUSH_INSN1(ret, location, getconstant, name);
5616 if (!popped) PUSH_INSN(ret, location, dup);
5617 PUSH_INSNL(ret, location, branchif, lfin);
5619 if (!popped) PUSH_INSN(ret, location, pop);
5620 PUSH_LABEL(ret, lassign);
5622 if (shareability != 0) {
5623 pm_compile_shareable_constant_value(iseq, node->
value, shareability, pm_constant_path_path(node->
target, scope_node), ret, scope_node,
true);
5626 PM_COMPILE_NOT_POPPED(node->
value);
5630 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
5633 PUSH_INSN1(ret, location, dupn,
INT2FIX(2));
5634 PUSH_INSN(ret, location, swap);
5637 PUSH_INSN1(ret, location, setconstant, name);
5638 PUSH_LABEL(ret, lfin);
5640 if (!popped) PUSH_INSN(ret, location, swap);
5641 PUSH_INSN(ret, location, pop);
5658 PM_COMPILE_NOT_POPPED(target->
parent);
5661 PUSH_INSN1(ret, location, putobject, rb_cObject);
5664 PUSH_INSN(ret, location, dup);
5665 PUSH_INSN1(ret, location, putobject,
Qtrue);
5666 PUSH_INSN1(ret, location, getconstant, name);
5668 if (shareability != 0) {
5669 pm_compile_shareable_constant_value(iseq, node->
value, shareability, pm_constant_path_path(node->
target, scope_node), ret, scope_node,
true);
5672 PM_COMPILE_NOT_POPPED(node->
value);
5675 PUSH_CALL(ret, location, method_id,
INT2FIX(1));
5676 PUSH_INSN(ret, location, swap);
5679 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
5680 PUSH_INSN(ret, location, swap);
5683 PUSH_INSN1(ret, location, setconstant, name);
5692#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))
5699pm_compile_scope_node(rb_iseq_t *iseq, pm_scope_node_t *scope_node,
const pm_node_location_t *node_location, LINK_ANCHOR *
const ret,
bool popped)
5711 bool trailing_comma =
false;
5717 if (scope_node->parameters != NULL) {
5721 parameters_node = cast->parameters;
5722 block_locals = &cast->locals;
5724 if (parameters_node) {
5726 trailing_comma =
true;
5737 body->
param.lead_num = maximum;
5738 body->
param.flags.ambiguous_param0 = maximum == 1;
5742 body->
param.lead_num = 1;
5743 body->
param.flags.ambiguous_param0 =
true;
5746 rb_bug(
"Unexpected node type for parameters: %s", pm_node_type_to_str(
PM_NODE_TYPE(scope_node->parameters)));
5750 struct rb_iseq_param_keyword *keyword = NULL;
5752 if (parameters_node) {
5753 optionals_list = ¶meters_node->
optionals;
5754 requireds_list = ¶meters_node->
requireds;
5755 keywords_list = ¶meters_node->
keywords;
5756 posts_list = ¶meters_node->
posts;
5759 body->
param.opt_num = 0;
5762 body->
param.lead_num = 0;
5763 body->
param.opt_num = 0;
5769 size_t locals_size = locals->
size;
5772 st_table *index_lookup_table = st_init_numtable();
5774 int table_size = (int) locals_size;
5780 if (keywords_list && keywords_list->
size) {
5784 if (requireds_list) {
5785 for (
size_t i = 0; i < requireds_list->
size; i++) {
5811 if (optionals_list && optionals_list->
size) {
5812 for (
size_t i = 0; i < optionals_list->
size; i++) {
5824 if (parameters_node) {
5825 if (parameters_node->
rest) {
5842 if (requireds_list->
size == 0 && optionals_list->
size == 0 && keywords_list->
size == 0) {
5843 ISEQ_BODY(iseq)->param.flags.use_block = TRUE;
5844 ISEQ_BODY(iseq)->param.flags.forwardable = TRUE;
5863 for (
size_t i = 0; i < posts_list->
size; i++) {
5874 if (keywords_list && keywords_list->
size) {
5875 for (
size_t i = 0; i < keywords_list->
size; i++) {
5883 if (parameters_node && parameters_node->
block) {
5893 rb_ast_id_table_t *local_table_for_iseq =
ALLOCV(idtmp,
sizeof(rb_ast_id_table_t) + table_size *
sizeof(
ID));
5894 local_table_for_iseq->size = table_size;
5914 int local_index = 0;
5921 if (requireds_list && requireds_list->
size) {
5922 for (
size_t i = 0; i < requireds_list->
size; i++, local_index++) {
5934 local = rb_make_temporary_id(local_index);
5935 local_table_for_iseq->ids[local_index] = local;
5944 ID local = pm_constant_id_lookup(scope_node, param->
name);
5945 local_table_for_iseq->ids[local_index] = local;
5948 pm_insert_local_index(param->
name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
5954 rb_bug(
"Unsupported node in requireds in parameters %s", pm_node_type_to_str(
PM_NODE_TYPE(required)));
5958 body->
param.lead_num = (int) requireds_list->
size;
5959 body->
param.flags.has_lead =
true;
5963 ID local = rb_make_temporary_id(local_index);
5964 local_table_for_iseq->ids[local_index++] = local;
5969 if (optionals_list && optionals_list->
size) {
5970 body->
param.opt_num = (int) optionals_list->
size;
5971 body->
param.flags.has_opt =
true;
5973 for (
size_t i = 0; i < optionals_list->
size; i++, local_index++) {
5978 ID local = pm_constant_id_lookup(scope_node, name);
5979 local_table_for_iseq->ids[local_index] = local;
5982 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
5989 if (parameters_node && parameters_node->
rest) {
5990 body->
param.rest_start = local_index;
5995 body->
param.flags.has_rest =
true;
6004 ID local = pm_constant_id_lookup(scope_node, name);
6005 local_table_for_iseq->ids[local_index] = local;
6008 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6014 body->
param.flags.anon_rest =
true;
6015 pm_insert_local_special(idMULT, local_index, index_lookup_table, local_table_for_iseq);
6024 if (posts_list && posts_list->
size) {
6025 body->
param.post_num = (int) posts_list->
size;
6026 body->
param.post_start = local_index;
6027 body->
param.flags.has_post =
true;
6029 for (
size_t i = 0; i < posts_list->
size; i++, local_index++) {
6041 local = rb_make_temporary_id(local_index);
6042 local_table_for_iseq->ids[local_index] = local;
6051 ID local = pm_constant_id_lookup(scope_node, param->
name);
6052 local_table_for_iseq->ids[local_index] = local;
6055 pm_insert_local_index(param->
name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6060 rb_bug(
"Unsupported node in posts in parameters %s", pm_node_type_to_str(
PM_NODE_TYPE(post_node)));
6068 if (keywords_list && keywords_list->
size) {
6069 keyword =
ZALLOC_N(
struct rb_iseq_param_keyword, 1);
6070 keyword->num = (int) keywords_list->
size;
6072 const VALUE default_values = rb_ary_hidden_new(1);
6075 for (
size_t i = 0; i < keywords_list->
size; i++) {
6083 keyword->required_num++;
6084 ID local = pm_constant_id_lookup(scope_node, name);
6087 local_table_for_iseq->ids[local_index] = local;
6090 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6096 for (
size_t i = 0; i < keywords_list->
size; i++) {
6108 if (
PM_NODE_FLAG_P(value, PM_NODE_FLAG_STATIC_LITERAL) && !PM_CONTAINER_P(value)) {
6109 rb_ary_push(default_values, pm_static_literal_value(iseq, value, scope_node));
6112 rb_ary_push(default_values, complex_mark);
6115 ID local = pm_constant_id_lookup(scope_node, name);
6117 local_table_for_iseq->ids[local_index] = local;
6120 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6130 for (
int i = 0; i <
RARRAY_LEN(default_values); i++) {
6132 if (dv == complex_mark) dv =
Qundef;
6136 keyword->default_values = dvs;
6140 keyword->bits_start = local_index;
6141 ID local = rb_make_temporary_id(local_index);
6142 local_table_for_iseq->ids[local_index] = local;
6145 body->
param.keyword = keyword;
6146 body->
param.flags.has_kw =
true;
6149 if (body->type == ISEQ_TYPE_BLOCK && local_index == 1 && requireds_list && requireds_list->
size == 1 && !trailing_comma) {
6150 body->
param.flags.ambiguous_param0 =
true;
6153 if (parameters_node) {
6161 body->
param.flags.accepts_no_kwarg =
true;
6168 if (!body->
param.flags.has_kw) {
6169 body->
param.keyword = keyword =
ZALLOC_N(
struct rb_iseq_param_keyword, 1);
6172 keyword->rest_start = local_index;
6173 body->
param.flags.has_kwrest =
true;
6178 ID local = pm_constant_id_lookup(scope_node, constant_id);
6179 local_table_for_iseq->ids[local_index] = local;
6182 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6186 body->
param.flags.anon_kwrest =
true;
6187 pm_insert_local_special(idPow, local_index, index_lookup_table, local_table_for_iseq);
6196 if (!ISEQ_BODY(iseq)->param.
flags.forwardable) {
6198 body->
param.rest_start = local_index;
6199 body->
param.flags.has_rest =
true;
6200 body->
param.flags.anon_rest =
true;
6201 pm_insert_local_special(idMULT, local_index++, index_lookup_table, local_table_for_iseq);
6205 body->
param.flags.has_kw =
false;
6206 body->
param.flags.has_kwrest =
true;
6207 body->
param.flags.anon_kwrest =
true;
6208 body->
param.keyword = keyword =
ZALLOC_N(
struct rb_iseq_param_keyword, 1);
6209 keyword->rest_start = local_index;
6210 pm_insert_local_special(idPow, local_index++, index_lookup_table, local_table_for_iseq);
6213 body->
param.block_start = local_index;
6214 body->
param.flags.has_block =
true;
6215 pm_insert_local_special(idAnd, local_index++, index_lookup_table, local_table_for_iseq);
6219 pm_insert_local_special(idDot3, local_index++, index_lookup_table, local_table_for_iseq);
6223 rb_bug(
"node type %s not expected as keyword_rest", pm_node_type_to_str(
PM_NODE_TYPE(parameters_node->
keyword_rest)));
6229 if (parameters_node->
block) {
6230 body->
param.block_start = local_index;
6231 body->
param.flags.has_block =
true;
6232 iseq_set_use_block(iseq);
6238 ID local = pm_constant_id_lookup(scope_node, name);
6239 local_table_for_iseq->ids[local_index] = local;
6242 pm_insert_local_index(name, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6246 pm_insert_local_special(idAnd, local_index, index_lookup_table, local_table_for_iseq);
6265 if (requireds_list && requireds_list->
size) {
6266 for (
size_t i = 0; i < requireds_list->
size; i++) {
6273 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);
6279 if (posts_list && posts_list->
size) {
6280 for (
size_t i = 0; i < posts_list->
size; i++) {
6287 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);
6295 body->
param.lead_num++;
6298 body->
param.rest_start = local_index;
6299 body->
param.flags.has_rest =
true;
6302 ID local = rb_make_temporary_id(local_index);
6303 local_table_for_iseq->ids[local_index] = local;
6311 for (
int i = 0; i < maximum; i++, local_index++) {
6312 const uint8_t param_name[] = {
'_',
'1' + i };
6314 RUBY_ASSERT(constant_id &&
"parser should fill in any gaps in numbered parameters");
6315 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6317 body->
param.lead_num = maximum;
6318 body->
param.flags.has_lead =
true;
6329 if (block_locals && block_locals->
size) {
6330 for (
size_t i = 0; i < block_locals->
size; i++, local_index++) {
6332 pm_insert_local_index(constant_id, local_index, index_lookup_table, local_table_for_iseq, scope_node);
6337 if (scope_node->locals.
size) {
6338 for (
size_t i = 0; i < scope_node->locals.
size; i++) {
6342 ctx.scope_node = scope_node;
6343 ctx.local_table_for_iseq = local_table_for_iseq;
6344 ctx.local_index = local_index;
6346 st_update(index_lookup_table, (st_data_t)constant_id, pm_local_table_insert_func, (st_data_t)&ctx);
6348 local_index = ctx.local_index;
6357 if (scope_node->index_lookup_table) {
6358 st_free_table(scope_node->index_lookup_table);
6360 scope_node->index_lookup_table = index_lookup_table;
6361 iseq_calc_param_size(iseq);
6363 if (ISEQ_BODY(iseq)->param.
flags.forwardable) {
6366 ISEQ_BODY(iseq)->param.size += 1;
6370 iseq_set_local_table(iseq, local_table_for_iseq, 0);
6371 scope_node->local_table_for_iseq_size = local_table_for_iseq->size;
6373 if (keyword != NULL) {
6374 size_t keyword_start_index = keyword->bits_start - keyword->num;
6375 keyword->table = (
ID *)&ISEQ_BODY(iseq)->local_table[keyword_start_index];
6380 if (optionals_list && optionals_list->
size) {
6388 for (
size_t i = 0; i < optionals_list->
size; i++) {
6389 label = NEW_LABEL(location.
line);
6390 opt_table[i] = label;
6391 PUSH_LABEL(ret, label);
6393 PM_COMPILE_NOT_POPPED(optional_node);
6397 label = NEW_LABEL(location.
line);
6398 opt_table[optionals_list->
size] = label;
6399 PUSH_LABEL(ret, label);
6401 body->
param.opt_table = (
const VALUE *) opt_table;
6404 if (keywords_list && keywords_list->
size) {
6405 size_t optional_index = 0;
6406 for (
size_t i = 0; i < keywords_list->
size; i++) {
6419 if (!
PM_NODE_FLAG_P(value, PM_NODE_FLAG_STATIC_LITERAL) || PM_CONTAINER_P(value)) {
6420 LABEL *end_label = NEW_LABEL(location.
line);
6422 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, name, 0);
6423 int kw_bits_idx = table_size - body->
param.keyword->bits_start;
6424 PUSH_INSN2(ret, location, checkkeyword,
INT2FIX(kw_bits_idx + VM_ENV_DATA_SIZE - 1),
INT2FIX(optional_index));
6425 PUSH_INSNL(ret, location, branchif, end_label);
6427 PUSH_SETLOCAL(ret, location, index.index, index.level);
6428 PUSH_LABEL(ret, end_label);
6438 rb_bug(
"Unexpected keyword parameter node type %s", pm_node_type_to_str(
PM_NODE_TYPE(keyword_parameter_node)));
6443 if (requireds_list && requireds_list->
size) {
6444 for (
size_t i = 0; i < requireds_list->
size; i++) {
6451 PUSH_GETLOCAL(ret, location, table_size - (
int)i, 0);
6457 if (posts_list && posts_list->
size) {
6458 for (
size_t i = 0; i < posts_list->
size; i++) {
6465 PUSH_GETLOCAL(ret, location, table_size - body->
param.post_start - (
int) i, 0);
6471 switch (body->type) {
6472 case ISEQ_TYPE_PLAIN: {
6476 pm_compile_regexp_dynamic(iseq, (
const pm_node_t *) cast, &cast->parts, &location, ret, popped, scope_node);
6480 case ISEQ_TYPE_BLOCK: {
6481 LABEL *start = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(0);
6482 LABEL *end = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(0);
6483 const pm_node_location_t block_location = { .line = body->location.first_lineno, .node_id = -1 };
6485 start->rescued = LABEL_RESCUE_BEG;
6486 end->rescued = LABEL_RESCUE_END;
6493 pm_compile_for_node_index(iseq, ((
const pm_for_node_t *) scope_node->ast_node)->index, ret, scope_node);
6497 PUSH_INSN(ret, block_location, nop);
6498 PUSH_LABEL(ret, start);
6500 if (scope_node->body != NULL) {
6504 PUSH_INSN1(ret, block_location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
6507 pm_scope_node_t next_scope_node;
6508 pm_scope_node_init((
const pm_node_t *) cast->statements, &next_scope_node, scope_node);
6510 const rb_iseq_t *block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(body->parent_iseq), ISEQ_TYPE_BLOCK, location.
line);
6511 pm_scope_node_destroy(&next_scope_node);
6513 PUSH_CALL_WITH_BLOCK(ret, block_location, id_core_set_postexe,
INT2FIX(0), block);
6518 pm_compile_regexp_dynamic(iseq, (
const pm_node_t *) cast, &cast->parts, &location, ret, popped, scope_node);
6522 pm_compile_node(iseq, scope_node->body, ret, popped, scope_node);
6527 PUSH_INSN(ret, block_location, putnil);
6530 PUSH_LABEL(ret, end);
6532 ISEQ_COMPILE_DATA(iseq)->last_line = body->location.code_location.end_pos.lineno;
6535 PUSH_CATCH_ENTRY(CATCH_TYPE_REDO, start, end, NULL, start);
6536 PUSH_CATCH_ENTRY(CATCH_TYPE_NEXT, start, end, NULL, end);
6539 case ISEQ_TYPE_ENSURE: {
6540 const pm_node_location_t statements_location = (scope_node->body != NULL ? PM_NODE_START_LOCATION(scope_node->parser, scope_node->body) : location);
6541 iseq_set_exception_local_table(iseq);
6543 if (scope_node->body != NULL) {
6544 PM_COMPILE_POPPED((
const pm_node_t *) scope_node->body);
6547 PUSH_GETLOCAL(ret, statements_location, 1, 0);
6548 PUSH_INSN1(ret, statements_location,
throw,
INT2FIX(0));
6551 case ISEQ_TYPE_METHOD: {
6552 ISEQ_COMPILE_DATA(iseq)->root_node = (
const void *) scope_node->body;
6555 if (scope_node->body) {
6556 PM_COMPILE((
const pm_node_t *) scope_node->body);
6559 PUSH_INSN(ret, location, putnil);
6562 ISEQ_COMPILE_DATA(iseq)->root_node = (
const void *) scope_node->body;
6565 ISEQ_COMPILE_DATA(iseq)->last_line = body->location.code_location.end_pos.lineno;
6568 case ISEQ_TYPE_RESCUE: {
6569 iseq_set_exception_local_table(iseq);
6571 LABEL *lab = NEW_LABEL(location.
line);
6572 LABEL *rescue_end = NEW_LABEL(location.
line);
6573 PUSH_GETLOCAL(ret, location, LVAR_ERRINFO, 0);
6575 PUSH_INSN1(ret, location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
6576 PUSH_INSNL(ret, location, branchif, lab);
6577 PUSH_INSNL(ret, location, jump, rescue_end);
6578 PUSH_LABEL(ret, lab);
6580 PM_COMPILE((
const pm_node_t *) scope_node->body);
6581 PUSH_INSN(ret, location, leave);
6582 PUSH_LABEL(ret, rescue_end);
6583 PUSH_GETLOCAL(ret, location, LVAR_ERRINFO, 0);
6586 PM_COMPILE((
const pm_node_t *) scope_node->ast_node);
6588 PUSH_INSN1(ret, location,
throw,
INT2FIX(0));
6593 if (scope_node->body) {
6594 PM_COMPILE((
const pm_node_t *) scope_node->body);
6597 PUSH_INSN(ret, location, putnil);
6603 const pm_node_location_t end_location = PM_NODE_END_LOCATION(scope_node->parser, scope_node->ast_node);
6605 ISEQ_COMPILE_DATA(iseq)->last_line = end_location.
line;
6609 const pm_node_location_t location = { .line = ISEQ_COMPILE_DATA(iseq)->last_line, .node_id = -1 };
6610 PUSH_INSN(ret, location, leave);
6619 PUSH_INSN1(ret, *location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
6623 VALUE operand =
ID2SYM(rb_intern3((
const char *) name_loc->
start, name_loc->
end - name_loc->
start, scope_node->encoding));
6624 PUSH_INSN1(ret, *location, putobject, operand);
6629 VALUE operand =
ID2SYM(rb_intern3((
const char *) name_loc->
start, name_loc->
end - name_loc->
start, scope_node->encoding));
6630 PUSH_INSN1(ret, *location, putobject, operand);
6633 PUSH_SEND(ret, *location, id_core_set_variable_alias,
INT2FIX(2));
6634 if (popped) PUSH_INSN(ret, *location, pop);
6640 PUSH_INSN1(ret, *location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
6641 PUSH_INSN1(ret, *location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CBASE));
6642 PM_COMPILE_NOT_POPPED(node->
new_name);
6643 PM_COMPILE_NOT_POPPED(node->
old_name);
6645 PUSH_SEND(ret, *location, id_core_set_method_alias,
INT2FIX(3));
6646 if (popped) PUSH_INSN(ret, *location, pop);
6650pm_compile_and_node(rb_iseq_t *iseq,
const pm_and_node_t *node,
const pm_node_location_t *location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
6652 LABEL *end_label = NEW_LABEL(location->
line);
6654 PM_COMPILE_NOT_POPPED(node->
left);
6655 if (!popped) PUSH_INSN(ret, *location, dup);
6656 PUSH_INSNL(ret, *location, branchunless, end_label);
6658 if (!popped) PUSH_INSN(ret, *location, pop);
6659 PM_COMPILE(node->
right);
6660 PUSH_LABEL(ret, end_label);
6673 if (elements->
size) {
6674 VALUE value = pm_static_literal_value(iseq, node, scope_node);
6675 PUSH_INSN1(ret, *location, duparray, value);
6678 PUSH_INSN1(ret, *location, newarray,
INT2FIX(0));
6696 const int max_new_array_size = 0x100;
6697 const unsigned int min_tmp_array_size = 0x40;
6699 int new_array_size = 0;
6700 bool first_chunk =
true;
6706 bool static_literal =
false;
6709#define FLUSH_CHUNK \
6710 if (new_array_size) { \
6711 if (first_chunk) PUSH_INSN1(ret, *location, newarray, INT2FIX(new_array_size)); \
6712 else PUSH_INSN1(ret, *location, pushtoarray, INT2FIX(new_array_size)); \
6713 first_chunk = false; \
6714 new_array_size = 0; \
6717 for (
size_t index = 0; index < elements->
size; index++) {
6725 PM_COMPILE_NOT_POPPED(splat_element->
expression);
6728 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_MULT, 0);
6729 PUSH_GETLOCAL(ret, *location, index.index, index.level);
6735 PUSH_INSN1(ret, *location, splatarray,
Qtrue);
6736 first_chunk =
false;
6739 PUSH_INSN(ret, *location, concattoarray);
6742 static_literal =
false;
6745 if (new_array_size == 0 && first_chunk) {
6746 PUSH_INSN1(ret, *location, newarray,
INT2FIX(0));
6747 first_chunk =
false;
6764 pm_compile_hash_elements(iseq, element, &keyword_hash->
elements, 0,
Qundef,
false, ret, scope_node);
6774 PUSH_INSN(ret, *location, pushtoarraykwsplat);
6782 !PM_CONTAINER_P(element) &&
6784 ((index + min_tmp_array_size) < elements->
size)
6789 size_t right_index = index + 1;
6791 right_index < elements->size &&
6793 !PM_CONTAINER_P(elements->
nodes[right_index])
6796 size_t tmp_array_size = right_index - index;
6797 if (tmp_array_size >= min_tmp_array_size) {
6798 VALUE tmp_array = rb_ary_hidden_new(tmp_array_size);
6801 for (; tmp_array_size; tmp_array_size--)
6802 rb_ary_push(tmp_array, pm_static_literal_value(iseq, elements->
nodes[index++], scope_node));
6810 PUSH_INSN1(ret, *location, duparray, tmp_array);
6811 first_chunk =
false;
6814 PUSH_INSN1(ret, *location, putobject, tmp_array);
6815 PUSH_INSN(ret, *location, concattoarray);
6819 PM_COMPILE_NOT_POPPED(element);
6820 if (++new_array_size >= max_new_array_size) FLUSH_CHUNK;
6821 static_literal =
true;
6824 PM_COMPILE_NOT_POPPED(element);
6825 if (++new_array_size >= max_new_array_size) FLUSH_CHUNK;
6826 static_literal =
false;
6831 if (popped) PUSH_INSN(ret, *location, pop);
6837pm_compile_break_node(rb_iseq_t *iseq,
const pm_break_node_t *node,
const pm_node_location_t *location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
6839 unsigned long throw_flag = 0;
6841 if (ISEQ_COMPILE_DATA(iseq)->redo_label != 0 && can_add_ensure_iseq(iseq)) {
6843 LABEL *splabel = NEW_LABEL(0);
6844 PUSH_LABEL(ret, splabel);
6845 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
6851 PUSH_INSN(ret, *location, putnil);
6854 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
6855 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->end_label);
6856 PUSH_ADJUST_RESTORE(ret, splabel);
6857 if (!popped) PUSH_INSN(ret, *location, putnil);
6860 const rb_iseq_t *ip = iseq;
6863 if (!ISEQ_COMPILE_DATA(ip)) {
6868 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
6869 throw_flag = VM_THROW_NO_ESCAPE_FLAG;
6871 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_BLOCK) {
6874 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_EVAL) {
6875 COMPILE_ERROR(iseq, location->
line,
"Invalid break");
6879 ip = ISEQ_BODY(ip)->parent_iseq;
6888 PUSH_INSN(ret, *location, putnil);
6891 PUSH_INSN1(ret, *location,
throw,
INT2FIX(throw_flag | TAG_BREAK));
6892 if (popped) PUSH_INSN(ret, *location, pop);
6897 COMPILE_ERROR(iseq, location->
line,
"Invalid break");
6902pm_compile_call_node(rb_iseq_t *iseq,
const pm_call_node_t *node, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
6904 ID method_id = pm_constant_id_lookup(scope_node, node->
name);
6910 const char *builtin_func;
6912 if (UNLIKELY(iseq_has_builtin_function_table(iseq)) && (builtin_func = pm_iseq_builtin_function_name(scope_node, node->
receiver, method_id)) != NULL) {
6913 pm_compile_builtin_function_call(iseq, ret, scope_node, node, &location, popped, ISEQ_COMPILE_DATA(iseq)->current_block, builtin_func);
6917 LABEL *start = NEW_LABEL(location.
line);
6918 if (node->
block) PUSH_LABEL(ret, start);
6920 switch (method_id) {
6922 if (pm_opt_str_freeze_p(iseq, node)) {
6924 const struct rb_callinfo *callinfo = new_callinfo(iseq, idUMinus, 0, 0, NULL, FALSE);
6925 PUSH_INSN2(ret, location, opt_str_uminus, value, callinfo);
6926 if (popped) PUSH_INSN(ret, location, pop);
6932 if (pm_opt_str_freeze_p(iseq, node)) {
6934 const struct rb_callinfo *callinfo = new_callinfo(iseq, idFreeze, 0, 0, NULL, FALSE);
6935 PUSH_INSN2(ret, location, opt_str_freeze, value, callinfo);
6936 if (popped) PUSH_INSN(ret, location, pop);
6942 if (pm_opt_aref_with_p(iseq, node)) {
6944 VALUE value = parse_static_literal_string(iseq, scope_node, (
const pm_node_t *)
string, &string->unescaped);
6946 PM_COMPILE_NOT_POPPED(node->
receiver);
6948 const struct rb_callinfo *callinfo = new_callinfo(iseq, idAREF, 1, 0, NULL, FALSE);
6949 PUSH_INSN2(ret, location, opt_aref_with, value, callinfo);
6952 PUSH_INSN(ret, location, pop);
6960 if (pm_opt_aset_with_p(iseq, node)) {
6962 VALUE value = parse_static_literal_string(iseq, scope_node, (
const pm_node_t *)
string, &string->unescaped);
6964 PM_COMPILE_NOT_POPPED(node->
receiver);
6968 PUSH_INSN(ret, location, swap);
6969 PUSH_INSN1(ret, location, topn,
INT2FIX(1));
6972 const struct rb_callinfo *callinfo = new_callinfo(iseq, idASET, 2, 0, NULL, FALSE);
6973 PUSH_INSN2(ret, location, opt_aset_with, value, callinfo);
6974 PUSH_INSN(ret, location, pop);
6982 PUSH_INSN(ret, location, putnil);
6986 PUSH_INSN(ret, location, putself);
6994 if (iseq_block_param_id_p(iseq, pm_constant_id_lookup(scope_node, read_node_cast->name), &idx, &level)) {
6995 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)));
6998 PM_COMPILE_NOT_POPPED(node->
receiver);
7002 PM_COMPILE_NOT_POPPED(node->
receiver);
7006 pm_compile_call(iseq, node, ret, popped, scope_node, method_id, start);
7016 flag = VM_CALL_FCALL;
7019 PM_COMPILE_NOT_POPPED(node->
receiver);
7021 LABEL *safe_label = NULL;
7023 safe_label = NEW_LABEL(location->
line);
7024 PUSH_INSN(ret, *location, dup);
7025 PUSH_INSNL(ret, *location, branchnil, safe_label);
7028 PUSH_INSN(ret, *location, dup);
7030 ID id_read_name = pm_constant_id_lookup(scope_node, node->
read_name);
7031 PUSH_SEND_WITH_FLAG(ret, *location, id_read_name,
INT2FIX(0),
INT2FIX(flag));
7033 PM_COMPILE_NOT_POPPED(node->
value);
7035 PUSH_SEND(ret, *location, id_operator,
INT2FIX(1));
7038 PUSH_INSN(ret, *location, swap);
7039 PUSH_INSN1(ret, *location, topn,
INT2FIX(1));
7042 ID id_write_name = pm_constant_id_lookup(scope_node, node->
write_name);
7043 PUSH_SEND_WITH_FLAG(ret, *location, id_write_name,
INT2FIX(1),
INT2FIX(flag));
7045 if (safe_label != NULL && popped) PUSH_LABEL(ret, safe_label);
7046 PUSH_INSN(ret, *location, pop);
7047 if (safe_label != NULL && !popped) PUSH_LABEL(ret, safe_label);
7067pm_compile_case_node_dispatch(rb_iseq_t *iseq,
VALUE dispatch,
const pm_node_t *node, LABEL *label,
const pm_scope_node_t *scope_node)
7073 key = pm_static_literal_value(iseq, node, scope_node);
7077 key = (
FIXABLE(intptr) ?
LONG2FIX((
long) intptr) : rb_dbl2big(intptr));
7089 key = pm_static_literal_value(iseq, node, scope_node);
7093 key = parse_static_literal_string(iseq, scope_node, node, &cast->
unescaped);
7100 if (
NIL_P(rb_hash_lookup(dispatch, key))) {
7101 rb_hash_aset(dispatch, key, ((
VALUE) label) | 1);
7111pm_compile_case_node(rb_iseq_t *iseq,
const pm_case_node_t *cast,
const pm_node_location_t *node_location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
7120 DECL_ANCHOR(cond_seq);
7125 DECL_ANCHOR(body_seq);
7129 LABEL *end_label = NEW_LABEL(location.
line);
7137 rb_code_location_t case_location = { 0 };
7140 if (PM_BRANCH_COVERAGE_P(iseq)) {
7141 case_location = pm_code_location(scope_node, (
const pm_node_t *) cast);
7142 branches = decl_branch_base(iseq, PTR2NUM(cast), &case_location,
"case");
7148 for (
size_t clause_index = 0; clause_index < conditions->
size; clause_index++) {
7152 int clause_lineno = pm_node_line_number(parser, (
const pm_node_t *) clause);
7153 LABEL *label = NEW_LABEL(clause_lineno);
7154 PUSH_LABEL(body_seq, label);
7157 if (PM_BRANCH_COVERAGE_P(iseq)) {
7158 rb_code_location_t branch_location = pm_code_location(scope_node, clause->statements != NULL ? ((
const pm_node_t *) clause->statements) : ((
const pm_node_t *) clause));
7159 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++,
"when", branches);
7162 if (clause->statements != NULL) {
7163 pm_compile_node(iseq, (
const pm_node_t *) clause->statements, body_seq, popped, scope_node);
7166 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7169 PUSH_INSNL(body_seq, location, jump, end_label);
7174 for (
size_t condition_index = 0; condition_index < conditions->
size; condition_index++) {
7179 PUSH_INSN(cond_seq, cond_location, putnil);
7180 pm_compile_node(iseq, condition, cond_seq,
false, scope_node);
7181 PUSH_INSN1(cond_seq, cond_location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_WHEN | VM_CHECKMATCH_ARRAY));
7182 PUSH_INSNL(cond_seq, cond_location, branchif, label);
7185 LABEL *next_label = NEW_LABEL(pm_node_line_number(parser, condition));
7186 pm_compile_branch_condition(iseq, cond_seq, condition, label, next_label,
false, scope_node);
7187 PUSH_LABEL(cond_seq, next_label);
7194 if (PM_BRANCH_COVERAGE_P(iseq)) {
7195 rb_code_location_t branch_location;
7198 branch_location = case_location;
7205 add_trace_branch_coverage(iseq, cond_seq, &branch_location, branch_location.beg_pos.column, branch_id,
"else", branches);
7213 PUSH_SYNTHETIC_PUTNIL(cond_seq, iseq);
7218 PUSH_INSNL(cond_seq, location, jump, end_label);
7219 PUSH_SEQ(ret, cond_seq);
7224 rb_code_location_t case_location = { 0 };
7227 if (PM_BRANCH_COVERAGE_P(iseq)) {
7228 case_location = pm_code_location(scope_node, (
const pm_node_t *) cast);
7229 branches = decl_branch_base(iseq, PTR2NUM(cast), &case_location,
"case");
7234 LABEL *else_label = NEW_LABEL(location.
line);
7242 if (ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction) {
7243 dispatch = rb_hash_new();
7244 RHASH_TBL_RAW(dispatch)->type = &cdhash_type;
7255 for (
size_t clause_index = 0; clause_index < conditions->
size; clause_index++) {
7260 LABEL *label = NEW_LABEL(clause_location.
line);
7265 for (
size_t condition_index = 0; condition_index < conditions->
size; condition_index++) {
7267 const pm_node_location_t condition_location = PM_NODE_START_LOCATION(parser, condition);
7272 if (dispatch !=
Qundef) {
7273 dispatch = pm_compile_case_node_dispatch(iseq, dispatch, condition, label, scope_node);
7277 PUSH_INSN(cond_seq, condition_location, dup);
7278 pm_compile_node(iseq, condition, cond_seq,
false, scope_node);
7279 PUSH_INSN1(cond_seq, condition_location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_CASE | VM_CHECKMATCH_ARRAY));
7284 VALUE value = parse_static_literal_string(iseq, scope_node, condition, &string->
unescaped);
7285 PUSH_INSN1(cond_seq, condition_location, putobject, value);
7288 pm_compile_node(iseq, condition, cond_seq,
false, scope_node);
7291 PUSH_INSN1(cond_seq, condition_location, topn,
INT2FIX(1));
7292 PUSH_SEND_WITH_FLAG(cond_seq, condition_location, idEqq,
INT2NUM(1),
INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
7295 PUSH_INSNL(cond_seq, condition_location, branchif, label);
7302 PUSH_LABEL(body_seq, label);
7303 PUSH_INSN(body_seq, clause_location, pop);
7306 if (PM_BRANCH_COVERAGE_P(iseq)) {
7307 rb_code_location_t branch_location = pm_code_location(scope_node, clause->statements != NULL ? ((
const pm_node_t *) clause->statements) : ((
const pm_node_t *) clause));
7308 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++,
"when", branches);
7311 if (clause->statements != NULL) {
7312 pm_compile_node(iseq, (
const pm_node_t *) clause->statements, body_seq, popped, scope_node);
7315 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7318 PUSH_INSNL(body_seq, clause_location, jump, end_label);
7329 if (dispatch !=
Qundef) {
7330 PUSH_INSN(ret, location, dup);
7331 PUSH_INSN2(ret, location, opt_case_dispatch, dispatch, else_label);
7332 LABEL_REF(else_label);
7335 PUSH_SEQ(ret, cond_seq);
7339 PUSH_LABEL(ret, else_label);
7343 PUSH_INSN(ret, else_location, pop);
7346 if (PM_BRANCH_COVERAGE_P(iseq)) {
7348 add_trace_branch_coverage(iseq, ret, &branch_location, branch_location.beg_pos.column, branch_id,
"else", branches);
7352 PUSH_INSNL(ret, else_location, jump, end_label);
7355 PUSH_INSN(ret, location, pop);
7358 if (PM_BRANCH_COVERAGE_P(iseq)) {
7359 add_trace_branch_coverage(iseq, ret, &case_location, case_location.beg_pos.column, branch_id,
"else", branches);
7362 if (!popped) PUSH_INSN(ret, location, putnil);
7363 PUSH_INSNL(ret, location, jump, end_label);
7367 PUSH_SEQ(ret, body_seq);
7368 PUSH_LABEL(ret, end_label);
7377 DECL_ANCHOR(body_seq);
7382 DECL_ANCHOR(cond_seq);
7386 LABEL *end_label = NEW_LABEL(location->
line);
7391 LABEL *else_label = NEW_LABEL(location->
line);
7395 rb_code_location_t case_location = { 0 };
7399 if (PM_BRANCH_COVERAGE_P(iseq)) {
7400 case_location = pm_code_location(scope_node, (
const pm_node_t *) node);
7401 branches = decl_branch_base(iseq, PTR2NUM(node), &case_location,
"case");
7411 if (in_single_pattern) {
7412 PUSH_INSN(ret, *location, putnil);
7413 PUSH_INSN(ret, *location, putnil);
7414 PUSH_INSN1(ret, *location, putobject,
Qfalse);
7415 PUSH_INSN(ret, *location, putnil);
7419 PUSH_INSN(ret, *location, putnil);
7431 const pm_node_location_t in_location = PM_NODE_START_LOCATION(scope_node->parser, in_node);
7435 PUSH_INSN(body_seq, in_location, putnil);
7438 LABEL *body_label = NEW_LABEL(in_location.
line);
7439 PUSH_LABEL(body_seq, body_label);
7440 PUSH_INSN1(body_seq, in_location, adjuststack,
INT2FIX(in_single_pattern ? 6 : 2));
7443 if (PM_BRANCH_COVERAGE_P(iseq)) {
7445 add_trace_branch_coverage(iseq, body_seq, &branch_location, branch_location.beg_pos.column, branch_id++,
"in", branches);
7452 PUSH_SYNTHETIC_PUTNIL(body_seq, iseq);
7455 PUSH_INSNL(body_seq, in_location, jump, end_label);
7456 LABEL *next_pattern_label = NEW_LABEL(pattern_location.
line);
7458 PUSH_INSN(cond_seq, pattern_location, dup);
7459 pm_compile_pattern(iseq, scope_node, in_node->
pattern, cond_seq, body_label, next_pattern_label, in_single_pattern,
false,
true, 2);
7460 PUSH_LABEL(cond_seq, next_pattern_label);
7461 LABEL_UNREMOVABLE(next_pattern_label);
7470 PUSH_LABEL(cond_seq, else_label);
7471 PUSH_INSN(cond_seq, *location, pop);
7472 PUSH_INSN(cond_seq, *location, pop);
7475 if (PM_BRANCH_COVERAGE_P(iseq)) {
7477 add_trace_branch_coverage(iseq, cond_seq, &branch_location, branch_location.beg_pos.column, branch_id,
"else", branches);
7480 PM_COMPILE_INTO_ANCHOR(cond_seq, (
const pm_node_t *) else_node);
7481 PUSH_INSNL(cond_seq, *location, jump, end_label);
7482 PUSH_INSN(cond_seq, *location, putnil);
7483 if (popped) PUSH_INSN(cond_seq, *location, putnil);
7488 PUSH_LABEL(cond_seq, else_label);
7491 add_trace_branch_coverage(iseq, cond_seq, &case_location, case_location.beg_pos.column, branch_id,
"else", branches);
7493 if (in_single_pattern) {
7494 pm_compile_pattern_error_handler(iseq, scope_node, (
const pm_node_t *) node, cond_seq, end_label, popped);
7497 PUSH_INSN1(cond_seq, *location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7499 PUSH_INSN1(cond_seq, *location, topn,
INT2FIX(2));
7500 PUSH_SEND(cond_seq, *location, id_core_raise,
INT2FIX(2));
7502 PUSH_INSN1(cond_seq, *location, adjuststack,
INT2FIX(3));
7503 if (!popped) PUSH_INSN(cond_seq, *location, putnil);
7504 PUSH_INSNL(cond_seq, *location, jump, end_label);
7505 PUSH_INSN1(cond_seq, *location, dupn,
INT2FIX(1));
7506 if (popped) PUSH_INSN(cond_seq, *location, putnil);
7513 PUSH_SEQ(ret, cond_seq);
7514 PUSH_SEQ(ret, body_seq);
7515 PUSH_LABEL(ret, end_label);
7521 const rb_iseq_t *block = NULL;
7522 const rb_iseq_t *previous_block = NULL;
7523 LABEL *retry_label = NULL;
7524 LABEL *retry_end_l = NULL;
7526 if (node->
block != NULL) {
7527 previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
7528 ISEQ_COMPILE_DATA(iseq)->current_block = NULL;
7530 retry_label = NEW_LABEL(location->
line);
7531 retry_end_l = NEW_LABEL(location->
line);
7533 PUSH_LABEL(ret, retry_label);
7536 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
7539 PUSH_INSN(ret, *location, putself);
7540 int flag = VM_CALL_ZSUPER | VM_CALL_SUPER | VM_CALL_FCALL;
7542 if (node->
block != NULL) {
7543 pm_scope_node_t next_scope_node;
7544 pm_scope_node_init((
const pm_node_t *) node->
block, &next_scope_node, scope_node);
7546 ISEQ_COMPILE_DATA(iseq)->current_block = block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location->
line);
7547 pm_scope_node_destroy(&next_scope_node);
7554 const rb_iseq_t *local_iseq = body->local_iseq;
7558 int depth = get_lvar_level(iseq);
7560 if (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->
param.flags.forwardable) {
7561 flag |= VM_CALL_FORWARDING;
7562 pm_local_index_t mult_local = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_DOT3, 0);
7563 PUSH_GETLOCAL(ret, *location, mult_local.index, mult_local.level);
7565 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, 0, flag, NULL, block != NULL);
7566 PUSH_INSN2(ret, *location, invokesuperforward, callinfo, block);
7568 if (popped) PUSH_INSN(ret, *location, pop);
7570 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
7575 if (local_body->
param.flags.has_lead) {
7577 for (
int i = 0; i < local_body->
param.lead_num; i++) {
7578 int idx = local_body->local_table_size - i;
7579 PUSH_GETLOCAL(args, *location, idx, depth);
7581 argc += local_body->
param.lead_num;
7584 if (local_body->
param.flags.has_opt) {
7586 for (
int j = 0; j < local_body->
param.opt_num; j++) {
7587 int idx = local_body->local_table_size - (argc + j);
7588 PUSH_GETLOCAL(args, *location, idx, depth);
7590 argc += local_body->
param.opt_num;
7593 if (local_body->
param.flags.has_rest) {
7595 int idx = local_body->local_table_size - local_body->
param.rest_start;
7596 PUSH_GETLOCAL(args, *location, idx, depth);
7597 PUSH_INSN1(args, *location, splatarray,
Qfalse);
7599 argc = local_body->
param.rest_start + 1;
7600 flag |= VM_CALL_ARGS_SPLAT;
7603 if (local_body->
param.flags.has_post) {
7605 int post_len = local_body->
param.post_num;
7606 int post_start = local_body->
param.post_start;
7609 for (; j < post_len; j++) {
7610 int idx = local_body->local_table_size - (post_start + j);
7611 PUSH_GETLOCAL(args, *location, idx, depth);
7614 if (local_body->
param.flags.has_rest) {
7616 PUSH_INSN1(args, *location, newarray,
INT2FIX(j));
7617 PUSH_INSN(args, *location, concatarray);
7620 argc = post_len + post_start;
7624 const struct rb_iseq_param_keyword *
const local_keyword = local_body->
param.keyword;
7625 if (local_body->
param.flags.has_kw) {
7626 int local_size = local_body->local_table_size;
7629 PUSH_INSN1(args, *location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
7631 if (local_body->
param.flags.has_kwrest) {
7632 int idx = local_body->local_table_size - local_keyword->rest_start;
7633 PUSH_GETLOCAL(args, *location, idx, depth);
7635 PUSH_SEND(args, *location, rb_intern(
"dup"),
INT2FIX(0));
7638 PUSH_INSN1(args, *location, newhash,
INT2FIX(0));
7641 for (; i < local_keyword->num; ++i) {
7642 ID id = local_keyword->table[i];
7643 int idx = local_size - get_local_var_idx(local_iseq,
id);
7647 PUSH_INSN1(args, *location, putobject, operand);
7650 PUSH_GETLOCAL(args, *location, idx, depth);
7653 PUSH_SEND(args, *location, id_core_hash_merge_ptr,
INT2FIX(i * 2 + 1));
7654 flag |= VM_CALL_KW_SPLAT| VM_CALL_KW_SPLAT_MUT;
7656 else if (local_body->
param.flags.has_kwrest) {
7657 int idx = local_body->local_table_size - local_keyword->rest_start;
7658 PUSH_GETLOCAL(args, *location, idx, depth);
7660 flag |= VM_CALL_KW_SPLAT;
7663 PUSH_SEQ(ret, args);
7666 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flag, NULL, block != NULL);
7667 PUSH_INSN2(ret, *location, invokesuper, callinfo, block);
7670 if (node->
block != NULL) {
7671 pm_compile_retry_end_label(iseq, ret, retry_end_l);
7672 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, block, retry_end_l);
7673 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
7676 if (popped) PUSH_INSN(ret, *location, pop);
7682 LABEL *matched_label = NEW_LABEL(location->
line);
7683 LABEL *unmatched_label = NEW_LABEL(location->
line);
7684 LABEL *done_label = NEW_LABEL(location->
line);
7688 PUSH_INSN(ret, *location, putnil);
7689 PUSH_INSN(ret, *location, putnil);
7690 PUSH_INSN1(ret, *location, putobject,
Qfalse);
7691 PUSH_INSN(ret, *location, putnil);
7692 PUSH_INSN(ret, *location, putnil);
7696 PM_COMPILE_NOT_POPPED(node->
value);
7700 PUSH_INSN(ret, *location, dup);
7707 pm_compile_pattern(iseq, scope_node, node->
pattern, ret, matched_label, unmatched_label,
true,
false,
true, 2);
7712 PUSH_LABEL(ret, unmatched_label);
7713 pm_compile_pattern_error_handler(iseq, scope_node, (
const pm_node_t *) node, ret, done_label, popped);
7717 PUSH_LABEL(ret, matched_label);
7718 PUSH_INSN1(ret, *location, adjuststack,
INT2FIX(6));
7719 if (!popped) PUSH_INSN(ret, *location, putnil);
7720 PUSH_INSNL(ret, *location, jump, done_label);
7722 PUSH_LABEL(ret, done_label);
7728 LABEL *fail_label = NEW_LABEL(location->
line);
7729 LABEL *end_label = NEW_LABEL(location->
line);
7740 PUSH_INSN1(ret, *location, getglobal, operand);
7743 PUSH_INSN(ret, *location, dup);
7744 PUSH_INSNL(ret, *location, branchunless, fail_label);
7750 if (targets_count == 1) {
7755 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, local_target->
name, local_target->
depth);
7759 PUSH_INSN1(ret, *location, putobject, operand);
7762 PUSH_SEND(ret, *location, idAREF,
INT2FIX(1));
7763 PUSH_LABEL(ret, fail_label);
7764 PUSH_SETLOCAL(ret, *location, index.index, index.level);
7765 if (popped) PUSH_INSN(ret, *location, pop);
7769 DECL_ANCHOR(fail_anchor);
7773 for (
size_t targets_index = 0; targets_index < targets_count; targets_index++) {
7778 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, local_target->
name, local_target->
depth);
7780 if (((
size_t) targets_index) < (targets_count - 1)) {
7781 PUSH_INSN(ret, *location, dup);
7786 PUSH_INSN1(ret, *location, putobject, operand);
7789 PUSH_SEND(ret, *location, idAREF,
INT2FIX(1));
7790 PUSH_SETLOCAL(ret, *location, index.index, index.level);
7792 PUSH_INSN(fail_anchor, *location, putnil);
7793 PUSH_SETLOCAL(fail_anchor, *location, index.index, index.level);
7797 PUSH_INSNL(ret, *location, jump, end_label);
7801 PUSH_LABEL(ret, fail_label);
7802 PUSH_INSN(ret, *location, pop);
7803 PUSH_SEQ(ret, fail_anchor);
7806 PUSH_LABEL(ret, end_label);
7807 if (popped) PUSH_INSN(ret, *location, pop);
7811pm_compile_next_node(rb_iseq_t *iseq,
const pm_next_node_t *node,
const pm_node_location_t *location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
7813 if (ISEQ_COMPILE_DATA(iseq)->redo_label != 0 && can_add_ensure_iseq(iseq)) {
7814 LABEL *splabel = NEW_LABEL(0);
7815 PUSH_LABEL(ret, splabel);
7821 PUSH_INSN(ret, *location, putnil);
7823 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
7825 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
7826 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->start_label);
7828 PUSH_ADJUST_RESTORE(ret, splabel);
7829 if (!popped) PUSH_INSN(ret, *location, putnil);
7831 else if (ISEQ_COMPILE_DATA(iseq)->end_label && can_add_ensure_iseq(iseq)) {
7832 LABEL *splabel = NEW_LABEL(0);
7834 PUSH_LABEL(ret, splabel);
7835 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->start_label);
7841 PUSH_INSN(ret, *location, putnil);
7844 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
7845 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->end_label);
7846 PUSH_ADJUST_RESTORE(ret, splabel);
7847 splabel->unremovable = FALSE;
7849 if (!popped) PUSH_INSN(ret, *location, putnil);
7852 const rb_iseq_t *ip = iseq;
7853 unsigned long throw_flag = 0;
7856 if (!ISEQ_COMPILE_DATA(ip)) {
7861 throw_flag = VM_THROW_NO_ESCAPE_FLAG;
7862 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
7866 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_BLOCK) {
7869 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_EVAL) {
7870 COMPILE_ERROR(iseq, location->
line,
"Invalid next");
7874 ip = ISEQ_BODY(ip)->parent_iseq;
7882 PUSH_INSN(ret, *location, putnil);
7885 PUSH_INSN1(ret, *location,
throw,
INT2FIX(throw_flag | TAG_NEXT));
7886 if (popped) PUSH_INSN(ret, *location, pop);
7889 COMPILE_ERROR(iseq, location->
line,
"Invalid next");
7895pm_compile_redo_node(rb_iseq_t *iseq,
const pm_node_location_t *location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
7897 if (ISEQ_COMPILE_DATA(iseq)->redo_label && can_add_ensure_iseq(iseq)) {
7898 LABEL *splabel = NEW_LABEL(0);
7900 PUSH_LABEL(ret, splabel);
7901 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->redo_label);
7902 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
7904 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->redo_label);
7905 PUSH_ADJUST_RESTORE(ret, splabel);
7906 if (!popped) PUSH_INSN(ret, *location, putnil);
7908 else if (ISEQ_BODY(iseq)->
type != ISEQ_TYPE_EVAL && ISEQ_COMPILE_DATA(iseq)->start_label && can_add_ensure_iseq(iseq)) {
7909 LABEL *splabel = NEW_LABEL(0);
7911 PUSH_LABEL(ret, splabel);
7912 pm_add_ensure_iseq(ret, iseq, 0, scope_node);
7913 PUSH_ADJUST(ret, *location, ISEQ_COMPILE_DATA(iseq)->start_label);
7915 PUSH_INSNL(ret, *location, jump, ISEQ_COMPILE_DATA(iseq)->start_label);
7916 PUSH_ADJUST_RESTORE(ret, splabel);
7917 if (!popped) PUSH_INSN(ret, *location, putnil);
7920 const rb_iseq_t *ip = iseq;
7923 if (!ISEQ_COMPILE_DATA(ip)) {
7928 if (ISEQ_COMPILE_DATA(ip)->redo_label != 0) {
7931 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_BLOCK) {
7934 else if (ISEQ_BODY(ip)->
type == ISEQ_TYPE_EVAL) {
7935 COMPILE_ERROR(iseq, location->
line,
"Invalid redo");
7939 ip = ISEQ_BODY(ip)->parent_iseq;
7943 PUSH_INSN(ret, *location, putnil);
7944 PUSH_INSN1(ret, *location,
throw,
INT2FIX(VM_THROW_NO_ESCAPE_FLAG | TAG_REDO));
7945 if (popped) PUSH_INSN(ret, *location, pop);
7948 COMPILE_ERROR(iseq, location->
line,
"Invalid redo");
7954pm_compile_rescue_node(rb_iseq_t *iseq,
const pm_rescue_node_t *node,
const pm_node_location_t *location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
7956 iseq_set_exception_local_table(iseq);
7960 LABEL *exception_match_label = NEW_LABEL(location->
line);
7961 LABEL *rescue_end_label = NEW_LABEL(location->
line);
7971 if (exceptions->
size > 0) {
7972 for (
size_t index = 0; index < exceptions->
size; index++) {
7973 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
7974 PM_COMPILE(exceptions->
nodes[index]);
7975 int checkmatch_flags = VM_CHECKMATCH_TYPE_RESCUE;
7977 checkmatch_flags |= VM_CHECKMATCH_ARRAY;
7979 PUSH_INSN1(ret, *location, checkmatch,
INT2FIX(checkmatch_flags));
7980 PUSH_INSNL(ret, *location, branchif, exception_match_label);
7984 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
7986 PUSH_INSN1(ret, *location, checkmatch,
INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
7987 PUSH_INSNL(ret, *location, branchif, exception_match_label);
7992 PUSH_INSNL(ret, *location, jump, rescue_end_label);
7997 PUSH_LABEL(ret, exception_match_label);
8004 DECL_ANCHOR(writes);
8005 DECL_ANCHOR(cleanup);
8007 pm_compile_target_node(iseq, node->
reference, ret, writes, cleanup, scope_node, NULL);
8008 PUSH_GETLOCAL(ret, *location, LVAR_ERRINFO, 0);
8010 PUSH_SEQ(ret, writes);
8011 PUSH_SEQ(ret, cleanup);
8021 LABEL *prev_end = ISEQ_COMPILE_DATA(iseq)->end_label;
8022 ISEQ_COMPILE_DATA(iseq)->end_label = NULL;
8027 ISEQ_COMPILE_DATA(iseq)->end_label = prev_end;
8030 PUSH_INSN(ret, *location, putnil);
8033 PUSH_INSN(ret, *location, leave);
8039 PUSH_LABEL(ret, rescue_end_label);
8044 PUSH_GETLOCAL(ret, *location, 1, 0);
8049pm_compile_return_node(rb_iseq_t *iseq,
const pm_return_node_t *node,
const pm_node_location_t *location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
8052 enum rb_iseq_type
type = ISEQ_BODY(iseq)->type;
8055 const rb_iseq_t *parent_iseq = iseq;
8056 enum rb_iseq_type parent_type = ISEQ_BODY(parent_iseq)->type;
8057 while (parent_type == ISEQ_TYPE_RESCUE || parent_type == ISEQ_TYPE_ENSURE) {
8058 if (!(parent_iseq = ISEQ_BODY(parent_iseq)->parent_iseq))
break;
8059 parent_type = ISEQ_BODY(parent_iseq)->type;
8062 switch (parent_type) {
8064 case ISEQ_TYPE_MAIN:
8066 rb_warn(
"argument of top-level return is ignored");
8068 if (parent_iseq == iseq) {
8069 type = ISEQ_TYPE_METHOD;
8076 if (
type == ISEQ_TYPE_METHOD) {
8077 splabel = NEW_LABEL(0);
8078 PUSH_LABEL(ret, splabel);
8079 PUSH_ADJUST(ret, *location, 0);
8082 if (arguments != NULL) {
8083 PM_COMPILE_NOT_POPPED((
const pm_node_t *) arguments);
8086 PUSH_INSN(ret, *location, putnil);
8089 if (
type == ISEQ_TYPE_METHOD && can_add_ensure_iseq(iseq)) {
8090 pm_add_ensure_iseq(ret, iseq, 1, scope_node);
8092 PUSH_INSN(ret, *location, leave);
8093 PUSH_ADJUST_RESTORE(ret, splabel);
8094 if (!popped) PUSH_INSN(ret, *location, putnil);
8097 PUSH_INSN1(ret, *location,
throw,
INT2FIX(TAG_RETURN));
8098 if (popped) PUSH_INSN(ret, *location, pop);
8103pm_compile_super_node(rb_iseq_t *iseq,
const pm_super_node_t *node,
const pm_node_location_t *location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
8107 LABEL *retry_label = NEW_LABEL(location->
line);
8108 LABEL *retry_end_l = NEW_LABEL(location->
line);
8110 const rb_iseq_t *previous_block = ISEQ_COMPILE_DATA(iseq)->current_block;
8111 const rb_iseq_t *current_block;
8112 ISEQ_COMPILE_DATA(iseq)->current_block = current_block = NULL;
8114 PUSH_LABEL(ret, retry_label);
8115 PUSH_INSN(ret, *location, putself);
8119 int argc = pm_setup_args(node->
arguments, node->
block, &flags, &keywords, iseq, ret, scope_node, location);
8121 flags |= VM_CALL_SUPER | VM_CALL_FCALL;
8124 pm_scope_node_t next_scope_node;
8125 pm_scope_node_init(node->
block, &next_scope_node, scope_node);
8127 ISEQ_COMPILE_DATA(iseq)->current_block = current_block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location->
line);
8128 pm_scope_node_destroy(&next_scope_node);
8132 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
8135 if ((flags & VM_CALL_ARGS_BLOCKARG) && (flags & VM_CALL_KW_SPLAT) && !(flags & VM_CALL_KW_SPLAT_MUT)) {
8136 PUSH_INSN(args, *location, splatkw);
8139 PUSH_SEQ(ret, args);
8140 if (is_forwardable && ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->param.
flags.forwardable) {
8141 flags |= VM_CALL_FORWARDING;
8144 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, current_block != NULL);
8145 PUSH_INSN2(ret, *location, invokesuperforward, callinfo, current_block);
8150 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, current_block != NULL);
8151 PUSH_INSN2(ret, *location, invokesuper, callinfo, current_block);
8156 pm_compile_retry_end_label(iseq, ret, retry_end_l);
8158 if (popped) PUSH_INSN(ret, *location, pop);
8159 ISEQ_COMPILE_DATA(iseq)->current_block = previous_block;
8160 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, current_block, retry_end_l);
8164pm_compile_yield_node(rb_iseq_t *iseq,
const pm_yield_node_t *node,
const pm_node_location_t *location, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
8166 switch (ISEQ_BODY(ISEQ_BODY(iseq)->local_iseq)->
type) {
8168 case ISEQ_TYPE_MAIN:
8169 case ISEQ_TYPE_CLASS:
8170 COMPILE_ERROR(iseq, location->
line,
"Invalid yield");
8180 argc = pm_setup_args(node->
arguments, NULL, &flags, &keywords, iseq, ret, scope_node, location);
8183 const struct rb_callinfo *callinfo = new_callinfo(iseq, 0, argc, flags, keywords, FALSE);
8184 PUSH_INSN1(ret, *location, invokeblock, callinfo);
8186 iseq_set_use_block(ISEQ_BODY(iseq)->local_iseq);
8187 if (popped) PUSH_INSN(ret, *location, pop);
8190 for (
const rb_iseq_t *tmp_iseq = iseq; tmp_iseq != ISEQ_BODY(iseq)->local_iseq; level++) {
8191 tmp_iseq = ISEQ_BODY(tmp_iseq)->parent_iseq;
8194 if (level > 0) access_outer_variables(iseq, level, rb_intern(
"yield"),
true);
8208pm_compile_node(rb_iseq_t *iseq,
const pm_node_t *node, LINK_ANCHOR *
const ret,
bool popped, pm_scope_node_t *scope_node)
8212 int lineno = (int) location.
line;
8219 lineno = (int) PM_NODE_START_LINE_COLUMN(parser, ((
const pm_begin_node_t *) node)->rescue_clause).line;
8228 ISEQ_COMPILE_DATA(iseq)->last_line = lineno;
8229 if (ISEQ_COVERAGE(iseq) && ISEQ_LINE_COVERAGE(iseq)) {
8230 event |= RUBY_EVENT_COVERAGE_LINE;
8232 PUSH_TRACE(ret, event);
8244 pm_compile_alias_method_node(iseq, (
const pm_alias_method_node_t *) node, &location, ret, popped, scope_node);
8249 pm_compile_and_node(iseq, (
const pm_and_node_t *) node, &location, ret, popped, scope_node);
8261 if (elements->
size == 1) {
8264 PM_COMPILE(elements->
nodes[0]);
8267 pm_compile_array_node(iseq, (
const pm_node_t *) cast, elements, &location, ret, popped, scope_node);
8275 pm_compile_array_node(iseq, (
const pm_node_t *) cast, &cast->elements, &location, ret, popped, scope_node);
8286 PM_COMPILE(cast->
key);
8287 PM_COMPILE(cast->
value);
8299 if (cast->
value != NULL) {
8300 PM_COMPILE(cast->
value);
8303 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_POW, 0);
8304 PUSH_GETLOCAL(ret, location, index.index, index.level);
8316 ID backref_val =
INT2FIX(rb_intern2(char_ptr, 1)) << 1 | 1;
8317 PUSH_INSN2(ret, location, getspecial,
INT2FIX(1), backref_val);
8329 pm_compile_ensure(iseq, cast, &location, ret, popped, scope_node);
8333 pm_compile_rescue(iseq, cast, &location, ret, popped, scope_node);
8342 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
8357 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, PM_CONSTANT_AND, 0);
8358 PUSH_INSN2(ret, location, getblockparamproxy,
INT2FIX(local_index.index + VM_ENV_DATA_SIZE - 1),
INT2FIX(local_index.level));
8368 pm_compile_break_node(iseq, (
const pm_break_node_t *) node, &location, ret, popped, scope_node);
8379 pm_compile_call_node(iseq, (
const pm_call_node_t *) node, ret, popped, scope_node);
8385 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);
8392 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);
8410 pm_compile_case_node(iseq, (
const pm_case_node_t *) node, &location, ret, popped, scope_node);
8421 pm_compile_case_match_node(iseq, (
const pm_case_match_node_t *) node, &location, ret, popped, scope_node);
8428 ID class_id = pm_constant_id_lookup(scope_node, cast->
name);
8429 VALUE class_name =
rb_str_freeze(rb_sprintf(
"<class:%"PRIsVALUE
">", rb_id2str(class_id)));
8431 pm_scope_node_t next_scope_node;
8432 pm_scope_node_init((
const pm_node_t *) cast, &next_scope_node, scope_node);
8434 const rb_iseq_t *class_iseq = NEW_CHILD_ISEQ(&next_scope_node, class_name, ISEQ_TYPE_CLASS, location.
line);
8435 pm_scope_node_destroy(&next_scope_node);
8438 const int flags = VM_DEFINECLASS_TYPE_CLASS |
8439 (cast->
superclass ? VM_DEFINECLASS_FLAG_HAS_SUPERCLASS : 0) |
8440 pm_compile_class_path(iseq, cast->
constant_path, &location, ret,
false, scope_node);
8446 PUSH_INSN(ret, location, putnil);
8451 PUSH_INSN3(ret, location, defineclass, operand, class_iseq,
INT2FIX(flags));
8455 if (popped) PUSH_INSN(ret, location, pop);
8462 LABEL *end_label = NEW_LABEL(location.
line);
8464 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
8467 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8468 if (!popped) PUSH_INSN(ret, location, dup);
8470 PUSH_INSNL(ret, location, branchunless, end_label);
8471 if (!popped) PUSH_INSN(ret, location, pop);
8473 PM_COMPILE_NOT_POPPED(cast->
value);
8474 if (!popped) PUSH_INSN(ret, location, dup);
8476 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8477 PUSH_LABEL(ret, end_label);
8486 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
8489 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8490 PM_COMPILE_NOT_POPPED(cast->
value);
8493 int flags = VM_CALL_ARGS_SIMPLE;
8494 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2NUM(1),
INT2FIX(flags));
8496 if (!popped) PUSH_INSN(ret, location, dup);
8497 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8505 LABEL *end_label = NEW_LABEL(location.
line);
8506 LABEL *start_label = NEW_LABEL(location.
line);
8508 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
8511 PUSH_INSN(ret, location, putnil);
8512 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_CVAR), name,
Qtrue);
8513 PUSH_INSNL(ret, location, branchunless, start_label);
8515 PUSH_INSN2(ret, location, getclassvariable, name, get_cvar_ic_value(iseq, name_id));
8516 if (!popped) PUSH_INSN(ret, location, dup);
8518 PUSH_INSNL(ret, location, branchif, end_label);
8519 if (!popped) PUSH_INSN(ret, location, pop);
8521 PUSH_LABEL(ret, start_label);
8522 PM_COMPILE_NOT_POPPED(cast->
value);
8523 if (!popped) PUSH_INSN(ret, location, dup);
8525 PUSH_INSN2(ret, location, setclassvariable, name, get_cvar_ic_value(iseq, name_id));
8526 PUSH_LABEL(ret, end_label);
8535 ID name = pm_constant_id_lookup(scope_node, cast->
name);
8536 PUSH_INSN2(ret, location, getclassvariable,
ID2SYM(name), get_cvar_ic_value(iseq, name));
8544 PM_COMPILE_NOT_POPPED(cast->
value);
8545 if (!popped) PUSH_INSN(ret, location, dup);
8547 ID name = pm_constant_id_lookup(scope_node, cast->
name);
8548 PUSH_INSN2(ret, location, setclassvariable,
ID2SYM(name), get_cvar_ic_value(iseq, name));
8557 if (ISEQ_COMPILE_DATA(iseq)->option->inline_const_cache && ((parts = pm_constant_path_parts(node, scope_node)) !=
Qnil)) {
8558 ISEQ_BODY(iseq)->ic_size++;
8559 PUSH_INSN1(ret, location, opt_getconstant_path, parts);
8562 DECL_ANCHOR(prefix);
8565 pm_compile_constant_path(iseq, node, prefix, body, popped, scope_node);
8566 if (LIST_INSN_SIZE_ZERO(prefix)) {
8567 PUSH_INSN(ret, location, putnil);
8570 PUSH_SEQ(ret, prefix);
8573 PUSH_SEQ(ret, body);
8576 if (popped) PUSH_INSN(ret, location, pop);
8583 pm_compile_constant_path_and_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8590 pm_compile_constant_path_or_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8597 pm_compile_constant_path_operator_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8604 pm_compile_constant_path_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8613 pm_compile_constant_read(iseq, name, &cast->
base.
location, location.
node_id, ret, scope_node);
8614 if (popped) PUSH_INSN(ret, location, pop);
8622 pm_compile_constant_and_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8629 pm_compile_constant_or_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8636 pm_compile_constant_operator_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8643 pm_compile_constant_write_node(iseq, cast, 0, &location, ret, popped, scope_node);
8653 ID method_name = pm_constant_id_lookup(scope_node, cast->
name);
8655 pm_scope_node_t next_scope_node;
8656 pm_scope_node_init((
const pm_node_t *) cast, &next_scope_node, scope_node);
8658 rb_iseq_t *method_iseq = NEW_ISEQ(&next_scope_node, rb_id2str(method_name), ISEQ_TYPE_METHOD, location.
line);
8659 pm_scope_node_destroy(&next_scope_node);
8662 PM_COMPILE_NOT_POPPED(cast->
receiver);
8663 PUSH_INSN2(ret, location, definesmethod,
ID2SYM(method_name), method_iseq);
8666 PUSH_INSN2(ret, location, definemethod,
ID2SYM(method_name), method_iseq);
8671 PUSH_INSN1(ret, location, putobject,
ID2SYM(method_name));
8680 pm_compile_defined_expr(iseq, cast->
value, &location, ret, popped, scope_node,
false);
8692 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
8695 if (popped) PUSH_INSN(ret, location, pop);
8709 PUSH_INSN1(ret, location, putobject,
Qfalse);
8717 LABEL *start = NEW_LABEL(location.
line);
8718 LABEL *end = NEW_LABEL(location.
line);
8719 PUSH_LABEL(ret, start);
8721 LABEL *prev_end_label = ISEQ_COMPILE_DATA(iseq)->end_label;
8722 ISEQ_COMPILE_DATA(iseq)->end_label = end;
8725 ISEQ_COMPILE_DATA(iseq)->end_label = prev_end_label;
8726 PUSH_LABEL(ret, end);
8740 PUSH_SYNTHETIC_PUTNIL(ret, iseq);
8750 LABEL *final_label = NEW_LABEL(location.
line);
8751 LABEL *then_label = NEW_LABEL(location.
line);
8752 LABEL *else_label = NEW_LABEL(location.
line);
8754 pm_compile_flip_flop(cast, else_label, then_label, iseq, location.
line, ret, popped, scope_node);
8756 PUSH_LABEL(ret, then_label);
8757 PUSH_INSN1(ret, location, putobject,
Qtrue);
8758 PUSH_INSNL(ret, location, jump, final_label);
8759 PUSH_LABEL(ret, else_label);
8760 PUSH_INSN1(ret, location, putobject,
Qfalse);
8761 PUSH_LABEL(ret, final_label);
8770 PUSH_INSN1(ret, location, putobject, operand);
8779 LABEL *retry_label = NEW_LABEL(location.
line);
8780 LABEL *retry_end_l = NEW_LABEL(location.
line);
8783 PUSH_LABEL(ret, retry_label);
8788 pm_scope_node_t next_scope_node;
8789 pm_scope_node_init((
const pm_node_t *) cast, &next_scope_node, scope_node);
8791 const rb_iseq_t *child_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, location.
line);
8792 pm_scope_node_destroy(&next_scope_node);
8794 const rb_iseq_t *prev_block = ISEQ_COMPILE_DATA(iseq)->current_block;
8795 ISEQ_COMPILE_DATA(iseq)->current_block = child_iseq;
8799 PUSH_SEND_WITH_BLOCK(ret, location, idEach,
INT2FIX(0), child_iseq);
8800 pm_compile_retry_end_label(iseq, ret, retry_end_l);
8802 if (popped) PUSH_INSN(ret, location, pop);
8803 ISEQ_COMPILE_DATA(iseq)->current_block = prev_block;
8804 PUSH_CATCH_ENTRY(CATCH_TYPE_BREAK, retry_label, retry_end_l, child_iseq, retry_end_l);
8808 rb_bug(
"Cannot compile a ForwardingArgumentsNode directly\n");
8822 LABEL *end_label = NEW_LABEL(location.
line);
8825 PUSH_INSN1(ret, location, getglobal, name);
8826 if (!popped) PUSH_INSN(ret, location, dup);
8828 PUSH_INSNL(ret, location, branchunless, end_label);
8829 if (!popped) PUSH_INSN(ret, location, pop);
8831 PM_COMPILE_NOT_POPPED(cast->
value);
8832 if (!popped) PUSH_INSN(ret, location, dup);
8834 PUSH_INSN1(ret, location, setglobal, name);
8835 PUSH_LABEL(ret, end_label);
8845 PUSH_INSN1(ret, location, getglobal, name);
8846 PM_COMPILE_NOT_POPPED(cast->
value);
8849 int flags = VM_CALL_ARGS_SIMPLE;
8850 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2NUM(1),
INT2FIX(flags));
8852 if (!popped) PUSH_INSN(ret, location, dup);
8853 PUSH_INSN1(ret, location, setglobal, name);
8861 LABEL *set_label = NEW_LABEL(location.
line);
8862 LABEL *end_label = NEW_LABEL(location.
line);
8864 PUSH_INSN(ret, location, putnil);
8867 PUSH_INSN3(ret, location, defined,
INT2FIX(DEFINED_GVAR), name,
Qtrue);
8868 PUSH_INSNL(ret, location, branchunless, set_label);
8870 PUSH_INSN1(ret, location, getglobal, name);
8871 if (!popped) PUSH_INSN(ret, location, dup);
8873 PUSH_INSNL(ret, location, branchif, end_label);
8874 if (!popped) PUSH_INSN(ret, location, pop);
8876 PUSH_LABEL(ret, set_label);
8877 PM_COMPILE_NOT_POPPED(cast->
value);
8878 if (!popped) PUSH_INSN(ret, location, dup);
8880 PUSH_INSN1(ret, location, setglobal, name);
8881 PUSH_LABEL(ret, end_label);
8891 PUSH_INSN1(ret, location, getglobal, name);
8892 if (popped) PUSH_INSN(ret, location, pop);
8900 PM_COMPILE_NOT_POPPED(cast->
value);
8901 if (!popped) PUSH_INSN(ret, location, dup);
8903 ID name = pm_constant_id_lookup(scope_node, cast->
name);
8904 PUSH_INSN1(ret, location, setglobal,
ID2SYM(name));
8922 PUSH_INSN1(ret, location, newhash,
INT2FIX(0));
8925 VALUE value = pm_static_literal_value(iseq, node, scope_node);
8926 PUSH_INSN1(ret, location, duphash, value);
8947 for (
size_t index = 0; index < elements->
size; index++) {
8948 PM_COMPILE_POPPED(elements->
nodes[index]);
8952 pm_compile_hash_elements(iseq, node, elements, 0,
Qundef,
false, ret, scope_node);
8968 pm_compile_conditional(iseq, &location,
PM_IF_NODE, (
const pm_node_t *) cast, cast->statements, cast->subsequent, cast->predicate, ret, popped, scope_node);
8976 PUSH_INSN1(ret, location, putobject, operand);
8990 PM_COMPILE(cast->
value);
8996 rb_bug(
"Should not ever enter an in node directly");
9003 pm_compile_index_operator_write_node(iseq, cast, &location, ret, popped, scope_node);
9010 pm_compile_index_control_flow_write_node(iseq, node, cast->
receiver, cast->
arguments, cast->
block, cast->
value, &location, ret, popped, scope_node);
9017 pm_compile_index_control_flow_write_node(iseq, node, cast->
receiver, cast->
arguments, cast->
block, cast->
value, &location, ret, popped, scope_node);
9024 LABEL *end_label = NEW_LABEL(location.
line);
9026 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
9029 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9030 if (!popped) PUSH_INSN(ret, location, dup);
9032 PUSH_INSNL(ret, location, branchunless, end_label);
9033 if (!popped) PUSH_INSN(ret, location, pop);
9035 PM_COMPILE_NOT_POPPED(cast->
value);
9036 if (!popped) PUSH_INSN(ret, location, dup);
9038 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9039 PUSH_LABEL(ret, end_label);
9048 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
9051 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9052 PM_COMPILE_NOT_POPPED(cast->
value);
9055 int flags = VM_CALL_ARGS_SIMPLE;
9056 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2NUM(1),
INT2FIX(flags));
9058 if (!popped) PUSH_INSN(ret, location, dup);
9059 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9067 LABEL *end_label = NEW_LABEL(location.
line);
9069 ID name_id = pm_constant_id_lookup(scope_node, cast->
name);
9072 PUSH_INSN2(ret, location, getinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9073 if (!popped) PUSH_INSN(ret, location, dup);
9075 PUSH_INSNL(ret, location, branchif, end_label);
9076 if (!popped) PUSH_INSN(ret, location, pop);
9078 PM_COMPILE_NOT_POPPED(cast->
value);
9079 if (!popped) PUSH_INSN(ret, location, dup);
9081 PUSH_INSN2(ret, location, setinstancevariable, name, get_ivar_ic_value(iseq, name_id));
9082 PUSH_LABEL(ret, end_label);
9091 ID name = pm_constant_id_lookup(scope_node, cast->
name);
9092 PUSH_INSN2(ret, location, getinstancevariable,
ID2SYM(name), get_ivar_ic_value(iseq, name));
9100 PM_COMPILE_NOT_POPPED(cast->
value);
9101 if (!popped) PUSH_INSN(ret, location, dup);
9103 ID name = pm_constant_id_lookup(scope_node, cast->
name);
9104 PUSH_INSN2(ret, location, setinstancevariable,
ID2SYM(name), get_ivar_ic_value(iseq, name));
9113 PUSH_INSN1(ret, location, putobject, operand);
9122 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9123 PUSH_INSN1(ret, location, putobject, regexp);
9130 PUSH_INSN1(ret, location, getglobal,
rb_id2sym(idLASTLINE));
9131 PUSH_SEND(ret, location, idEqTilde,
INT2NUM(1));
9132 if (popped) PUSH_INSN(ret, location, pop);
9140 const rb_iseq_t *prevblock = ISEQ_COMPILE_DATA(iseq)->current_block;
9141 const rb_iseq_t *block_iseq = NULL;
9142 int ise_index = ISEQ_BODY(iseq)->ise_size++;
9144 pm_scope_node_t next_scope_node;
9145 pm_scope_node_init(node, &next_scope_node, scope_node);
9147 block_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_PLAIN, location.
line);
9148 pm_scope_node_destroy(&next_scope_node);
9150 ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq;
9151 PUSH_INSN2(ret, location, once, block_iseq,
INT2FIX(ise_index));
9152 ISEQ_COMPILE_DATA(iseq)->current_block = prevblock;
9154 if (popped) PUSH_INSN(ret, location, pop);
9160 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9161 PUSH_INSN1(ret, location, putobject, regexp);
9166 if (popped) PUSH_INSN(ret, location, pop);
9176 VALUE string = pm_static_literal_value(iseq, node, scope_node);
9179 PUSH_INSN1(ret, location, putobject,
string);
9182 PUSH_INSN1(ret, location, putstring,
string);
9185 PUSH_INSN1(ret, location, putchilledstring,
string);
9191 int length = pm_interpolated_node_compile(iseq, &cast->
parts, &location, ret, popped, scope_node, NULL, NULL);
9192 if (length > 1) PUSH_INSN1(ret, location, concatstrings,
INT2FIX(length));
9193 if (popped) PUSH_INSN(ret, location, pop);
9202 int length = pm_interpolated_node_compile(iseq, &cast->
parts, &location, ret, popped, scope_node, NULL, NULL);
9205 PUSH_INSN1(ret, location, concatstrings,
INT2FIX(length));
9209 PUSH_INSN(ret, location, intern);
9212 PUSH_INSN(ret, location, pop);
9222 PUSH_INSN(ret, location, putself);
9224 int length = pm_interpolated_node_compile(iseq, &cast->
parts, &location, ret,
false, scope_node, NULL, NULL);
9225 if (length > 1) PUSH_INSN1(ret, location, concatstrings,
INT2FIX(length));
9227 PUSH_SEND_WITH_FLAG(ret, location, idBackquote,
INT2NUM(1),
INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
9228 if (popped) PUSH_INSN(ret, location, pop);
9236 PUSH_GETLOCAL(ret, location, scope_node->local_table_for_iseq_size, 0);
9249 PM_COMPILE(element);
9252 if (!popped) PUSH_INSN1(ret, location, newhash,
INT2FIX(elements->
size * 2));
9260 pm_scope_node_t next_scope_node;
9261 pm_scope_node_init(node, &next_scope_node, scope_node);
9263 int opening_lineno = pm_location_line_number(parser, &cast->
opening_loc);
9264 const rb_iseq_t *block = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, opening_lineno);
9265 pm_scope_node_destroy(&next_scope_node);
9268 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
9269 PUSH_CALL_WITH_BLOCK(ret, location, idLambda, argc, block);
9272 if (popped) PUSH_INSN(ret, location, pop);
9279 LABEL *end_label = NEW_LABEL(location.
line);
9281 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->
name, cast->
depth);
9282 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9283 if (!popped) PUSH_INSN(ret, location, dup);
9285 PUSH_INSNL(ret, location, branchunless, end_label);
9286 if (!popped) PUSH_INSN(ret, location, pop);
9288 PM_COMPILE_NOT_POPPED(cast->
value);
9289 if (!popped) PUSH_INSN(ret, location, dup);
9291 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9292 PUSH_LABEL(ret, end_label);
9301 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->
name, cast->
depth);
9302 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9304 PM_COMPILE_NOT_POPPED(cast->
value);
9307 PUSH_SEND_WITH_FLAG(ret, location, method_id,
INT2NUM(1),
INT2FIX(VM_CALL_ARGS_SIMPLE));
9309 if (!popped) PUSH_INSN(ret, location, dup);
9310 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9319 LABEL *set_label = NEW_LABEL(location.
line);
9320 LABEL *end_label = NEW_LABEL(location.
line);
9322 PUSH_INSN1(ret, location, putobject,
Qtrue);
9323 PUSH_INSNL(ret, location, branchunless, set_label);
9325 pm_local_index_t local_index = pm_lookup_local_index(iseq, scope_node, cast->
name, cast->
depth);
9326 PUSH_GETLOCAL(ret, location, local_index.index, local_index.level);
9327 if (!popped) PUSH_INSN(ret, location, dup);
9329 PUSH_INSNL(ret, location, branchif, end_label);
9330 if (!popped) PUSH_INSN(ret, location, pop);
9332 PUSH_LABEL(ret, set_label);
9333 PM_COMPILE_NOT_POPPED(cast->
value);
9334 if (!popped) PUSH_INSN(ret, location, dup);
9336 PUSH_SETLOCAL(ret, location, local_index.index, local_index.level);
9337 PUSH_LABEL(ret, end_label);
9346 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->
name, cast->
depth);
9347 PUSH_GETLOCAL(ret, location, index.index, index.level);
9356 PM_COMPILE_NOT_POPPED(cast->
value);
9357 if (!popped) PUSH_INSN(ret, location, dup);
9359 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->
name, cast->
depth);
9360 PUSH_SETLOCAL(ret, location, index.index, index.level);
9366 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9368 PUSH_INSN1(ret, location, putobject, regexp);
9370 PUSH_SEND(ret, location, idEqTilde,
INT2NUM(1));
9371 if (popped) PUSH_INSN(ret, location, pop);
9382 PUSH_INSN(ret, location, putnil);
9385 PM_COMPILE_NOT_POPPED(cast->
value);
9386 PUSH_INSN(ret, location, dup);
9390 LABEL *matched_label = NEW_LABEL(location.
line);
9391 LABEL *unmatched_label = NEW_LABEL(location.
line);
9392 LABEL *done_label = NEW_LABEL(location.
line);
9393 pm_compile_pattern(iseq, scope_node, cast->
pattern, ret, matched_label, unmatched_label,
false,
false,
true, 2);
9397 PUSH_LABEL(ret, unmatched_label);
9398 PUSH_INSN(ret, location, pop);
9399 PUSH_INSN(ret, location, pop);
9401 if (!popped) PUSH_INSN1(ret, location, putobject,
Qfalse);
9402 PUSH_INSNL(ret, location, jump, done_label);
9403 PUSH_INSN(ret, location, putnil);
9407 PUSH_LABEL(ret, matched_label);
9408 PUSH_INSN1(ret, location, adjuststack,
INT2FIX(2));
9409 if (!popped) PUSH_INSN1(ret, location, putobject,
Qtrue);
9410 PUSH_INSNL(ret, location, jump, done_label);
9412 PUSH_LABEL(ret, done_label);
9438 pm_compile_match_write_node(iseq, (
const pm_match_write_node_t *) node, &location, ret, popped, scope_node);
9441 rb_bug(
"A pm_missing_node_t should not exist in prism's AST.");
9448 ID module_id = pm_constant_id_lookup(scope_node, cast->
name);
9449 VALUE module_name =
rb_str_freeze(rb_sprintf(
"<module:%"PRIsVALUE
">", rb_id2str(module_id)));
9451 pm_scope_node_t next_scope_node;
9452 pm_scope_node_init((
const pm_node_t *) cast, &next_scope_node, scope_node);
9454 const rb_iseq_t *module_iseq = NEW_CHILD_ISEQ(&next_scope_node, module_name, ISEQ_TYPE_CLASS, location.
line);
9455 pm_scope_node_destroy(&next_scope_node);
9457 const int flags = VM_DEFINECLASS_TYPE_MODULE | pm_compile_class_path(iseq, cast->
constant_path, &location, ret,
false, scope_node);
9458 PUSH_INSN(ret, location, putnil);
9459 PUSH_INSN3(ret, location, defineclass,
ID2SYM(module_id), module_iseq,
INT2FIX(flags));
9462 if (popped) PUSH_INSN(ret, location, pop);
9469 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->
name, 0);
9471 PUSH_SETLOCAL(ret, location, index.index, index.level);
9485 DECL_ANCHOR(writes);
9486 DECL_ANCHOR(cleanup);
9489 state.position = popped ? 0 : 1;
9490 pm_compile_multi_target_node(iseq, node, ret, writes, cleanup, scope_node, &state);
9492 PM_COMPILE_NOT_POPPED(cast->
value);
9493 if (!popped) PUSH_INSN(ret, location, dup);
9495 PUSH_SEQ(ret, writes);
9496 if (!popped && state.stack_size >= 1) {
9499 PUSH_INSN1(ret, location, setn,
INT2FIX(state.stack_size));
9504 pm_multi_target_state_update(&state);
9506 PUSH_SEQ(ret, cleanup);
9515 pm_compile_next_node(iseq, (
const pm_next_node_t *) node, &location, ret, popped, scope_node);
9521 PUSH_INSN(ret, location, putnil);
9529 ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg = TRUE;
9538 if (reference_number > 0) {
9539 PUSH_INSN2(ret, location, getspecial,
INT2FIX(1),
INT2FIX(reference_number << 1));
9542 PUSH_INSN(ret, location, putnil);
9553 LABEL *end_label = NEW_LABEL(location.
line);
9554 PM_COMPILE_NOT_POPPED(cast->
left);
9556 if (!popped) PUSH_INSN(ret, location, dup);
9557 PUSH_INSNL(ret, location, branchif, end_label);
9559 if (!popped) PUSH_INSN(ret, location, pop);
9560 PM_COMPILE(cast->
right);
9561 PUSH_LABEL(ret, end_label);
9569 PM_COMPILE_NOT_POPPED(cast->
value);
9571 pm_local_index_t index = pm_lookup_local_index(iseq, scope_node, cast->
name, 0);
9572 PUSH_SETLOCAL(ret, location, index.index, index.level);
9584 if (cast->
body != NULL) {
9585 PM_COMPILE(cast->
body);
9588 PUSH_INSN(ret, location, putnil);
9605 DECL_ANCHOR(inner_pre);
9608 DECL_ANCHOR(inner_body);
9613 for (
size_t index = 0; index < body->
size; index++) {
9614 pm_compile_node(iseq, body->
nodes[index], inner_body,
true, scope_node);
9619 PUSH_INSN(inner_body, location, putnil);
9625 PUSH_SEQ(outer_pre, inner_pre);
9626 PUSH_SEQ(outer_pre, inner_body);
9634 const rb_iseq_t *child_iseq;
9635 const rb_iseq_t *prevblock = ISEQ_COMPILE_DATA(iseq)->current_block;
9637 pm_scope_node_t next_scope_node;
9638 pm_scope_node_init(node, &next_scope_node, scope_node);
9639 child_iseq = NEW_CHILD_ISEQ(&next_scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, lineno);
9640 pm_scope_node_destroy(&next_scope_node);
9642 ISEQ_COMPILE_DATA(iseq)->current_block = child_iseq;
9644 int is_index = ISEQ_BODY(iseq)->ise_size++;
9645 PUSH_INSN2(ret, location, once, child_iseq,
INT2FIX(is_index));
9647 if (popped) PUSH_INSN(ret, location, pop);
9649 ISEQ_COMPILE_DATA(iseq)->current_block = prevblock;
9659 if (pm_optimizable_range_item_p(cast->
left) && pm_optimizable_range_item_p(cast->
right)) {
9670 PUSH_INSN1(ret, location, putobject, val);
9674 if (cast->
left != NULL) {
9675 PM_COMPILE(cast->
left);
9678 PUSH_INSN(ret, location, putnil);
9681 if (cast->
right != NULL) {
9682 PM_COMPILE(cast->
right);
9685 PUSH_INSN(ret, location, putnil);
9689 PUSH_INSN1(ret, location, newrange,
INT2FIX(exclude_end ? 1 : 0));
9698 PUSH_INSN1(ret, location, putobject, parse_rational((
const pm_rational_node_t *) node));
9705 pm_compile_redo_node(iseq, &location, ret, popped, scope_node);
9711 VALUE regexp = pm_static_literal_value(iseq, node, scope_node);
9712 PUSH_INSN1(ret, location, putobject, regexp);
9719 pm_compile_rescue_node(iseq, (
const pm_rescue_node_t *) node, &location, ret, popped, scope_node);
9726 pm_scope_node_t rescue_scope_node;
9727 pm_scope_node_init((
const pm_node_t *) cast, &rescue_scope_node, scope_node);
9729 rb_iseq_t *rescue_iseq = NEW_CHILD_ISEQ(
9736 pm_scope_node_destroy(&rescue_scope_node);
9738 LABEL *lstart = NEW_LABEL(location.
line);
9739 LABEL *lend = NEW_LABEL(location.
line);
9740 LABEL *lcont = NEW_LABEL(location.
line);
9742 lstart->rescued = LABEL_RESCUE_BEG;
9743 lend->rescued = LABEL_RESCUE_END;
9745 PUSH_LABEL(ret, lstart);
9747 PUSH_LABEL(ret, lend);
9749 PUSH_INSN(ret, location, nop);
9750 PUSH_LABEL(ret, lcont);
9751 if (popped) PUSH_INSN(ret, location, pop);
9753 PUSH_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue_iseq, lcont);
9754 PUSH_CATCH_ENTRY(CATCH_TYPE_RETRY, lend, lcont, NULL, lstart);
9763 pm_compile_return_node(iseq, (
const pm_return_node_t *) node, &location, ret, popped, scope_node);
9768 if (ISEQ_BODY(iseq)->
type == ISEQ_TYPE_RESCUE) {
9769 PUSH_INSN(ret, location, putnil);
9770 PUSH_INSN1(ret, location,
throw,
INT2FIX(TAG_RETRY));
9771 if (popped) PUSH_INSN(ret, location, pop);
9774 COMPILE_ERROR(iseq, location.
line,
"Invalid retry");
9780 pm_compile_scope_node(iseq, (pm_scope_node_t *) node, &location, ret, popped);
9786 PUSH_INSN(ret, location, putself);
9822 rb_bug(
"Unexpected node type for shareable constant write: %s", pm_node_type_to_str(
PM_NODE_TYPE(cast->
write)));
9833 pm_scope_node_t next_scope_node;
9834 pm_scope_node_init((
const pm_node_t *) cast, &next_scope_node, scope_node);
9835 const rb_iseq_t *child_iseq = NEW_ISEQ(&next_scope_node, rb_fstring_lit(
"singleton class"), ISEQ_TYPE_CLASS, location.
line);
9836 pm_scope_node_destroy(&next_scope_node);
9839 PUSH_INSN(ret, location, putnil);
9842 CONST_ID(singletonclass,
"singletonclass");
9843 PUSH_INSN3(ret, location, defineclass,
ID2SYM(singletonclass), child_iseq,
INT2FIX(VM_DEFINECLASS_TYPE_SINGLETON_CLASS));
9845 if (popped) PUSH_INSN(ret, location, pop);
9854 VALUE value = pm_static_literal_value(iseq, node, scope_node);
9855 PUSH_INSN1(ret, location, putobject, value);
9864 VALUE string = pm_source_file_value(cast, scope_node);
9867 PUSH_INSN1(ret, location, putobject,
string);
9870 PUSH_INSN1(ret, location, putstring,
string);
9873 PUSH_INSN1(ret, location, putchilledstring,
string);
9882 VALUE value = pm_static_literal_value(iseq, node, scope_node);
9883 PUSH_INSN1(ret, location, putobject, value);
9896 PUSH_INSN1(ret, location, splatarray,
Qtrue);
9905 if (body->
size > 0) {
9906 for (
size_t index = 0; index < body->
size - 1; index++) {
9907 PM_COMPILE_POPPED(body->
nodes[index]);
9909 PM_COMPILE(body->
nodes[body->
size - 1]);
9912 PUSH_INSN(ret, location, putnil);
9921 VALUE value = parse_static_literal_string(iseq, scope_node, node, &cast->
unescaped);
9924 PUSH_INSN1(ret, location, putobject, value);
9927 PUSH_INSN1(ret, location, putstring, value);
9930 PUSH_INSN1(ret, location, putchilledstring, value);
9939 pm_compile_super_node(iseq, (
const pm_super_node_t *) node, &location, ret, popped, scope_node);
9945 VALUE value = pm_static_literal_value(iseq, node, scope_node);
9946 PUSH_INSN1(ret, location, putobject, value);
9954 PUSH_INSN1(ret, location, putobject,
Qtrue);
9964 for (
size_t index = 0; index < names->
size; index++) {
9965 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
9966 PUSH_INSN1(ret, location, putspecialobject,
INT2FIX(VM_SPECIAL_OBJECT_CBASE));
9968 PM_COMPILE_NOT_POPPED(names->
nodes[index]);
9969 PUSH_SEND(ret, location, id_core_undef_method,
INT2NUM(2));
9971 if (index < names->size - 1) {
9972 PUSH_INSN(ret, location, pop);
9976 if (popped) PUSH_INSN(ret, location, pop);
9991 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);
10001 pm_compile_loop(iseq, &location, cast->
base.
flags,
PM_UNTIL_NODE, (
const pm_node_t *) cast, cast->statements, cast->predicate, ret, popped, scope_node);
10011 pm_compile_loop(iseq, &location, cast->
base.
flags,
PM_WHILE_NODE, (
const pm_node_t *) cast, cast->statements, cast->predicate, ret, popped, scope_node);
10018 VALUE value = parse_static_literal_string(iseq, scope_node, node, &cast->
unescaped);
10020 PUSH_INSN(ret, location, putself);
10021 PUSH_INSN1(ret, location, putobject, value);
10022 PUSH_SEND_WITH_FLAG(ret, location, idBackquote,
INT2NUM(1),
INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE));
10023 if (popped) PUSH_INSN(ret, location, pop);
10033 pm_compile_yield_node(iseq, (
const pm_yield_node_t *) node, &location, ret, popped, scope_node);
10041#undef PM_CONTAINER_P
10045pm_iseq_pre_execution_p(rb_iseq_t *iseq)
10047 switch (ISEQ_BODY(iseq)->
type) {
10048 case ISEQ_TYPE_TOP:
10049 case ISEQ_TYPE_EVAL:
10050 case ISEQ_TYPE_MAIN:
10065pm_iseq_compile_node(rb_iseq_t *iseq, pm_scope_node_t *node)
10069 if (pm_iseq_pre_execution_p(iseq)) {
10081 pm_compile_node(iseq, (
const pm_node_t *) node, body,
false, node);
10085 PUSH_SEQ(ret, pre);
10086 PUSH_SEQ(ret, body);
10091 pm_compile_node(iseq, (
const pm_node_t *) node, ret,
false, node);
10094 CHECK(iseq_setup_insn(iseq, ret));
10095 return iseq_setup(iseq, ret);
10105 if (result->
node.ast_node != NULL) {
10106 pm_node_destroy(&result->
parser, result->
node.ast_node);
10111 pm_scope_node_destroy(&result->
node);
10114 pm_parser_free(&result->
parser);
10115 pm_string_free(&result->
input);
10116 pm_options_free(&result->
options);
10152#define PM_COLOR_BOLD "\033[1m"
10153#define PM_COLOR_GRAY "\033[2m"
10154#define PM_COLOR_RED "\033[1;31m"
10155#define PM_COLOR_RESET "\033[m"
10156#define PM_ERROR_TRUNCATE 30
10161 if (errors == NULL)
return NULL;
10165 pm_line_column_t start = pm_newline_list_line_column(newline_list, error->location.
start, start_line);
10166 pm_line_column_t end = pm_newline_list_line_column(newline_list, error->location.end, start_line);
10174 (index < error_list->size) &&
10175 (errors[index].error != NULL) &&
10177 (errors[index].line < start.
line) ||
10184 if (index + 1 < error_list->
size) {
10185 memmove(&errors[index + 1], &errors[index],
sizeof(
pm_parse_error_t) * (error_list->
size - index - 1));
10189 uint32_t column_end;
10191 column_end = end.
column;
10193 column_end = (uint32_t) (newline_list->
offsets[start.
line - start_line + 1] - newline_list->
offsets[start.
line - start_line] - 1);
10197 if (start.
column == column_end) column_end++;
10201 .line = start.
line,
10202 .column_start = start.
column,
10203 .column_end = column_end
10211#define pm_buffer_append_literal(buffer, str) pm_buffer_append_string(buffer, str, rb_strlen_lit(str))
10214pm_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) {
10215 int32_t line_delta = line - parser->
start_line;
10216 assert(line_delta >= 0);
10218 size_t index = (size_t) line_delta;
10219 assert(index < newline_list->size);
10221 const uint8_t *start = &parser->
start[newline_list->
offsets[index]];
10222 const uint8_t *end;
10224 if (index >= newline_list->
size - 1) {
10227 end = &parser->
start[newline_list->
offsets[index + 1]];
10230 pm_buffer_append_format(buffer, number_prefix, line);
10233 bool truncate_end =
false;
10234 if ((column_end != 0) && ((end - (start + column_end)) >= PM_ERROR_TRUNCATE)) {
10235 end = start + column_end + PM_ERROR_TRUNCATE;
10236 truncate_end =
true;
10240 if (column_start >= PM_ERROR_TRUNCATE) {
10241 pm_buffer_append_string(buffer,
"... ", 4);
10242 start += column_start;
10245 pm_buffer_append_string(buffer, (
const char *) start, (
size_t) (end - start));
10247 if (truncate_end) {
10248 pm_buffer_append_string(buffer,
" ...\n", 5);
10249 }
else if (end == parser->
end && end[-1] !=
'\n') {
10250 pm_buffer_append_string(buffer,
"\n", 1);
10259 assert(error_list->
size != 0);
10263 const int32_t start_line = parser->
start_line;
10266 pm_parse_error_t *errors = pm_parse_errors_format_sort(parser, error_list, newline_list);
10267 if (errors == NULL)
return;
10273 int32_t first_line_number = errors[0].
line;
10274 int32_t last_line_number = errors[error_list->
size - 1].
line;
10279 if (first_line_number < 0) first_line_number = (-first_line_number) * 10;
10280 if (last_line_number < 0) last_line_number = (-last_line_number) * 10;
10281 int32_t max_line_number = first_line_number > last_line_number ? first_line_number : last_line_number;
10283 if (max_line_number < 10) {
10284 if (highlight > 0) {
10286 .number_prefix = PM_COLOR_GRAY
"%1" PRIi32
" | " PM_COLOR_RESET,
10287 .blank_prefix = PM_COLOR_GRAY
" | " PM_COLOR_RESET,
10288 .divider = PM_COLOR_GRAY
" ~~~~~" PM_COLOR_RESET
"\n"
10292 .number_prefix =
"%1" PRIi32
" | ",
10293 .blank_prefix =
" | ",
10294 .divider =
" ~~~~~\n"
10297 }
else if (max_line_number < 100) {
10298 if (highlight > 0) {
10300 .number_prefix = PM_COLOR_GRAY
"%2" PRIi32
" | " PM_COLOR_RESET,
10301 .blank_prefix = PM_COLOR_GRAY
" | " PM_COLOR_RESET,
10302 .divider = PM_COLOR_GRAY
" ~~~~~~" PM_COLOR_RESET
"\n"
10306 .number_prefix =
"%2" PRIi32
" | ",
10307 .blank_prefix =
" | ",
10308 .divider =
" ~~~~~~\n"
10311 }
else if (max_line_number < 1000) {
10312 if (highlight > 0) {
10314 .number_prefix = PM_COLOR_GRAY
"%3" PRIi32
" | " PM_COLOR_RESET,
10315 .blank_prefix = PM_COLOR_GRAY
" | " PM_COLOR_RESET,
10316 .divider = PM_COLOR_GRAY
" ~~~~~~~" PM_COLOR_RESET
"\n"
10320 .number_prefix =
"%3" PRIi32
" | ",
10321 .blank_prefix =
" | ",
10322 .divider =
" ~~~~~~~\n"
10325 }
else if (max_line_number < 10000) {
10326 if (highlight > 0) {
10328 .number_prefix = PM_COLOR_GRAY
"%4" PRIi32
" | " PM_COLOR_RESET,
10329 .blank_prefix = PM_COLOR_GRAY
" | " PM_COLOR_RESET,
10330 .divider = PM_COLOR_GRAY
" ~~~~~~~~" PM_COLOR_RESET
"\n"
10334 .number_prefix =
"%4" PRIi32
" | ",
10335 .blank_prefix =
" | ",
10336 .divider =
" ~~~~~~~~\n"
10340 if (highlight > 0) {
10342 .number_prefix = PM_COLOR_GRAY
"%5" PRIi32
" | " PM_COLOR_RESET,
10343 .blank_prefix = PM_COLOR_GRAY
" | " PM_COLOR_RESET,
10344 .divider = PM_COLOR_GRAY
" ~~~~~~~~" PM_COLOR_RESET
"\n"
10348 .number_prefix =
"%5" PRIi32
" | ",
10349 .blank_prefix =
" | ",
10350 .divider =
" ~~~~~~~~\n"
10364 uint32_t last_column_start = 0;
10367 for (
size_t index = 0; index < error_list->
size; index++) {
10372 if (error->
line - last_line > 1) {
10373 if (error->
line - last_line > 2) {
10374 if ((index != 0) && (error->
line - last_line > 3)) {
10378 pm_buffer_append_string(buffer,
" ", 2);
10379 pm_parse_errors_format_line(parser, newline_list, error_format.
number_prefix, error->
line - 2, 0, 0, buffer);
10382 pm_buffer_append_string(buffer,
" ", 2);
10383 pm_parse_errors_format_line(parser, newline_list, error_format.
number_prefix, error->
line - 1, 0, 0, buffer);
10388 if ((index == 0) || (error->
line != last_line)) {
10389 if (highlight > 1) {
10390 pm_buffer_append_literal(buffer, PM_COLOR_RED
"> " PM_COLOR_RESET);
10391 }
else if (highlight > 0) {
10392 pm_buffer_append_literal(buffer, PM_COLOR_BOLD
"> " PM_COLOR_RESET);
10394 pm_buffer_append_literal(buffer,
"> ");
10401 for (
size_t next_index = index + 1; next_index < error_list->
size; next_index++) {
10402 if (errors[next_index].line != error->
line)
break;
10403 if (errors[next_index].column_end > column_end) column_end = errors[next_index].
column_end;
10409 const uint8_t *start = &parser->
start[newline_list->
offsets[error->
line - start_line]];
10410 if (start == parser->
end) pm_buffer_append_byte(buffer,
'\n');
10421 pm_buffer_append_string(buffer,
" ", 2);
10425 if (last_column_start >= PM_ERROR_TRUNCATE) {
10426 pm_buffer_append_string(buffer,
" ", 4);
10427 column = last_column_start;
10430 while (column < error->column_start) {
10431 pm_buffer_append_byte(buffer,
' ');
10433 size_t char_width = encoding->
char_width(start + column, parser->
end - (start + column));
10434 column += (char_width == 0 ? 1 : char_width);
10437 if (highlight > 1) pm_buffer_append_literal(buffer, PM_COLOR_RED);
10438 else if (highlight > 0) pm_buffer_append_literal(buffer, PM_COLOR_BOLD);
10439 pm_buffer_append_byte(buffer,
'^');
10441 size_t char_width = encoding->
char_width(start + column, parser->
end - (start + column));
10442 column += (char_width == 0 ? 1 : char_width);
10444 while (column < error->column_end) {
10445 pm_buffer_append_byte(buffer,
'~');
10447 size_t char_width = encoding->
char_width(start + column, parser->
end - (start + column));
10448 column += (char_width == 0 ? 1 : char_width);
10451 if (highlight > 0) pm_buffer_append_literal(buffer, PM_COLOR_RESET);
10453 if (inline_messages) {
10454 pm_buffer_append_byte(buffer,
' ');
10455 assert(error->
error != NULL);
10458 pm_buffer_append_string(buffer, message, strlen(message));
10461 pm_buffer_append_byte(buffer,
'\n');
10465 last_line = error->
line;
10468 if (index == error_list->
size - 1) {
10469 next_line = (((int32_t) newline_list->
size) + parser->
start_line);
10478 next_line = errors[index + 1].
line;
10481 if (next_line - last_line > 1) {
10482 pm_buffer_append_string(buffer,
" ", 2);
10483 pm_parse_errors_format_line(parser, newline_list, error_format.
number_prefix, ++last_line, 0, 0, buffer);
10486 if (next_line - last_line > 1) {
10487 pm_buffer_append_string(buffer,
" ", 2);
10488 pm_parse_errors_format_line(parser, newline_list, error_format.
number_prefix, ++last_line, 0, 0, buffer);
10496#undef PM_ERROR_TRUNCATE
10497#undef PM_COLOR_GRAY
10499#undef PM_COLOR_RESET
10510 const size_t start_line = pm_newline_list_line_column(&parser->
newline_list, location->
start, 1).line;
10511 const size_t end_line = pm_newline_list_line_column(&parser->
newline_list, location->
end, 1).line;
10517 while (start < end) {
10518 if ((width = pm_encoding_utf_8_char_width(start, end - start)) == 0)
return false;
10534 bool valid_utf8 =
true;
10539 int highlight = rb_stderr_tty_p();
10541 const char *no_color = getenv(
"NO_COLOR");
10542 highlight = (no_color == NULL || no_color[0] ==
'\0') ? 2 : 1;
10546 switch (error->level) {
10553 if (valid_utf8 && !pm_parse_process_error_utf8_p(parser, &error->location)) {
10554 valid_utf8 =
false;
10561 int32_t line_number = (int32_t) pm_location_line_number(parser, &error->location);
10563 pm_buffer_append_format(
10565 "%.*s:%" PRIi32
": %s",
10566 (
int) pm_string_length(filepath),
10567 pm_string_source(filepath),
10572 if (pm_parse_process_error_utf8_p(parser, &error->location)) {
10573 pm_buffer_append_byte(&buffer,
'\n');
10576 pm_list_t error_list = { .size = 1, .head = list_node, .tail = list_node };
10578 pm_parse_errors_format(parser, &error_list, &buffer, highlight,
false);
10581 VALUE value =
rb_exc_new(rb_eArgError, pm_buffer_value(&buffer), pm_buffer_length(&buffer));
10582 pm_buffer_free(&buffer);
10598 pm_buffer_append_format(
10600 "%.*s:%" PRIi32
": syntax error%s found\n",
10601 (
int) pm_string_length(filepath),
10602 pm_string_source(filepath),
10603 (int32_t) pm_location_line_number(parser, &head->location),
10608 pm_parse_errors_format(parser, &parser->
error_list, &buffer, highlight,
true);
10612 if (error != head) pm_buffer_append_byte(&buffer,
'\n');
10613 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);
10617 VALUE message = rb_enc_str_new(pm_buffer_value(&buffer), pm_buffer_length(&buffer), result->
node.encoding);
10621 VALUE path = rb_enc_str_new((
const char *) pm_string_source(filepath), pm_string_length(filepath), filepath_encoding);
10624 pm_buffer_free(&buffer);
10641 pm_scope_node_t *scope_node = &result->
node;
10643 int coverage_enabled = scope_node->coverage_enabled;
10645 pm_scope_node_init(node, scope_node, NULL);
10648 scope_node->encoding = rb_enc_find(parser->
encoding->
name);
10649 if (!scope_node->encoding) rb_bug(
"Encoding not found %s!", parser->
encoding->
name);
10651 scope_node->coverage_enabled = coverage_enabled;
10655 if (script_lines != NULL) {
10660 size_t length = index == parser->
newline_list.
size - 1 ? ((size_t) (parser->
end - (parser->
start + offset))) : (parser->newline_list.offsets[index + 1] - offset);
10661 rb_ary_push(*script_lines, rb_enc_str_new((
const char *) parser->
start + offset, length, scope_node->encoding));
10669 const char *warning_filepath = (
const char *) pm_string_source(&parser->
filepath);
10672 int line = pm_location_line_number(parser, &warning->
location);
10675 rb_enc_compile_warning(scope_node->encoding, warning_filepath, line,
"%s", warning->
message);
10678 rb_enc_compile_warn(scope_node->encoding, warning_filepath, line,
"%s", warning->
message);
10684 VALUE error = pm_parse_process_error(result);
10693 scope_node->parser = parser;
10698 scope_node->constants[index] = rb_intern3((
const char *) constant->
start, constant->
length, scope_node->encoding);
10701 scope_node->index_lookup_table = st_init_numtable();
10703 for (
size_t index = 0; index < locals->
size; index++) {
10704 st_insert(scope_node->index_lookup_table, locals->
ids[index], index);
10718pm_options_frozen_string_literal_init(
pm_options_t *options)
10720 int frozen_string_literal = rb_iseq_opt_frozen_string_literal();
10722 switch (frozen_string_literal) {
10723 case ISEQ_FROZEN_STRING_LITERAL_UNSET:
10725 case ISEQ_FROZEN_STRING_LITERAL_DISABLED:
10726 pm_options_frozen_string_literal_set(options,
false);
10728 case ISEQ_FROZEN_STRING_LITERAL_ENABLED:
10729 pm_options_frozen_string_literal_set(options,
true);
10732 rb_bug(
"pm_options_frozen_string_literal_init: invalid frozen_string_literal=%d", frozen_string_literal);
10742pm_parse_file_script_lines(
const pm_scope_node_t *scope_node,
const pm_parser_t *parser)
10745 const char *start = (
const char *) parser->
start;
10746 const char *end = (
const char *) parser->
end;
10751 size_t last_offset = newline_list->
offsets[newline_list->
size - 1];
10752 bool last_push = start + last_offset != end;
10755 VALUE lines = rb_ary_new_capa(newline_list->
size - (last_push ? 0 : 1));
10757 for (
size_t index = 0; index < newline_list->
size - 1; index++) {
10758 size_t offset = newline_list->
offsets[index];
10759 size_t length = newline_list->
offsets[index + 1] - offset;
10761 rb_ary_push(lines, rb_enc_str_new(start + offset, length, scope_node->encoding));
10766 rb_ary_push(lines, rb_enc_str_new(start + last_offset, end - (start + last_offset), scope_node->encoding));
10776pm_read_file(
pm_string_t *
string,
const char *filepath)
10780 int length = MultiByteToWideChar(CP_UTF8, 0, filepath, -1, NULL, 0);
10783 WCHAR *wfilepath =
xmalloc(
sizeof(WCHAR) * ((
size_t) length));
10784 if ((wfilepath == NULL) || (MultiByteToWideChar(CP_UTF8, 0, filepath, -1, wfilepath, length) == 0)) {
10789 HANDLE file = CreateFileW(wfilepath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
10790 if (file == INVALID_HANDLE_VALUE) {
10793 if (GetLastError() == ERROR_ACCESS_DENIED) {
10794 DWORD attributes = GetFileAttributesW(wfilepath);
10795 if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
10805 DWORD file_size = GetFileSize(file, NULL);
10806 if (file_size == INVALID_FILE_SIZE) {
10814 if (file_size == 0) {
10817 const uint8_t source[] =
"";
10818 *
string = (
pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
10823 HANDLE mapping = CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, NULL);
10824 if (mapping == NULL) {
10831 uint8_t *source = (uint8_t *) MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, 0);
10832 CloseHandle(mapping);
10836 if (source == NULL) {
10840 *
string = (
pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = (size_t) file_size };
10842#elif defined(_POSIX_MAPPED_FILES)
10844 const int open_mode = O_RDONLY | O_NONBLOCK;
10845 int fd = open(filepath, open_mode);
10852 if (fstat(fd, &sb) == -1) {
10858 if (S_ISDIR(sb.st_mode)) {
10866 if (S_ISFIFO(sb.st_mode) || S_ISCHR(sb.st_mode)) {
10875 long len = RSTRING_LEN(contents);
10880 size_t length = (size_t)
len;
10881 uint8_t *source = malloc(length);
10882 memcpy(source, RSTRING_PTR(contents), length);
10883 *
string = (
pm_string_t) { .type = PM_STRING_OWNED, .source = source, .length = length };
10889 size_t size = (size_t) sb.st_size;
10890 uint8_t *source = NULL;
10894 const uint8_t source[] =
"";
10895 *
string = (
pm_string_t) { .type = PM_STRING_CONSTANT, .source = source, .length = 0 };
10899 source = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
10900 if (source == MAP_FAILED) {
10906 *
string = (
pm_string_t) { .type = PM_STRING_MAPPED, .source = source, .length = size };
10909 return pm_string_file_init(
string, filepath);
10923 pm_options_frozen_string_literal_init(&result->
options);
10932 err = rb_w32_map_errno(GetLastError());
10964 pm_options_filepath_set(&result->
options, RSTRING_PTR(filepath));
10967 pm_parser_init(&result->
parser, pm_string_source(&result->
input), pm_string_length(&result->
input), &result->
options);
10970 VALUE error = pm_parse_process(result, node, script_lines);
10975 ID id_script_lines = rb_intern(
"SCRIPT_LINES__");
10981 rb_hash_aset(constant_script_lines, filepath, pm_parse_file_script_lines(&result->
node, &result->
parser));
10995 VALUE error = pm_load_file(result, filepath,
false);
10996 if (
NIL_P(error)) {
10997 error = pm_parse_file(result, filepath, script_lines);
11012 rb_encoding *encoding = rb_enc_get(source);
11013 if (!rb_enc_asciicompat(encoding)) {
11017 pm_options_frozen_string_literal_init(&result->
options);
11018 pm_string_constant_init(&result->
input, RSTRING_PTR(source), RSTRING_LEN(source));
11019 pm_options_encoding_set(&result->
options, rb_enc_name(encoding));
11022 pm_options_filepath_set(&result->
options, RSTRING_PTR(filepath));
11025 pm_parser_init(&result->
parser, pm_string_source(&result->
input), pm_string_length(&result->
input), &result->
options);
11028 return pm_parse_process(result, node, script_lines);
11035pm_parse_stdin_fgets(
char *
string,
int size,
void *stream)
11044 const char *cstr = RSTRING_PTR(line);
11045 long length = RSTRING_LEN(line);
11047 memcpy(
string, cstr, length);
11048 string[length] =
'\0';
11054void rb_reset_argf_lineno(
long n);
11064 pm_options_frozen_string_literal_init(&result->
options);
11072 pm_string_owned_init(&result->
input, (uint8_t *) pm_buffer_value(&buffer), pm_buffer_length(&buffer));
11076 rb_reset_argf_lineno(0);
11078 return pm_parse_process(result, node, NULL);
11082#define NEW_ISEQ OLD_ISEQ
11084#undef NEW_CHILD_ISEQ
11085#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.
struct pm_block_parameter_node pm_block_parameter_node_t
BlockParameterNode.
struct pm_call_target_node pm_call_target_node_t
CallTargetNode.
struct pm_else_node pm_else_node_t
ElseNode.
struct pm_assoc_node pm_assoc_node_t
AssocNode.
struct pm_undef_node pm_undef_node_t
UndefNode.
struct pm_class_variable_and_write_node pm_class_variable_and_write_node_t
ClassVariableAndWriteNode.
struct pm_index_and_write_node pm_index_and_write_node_t
IndexAndWriteNode.
struct pm_index_target_node pm_index_target_node_t
IndexTargetNode.
struct pm_local_variable_target_node pm_local_variable_target_node_t
LocalVariableTargetNode.
struct pm_constant_path_or_write_node pm_constant_path_or_write_node_t
ConstantPathOrWriteNode.
struct pm_embedded_statements_node pm_embedded_statements_node_t
EmbeddedStatementsNode.
struct pm_block_node pm_block_node_t
BlockNode.
struct pm_hash_pattern_node pm_hash_pattern_node_t
HashPatternNode.
struct pm_optional_parameter_node pm_optional_parameter_node_t
OptionalParameterNode.
struct pm_x_string_node pm_x_string_node_t
XStringNode.
struct pm_forwarding_super_node pm_forwarding_super_node_t
ForwardingSuperNode.
struct pm_numbered_reference_read_node pm_numbered_reference_read_node_t
NumberedReferenceReadNode.
struct pm_embedded_variable_node pm_embedded_variable_node_t
EmbeddedVariableNode.
struct pm_class_variable_write_node pm_class_variable_write_node_t
ClassVariableWriteNode.
struct pm_interpolated_string_node pm_interpolated_string_node_t
InterpolatedStringNode.
struct pm_class_variable_or_write_node pm_class_variable_or_write_node_t
ClassVariableOrWriteNode.
struct pm_optional_keyword_parameter_node pm_optional_keyword_parameter_node_t
OptionalKeywordParameterNode.
struct pm_call_or_write_node pm_call_or_write_node_t
CallOrWriteNode.
struct pm_call_node pm_call_node_t
CallNode.
struct pm_class_variable_read_node pm_class_variable_read_node_t
ClassVariableReadNode.
struct pm_match_required_node pm_match_required_node_t
MatchRequiredNode.
struct pm_shareable_constant_node pm_shareable_constant_node_t
ShareableConstantNode.
struct pm_constant_and_write_node pm_constant_and_write_node_t
ConstantAndWriteNode.
@ 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...
struct pm_constant_path_operator_write_node pm_constant_path_operator_write_node_t
ConstantPathOperatorWriteNode.
@ PM_RANGE_FLAGS_EXCLUDE_END
... operator
struct pm_local_variable_or_write_node pm_local_variable_or_write_node_t
LocalVariableOrWriteNode.
struct pm_local_variable_read_node pm_local_variable_read_node_t
LocalVariableReadNode.
struct pm_global_variable_and_write_node pm_global_variable_and_write_node_t
GlobalVariableAndWriteNode.
struct pm_arguments_node pm_arguments_node_t
ArgumentsNode.
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_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_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_EMBEDDED_STATEMENTS_NODE
EmbeddedStatementsNode.
@ PM_INTERPOLATED_REGULAR_EXPRESSION_NODE
InterpolatedRegularExpressionNode.
@ PM_INDEX_TARGET_NODE
IndexTargetNode.
@ PM_KEYWORD_REST_PARAMETER_NODE
KeywordRestParameterNode.
struct pm_begin_node pm_begin_node_t
BeginNode.
struct pm_statements_node pm_statements_node_t
StatementsNode.
struct pm_instance_variable_write_node pm_instance_variable_write_node_t
InstanceVariableWriteNode.
struct pm_keyword_hash_node pm_keyword_hash_node_t
KeywordHashNode.
struct pm_return_node pm_return_node_t
ReturnNode.
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
struct pm_constant_path_node pm_constant_path_node_t
ConstantPathNode.
struct pm_local_variable_write_node pm_local_variable_write_node_t
LocalVariableWriteNode.
@ 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
struct pm_implicit_node pm_implicit_node_t
ImplicitNode.
struct pm_yield_node pm_yield_node_t
YieldNode.
@ 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
struct pm_local_variable_and_write_node pm_local_variable_and_write_node_t
LocalVariableAndWriteNode.
struct pm_parameters_node pm_parameters_node_t
ParametersNode.
struct pm_lambda_node pm_lambda_node_t
LambdaNode.
#define PM_NODE_FLAG_P(node, flag)
Return true if the given flag is set on the given node.
struct pm_module_node pm_module_node_t
ModuleNode.
struct pm_case_node pm_case_node_t
CaseNode.
struct pm_in_node pm_in_node_t
InNode.
struct pm_if_node pm_if_node_t
IfNode.
struct pm_constant_path_write_node pm_constant_path_write_node_t
ConstantPathWriteNode.
struct pm_pre_execution_node pm_pre_execution_node_t
PreExecutionNode.
struct pm_rescue_modifier_node pm_rescue_modifier_node_t
RescueModifierNode.
struct pm_splat_node pm_splat_node_t
SplatNode.
struct pm_match_write_node pm_match_write_node_t
MatchWriteNode.
struct pm_multi_write_node pm_multi_write_node_t
MultiWriteNode.
struct pm_local_variable_operator_write_node pm_local_variable_operator_write_node_t
LocalVariableOperatorWriteNode.
struct pm_block_argument_node pm_block_argument_node_t
BlockArgumentNode.
struct pm_interpolated_x_string_node pm_interpolated_x_string_node_t
InterpolatedXStringNode.
struct pm_constant_write_node pm_constant_write_node_t
ConstantWriteNode.
struct pm_flip_flop_node pm_flip_flop_node_t
FlipFlopNode.
struct pm_required_keyword_parameter_node pm_required_keyword_parameter_node_t
RequiredKeywordParameterNode.
#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.
struct pm_alias_global_variable_node pm_alias_global_variable_node_t
AliasGlobalVariableNode.
struct pm_post_execution_node pm_post_execution_node_t
PostExecutionNode.
struct pm_alias_method_node pm_alias_method_node_t
AliasMethodNode.
struct pm_keyword_rest_parameter_node pm_keyword_rest_parameter_node_t
KeywordRestParameterNode.
struct pm_global_variable_read_node pm_global_variable_read_node_t
GlobalVariableReadNode.
struct pm_match_last_line_node pm_match_last_line_node_t
MatchLastLineNode.
struct pm_hash_node pm_hash_node_t
HashNode.
struct pm_block_local_variable_node pm_block_local_variable_node_t
BlockLocalVariableNode.
struct pm_multi_target_node pm_multi_target_node_t
MultiTargetNode.
struct pm_rational_node pm_rational_node_t
RationalNode.
struct pm_class_node pm_class_node_t
ClassNode.
struct pm_pinned_expression_node pm_pinned_expression_node_t
PinnedExpressionNode.
struct pm_constant_operator_write_node pm_constant_operator_write_node_t
ConstantOperatorWriteNode.
struct pm_ensure_node pm_ensure_node_t
EnsureNode.
struct pm_index_or_write_node pm_index_or_write_node_t
IndexOrWriteNode.
struct pm_constant_or_write_node pm_constant_or_write_node_t
ConstantOrWriteNode.
struct pm_index_operator_write_node pm_index_operator_write_node_t
IndexOperatorWriteNode.
struct pm_when_node pm_when_node_t
WhenNode.
struct pm_super_node pm_super_node_t
SuperNode.
struct pm_range_node pm_range_node_t
RangeNode.
struct pm_and_node pm_and_node_t
AndNode.
struct pm_constant_path_and_write_node pm_constant_path_and_write_node_t
ConstantPathAndWriteNode.
struct pm_rest_parameter_node pm_rest_parameter_node_t
RestParameterNode.
struct pm_assoc_splat_node pm_assoc_splat_node_t
AssocSplatNode.
@ 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
struct pm_constant_read_node pm_constant_read_node_t
ConstantReadNode.
struct pm_match_predicate_node pm_match_predicate_node_t
MatchPredicateNode.
struct pm_or_node pm_or_node_t
OrNode.
struct pm_case_match_node pm_case_match_node_t
CaseMatchNode.
struct pm_call_and_write_node pm_call_and_write_node_t
CallAndWriteNode.
@ 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
struct pm_until_node pm_until_node_t
UntilNode.
uint16_t pm_node_type_t
This is the type of node embedded in the node struct.
struct pm_imaginary_node pm_imaginary_node_t
ImaginaryNode.
struct pm_array_pattern_node pm_array_pattern_node_t
ArrayPatternNode.
@ 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...
struct pm_break_node pm_break_node_t
BreakNode.
struct pm_integer_node pm_integer_node_t
IntegerNode.
struct pm_constant_path_target_node pm_constant_path_target_node_t
ConstantPathTargetNode.
struct pm_call_operator_write_node pm_call_operator_write_node_t
CallOperatorWriteNode.
struct pm_for_node pm_for_node_t
ForNode.
struct pm_global_variable_target_node pm_global_variable_target_node_t
GlobalVariableTargetNode.
struct pm_node_list pm_node_list_t
A list of nodes in the source, most often used for lists of children.
struct pm_required_parameter_node pm_required_parameter_node_t
RequiredParameterNode.
struct pm_symbol_node pm_symbol_node_t
SymbolNode.
struct pm_block_parameters_node pm_block_parameters_node_t
BlockParametersNode.
struct pm_alternation_pattern_node pm_alternation_pattern_node_t
AlternationPatternNode.
struct pm_parentheses_node pm_parentheses_node_t
ParenthesesNode.
@ 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
struct pm_instance_variable_read_node pm_instance_variable_read_node_t
InstanceVariableReadNode.
struct pm_constant_target_node pm_constant_target_node_t
ConstantTargetNode.
struct pm_node pm_node_t
This is the base structure that represents a node in the syntax tree.
struct pm_defined_node pm_defined_node_t
DefinedNode.
struct pm_interpolated_symbol_node pm_interpolated_symbol_node_t
InterpolatedSymbolNode.
struct pm_class_variable_target_node pm_class_variable_target_node_t
ClassVariableTargetNode.
struct pm_def_node pm_def_node_t
DefNode.
struct pm_singleton_class_node pm_singleton_class_node_t
SingletonClassNode.
uint16_t pm_node_flags_t
These are the flags embedded in the node struct.
struct pm_capture_pattern_node pm_capture_pattern_node_t
CapturePatternNode.
struct pm_source_file_node pm_source_file_node_t
SourceFileNode.
struct pm_regular_expression_node pm_regular_expression_node_t
RegularExpressionNode.
struct pm_global_variable_or_write_node pm_global_variable_or_write_node_t
GlobalVariableOrWriteNode.
struct pm_rescue_node pm_rescue_node_t
RescueNode.
struct pm_array_node pm_array_node_t
ArrayNode.
struct pm_while_node pm_while_node_t
WhileNode.
struct pm_global_variable_write_node pm_global_variable_write_node_t
GlobalVariableWriteNode.
struct pm_instance_variable_or_write_node pm_instance_variable_or_write_node_t
InstanceVariableOrWriteNode.
@ 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
struct pm_interpolated_match_last_line_node pm_interpolated_match_last_line_node_t
InterpolatedMatchLastLineNode.
struct pm_numbered_parameters_node pm_numbered_parameters_node_t
NumberedParametersNode.
struct pm_class_variable_operator_write_node pm_class_variable_operator_write_node_t
ClassVariableOperatorWriteNode.
struct pm_next_node pm_next_node_t
NextNode.
struct pm_unless_node pm_unless_node_t
UnlessNode.
struct pm_interpolated_regular_expression_node pm_interpolated_regular_expression_node_t
InterpolatedRegularExpressionNode.
struct pm_instance_variable_target_node pm_instance_variable_target_node_t
InstanceVariableTargetNode.
struct pm_string_node pm_string_node_t
StringNode.
struct pm_float_node pm_float_node_t
FloatNode.
struct pm_global_variable_operator_write_node pm_global_variable_operator_write_node_t
GlobalVariableOperatorWriteNode.
struct pm_instance_variable_operator_write_node pm_instance_variable_operator_write_node_t
InstanceVariableOperatorWriteNode.
@ PM_LOOP_FLAGS_BEGIN_MODIFIER
a loop after a begin statement, so the body is executed first before the condition
struct pm_pinned_variable_node pm_pinned_variable_node_t
PinnedVariableNode.
struct pm_instance_variable_and_write_node pm_instance_variable_and_write_node_t
InstanceVariableAndWriteNode.
struct pm_program_node pm_program_node_t
ProgramNode.
struct pm_find_pattern_node pm_find_pattern_node_t
FindPatternNode.
@ 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.
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_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.
struct pm_options pm_options_t
The options that can be passed to the parser.
struct pm_parser pm_parser_t
The parser used to parse Ruby source.
uint32_t pm_constant_id_t
A constant id is a unique identifier for a constant in the constant pool.
struct pm_list_node pm_list_node_t
This struct represents an abstract linked list that provides common functionality.
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.
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.
struct pm_node * value
ClassVariableAndWriteNode#value.
pm_constant_id_t name
ClassVariableAndWriteNode#name.
pm_constant_id_t name
ClassVariableOperatorWriteNode#name.
pm_constant_id_t binary_operator
ClassVariableOperatorWriteNode#binary_operator.
struct pm_node * value
ClassVariableOperatorWriteNode#value.
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.
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.
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.
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.
struct pm_node * value
GlobalVariableAndWriteNode#value.
pm_constant_id_t name
GlobalVariableAndWriteNode#name.
pm_constant_id_t name
GlobalVariableOperatorWriteNode#name.
pm_constant_id_t binary_operator
GlobalVariableOperatorWriteNode#binary_operator.
struct pm_node * value
GlobalVariableOperatorWriteNode#value.
pm_constant_id_t name
GlobalVariableOrWriteNode#name.
struct pm_node * value
GlobalVariableOrWriteNode#value.
pm_constant_id_t name
GlobalVariableReadNode#name.
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.
struct pm_node * value
InstanceVariableAndWriteNode#value.
pm_constant_id_t name
InstanceVariableAndWriteNode#name.
struct pm_node * value
InstanceVariableOperatorWriteNode#value.
pm_constant_id_t binary_operator
InstanceVariableOperatorWriteNode#binary_operator.
pm_constant_id_t name
InstanceVariableOperatorWriteNode#name.
struct pm_node * value
InstanceVariableOrWriteNode#value.
pm_constant_id_t name
InstanceVariableOrWriteNode#name.
pm_constant_id_t name
InstanceVariableReadNode#name.
pm_constant_id_t name
InstanceVariableTargetNode#name.
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.
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.
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.
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.
pm_constant_id_t name
LocalVariableAndWriteNode#name.
uint32_t depth
LocalVariableAndWriteNode#depth.
struct pm_node * value
LocalVariableAndWriteNode#value.
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.
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.
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.
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.
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.
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.
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.
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::@000024342312237062266020177166377106262102236123 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.