diff options
Diffstat (limited to 'prism/prism_compiler.c')
| -rw-r--r-- | prism/prism_compiler.c | 2150 |
1 files changed, 2150 insertions, 0 deletions
diff --git a/prism/prism_compiler.c b/prism/prism_compiler.c new file mode 100644 index 0000000000..4b3e6ec11b --- /dev/null +++ b/prism/prism_compiler.c @@ -0,0 +1,2150 @@ +#include "yarp.h" + +#define OLD_ISEQ NEW_ISEQ +#undef NEW_ISEQ + +#define NEW_ISEQ(node, name, type, line_no) \ + yp_new_child_iseq(iseq, (node), parser, rb_fstring(name), 0, (type), (line_no)) + +#define OLD_CHILD_ISEQ NEW_CHILD_ISEQ +#undef NEW_CHILD_ISEQ + +#define NEW_CHILD_ISEQ(node, name, type, line_no) \ + yp_new_child_iseq(iseq, (node), parser, rb_fstring(name), iseq, (type), (line_no)) + +#define YP_COMPILE(node) \ + yp_compile_node(iseq, (node), ret, src, popped, compile_context) + +#define YP_COMPILE_POPPED(node) \ + yp_compile_node(iseq, (node), ret, src, true, compile_context) + +#define YP_COMPILE_NOT_POPPED(node) \ + yp_compile_node(iseq, (node), ret, src, false, compile_context) + +#define YP_POP_IF_POPPED \ + if (popped) ADD_INSN(ret, &dummy_line_node, pop); + +#define YP_POP_UNLESS_POPPED \ + if (!popped) ADD_INSN(ret, &dummy_line_node, pop); + +#define YP_DUP_UNLESS_POPPED \ + if (!popped) ADD_INSN(ret, &dummy_line_node, dup); + +#define YP_PUTNIL_UNLESS_POPPED \ + if (!popped) ADD_INSN(ret, &dummy_line_node, putnil); + +rb_iseq_t * +yp_iseq_new_with_opt(yp_scope_node_t *node, yp_parser_t *parser, VALUE name, VALUE path, VALUE realpath, + int first_lineno, const rb_iseq_t *parent, int isolated_depth, + enum rb_iseq_type type, const rb_compile_option_t *option); + +static VALUE +parse_integer(const yp_integer_node_t *node) +{ + const char *start = (const char *) node->base.location.start; + const char *end = (const char *) node->base.location.end; + + size_t length = end - start; + int base = -10; + + switch (node->base.flags & (YP_INTEGER_BASE_FLAGS_BINARY | YP_INTEGER_BASE_FLAGS_DECIMAL | YP_INTEGER_BASE_FLAGS_OCTAL | YP_INTEGER_BASE_FLAGS_HEXADECIMAL)) { + case YP_INTEGER_BASE_FLAGS_BINARY: + base = 2; + break; + case YP_INTEGER_BASE_FLAGS_DECIMAL: + base = 10; + break; + case YP_INTEGER_BASE_FLAGS_OCTAL: + base = 8; + break; + case YP_INTEGER_BASE_FLAGS_HEXADECIMAL: + base = 16; + break; + default: + rb_bug("Unexpected integer base"); + } + + return rb_int_parse_cstr(start, length, NULL, NULL, base, RB_INT_PARSE_DEFAULT); +} + +static VALUE +parse_float(const yp_node_t *node) +{ + const uint8_t *start = node->location.start; + const uint8_t *end = node->location.end; + size_t length = end - start; + + char *buffer = malloc(length + 1); + memcpy(buffer, start, length); + + buffer[length] = '\0'; + VALUE number = DBL2NUM(rb_cstr_to_dbl(buffer, 0)); + + free(buffer); + return number; +} + +static VALUE +parse_rational(const yp_node_t *node) +{ + const uint8_t *start = node->location.start; + const uint8_t *end = node->location.end - 1; + size_t length = end - start; + + VALUE res; + if (YP_NODE_TYPE_P(((yp_rational_node_t *)node)->numeric, YP_FLOAT_NODE)) { + char *buffer = malloc(length + 1); + memcpy(buffer, start, length); + + buffer[length] = '\0'; + + char *decimal = memchr(buffer, '.', length); + RUBY_ASSERT(decimal); + size_t seen_decimal = decimal - buffer; + size_t fraclen = length - seen_decimal - 1; + memmove(decimal, decimal + 1, fraclen + 1); + + VALUE v = rb_cstr_to_inum(buffer, 10, false); + res = rb_rational_new(v, rb_int_positive_pow(10, fraclen)); + + free(buffer); + } + else { + RUBY_ASSERT(YP_NODE_TYPE_P(((yp_rational_node_t *)node)->numeric, YP_INTEGER_NODE)); + VALUE number = rb_int_parse_cstr((const char *)start, length, NULL, NULL, -10, RB_INT_PARSE_DEFAULT); + res = rb_rational_raw(number, INT2FIX(1)); + } + + return res; +} + +static VALUE +parse_imaginary(yp_imaginary_node_t *node) +{ + VALUE imaginary_part; + switch (YP_NODE_TYPE(node->numeric)) { + case YP_FLOAT_NODE: { + imaginary_part = parse_float(node->numeric); + break; + } + case YP_INTEGER_NODE: { + imaginary_part = parse_integer((yp_integer_node_t *) node->numeric); + break; + } + case YP_RATIONAL_NODE: { + imaginary_part = parse_rational(node->numeric); + break; + } + default: + rb_bug("Unexpected numeric type on imaginary number"); + } + + return rb_complex_raw(INT2FIX(0), imaginary_part); +} + +static inline VALUE +parse_string(yp_string_t *string) +{ + return rb_str_new((const char *) yp_string_source(string), yp_string_length(string)); +} + +static inline ID +parse_symbol(const uint8_t *start, const uint8_t *end) +{ + return rb_intern2((const char *) start, end - start); +} + +static inline ID +parse_string_symbol(yp_string_t *string) { + const uint8_t *start = yp_string_source(string); + return parse_symbol(start, start + yp_string_length(string)); +} + +static inline ID +parse_location_symbol(yp_location_t *location) { + return parse_symbol(location->start, location->end); +} + +static int +yp_optimizable_range_item_p(yp_node_t *node) +{ + return (!node || YP_NODE_TYPE_P(node, YP_INTEGER_NODE) || YP_NODE_TYPE_P(node, YP_NIL_NODE)); +} + +/** + * Certain nodes can be compiled literally, which can lead to further + * optimizations. These nodes will all have the YP_NODE_FLAG_STATIC_LITERAL flag + * set. + */ +static inline bool +yp_static_node_literal_p(yp_node_t *node) { + return node->flags & YP_NODE_FLAG_STATIC_LITERAL; +} + +static inline VALUE +yp_static_literal_value(yp_node_t *node) +{ + switch(YP_NODE_TYPE(node)) { + case YP_FALSE_NODE: + return Qfalse; + case YP_FLOAT_NODE: + return parse_float(node); + case YP_IMAGINARY_NODE: + return parse_imaginary((yp_imaginary_node_t *)node); + case YP_INTEGER_NODE: + return parse_integer((yp_integer_node_t *) node); + case YP_NIL_NODE: + return Qnil; + case YP_RATIONAL_NODE: + return parse_rational(node); + case YP_STRING_NODE: + return parse_string(&((yp_string_node_t *)node)->unescaped); + case YP_SYMBOL_NODE: + return ID2SYM(parse_string_symbol(&((yp_symbol_node_t *)node)->unescaped)); + case YP_TRUE_NODE: + return Qtrue; + // TODO: Implement this method for the other literal nodes described above + default: + rb_raise(rb_eArgError, "Don't have a literal value for this type"); + return Qfalse; + } +} + +static void +yp_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const yp_node_t *cond, + LABEL *then_label, LABEL *else_label, const uint8_t *src, bool popped, yp_compile_context_t *compile_context); + +static void +yp_compile_logical(rb_iseq_t *iseq, LINK_ANCHOR *const ret, yp_node_t *cond, + LABEL *then_label, LABEL *else_label, const uint8_t *src, bool popped, yp_compile_context_t *compile_context) +{ + yp_parser_t *parser = compile_context->parser; + yp_newline_list_t newline_list = parser->newline_list; + int lineno = (int)yp_newline_list_line_column(&newline_list, cond->location.start).line; + NODE dummy_line_node = generate_dummy_line_node(lineno, lineno); + + DECL_ANCHOR(seq); + INIT_ANCHOR(seq); + LABEL *label = NEW_LABEL(lineno); + if (!then_label) then_label = label; + else if (!else_label) else_label = label; + + yp_compile_branch_condition(iseq, seq, cond, then_label, else_label, src, popped, compile_context); + + if (LIST_INSN_SIZE_ONE(seq)) { + INSN *insn = (INSN *)ELEM_FIRST_INSN(FIRST_ELEMENT(seq)); + if (insn->insn_id == BIN(jump) && (LABEL *)(insn->operands[0]) == label) + return; + } + if (!label->refcnt) { + ADD_INSN(seq, &dummy_line_node, putnil); + } + else { + ADD_LABEL(seq, label); + } + ADD_SEQ(ret, seq); + return; +} + +static void yp_compile_node(rb_iseq_t *iseq, const yp_node_t *node, LINK_ANCHOR *const ret, const uint8_t *src, bool popped, yp_compile_context_t *context); + +static void +yp_compile_branch_condition(rb_iseq_t *iseq, LINK_ANCHOR *const ret, const yp_node_t *cond, + LABEL *then_label, LABEL *else_label, const uint8_t *src, bool popped, yp_compile_context_t *compile_context) +{ + yp_parser_t *parser = compile_context->parser; + yp_newline_list_t newline_list = parser->newline_list; + int lineno = (int) yp_newline_list_line_column(&newline_list, cond->location.start).line; + NODE dummy_line_node = generate_dummy_line_node(lineno, lineno); + +again: + switch (YP_NODE_TYPE(cond)) { + case YP_AND_NODE: { + yp_and_node_t *and_node = (yp_and_node_t *)cond; + yp_compile_logical(iseq, ret, and_node->left, NULL, else_label, src, popped, compile_context); + cond = and_node->right; + goto again; + } + case YP_OR_NODE: { + yp_or_node_t *or_node = (yp_or_node_t *)cond; + yp_compile_logical(iseq, ret, or_node->left, then_label, NULL, src, popped, compile_context); + cond = or_node->right; + goto again; + } + case YP_FALSE_NODE: + case YP_NIL_NODE: + ADD_INSNL(ret, &dummy_line_node, jump, else_label); + return; + case YP_FLOAT_NODE: + case YP_IMAGINARY_NODE: + case YP_INTEGER_NODE: + case YP_LAMBDA_NODE: + case YP_RATIONAL_NODE: + case YP_REGULAR_EXPRESSION_NODE: + case YP_STRING_NODE: + case YP_SYMBOL_NODE: + case YP_TRUE_NODE: + ADD_INSNL(ret, &dummy_line_node, jump, then_label); + return; + // TODO: Several more nodes in this case statement + default: + { + DECL_ANCHOR(cond_seq); + INIT_ANCHOR(cond_seq); + + yp_compile_node(iseq, cond, cond_seq, src, false, compile_context); + ADD_SEQ(ret, cond_seq); + } + break; + } + ADD_INSNL(ret, &dummy_line_node, branchunless, else_label); + ADD_INSNL(ret, &dummy_line_node, jump, then_label); + return; +} + +static void +yp_compile_if(rb_iseq_t *iseq, const int line, yp_statements_node_t *node_body, yp_node_t *node_else, yp_node_t *predicate, LINK_ANCHOR *const ret, const uint8_t *src, bool popped, yp_compile_context_t *compile_context) { + NODE dummy_line_node = generate_dummy_line_node(line, line); + + DECL_ANCHOR(cond_seq); + + LABEL *then_label, *else_label, *end_label; + + INIT_ANCHOR(cond_seq); + then_label = NEW_LABEL(line); + else_label = NEW_LABEL(line); + end_label = 0; + + yp_compile_branch_condition(iseq, cond_seq, predicate, then_label, else_label, src, popped, compile_context); + ADD_SEQ(ret, cond_seq); + + if (then_label->refcnt) { + ADD_LABEL(ret, then_label); + + DECL_ANCHOR(then_seq); + INIT_ANCHOR(then_seq); + if (node_body) { + yp_compile_node(iseq, (yp_node_t *)node_body, then_seq, src, popped, compile_context); + YP_POP_IF_POPPED; + } + else { + YP_PUTNIL_UNLESS_POPPED; + } + + if (else_label->refcnt) { + end_label = NEW_LABEL(line); + ADD_INSNL(then_seq, &dummy_line_node, jump, end_label); + YP_POP_UNLESS_POPPED; + } + ADD_SEQ(ret, then_seq); + } + + if (else_label->refcnt) { + ADD_LABEL(ret, else_label); + + DECL_ANCHOR(else_seq); + INIT_ANCHOR(else_seq); + if (node_else) { + yp_compile_node(iseq, (yp_node_t *)(((yp_else_node_t *)node_else)->statements), else_seq, src, popped, compile_context); + } + else { + YP_PUTNIL_UNLESS_POPPED; + } + + ADD_SEQ(ret, else_seq); + } + + if (end_label) { + ADD_LABEL(ret, end_label); + } + + return; +} + +static void +yp_compile_while(rb_iseq_t *iseq, int lineno, yp_node_flags_t flags, enum yp_node_type type, yp_statements_node_t *statements, yp_node_t *predicate, LINK_ANCHOR *const ret, const uint8_t *src, bool popped, yp_compile_context_t *compile_context) +{ + NODE dummy_line_node = generate_dummy_line_node(lineno, lineno); + + LABEL *prev_start_label = ISEQ_COMPILE_DATA(iseq)->start_label; + LABEL *prev_end_label = ISEQ_COMPILE_DATA(iseq)->end_label; + LABEL *prev_redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label; + + // TODO: Deal with ensures in here + LABEL *next_label = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(lineno); /* next */ + LABEL *redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label = NEW_LABEL(lineno); /* redo */ + LABEL *break_label = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(lineno); /* break */ + LABEL *end_label = NEW_LABEL(lineno); + LABEL *adjust_label = NEW_LABEL(lineno); + + LABEL *next_catch_label = NEW_LABEL(lineno); + LABEL *tmp_label = NULL; + + // begin; end while true + if (flags & YP_LOOP_FLAGS_BEGIN_MODIFIER) { + tmp_label = NEW_LABEL(lineno); + ADD_INSNL(ret, &dummy_line_node, jump, tmp_label); + } + else { + // while true; end + ADD_INSNL(ret, &dummy_line_node, jump, next_label); + } + + ADD_LABEL(ret, adjust_label); + ADD_INSN(ret, &dummy_line_node, putnil); + ADD_LABEL(ret, next_catch_label); + ADD_INSN(ret, &dummy_line_node, pop); + ADD_INSNL(ret, &dummy_line_node, jump, next_label); + if (tmp_label) ADD_LABEL(ret, tmp_label); + + ADD_LABEL(ret, redo_label); + if (statements) { + YP_COMPILE_POPPED((yp_node_t *)statements); + } + + ADD_LABEL(ret, next_label); + + if (type == YP_WHILE_NODE) { + yp_compile_branch_condition(iseq, ret, predicate, redo_label, end_label, src, popped, compile_context); + } else if (type == YP_UNTIL_NODE) { + yp_compile_branch_condition(iseq, ret, predicate, end_label, redo_label, src, popped, compile_context); + } + + ADD_LABEL(ret, end_label); + ADD_ADJUST_RESTORE(ret, adjust_label); + + ADD_INSN(ret, &dummy_line_node, putnil); + + ADD_LABEL(ret, break_label); + + YP_POP_IF_POPPED; + + ADD_CATCH_ENTRY(CATCH_TYPE_BREAK, redo_label, break_label, NULL, + break_label); + ADD_CATCH_ENTRY(CATCH_TYPE_NEXT, redo_label, break_label, NULL, + next_catch_label); + ADD_CATCH_ENTRY(CATCH_TYPE_REDO, redo_label, break_label, NULL, + ISEQ_COMPILE_DATA(iseq)->redo_label); + + ISEQ_COMPILE_DATA(iseq)->start_label = prev_start_label; + ISEQ_COMPILE_DATA(iseq)->end_label = prev_end_label; + ISEQ_COMPILE_DATA(iseq)->redo_label = prev_redo_label; + return; +} + +static void +yp_interpolated_node_compile(yp_node_list_t parts, rb_iseq_t *iseq, NODE dummy_line_node, LINK_ANCHOR *const ret, const uint8_t *src, bool popped, yp_compile_context_t *compile_context) +{ + size_t parts_size = parts.size; + + if (parts_size > 0) { + for (size_t index = 0; index < parts_size; index++) { + yp_node_t *part = parts.nodes[index]; + + if (YP_NODE_TYPE_P(part, YP_STRING_NODE)) { + yp_string_node_t *string_node = (yp_string_node_t *) part; + ADD_INSN1(ret, &dummy_line_node, putobject, parse_string(&string_node->unescaped)); + } + else { + YP_COMPILE_NOT_POPPED(part); + ADD_INSN(ret, &dummy_line_node, dup); + ADD_INSN1(ret, &dummy_line_node, objtostring, new_callinfo(iseq, idTo_s, 0, VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE , NULL, FALSE)); + ADD_INSN(ret, &dummy_line_node, anytostring); + } + } + } + else { + ADD_INSN(ret, &dummy_line_node, putnil); + } +} +static int +yp_lookup_local_index(rb_iseq_t *iseq, yp_compile_context_t *compile_context, yp_constant_id_t constant_id) +{ + st_data_t local_index; + + int num_params = ISEQ_BODY(iseq)->param.size; + + if (!st_lookup(compile_context->index_lookup_table, constant_id, &local_index)) { + rb_bug("This local does not exist"); + } + + return num_params - (int)local_index; +} + +static int +yp_lookup_local_index_with_depth(rb_iseq_t *iseq, yp_compile_context_t *compile_context, yp_constant_id_t constant_id, uint32_t depth) +{ + for(uint32_t i = 0; i < depth; i++) { + compile_context = compile_context->previous; + iseq = (rb_iseq_t *)ISEQ_BODY(iseq)->parent_iseq; + } + + return yp_lookup_local_index(iseq, compile_context, constant_id); +} + +// This returns the CRuby ID which maps to the yp_constant_id_t +// +// Constant_ids in YARP are indexes of the constants in YARP's constant pool. +// We add a constants mapping on the compile_context which is a mapping from +// these constant_id indexes to the CRuby IDs that they represent. +// This helper method allows easy access to those IDs +static ID +yp_constant_id_lookup(yp_compile_context_t *compile_context, yp_constant_id_t constant_id) +{ + return compile_context->constants[constant_id - 1]; +} + +static rb_iseq_t * +yp_new_child_iseq(rb_iseq_t *iseq, yp_scope_node_t * node, yp_parser_t *parser, + VALUE name, const rb_iseq_t *parent, enum rb_iseq_type type, int line_no) +{ + debugs("[new_child_iseq]> ---------------------------------------\n"); + int isolated_depth = ISEQ_COMPILE_DATA(iseq)->isolated_depth; + rb_iseq_t * ret_iseq = yp_iseq_new_with_opt(node, parser, name, + rb_iseq_path(iseq), rb_iseq_realpath(iseq), + line_no, parent, + isolated_depth ? isolated_depth + 1 : 0, + type, ISEQ_COMPILE_DATA(iseq)->option); + debugs("[new_child_iseq]< ---------------------------------------\n"); + return ret_iseq; +} + +static int +yp_compile_class_path(LINK_ANCHOR *const ret, rb_iseq_t *iseq, const yp_node_t *constant_path_node, const NODE *line_node, const uint8_t * src, bool popped, yp_compile_context_t *compile_context) +{ + if (YP_NODE_TYPE_P(constant_path_node, YP_CONSTANT_PATH_NODE)) { + yp_node_t *parent = ((yp_constant_path_node_t *)constant_path_node)->parent; + if (parent) { + /* Bar::Foo */ + YP_COMPILE(parent); + return VM_DEFINECLASS_FLAG_SCOPED; + } + else { + /* toplevel class ::Foo */ + ADD_INSN1(ret, line_node, putobject, rb_cObject); + return VM_DEFINECLASS_FLAG_SCOPED; + } + } + else { + /* class at cbase Foo */ + ADD_INSN1(ret, line_node, putspecialobject, + INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE)); + return 0; + } +} + +/** + * In order to properly compile multiple-assignment, some preprocessing needs to + * be performed in the case of call or constant path targets. This is when they + * are read, the "parent" of each of these nodes should only be read once (the + * receiver in the case of a call, the parent constant in the case of a constant + * path). + */ +static uint8_t +yp_compile_multi_write_lhs(rb_iseq_t *iseq, NODE dummy_line_node, const yp_node_t *node, LINK_ANCHOR *const ret, yp_compile_context_t *compile_context, uint8_t pushed, bool nested) { + switch (YP_NODE_TYPE(node)) { + case YP_MULTI_TARGET_NODE: { + yp_multi_target_node_t *cast = (yp_multi_target_node_t *) node; + for (size_t index = 0; index < cast->targets.size; index++) { + pushed = yp_compile_multi_write_lhs(iseq, dummy_line_node, cast->targets.nodes[index], ret, compile_context, pushed, false); + } + break; + } + case YP_CONSTANT_PATH_TARGET_NODE: { + yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *)node; + if (cast->parent) { + ADD_INSN(ret, &dummy_line_node, putnil); + pushed = yp_compile_multi_write_lhs(iseq, dummy_line_node, cast->parent, ret, compile_context, pushed, false); + } else { + ADD_INSN1(ret, &dummy_line_node, putobject, rb_cObject); + } + break; + } + case YP_CONSTANT_PATH_NODE: { + yp_constant_path_node_t *cast = (yp_constant_path_node_t *) node; + if (cast->parent) { + pushed = yp_compile_multi_write_lhs(iseq, dummy_line_node, cast->parent, ret, compile_context, pushed, false); + } else { + ADD_INSN(ret, &dummy_line_node, pop); + ADD_INSN1(ret, &dummy_line_node, putobject, rb_cObject); + } + pushed = yp_compile_multi_write_lhs(iseq, dummy_line_node, cast->child, ret, compile_context, pushed, cast->parent); + break; + } + case YP_CONSTANT_READ_NODE: { + yp_constant_read_node_t *cast = (yp_constant_read_node_t *) node; + ADD_INSN1(ret, &dummy_line_node, putobject, RBOOL(!nested)); + ADD_INSN1(ret, &dummy_line_node, getconstant, ID2SYM(yp_constant_id_lookup(compile_context, cast->name))); + pushed = pushed + 2; + break; + } + default: + break; + } + + return pushed; +} + +/* + * Compiles a YARP node into instruction sequences + * + * iseq - The current instruction sequence object (used for locals) + * node - The yarp node to compile + * ret - The linked list of instruction sequences to append instructions onto + * popped - True if compiling something with no side effects, so instructions don't + * need to be added + * compile_context - Stores parser and local information + */ +static void +yp_compile_node(rb_iseq_t *iseq, const yp_node_t *node, LINK_ANCHOR *const ret, const uint8_t *src, bool popped, yp_compile_context_t *compile_context) +{ + yp_parser_t *parser = compile_context->parser; + yp_newline_list_t newline_list = parser->newline_list; + int lineno = (int)yp_newline_list_line_column(&newline_list, node->location.start).line; + NODE dummy_line_node = generate_dummy_line_node(lineno, lineno); + + switch (YP_NODE_TYPE(node)) { + case YP_ALIAS_METHOD_NODE: { + yp_alias_method_node_t *alias_node = (yp_alias_method_node_t *) node; + + ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE)); + ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE)); + + YP_COMPILE_NOT_POPPED(alias_node->new_name); + YP_COMPILE_NOT_POPPED(alias_node->old_name); + + ADD_SEND(ret, &dummy_line_node, id_core_set_method_alias, INT2FIX(3)); + + YP_POP_IF_POPPED; + + return; + } + case YP_AND_NODE: { + yp_and_node_t *and_node = (yp_and_node_t *) node; + + LABEL *end_label = NEW_LABEL(lineno); + YP_COMPILE_NOT_POPPED(and_node->left); + YP_DUP_UNLESS_POPPED; + ADD_INSNL(ret, &dummy_line_node, branchunless, end_label); + + YP_POP_UNLESS_POPPED; + YP_COMPILE(and_node->right); + ADD_LABEL(ret, end_label); + return; + } + case YP_ARGUMENTS_NODE: { + yp_arguments_node_t *arguments_node = (yp_arguments_node_t *) node; + yp_node_list_t node_list = arguments_node->arguments; + for (size_t index = 0; index < node_list.size; index++) { + YP_COMPILE(node_list.nodes[index]); + } + return; + } + case YP_ARRAY_NODE: { + yp_array_node_t *array_node = (yp_array_node_t *) node; + yp_node_list_t elements = array_node->elements; + if (elements.size == 1 && yp_static_node_literal_p(elements.nodes[0]) && !popped) { + VALUE ary = rb_ary_hidden_new(1); + rb_ary_push(ary, yp_static_literal_value(elements.nodes[0])); + OBJ_FREEZE(ary); + + ADD_INSN1(ret, &dummy_line_node, duparray, ary); + } + else { + for (size_t index = 0; index < elements.size; index++) { + YP_COMPILE(elements.nodes[index]); + } + + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, newarray, INT2FIX(elements.size)); + } + } + + return; + } + case YP_ASSOC_NODE: { + yp_assoc_node_t *assoc_node = (yp_assoc_node_t *) node; + YP_COMPILE(assoc_node->key); + if (assoc_node->value) { + YP_COMPILE(assoc_node->value); + } + return; + } + case YP_ASSOC_SPLAT_NODE: { + yp_assoc_splat_node_t *assoc_splat_node = (yp_assoc_splat_node_t *)node; + YP_COMPILE(assoc_splat_node->value); + + // TODO: Not sure this is accurate, look at FLUSH_CHUNK in the compiler + ADD_INSN1(ret, &dummy_line_node, newarraykwsplat, INT2FIX(0)); + + YP_POP_IF_POPPED; + return; + } + case YP_BACK_REFERENCE_READ_NODE: { + if (!popped) { + // Since a back reference is `$<char>`, ruby represents the ID as the + // an rb_intern on the value after the `$`. + char *char_ptr = (char *)(node->location.start) + 1; + ID backref_val = INT2FIX(rb_intern2(char_ptr, 1)) << 1 | 1; + ADD_INSN2(ret, &dummy_line_node, getspecial, INT2FIX(1), backref_val); + } + return; + } + case YP_BEGIN_NODE: { + yp_begin_node_t *begin_node = (yp_begin_node_t *) node; + if (begin_node->statements) { + YP_COMPILE((yp_node_t *)begin_node->statements); + } + else { + ADD_INSN(ret, &dummy_line_node, putnil); + } + return; + } + case YP_BLOCK_ARGUMENT_NODE: { + yp_block_argument_node_t *block_argument_node = (yp_block_argument_node_t *) node; + YP_COMPILE(block_argument_node->expression); + return; + } + case YP_BREAK_NODE: { + yp_break_node_t *break_node = (yp_break_node_t *) node; + if (break_node->arguments) { + YP_COMPILE_NOT_POPPED((yp_node_t *)break_node->arguments); + } + else { + ADD_INSN(ret, &dummy_line_node, putnil); + } + + ADD_INSNL(ret, &dummy_line_node, jump, ISEQ_COMPILE_DATA(iseq)->end_label); + + return; + } + case YP_CALL_NODE: { + yp_call_node_t *call_node = (yp_call_node_t *) node; + + ID method_id = parse_string_symbol(&call_node->name); + int flags = 0; + int orig_argc = 0; + + if (call_node->receiver == NULL) { + ADD_INSN(ret, &dummy_line_node, putself); + } else { + YP_COMPILE_NOT_POPPED(call_node->receiver); + } + + if (call_node->arguments == NULL) { + if (flags & VM_CALL_FCALL) { + flags |= VM_CALL_VCALL; + } + } else { + yp_arguments_node_t *arguments = call_node->arguments; + YP_COMPILE_NOT_POPPED((yp_node_t *) arguments); + orig_argc = (int)arguments->arguments.size; + } + + VALUE block_iseq = Qnil; + if (call_node->block != NULL && YP_NODE_TYPE_P(call_node->block, YP_BLOCK_NODE)) { + // Scope associated with the block + yp_scope_node_t scope_node; + yp_scope_node_init(call_node->block, &scope_node); + + const rb_iseq_t *block_iseq = NEW_CHILD_ISEQ(&scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, lineno); + ISEQ_COMPILE_DATA(iseq)->current_block = block_iseq; + ADD_SEND_WITH_BLOCK(ret, &dummy_line_node, method_id, INT2FIX(orig_argc), block_iseq); + } + else { + if (node->flags & YP_CALL_NODE_FLAGS_VARIABLE_CALL) { + flags |= VM_CALL_VCALL; + } + + if (call_node->block != NULL) { + YP_COMPILE_NOT_POPPED(call_node->block); + flags |= VM_CALL_ARGS_BLOCKARG; + } + + if (block_iseq == Qnil && flags == 0) { + flags |= VM_CALL_ARGS_SIMPLE; + } + + if (call_node->receiver == NULL) { + flags |= VM_CALL_FCALL; + } + + ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(orig_argc), INT2FIX(flags)); + } + YP_POP_IF_POPPED; + return; + } + case YP_CLASS_NODE: { + yp_class_node_t *class_node = (yp_class_node_t *)node; + yp_scope_node_t scope_node; + yp_scope_node_init((yp_node_t *)class_node, &scope_node); + + ID class_id = yp_constant_id_lookup(compile_context, class_node->name); + + VALUE class_name = rb_str_freeze(rb_sprintf("<class:%"PRIsVALUE">", rb_id2str(class_id))); + + const rb_iseq_t *class_iseq = NEW_CHILD_ISEQ(&scope_node, class_name, ISEQ_TYPE_CLASS, lineno); + + // TODO: Once we merge constant path nodes correctly, fix this flag + const int flags = VM_DEFINECLASS_TYPE_CLASS | + (class_node->superclass ? VM_DEFINECLASS_FLAG_HAS_SUPERCLASS : 0) | + yp_compile_class_path(ret, iseq, class_node->constant_path, &dummy_line_node, src, false, compile_context); + + if (class_node->superclass) { + YP_COMPILE(class_node->superclass); + } + else { + ADD_INSN(ret, &dummy_line_node, putnil); + } + + ADD_INSN3(ret, &dummy_line_node, defineclass, ID2SYM(class_id), class_iseq, INT2FIX(flags)); + RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)class_iseq); + + YP_POP_IF_POPPED; + return; + } + case YP_CLASS_VARIABLE_AND_WRITE_NODE: { + yp_class_variable_and_write_node_t *class_variable_and_write_node = (yp_class_variable_and_write_node_t*) node; + + LABEL *end_label = NEW_LABEL(lineno); + + ID class_variable_name_id = yp_constant_id_lookup(compile_context, class_variable_and_write_node->name); + VALUE class_variable_name_val = ID2SYM(class_variable_name_id); + + ADD_INSN2(ret, &dummy_line_node, getclassvariable, + class_variable_name_val, + get_cvar_ic_value(iseq, class_variable_name_id)); + + YP_DUP_UNLESS_POPPED; + + ADD_INSNL(ret, &dummy_line_node, branchunless, end_label); + + YP_POP_UNLESS_POPPED; + + YP_COMPILE_NOT_POPPED(class_variable_and_write_node->value); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN2(ret, &dummy_line_node, setclassvariable, + class_variable_name_val, + get_cvar_ic_value(iseq, class_variable_name_id)); + ADD_LABEL(ret, end_label); + + return; + } + case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE: { + yp_class_variable_operator_write_node_t *class_variable_operator_write_node = (yp_class_variable_operator_write_node_t*) node; + + ID class_variable_name_id = yp_constant_id_lookup(compile_context, class_variable_operator_write_node->name); + VALUE class_variable_name_val = ID2SYM(class_variable_name_id); + + ADD_INSN2(ret, &dummy_line_node, getclassvariable, + class_variable_name_val, + get_cvar_ic_value(iseq, class_variable_name_id)); + + YP_COMPILE_NOT_POPPED(class_variable_operator_write_node->value); + ID method_id = yp_constant_id_lookup(compile_context, class_variable_operator_write_node->operator); + + int flags = VM_CALL_ARGS_SIMPLE; + ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(1), INT2FIX(flags)); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN2(ret, &dummy_line_node, setclassvariable, + class_variable_name_val, + get_cvar_ic_value(iseq, class_variable_name_id)); + + return; + } + case YP_CLASS_VARIABLE_OR_WRITE_NODE: { + yp_class_variable_or_write_node_t *class_variable_or_write_node = (yp_class_variable_or_write_node_t*) node; + + LABEL *end_label = NEW_LABEL(lineno); + + ID class_variable_name_id = yp_constant_id_lookup(compile_context, class_variable_or_write_node->name); + VALUE class_variable_name_val = ID2SYM(class_variable_name_id); + + ADD_INSN2(ret, &dummy_line_node, getclassvariable, + class_variable_name_val, + get_cvar_ic_value(iseq, class_variable_name_id)); + + YP_DUP_UNLESS_POPPED; + + ADD_INSNL(ret, &dummy_line_node, branchif, end_label); + + YP_POP_UNLESS_POPPED; + + YP_COMPILE_NOT_POPPED(class_variable_or_write_node->value); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN2(ret, &dummy_line_node, setclassvariable, + class_variable_name_val, + get_cvar_ic_value(iseq, class_variable_name_id)); + ADD_LABEL(ret, end_label); + + return; + } + case YP_CLASS_VARIABLE_READ_NODE: { + if (!popped) { + yp_class_variable_read_node_t *class_variable_read_node = (yp_class_variable_read_node_t *) node; + ID cvar_name = yp_constant_id_lookup(compile_context, class_variable_read_node->name); + ADD_INSN2( + ret, + &dummy_line_node, + getclassvariable, + ID2SYM(cvar_name), + get_cvar_ic_value(iseq, cvar_name) + ); + } + return; + } + case YP_CLASS_VARIABLE_TARGET_NODE: { + yp_class_variable_target_node_t *write_node = (yp_class_variable_target_node_t *) node; + ID cvar_name = yp_constant_id_lookup(compile_context, write_node->name); + ADD_INSN2(ret, &dummy_line_node, setclassvariable, ID2SYM(cvar_name), get_cvar_ic_value(iseq, cvar_name)); + return; + } + case YP_CLASS_VARIABLE_WRITE_NODE: { + yp_class_variable_write_node_t *write_node = (yp_class_variable_write_node_t *) node; + YP_COMPILE_NOT_POPPED(write_node->value); + YP_DUP_UNLESS_POPPED; + + ID cvar_name = yp_constant_id_lookup(compile_context, write_node->name); + ADD_INSN2(ret, &dummy_line_node, setclassvariable, ID2SYM(cvar_name), get_cvar_ic_value(iseq, cvar_name)); + return; + } + case YP_CONSTANT_PATH_NODE: { + yp_constant_path_node_t *constant_path_node = (yp_constant_path_node_t*) node; + if (constant_path_node->parent) { + YP_COMPILE_NOT_POPPED(constant_path_node->parent); + } + ADD_INSN1(ret, &dummy_line_node, putobject, Qfalse); + + assert(YP_NODE_TYPE_P(constant_path_node->child, YP_CONSTANT_READ_NODE)); + yp_constant_read_node_t *child = (yp_constant_read_node_t *) constant_path_node->child; + + ADD_INSN1(ret, &dummy_line_node, getconstant, ID2SYM(yp_constant_id_lookup(compile_context, child->name))); + YP_POP_IF_POPPED; + return; + } + case YP_CONSTANT_PATH_TARGET_NODE: { + yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *)node; + + YP_COMPILE(cast->parent); + + return; + } + case YP_CONSTANT_PATH_WRITE_NODE: { + yp_constant_path_write_node_t *constant_path_write_node = (yp_constant_path_write_node_t*) node; + YP_COMPILE(constant_path_write_node->value); + YP_DUP_UNLESS_POPPED; + + ID constant_var_name = parse_location_symbol(&constant_path_write_node->target->base.location); + + ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE)); + ADD_INSN1(ret, &dummy_line_node, setconstant, ID2SYM(constant_var_name)); + return; + } + case YP_CONSTANT_READ_NODE: { + yp_constant_read_node_t *constant_read_node = (yp_constant_read_node_t *) node; + ADD_INSN(ret, &dummy_line_node, putnil); + ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue); + ADD_INSN1(ret, &dummy_line_node, getconstant, ID2SYM(yp_constant_id_lookup(compile_context, constant_read_node->name))); + YP_POP_IF_POPPED; + return; + } + case YP_CONSTANT_AND_WRITE_NODE: { + yp_constant_and_write_node_t *constant_and_write_node = (yp_constant_and_write_node_t*) node; + + LABEL *end_label = NEW_LABEL(lineno); + + VALUE constant_name = ID2SYM(yp_constant_id_lookup(compile_context, constant_and_write_node->name)); + + ADD_INSN(ret, &dummy_line_node, putnil); + ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue); + ADD_INSN1(ret, &dummy_line_node, getconstant, constant_name); + YP_DUP_UNLESS_POPPED; + + ADD_INSNL(ret, &dummy_line_node, branchunless, end_label); + + YP_POP_UNLESS_POPPED; + + YP_COMPILE_NOT_POPPED(constant_and_write_node->value); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE)); + ADD_INSN1(ret, &dummy_line_node, setconstant, constant_name); + ADD_LABEL(ret, end_label); + + return; + } + case YP_CONSTANT_OPERATOR_WRITE_NODE: { + yp_constant_operator_write_node_t *constant_operator_write_node = (yp_constant_operator_write_node_t*) node; + + ID constant_name = yp_constant_id_lookup(compile_context, constant_operator_write_node->name); + ADD_INSN(ret, &dummy_line_node, putnil); + ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue); + ADD_INSN1(ret, &dummy_line_node, getconstant, ID2SYM(constant_name)); + + YP_COMPILE_NOT_POPPED(constant_operator_write_node->value); + ID method_id = yp_constant_id_lookup(compile_context, constant_operator_write_node->operator); + + int flags = VM_CALL_ARGS_SIMPLE; + ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(1), INT2FIX(flags)); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE)); + ADD_INSN1(ret, &dummy_line_node, setconstant, ID2SYM(constant_name)); + + return; + } + case YP_CONSTANT_OR_WRITE_NODE: { + yp_constant_or_write_node_t *constant_or_write_node = (yp_constant_or_write_node_t*) node; + + LABEL *set_label= NEW_LABEL(lineno); + LABEL *end_label = NEW_LABEL(lineno); + + ADD_INSN(ret, &dummy_line_node, putnil); + VALUE constant_name = ID2SYM(yp_constant_id_lookup(compile_context, constant_or_write_node->name)); + + ADD_INSN3(ret, &dummy_line_node, defined, INT2FIX(DEFINED_CONST), constant_name, Qtrue); + + ADD_INSNL(ret, &dummy_line_node, branchunless, set_label); + + ADD_INSN(ret, &dummy_line_node, putnil); + ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue); + ADD_INSN1(ret, &dummy_line_node, getconstant, constant_name); + + YP_DUP_UNLESS_POPPED; + + ADD_INSNL(ret, &dummy_line_node, branchif, end_label); + + YP_POP_UNLESS_POPPED; + + ADD_LABEL(ret, set_label); + YP_COMPILE_NOT_POPPED(constant_or_write_node->value); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE)); + ADD_INSN1(ret, &dummy_line_node, setconstant, constant_name); + ADD_LABEL(ret, end_label); + + return; + } + case YP_CONSTANT_TARGET_NODE: { + yp_constant_target_node_t *constant_write_node = (yp_constant_target_node_t *) node; + ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE)); + ADD_INSN1(ret, &dummy_line_node, setconstant, ID2SYM(yp_constant_id_lookup(compile_context, constant_write_node->name))); + return; + } + case YP_CONSTANT_WRITE_NODE: { + yp_constant_write_node_t *constant_write_node = (yp_constant_write_node_t *) node; + YP_COMPILE_NOT_POPPED(constant_write_node->value); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CONST_BASE)); + ADD_INSN1(ret, &dummy_line_node, setconstant, ID2SYM(yp_constant_id_lookup(compile_context, constant_write_node->name))); + return; + } + case YP_DEF_NODE: { + yp_def_node_t *def_node = (yp_def_node_t *) node; + ID method_name = yp_constant_id_lookup(compile_context, def_node->name); + yp_scope_node_t scope_node; + yp_scope_node_init((yp_node_t *)def_node, &scope_node); + rb_iseq_t *method_iseq = NEW_ISEQ(&scope_node, rb_id2str(method_name), ISEQ_TYPE_METHOD, lineno); + + ADD_INSN2(ret, &dummy_line_node, definemethod, ID2SYM(method_name), method_iseq); + RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)method_iseq); + + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, putobject, ID2SYM(method_name)); + } + return; + } + case YP_DEFINED_NODE: { + ADD_INSN(ret, &dummy_line_node, putself); + yp_defined_node_t *defined_node = (yp_defined_node_t *)node; + // TODO: Correct defined_type + enum defined_type dtype = DEFINED_CONST; + + VALUE sym = Qnil; + if (YP_NODE_TYPE_P(defined_node->value, YP_INTEGER_NODE)) { + sym = parse_integer((yp_integer_node_t *) defined_node->value); + } + + ADD_INSN3(ret, &dummy_line_node, defined, INT2FIX(dtype), sym, rb_iseq_defined_string(dtype)); + return; + } + case YP_EMBEDDED_STATEMENTS_NODE: { + yp_embedded_statements_node_t *embedded_statements_node = (yp_embedded_statements_node_t *)node; + + if (embedded_statements_node->statements) { + YP_COMPILE((yp_node_t *) (embedded_statements_node->statements)); + } + else { + ADD_INSN(ret, &dummy_line_node, putnil); + } + + YP_POP_IF_POPPED; + // TODO: Concatenate the strings that exist here + return; + } + case YP_EMBEDDED_VARIABLE_NODE: { + yp_embedded_variable_node_t *embedded_node = (yp_embedded_variable_node_t *)node; + YP_COMPILE(embedded_node->variable); + return; + } + case YP_FALSE_NODE: + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, putobject, Qfalse); + } + return; + case YP_FLIP_FLOP_NODE: { + // TODO: The labels here are wrong, figure out why..... + yp_flip_flop_node_t *flip_flop_node = (yp_flip_flop_node_t *)node; + + LABEL *lend = NEW_LABEL(lineno); + LABEL *then_label = NEW_LABEL(lineno); + LABEL *else_label = NEW_LABEL(lineno); + //TODO: int again = type == NODE_FLIP2; + int again = 0; + + rb_num_t cnt = ISEQ_FLIP_CNT_INCREMENT(ISEQ_BODY(iseq)->local_iseq) + + VM_SVAR_FLIPFLOP_START; + VALUE key = INT2FIX(cnt); + + ADD_INSN2(ret, &dummy_line_node, getspecial, key, INT2FIX(0)); + ADD_INSNL(ret, &dummy_line_node, branchif, lend); + + YP_COMPILE(flip_flop_node->left); + /* *flip == 0 */ + ADD_INSNL(ret, &dummy_line_node, branchunless, else_label); + ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue); + ADD_INSN1(ret, &dummy_line_node, setspecial, key); + if (!again) { + ADD_INSNL(ret, &dummy_line_node, jump, then_label); + } + + /* *flip == 1 */ + ADD_LABEL(ret, lend); + YP_COMPILE(flip_flop_node->right); + ADD_INSNL(ret, &dummy_line_node, branchunless, then_label); + ADD_INSN1(ret, &dummy_line_node, putobject, Qfalse); + ADD_INSN1(ret, &dummy_line_node, setspecial, key); + ADD_INSNL(ret, &dummy_line_node, jump, then_label); + ADD_LABEL(ret, then_label); + ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue); + ADD_INSNL(ret, &dummy_line_node, jump, lend); + ADD_LABEL(ret, else_label); + ADD_INSN1(ret, &dummy_line_node, putobject, Qfalse); + ADD_LABEL(ret, lend); + return; + } + case YP_FLOAT_NODE: { + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, putobject, parse_float(node)); + } + return; + } + case YP_GLOBAL_VARIABLE_AND_WRITE_NODE: { + yp_global_variable_and_write_node_t *global_variable_and_write_node = (yp_global_variable_and_write_node_t*) node; + + LABEL *end_label = NEW_LABEL(lineno); + + VALUE global_variable_name = ID2SYM(yp_constant_id_lookup(compile_context, global_variable_and_write_node->name)); + + ADD_INSN1(ret, &dummy_line_node, getglobal, global_variable_name); + + YP_DUP_UNLESS_POPPED; + + ADD_INSNL(ret, &dummy_line_node, branchunless, end_label); + + YP_POP_UNLESS_POPPED; + + YP_COMPILE_NOT_POPPED(global_variable_and_write_node->value); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN1(ret, &dummy_line_node, setglobal, global_variable_name); + ADD_LABEL(ret, end_label); + + return; + } + case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: { + yp_global_variable_operator_write_node_t *global_variable_operator_write_node = (yp_global_variable_operator_write_node_t*) node; + + VALUE global_variable_name = ID2SYM(yp_constant_id_lookup(compile_context, global_variable_operator_write_node->name)); + ADD_INSN1(ret, &dummy_line_node, getglobal, global_variable_name); + + YP_COMPILE_NOT_POPPED(global_variable_operator_write_node->value); + ID method_id = yp_constant_id_lookup(compile_context, global_variable_operator_write_node->operator); + + int flags = VM_CALL_ARGS_SIMPLE; + ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(1), INT2FIX(flags)); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN1(ret, &dummy_line_node, setglobal, global_variable_name); + + return; + } + case YP_GLOBAL_VARIABLE_OR_WRITE_NODE: { + yp_global_variable_or_write_node_t *global_variable_or_write_node = (yp_global_variable_or_write_node_t*) node; + + LABEL *set_label= NEW_LABEL(lineno); + LABEL *end_label = NEW_LABEL(lineno); + + ADD_INSN(ret, &dummy_line_node, putnil); + VALUE global_variable_name = ID2SYM(yp_constant_id_lookup(compile_context, global_variable_or_write_node->name)); + + ADD_INSN3(ret, &dummy_line_node, defined, INT2FIX(DEFINED_GVAR), global_variable_name, Qtrue); + + ADD_INSNL(ret, &dummy_line_node, branchunless, set_label); + + ADD_INSN1(ret, &dummy_line_node, getglobal, global_variable_name); + + YP_DUP_UNLESS_POPPED; + + ADD_INSNL(ret, &dummy_line_node, branchif, end_label); + + YP_POP_UNLESS_POPPED; + + ADD_LABEL(ret, set_label); + YP_COMPILE_NOT_POPPED(global_variable_or_write_node->value); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN1(ret, &dummy_line_node, setglobal, global_variable_name); + ADD_LABEL(ret, end_label); + + return; + } + case YP_GLOBAL_VARIABLE_READ_NODE: { + yp_global_variable_read_node_t *global_variable_read_node = (yp_global_variable_read_node_t *)node; + VALUE global_variable_name = ID2SYM(yp_constant_id_lookup(compile_context, global_variable_read_node->name)); + ADD_INSN1(ret, &dummy_line_node, getglobal, global_variable_name); + YP_POP_IF_POPPED; + return; + } + case YP_GLOBAL_VARIABLE_TARGET_NODE: { + yp_global_variable_target_node_t *write_node = (yp_global_variable_target_node_t *) node; + + ID ivar_name = yp_constant_id_lookup(compile_context, write_node->name); + ADD_INSN1(ret, &dummy_line_node, setglobal, ID2SYM(ivar_name)); + return; + } + case YP_GLOBAL_VARIABLE_WRITE_NODE: { + yp_global_variable_write_node_t *write_node = (yp_global_variable_write_node_t *) node; + YP_COMPILE_NOT_POPPED(write_node->value); + YP_DUP_UNLESS_POPPED; + ID ivar_name = yp_constant_id_lookup(compile_context, write_node->name); + ADD_INSN1(ret, &dummy_line_node, setglobal, ID2SYM(ivar_name)); + return; + } + case YP_HASH_NODE: { + yp_hash_node_t *hash_node = (yp_hash_node_t *) node; + yp_node_list_t elements = hash_node->elements; + + if (elements.size == 1) { + assert(YP_NODE_TYPE_P(elements.nodes[0], YP_ASSOC_NODE)); + yp_assoc_node_t *assoc_node = (yp_assoc_node_t *) elements.nodes[0]; + + if (yp_static_node_literal_p(assoc_node->key) && + yp_static_node_literal_p(assoc_node->value)) { + VALUE hash = rb_hash_new_with_size(1); + hash = rb_obj_hide(hash); + OBJ_FREEZE(hash); + ADD_INSN1(ret, &dummy_line_node, duphash, hash); + return; + } + } + + for (size_t index = 0; index < elements.size; index++) { + YP_COMPILE(elements.nodes[index]); + } + + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, newhash, INT2FIX(elements.size * 2)); + } + return; + } + case YP_IF_NODE: { + const int line = (int)yp_newline_list_line_column(&(parser->newline_list), node->location.start).line; + yp_if_node_t *if_node = (yp_if_node_t *)node; + yp_statements_node_t *node_body = if_node->statements; + yp_node_t *node_else = if_node->consequent; + yp_node_t *predicate = if_node->predicate; + + yp_compile_if(iseq, line, node_body, node_else, predicate, ret, src, popped, compile_context); + return; + } + case YP_IMAGINARY_NODE: { + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, putobject, parse_imaginary((yp_imaginary_node_t *)node)); + } + return; + } + case YP_INSTANCE_VARIABLE_AND_WRITE_NODE: { + yp_instance_variable_and_write_node_t *instance_variable_and_write_node = (yp_instance_variable_and_write_node_t*) node; + + LABEL *end_label = NEW_LABEL(lineno); + + ID instance_variable_name_id = yp_constant_id_lookup(compile_context, instance_variable_and_write_node->name); + + VALUE instance_variable_name_val = ID2SYM(instance_variable_name_id); + + ADD_INSN2(ret, &dummy_line_node, getinstancevariable, + instance_variable_name_val, + get_ivar_ic_value(iseq, instance_variable_name_id)); + + YP_DUP_UNLESS_POPPED; + + ADD_INSNL(ret, &dummy_line_node, branchunless, end_label); + + YP_POP_UNLESS_POPPED; + + YP_COMPILE_NOT_POPPED(instance_variable_and_write_node->value); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN2(ret, &dummy_line_node, setinstancevariable, + instance_variable_name_val, + get_ivar_ic_value(iseq, instance_variable_name_id)); + ADD_LABEL(ret, end_label); + + return; + } + case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: { + yp_instance_variable_operator_write_node_t *instance_variable_operator_write_node = (yp_instance_variable_operator_write_node_t*) node; + + ID instance_variable_name_id = yp_constant_id_lookup(compile_context, instance_variable_operator_write_node->name); + VALUE instance_variable_name_val = ID2SYM(instance_variable_name_id); + + ADD_INSN2(ret, &dummy_line_node, getinstancevariable, + instance_variable_name_val, + get_ivar_ic_value(iseq, instance_variable_name_id)); + + YP_COMPILE_NOT_POPPED(instance_variable_operator_write_node->value); + ID method_id = yp_constant_id_lookup(compile_context, instance_variable_operator_write_node->operator); + + int flags = VM_CALL_ARGS_SIMPLE; + ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(1), INT2FIX(flags)); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN2(ret, &dummy_line_node, setinstancevariable, + instance_variable_name_val, + get_ivar_ic_value(iseq, instance_variable_name_id)); + + return; + } + case YP_INSTANCE_VARIABLE_OR_WRITE_NODE: { + yp_instance_variable_or_write_node_t *instance_variable_or_write_node = (yp_instance_variable_or_write_node_t*) node; + + LABEL *end_label = NEW_LABEL(lineno); + + ID instance_variable_name_id = yp_constant_id_lookup(compile_context, instance_variable_or_write_node->name); + VALUE instance_variable_name_val = ID2SYM(instance_variable_name_id); + + ADD_INSN2(ret, &dummy_line_node, getinstancevariable, + instance_variable_name_val, + get_ivar_ic_value(iseq, instance_variable_name_id)); + + YP_DUP_UNLESS_POPPED; + + ADD_INSNL(ret, &dummy_line_node, branchif, end_label); + + YP_POP_UNLESS_POPPED; + + YP_COMPILE_NOT_POPPED(instance_variable_or_write_node->value); + + YP_DUP_UNLESS_POPPED; + + ADD_INSN2(ret, &dummy_line_node, setinstancevariable, + instance_variable_name_val, + get_ivar_ic_value(iseq, instance_variable_name_id)); + ADD_LABEL(ret, end_label); + + return; + } + case YP_INSTANCE_VARIABLE_READ_NODE: { + if (!popped) { + yp_instance_variable_read_node_t *instance_variable_read_node = (yp_instance_variable_read_node_t *) node; + ID ivar_name = yp_constant_id_lookup(compile_context, instance_variable_read_node->name); + ADD_INSN2(ret, &dummy_line_node, getinstancevariable, + ID2SYM(ivar_name), + get_ivar_ic_value(iseq, ivar_name)); + } + return; + } + case YP_INSTANCE_VARIABLE_TARGET_NODE: { + yp_instance_variable_target_node_t *write_node = (yp_instance_variable_target_node_t *) node; + + ID ivar_name = yp_constant_id_lookup(compile_context, write_node->name); + ADD_INSN2(ret, &dummy_line_node, setinstancevariable, + ID2SYM(ivar_name), + get_ivar_ic_value(iseq, ivar_name)); + return; + } + case YP_INSTANCE_VARIABLE_WRITE_NODE: { + yp_instance_variable_write_node_t *write_node = (yp_instance_variable_write_node_t *) node; + YP_COMPILE_NOT_POPPED(write_node->value); + + YP_DUP_UNLESS_POPPED; + + ID ivar_name = yp_constant_id_lookup(compile_context, write_node->name); + ADD_INSN2(ret, &dummy_line_node, setinstancevariable, + ID2SYM(ivar_name), + get_ivar_ic_value(iseq, ivar_name)); + return; + } + case YP_INTEGER_NODE: { + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, putobject, parse_integer((yp_integer_node_t *) node)); + } + return; + } + case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: { + yp_interpolated_regular_expression_node_t *interp_regular_expression_node= (yp_interpolated_regular_expression_node_t *) node; + yp_interpolated_node_compile(interp_regular_expression_node->parts, iseq, dummy_line_node, ret, src, popped, compile_context); + if (interp_regular_expression_node->parts.size > 1) { + ADD_INSN2(ret, &dummy_line_node, toregexp, INT2FIX(0), INT2FIX((int)(interp_regular_expression_node->parts.size))); + } + + YP_POP_IF_POPPED; + return; + } + case YP_INTERPOLATED_STRING_NODE: { + yp_interpolated_string_node_t *interp_string_node = (yp_interpolated_string_node_t *) node; + yp_interpolated_node_compile(interp_string_node->parts, iseq, dummy_line_node, ret, src, popped, compile_context); + + size_t parts_size = interp_string_node->parts.size; + if (parts_size > 1) { + ADD_INSN1(ret, &dummy_line_node, concatstrings, INT2FIX((int)(parts_size))); + } + + YP_POP_IF_POPPED; + return; + } + case YP_INTERPOLATED_SYMBOL_NODE: { + yp_interpolated_symbol_node_t *interp_symbol_node = (yp_interpolated_symbol_node_t *) node; + yp_interpolated_node_compile(interp_symbol_node->parts, iseq, dummy_line_node, ret, src, popped, compile_context); + + size_t parts_size = interp_symbol_node->parts.size; + if (parts_size > 1) { + ADD_INSN1(ret, &dummy_line_node, concatstrings, INT2FIX((int)(parts_size))); + } + + if (!popped) { + ADD_INSN(ret, &dummy_line_node, intern); + } + else { + ADD_INSN(ret, &dummy_line_node, pop); + } + + return; + } + case YP_INTERPOLATED_X_STRING_NODE: { + yp_interpolated_x_string_node_t *interp_x_string_node = (yp_interpolated_x_string_node_t *) node; + ADD_INSN(ret, &dummy_line_node, putself); + yp_interpolated_node_compile(interp_x_string_node->parts, iseq, dummy_line_node, ret, src, false, compile_context); + + size_t parts_size = interp_x_string_node->parts.size; + if (parts_size > 1) { + ADD_INSN1(ret, &dummy_line_node, concatstrings, INT2FIX((int)(parts_size))); + } + + ADD_SEND_WITH_FLAG(ret, &dummy_line_node, idBackquote, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE)); + YP_POP_IF_POPPED; + return; + } + case YP_KEYWORD_HASH_NODE: { + yp_keyword_hash_node_t *keyword_hash_node = (yp_keyword_hash_node_t *) node; + yp_node_list_t elements = keyword_hash_node->elements; + + for (size_t index = 0; index < elements.size; index++) { + YP_COMPILE(elements.nodes[index]); + } + + ADD_INSN1(ret, &dummy_line_node, newhash, INT2FIX(elements.size * 2)); + return; + } + case YP_LAMBDA_NODE: { + yp_scope_node_t scope_node; + yp_scope_node_init((yp_node_t *)node, &scope_node); + + const rb_iseq_t *block = NEW_CHILD_ISEQ(&scope_node, make_name_for_block(iseq), ISEQ_TYPE_BLOCK, lineno); + VALUE argc = INT2FIX(0); + + ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE)); + ADD_CALL_WITH_BLOCK(ret, &dummy_line_node, idLambda, argc, block); + RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)block); + + YP_POP_IF_POPPED; + return; + } + case YP_LOCAL_VARIABLE_AND_WRITE_NODE: { + yp_local_variable_and_write_node_t *local_variable_and_write_node = (yp_local_variable_and_write_node_t*) node; + + LABEL *end_label = NEW_LABEL(lineno); + + yp_constant_id_t constant_id = local_variable_and_write_node->name; + int depth = local_variable_and_write_node->depth; + int local_index = yp_lookup_local_index_with_depth(iseq, compile_context, constant_id, depth); + ADD_GETLOCAL(ret, &dummy_line_node, local_index, depth); + + YP_DUP_UNLESS_POPPED; + + ADD_INSNL(ret, &dummy_line_node, branchunless, end_label); + + YP_POP_UNLESS_POPPED; + + YP_COMPILE_NOT_POPPED(local_variable_and_write_node->value); + + YP_DUP_UNLESS_POPPED; + + ADD_SETLOCAL(ret, &dummy_line_node, local_index, depth); + ADD_LABEL(ret, end_label); + + return; + } + case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: { + yp_local_variable_operator_write_node_t *local_variable_operator_write_node = (yp_local_variable_operator_write_node_t*) node; + + yp_constant_id_t constant_id = local_variable_operator_write_node->name; + + int depth = local_variable_operator_write_node->depth; + int local_index = yp_lookup_local_index_with_depth(iseq, compile_context, constant_id, depth); + ADD_GETLOCAL(ret, &dummy_line_node, local_index, depth); + + YP_COMPILE_NOT_POPPED(local_variable_operator_write_node->value); + ID method_id = yp_constant_id_lookup(compile_context, local_variable_operator_write_node->operator); + + int flags = VM_CALL_ARGS_SIMPLE | VM_CALL_FCALL | VM_CALL_VCALL; + ADD_SEND_WITH_FLAG(ret, &dummy_line_node, method_id, INT2NUM(1), INT2FIX(flags)); + + YP_DUP_UNLESS_POPPED; + + ADD_SETLOCAL(ret, &dummy_line_node, local_index, depth); + + return; + } + case YP_LOCAL_VARIABLE_OR_WRITE_NODE: { + yp_local_variable_or_write_node_t *local_variable_or_write_node = (yp_local_variable_or_write_node_t*) node; + + LABEL *set_label= NEW_LABEL(lineno); + LABEL *end_label = NEW_LABEL(lineno); + + ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue); + ADD_INSNL(ret, &dummy_line_node, branchunless, set_label); + + yp_constant_id_t constant_id = local_variable_or_write_node->name; + int depth = local_variable_or_write_node->depth; + int local_index = yp_lookup_local_index_with_depth(iseq, compile_context, constant_id, depth); + ADD_GETLOCAL(ret, &dummy_line_node, local_index, depth); + + YP_DUP_UNLESS_POPPED; + + ADD_INSNL(ret, &dummy_line_node, branchif, end_label); + + YP_POP_UNLESS_POPPED; + + ADD_LABEL(ret, set_label); + YP_COMPILE_NOT_POPPED(local_variable_or_write_node->value); + + YP_DUP_UNLESS_POPPED; + + ADD_SETLOCAL(ret, &dummy_line_node, local_index, depth); + ADD_LABEL(ret, end_label); + + return; + } + case YP_LOCAL_VARIABLE_READ_NODE: { + yp_local_variable_read_node_t *local_read_node = (yp_local_variable_read_node_t *) node; + + if (!popped) { + int index = yp_lookup_local_index(iseq, compile_context, local_read_node->name); + ADD_GETLOCAL(ret, &dummy_line_node, index, local_read_node->depth); + } + return; + } + case YP_LOCAL_VARIABLE_TARGET_NODE: { + yp_local_variable_target_node_t *local_write_node = (yp_local_variable_target_node_t *) node; + + yp_constant_id_t constant_id = local_write_node->name; + int index = yp_lookup_local_index(iseq, compile_context, constant_id); + + ADD_SETLOCAL(ret, &dummy_line_node, (int)index, local_write_node->depth); + return; + } + case YP_LOCAL_VARIABLE_WRITE_NODE: { + yp_local_variable_write_node_t *local_write_node = (yp_local_variable_write_node_t *) node; + YP_COMPILE_NOT_POPPED(local_write_node->value); + + YP_DUP_UNLESS_POPPED; + + yp_constant_id_t constant_id = local_write_node->name; + int index = yp_lookup_local_index(iseq, compile_context, constant_id); + + ADD_SETLOCAL(ret, &dummy_line_node, (int)index, local_write_node->depth); + return; + } + case YP_MISSING_NODE: { + rb_bug("A yp_missing_node_t should not exist in YARP's AST."); + return; + } + case YP_MODULE_NODE: { + yp_module_node_t *module_node = (yp_module_node_t *)node; + yp_scope_node_t scope_node; + yp_scope_node_init((yp_node_t *)module_node, &scope_node); + + ID module_id = yp_constant_id_lookup(compile_context, module_node->name); + VALUE module_name = rb_str_freeze(rb_sprintf("<module:%"PRIsVALUE">", rb_id2str(module_id))); + + const rb_iseq_t *module_iseq = NEW_CHILD_ISEQ(&scope_node, module_name, ISEQ_TYPE_CLASS, lineno); + + const int flags = VM_DEFINECLASS_TYPE_MODULE | + yp_compile_class_path(ret, iseq, module_node->constant_path, &dummy_line_node, src, popped, compile_context); + + ADD_INSN(ret, &dummy_line_node, putnil); + ADD_INSN3(ret, &dummy_line_node, defineclass, ID2SYM(module_id), module_iseq, INT2FIX(flags)); + RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)module_iseq); + + YP_POP_IF_POPPED; + return; + } + case YP_MULTI_TARGET_NODE: { + yp_multi_target_node_t *cast = (yp_multi_target_node_t *) node; + for (size_t index = 0; index < cast->targets.size; index++) { + YP_COMPILE(cast->targets.nodes[index]); + } + return; + } + case YP_MULTI_WRITE_NODE: { + yp_multi_write_node_t *multi_write_node = (yp_multi_write_node_t *)node; + yp_node_list_t node_list = multi_write_node->targets; + + // pre-process the left hand side of multi-assignments. + uint8_t pushed = 0; + for (size_t index = 0; index < node_list.size; index++) { + pushed = yp_compile_multi_write_lhs(iseq, dummy_line_node, node_list.nodes[index], ret, compile_context, pushed, false); + } + + YP_COMPILE_NOT_POPPED(multi_write_node->value); + + // TODO: int flag = 0x02 | (NODE_NAMED_REST_P(restn) ? 0x01 : 0x00); + int flag = 0x00; + + if (!popped) { + ADD_INSN(ret, &dummy_line_node, dup); + } + ADD_INSN2(ret, &dummy_line_node, expandarray, INT2FIX(multi_write_node->targets.size), INT2FIX(flag)); + + for (size_t index = 0; index < node_list.size; index++) { + yp_node_t *considered_node = node_list.nodes[index]; + + if (YP_NODE_TYPE_P(considered_node, YP_CONSTANT_PATH_TARGET_NODE) && pushed > 0) { + yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *)considered_node; + ID name = yp_constant_id_lookup(compile_context, ((yp_constant_read_node_t * ) cast->child)->name); + + pushed -= 2; + + ADD_INSN1(ret, &dummy_line_node, topn, INT2FIX(pushed)); + ADD_INSN1(ret, &dummy_line_node, setconstant, ID2SYM(name)); + } else { + YP_COMPILE(node_list.nodes[index]); + } + } + + if (pushed) { + ADD_INSN1(ret, &dummy_line_node, setn, INT2FIX(pushed)); + for (uint8_t index = 0; index < pushed; index++) { + ADD_INSN(ret, &dummy_line_node, pop); + } + } + + return; + } + case YP_NEXT_NODE: { + yp_next_node_t *next_node = (yp_next_node_t *) node; + if (next_node->arguments) { + YP_COMPILE_NOT_POPPED((yp_node_t *)next_node->arguments); + } + else { + ADD_INSN(ret, &dummy_line_node, putnil); + } + + ADD_INSN(ret, &dummy_line_node, pop); + ADD_INSNL(ret, &dummy_line_node, jump, ISEQ_COMPILE_DATA(iseq)->start_label); + + return; + } + case YP_NIL_NODE: + YP_PUTNIL_UNLESS_POPPED + return; + case YP_NUMBERED_REFERENCE_READ_NODE: { + if (!popped) { + uint32_t reference_number = ((yp_numbered_reference_read_node_t *)node)->number; + ADD_INSN2(ret, &dummy_line_node, getspecial, INT2FIX(1), INT2FIX(reference_number << 1)); + } + return; + } + case YP_OR_NODE: { + yp_or_node_t *or_node = (yp_or_node_t *) node; + + LABEL *end_label = NEW_LABEL(lineno); + YP_COMPILE_NOT_POPPED(or_node->left); + + YP_DUP_UNLESS_POPPED; + ADD_INSNL(ret, &dummy_line_node, branchif, end_label); + + YP_POP_UNLESS_POPPED; + YP_COMPILE(or_node->right); + ADD_LABEL(ret, end_label); + + return; + } + case YP_OPTIONAL_PARAMETER_NODE: { + yp_optional_parameter_node_t *optional_parameter_node = (yp_optional_parameter_node_t *)node; + YP_COMPILE_NOT_POPPED(optional_parameter_node->value); + + int index = yp_lookup_local_index(iseq, compile_context, optional_parameter_node->name); + + ADD_SETLOCAL(ret, &dummy_line_node, index, 0); + + return; + } + case YP_PARENTHESES_NODE: { + yp_parentheses_node_t *parentheses_node = (yp_parentheses_node_t *) node; + + if (parentheses_node->body == NULL) { + YP_PUTNIL_UNLESS_POPPED; + } else { + YP_COMPILE(parentheses_node->body); + } + + return; + } + case YP_PROGRAM_NODE: { + yp_program_node_t *program_node = (yp_program_node_t *) node; + + yp_scope_node_t scope_node; + yp_scope_node_init((yp_node_t *)node, &scope_node); + if (program_node->statements->body.size == 0) { + ADD_INSN(ret, &dummy_line_node, putnil); + ADD_INSN(ret, &dummy_line_node, leave); + } else { + yp_scope_node_t *res_node = &scope_node; + YP_COMPILE((yp_node_t *) res_node); + } + + return; + } + case YP_RANGE_NODE: { + yp_range_node_t *range_node = (yp_range_node_t *) node; + bool exclusive = (range_node->operator_loc.end - range_node->operator_loc.start) == 3; + + if (yp_optimizable_range_item_p(range_node->left) && yp_optimizable_range_item_p(range_node->right)) { + if (!popped) { + yp_node_t *left = range_node->left; + yp_node_t *right = range_node->right; + VALUE val = rb_range_new( + left && YP_NODE_TYPE_P(left, YP_INTEGER_NODE) ? parse_integer((yp_integer_node_t *) left) : Qnil, + right && YP_NODE_TYPE_P(right, YP_INTEGER_NODE) ? parse_integer((yp_integer_node_t *) right) : Qnil, + exclusive + ); + ADD_INSN1(ret, &dummy_line_node, putobject, val); + RB_OBJ_WRITTEN(iseq, Qundef, val); + } + } + else { + if (range_node->left == NULL) { + ADD_INSN(ret, &dummy_line_node, putnil); + } else { + YP_COMPILE(range_node->left); + } + + if (range_node->right == NULL) { + ADD_INSN(ret, &dummy_line_node, putnil); + } else { + YP_COMPILE(range_node->right); + } + + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, newrange, INT2FIX(exclusive)); + } + } + return; + } + case YP_RATIONAL_NODE: { + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, putobject, parse_rational(node)); + } + return; + } + case YP_REDO_NODE: { + ADD_INSNL(ret, &dummy_line_node, jump, ISEQ_COMPILE_DATA(iseq)->redo_label); + return; + } + case YP_REGULAR_EXPRESSION_NODE: { + if (!popped) { + yp_regular_expression_node_t *regular_expression_node = (yp_regular_expression_node_t *) node; + VALUE regex_str = parse_string(®ular_expression_node->unescaped); + int flags = 0; + + if (regular_expression_node->base.flags & YP_REGULAR_EXPRESSION_FLAGS_IGNORE_CASE) { + flags |= ONIG_OPTION_IGNORECASE; + } + + if (regular_expression_node->base.flags & YP_REGULAR_EXPRESSION_FLAGS_MULTI_LINE) { + flags |= ONIG_OPTION_MULTILINE; + } + + if (regular_expression_node->base.flags & YP_REGULAR_EXPRESSION_FLAGS_EXTENDED) { + flags |= ONIG_OPTION_EXTEND; + } + + VALUE regex = rb_reg_new(RSTRING_PTR(regex_str), RSTRING_LEN(regex_str), flags); + ADD_INSN1(ret, &dummy_line_node, putobject, regex); + } + return; + } + case YP_RETURN_NODE: { + yp_arguments_node_t *arguments = ((yp_return_node_t *)node)->arguments; + + if (arguments) { + YP_COMPILE((yp_node_t *)arguments); + } + else { + ADD_INSN(ret, &dummy_line_node, putnil); + } + + ADD_TRACE(ret, RUBY_EVENT_RETURN); + ADD_INSN(ret, &dummy_line_node, leave); + + if (!popped) { + ADD_INSN(ret, &dummy_line_node, putnil); + } + return; + } + case YP_SCOPE_NODE: { + yp_scope_node_t *scope_node = (yp_scope_node_t *)node; + yp_constant_id_list_t locals = scope_node->locals; + + yp_parameters_node_t *parameters_node = (yp_parameters_node_t *)scope_node->parameters; + yp_node_list_t requireds_list = YP_EMPTY_NODE_LIST; + yp_node_list_t optionals_list = YP_EMPTY_NODE_LIST; + + if (parameters_node) { + requireds_list = parameters_node->requireds; + optionals_list = parameters_node->optionals; + } + + size_t size = locals.size; + + // Index lookup table buffer size is only the number of the locals + st_table *index_lookup_table = st_init_numtable(); + + VALUE idtmp = 0; + rb_ast_id_table_t *tbl = ALLOCV(idtmp, sizeof(rb_ast_id_table_t) + size * sizeof(ID)); + tbl->size = (int)size; + + // First param gets 0, second param 1, param n... + // Calculate the local index for all locals + for (size_t i = 0; i < size; i++) { + yp_constant_id_t constant_id = locals.ids[i]; + ID local = yp_constant_id_lookup(compile_context, constant_id); + tbl->ids[i] = local; + st_insert(index_lookup_table, constant_id, i); + } + + yp_compile_context_t scope_compile_context = { + .parser = parser, + .previous = compile_context, + .constants = compile_context->constants, + .index_lookup_table = index_lookup_table + }; + + ISEQ_BODY(iseq)->param.lead_num = (int)requireds_list.size; + ISEQ_BODY(iseq)->param.opt_num = (int)optionals_list.size; + // TODO: Set all the other nums (good comment by lead_num illustrating what they are) + ISEQ_BODY(iseq)->param.size = (unsigned int)size; + + if (optionals_list.size) { + LABEL **opt_table = (LABEL **)ALLOC_N(VALUE, optionals_list.size + 1); + LABEL *label; + + // TODO: Should we make an api for NEW_LABEL where you can pass + // a pointer to the label it should fill out? We already + // have a list of labels allocated above so it seems wasteful + // to do the copies. + for (size_t i = 0; i < optionals_list.size; i++) { + label = NEW_LABEL(lineno); + opt_table[i] = label; + ADD_LABEL(ret, label); + yp_node_t *optional_node = optionals_list.nodes[i]; + yp_compile_node(iseq, optional_node, ret, src, false, &scope_compile_context); + } + + // Set the last label + label = NEW_LABEL(lineno); + opt_table[optionals_list.size] = label; + ADD_LABEL(ret, label); + + ISEQ_BODY(iseq)->param.flags.has_opt = TRUE; + ISEQ_BODY(iseq)->param.opt_table = (const VALUE *)opt_table; + } + + iseq_set_local_table(iseq, tbl); + + switch (ISEQ_BODY(iseq)->type) { + case ISEQ_TYPE_BLOCK: + { + LABEL *start = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(0); + LABEL *end = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(0); + + start->rescued = LABEL_RESCUE_BEG; + end->rescued = LABEL_RESCUE_END; + + ADD_TRACE(ret, RUBY_EVENT_B_CALL); + NODE dummy_line_node = generate_dummy_line_node(ISEQ_BODY(iseq)->location.first_lineno, -1); + ADD_INSN (ret, &dummy_line_node, nop); + ADD_LABEL(ret, start); + + if (scope_node->body) { + yp_compile_node(iseq, (yp_node_t *)(scope_node->body), ret, src, popped, &scope_compile_context); + } + else { + ADD_INSN(ret, &dummy_line_node, putnil); + } + + ADD_LABEL(ret, end); + ADD_TRACE(ret, RUBY_EVENT_B_RETURN); + ISEQ_COMPILE_DATA(iseq)->last_line = ISEQ_BODY(iseq)->location.code_location.end_pos.lineno; + + /* wide range catch handler must put at last */ + ADD_CATCH_ENTRY(CATCH_TYPE_REDO, start, end, NULL, start); + ADD_CATCH_ENTRY(CATCH_TYPE_NEXT, start, end, NULL, end); + break; + } + default: + if (scope_node->body) { + yp_compile_node(iseq, (yp_node_t *)(scope_node->body), ret, src, popped, &scope_compile_context); + } + else { + ADD_INSN(ret, &dummy_line_node, putnil); + } + } + + free(index_lookup_table); + + ADD_INSN(ret, &dummy_line_node, leave); + return; + } + case YP_SELF_NODE: + if (!popped) { + ADD_INSN(ret, &dummy_line_node, putself); + } + return; + case YP_SINGLETON_CLASS_NODE: { + yp_singleton_class_node_t *singleton_class_node = (yp_singleton_class_node_t *)node; + yp_scope_node_t scope_node; + yp_scope_node_init((yp_node_t *)singleton_class_node, &scope_node); + + const rb_iseq_t *singleton_class = NEW_ISEQ(&scope_node, rb_fstring_lit("singleton class"), + ISEQ_TYPE_CLASS, lineno); + + YP_COMPILE(singleton_class_node->expression); + ADD_INSN(ret, &dummy_line_node, putnil); + ID singletonclass; + CONST_ID(singletonclass, "singletonclass"); + + ADD_INSN3(ret, &dummy_line_node, defineclass, + ID2SYM(singletonclass), singleton_class, + INT2FIX(VM_DEFINECLASS_TYPE_SINGLETON_CLASS)); + RB_OBJ_WRITTEN(iseq, Qundef, (VALUE)singleton_class); + + return; + } + case YP_SOURCE_ENCODING_NODE: { + const char *encoding = compile_context->parser->encoding.name; + if (!popped) { + rb_encoding *enc = rb_find_encoding(rb_str_new_cstr(encoding)); + if (!enc) { + rb_bug("Encoding not found!"); + } + ADD_INSN1(ret, &dummy_line_node, putobject, rb_enc_from_encoding(enc)); + } + return; + } + case YP_SOURCE_FILE_NODE: { + yp_source_file_node_t *source_file_node = (yp_source_file_node_t *)node; + + if (!popped) { + VALUE filepath; + if (source_file_node->filepath.length == 0) { + filepath = rb_fstring_lit("<compiled>"); + } + else { + filepath = parse_string(&source_file_node->filepath); + } + + ADD_INSN1(ret, &dummy_line_node, putstring, filepath); + } + return; + } + case YP_SOURCE_LINE_NODE: { + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, putobject, INT2FIX(lineno)); + } + return; + } + case YP_SPLAT_NODE: { + yp_splat_node_t *splat_node = (yp_splat_node_t *)node; + YP_COMPILE(splat_node->expression); + + ADD_INSN1(ret, &dummy_line_node, splatarray, Qtrue); + + YP_POP_IF_POPPED; + return; + } + case YP_STATEMENTS_NODE: { + yp_statements_node_t *statements_node = (yp_statements_node_t *) node; + yp_node_list_t node_list = statements_node->body; + for (size_t index = 0; index < node_list.size - 1; index++) { + YP_COMPILE_POPPED(node_list.nodes[index]); + } + if (node_list.size > 0) { + YP_COMPILE(node_list.nodes[node_list.size - 1]); + } + else { + ADD_INSN(ret, &dummy_line_node, putnil); + } + return; + } + case YP_STRING_CONCAT_NODE: { + yp_string_concat_node_t *str_concat_node = (yp_string_concat_node_t *)node; + YP_COMPILE(str_concat_node->left); + YP_COMPILE(str_concat_node->right); + return; + } + case YP_STRING_NODE: { + if (!popped) { + yp_string_node_t *string_node = (yp_string_node_t *) node; + ADD_INSN1(ret, &dummy_line_node, putstring, parse_string(&string_node->unescaped)); + } + return; + } + case YP_SYMBOL_NODE: { + yp_symbol_node_t *symbol_node = (yp_symbol_node_t *) node; + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, putobject, ID2SYM(parse_string_symbol(&symbol_node->unescaped))); + } + return; + } + case YP_TRUE_NODE: + if (!popped) { + ADD_INSN1(ret, &dummy_line_node, putobject, Qtrue); + } + return; + case YP_UNDEF_NODE: { + yp_undef_node_t *undef_node = (yp_undef_node_t *) node; + + for (size_t index = 0; index < undef_node->names.size; index++) { + ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE)); + ADD_INSN1(ret, &dummy_line_node, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE)); + + YP_COMPILE(undef_node->names.nodes[index]); + + ADD_SEND(ret, &dummy_line_node, id_core_undef_method, INT2NUM(2)); + + if (index < undef_node->names.size - 1) + ADD_INSN(ret, &dummy_line_node, pop); + } + + return; + } + case YP_UNLESS_NODE: { + const int line = (int)yp_newline_list_line_column(&(parser->newline_list), node->location.start).line; + yp_unless_node_t *unless_node = (yp_unless_node_t *)node; + yp_statements_node_t *node_body = unless_node->statements; + yp_node_t *node_else = (yp_node_t *)(unless_node->consequent); + yp_node_t *predicate = unless_node->predicate; + + yp_compile_if(iseq, line, node_body, node_else, predicate, ret, src, popped, compile_context); + return; + } + case YP_UNTIL_NODE: { + yp_until_node_t *until_node = (yp_until_node_t *)node; + yp_statements_node_t *statements = until_node->statements; + yp_node_t *predicate = until_node->predicate; + yp_node_flags_t flags = node->flags; + + yp_compile_while(iseq, lineno, flags, node->type, statements, predicate, ret, src, popped, compile_context); + return; + } + case YP_WHILE_NODE: { + yp_while_node_t *while_node = (yp_while_node_t *)node; + yp_statements_node_t *statements = while_node->statements; + yp_node_t *predicate = while_node->predicate; + yp_node_flags_t flags = node->flags; + + yp_compile_while(iseq, lineno, flags, node->type, statements, predicate, ret, src, popped, compile_context); + return; + } + case YP_X_STRING_NODE: { + yp_x_string_node_t *xstring_node = (yp_x_string_node_t *) node; + ADD_INSN(ret, &dummy_line_node, putself); + ADD_INSN1(ret, &dummy_line_node, putobject, parse_string(&xstring_node->unescaped)); + ADD_SEND_WITH_FLAG(ret, &dummy_line_node, idBackquote, INT2NUM(1), INT2FIX(VM_CALL_FCALL | VM_CALL_ARGS_SIMPLE)); + + YP_POP_IF_POPPED; + return; + } + case YP_YIELD_NODE: { + unsigned int flag = 0; + struct rb_callinfo_kwarg *keywords = NULL; + + VALUE argc = INT2FIX(0); + + ADD_INSN1(ret, &dummy_line_node, invokeblock, new_callinfo(iseq, 0, FIX2INT(argc), flag, keywords, FALSE)); + + YP_POP_IF_POPPED; + + int level = 0; + const rb_iseq_t *tmp_iseq = iseq; + for (; tmp_iseq != ISEQ_BODY(iseq)->local_iseq; level++ ) { + tmp_iseq = ISEQ_BODY(tmp_iseq)->parent_iseq; + } + + if (level > 0) access_outer_variables(iseq, level, rb_intern("yield"), true); + + return; + } + default: + rb_raise(rb_eNotImpError, "node type %s not implemented", yp_node_type_to_str(YP_NODE_TYPE(node))); + return; + } +} + +static VALUE +rb_translate_yarp(rb_iseq_t *iseq, const yp_node_t *node, LINK_ANCHOR *const ret, yp_compile_context_t *compile_context) +{ + RUBY_ASSERT(ISEQ_COMPILE_DATA(iseq)); + RUBY_ASSERT(YP_NODE_TYPE_P(node, YP_PROGRAM_NODE) || YP_NODE_TYPE_P(node, YP_SCOPE_NODE)); + + yp_compile_node(iseq, node, ret, node->location.start, false, compile_context); + iseq_set_sequence(iseq, ret); + return Qnil; +} + +#undef NEW_ISEQ +#define NEW_ISEQ OLD_ISEQ + +#undef NEW_CHILD_ISEQ +#define NEW_CHILD_ISEQ OLD_CHILD_ISEQ |