Fwd: nobu:r39626 (trunk): compile.c: nd_line(node)

[email protected]$H!“L?Na$4$H$K9THV9fIU$1$F$$$?$N$,$:[email protected]$,$”$k$h$&$J5$$,$7$^(B
$B$9!#$3$NJQ99$N0U?^$r65$($FLc$($^$9$+!)(B

-------- Original Message --------
Subject: [ruby-changes:27574] nobu:r39626 (trunk): compile.c:
nd_line(node)
Date: Thu, 7 Mar 2013 14:18:19 +0900 (JST)
From: nobu [email protected]
Reply-To: [email protected]
To: [email protected]

nobu 2013-03-07 14:17:04 +0900 (Thu, 07 Mar 2013)

New Revision: 39626

http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=39626

Log:
compile.c: nd_line(node)

* compile.c (iseq_compile_each): keep nd_line(node) in a local
  variable.

Modified files:
trunk/compile.c

Index: compile.c

— compile.c (revision 39625)
+++ compile.c (revision 39626)
@@ -3155,6 +3155,7 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
https://github.com/ruby/ruby/blob/trunk/compile.c#L3155
{
enum node_type type;
LINK_ELEMENT *saved_last_element = 0;

  • iseq->compile_data->last_line = (int)nd_line(node);
  • iseq->compile_data->last_line = line = (int)nd_line(node);
    debug_node_start(node);

    type = nd_type(node);

    if (node->flags & NODE_FL_NEWLINE) {

  • ADD_TRACE(ret, nd_line(node), RUBY_EVENT_LINE);
  • ADD_TRACE(ret, line, RUBY_EVENT_LINE);
    saved_last_element = ret->last;
    }

@@ -3195,9 +3196,9 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
https://github.com/ruby/ruby/blob/trunk/compile.c#L3196
INIT_ANCHOR(cond_seq);
INIT_ANCHOR(then_seq);
INIT_ANCHOR(else_seq);

  • then_label = NEW_LABEL(nd_line(node));
  • else_label = NEW_LABEL(nd_line(node));
  • end_label = NEW_LABEL(nd_line(node));
  • then_label = NEW_LABEL(line);

  • else_label = NEW_LABEL(line);

  • end_label = NEW_LABEL(line);

    compile_branch_condition(iseq, cond_seq, node->nd_cond,
    then_label, else_label);
    @@ -3208,7 +3209,7 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
    https://github.com/ruby/ruby/blob/trunk/compile.c#L3209

    ADD_LABEL(ret, then_label);
    ADD_SEQ(ret, then_seq);

  • ADD_INSNL(ret, nd_line(node), jump, end_label);
  • ADD_INSNL(ret, line, jump, end_label);

    ADD_LABEL(ret, else_label);
    ADD_SEQ(ret, else_seq);
    @@ -3241,24 +3242,25 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
    https://github.com/ruby/ruby/blob/trunk/compile.c#L3242

    node = node->nd_body;
    type = nd_type(node);

  • line = nd_line(node);

    if (type != NODE_WHEN) {
    COMPILE_ERROR((ERROR_ARGS “NODE_CASE: unexpected node. must be
    NODE_WHEN, but %s”, ruby_node_name(type)));
    }

  • endlabel = NEW_LABEL(nd_line(node));
  • elselabel = NEW_LABEL(nd_line(node));
  • endlabel = NEW_LABEL(line);

  • elselabel = NEW_LABEL(line);

    ADD_SEQ(ret, head); /* case VAL */

    while (type == NODE_WHEN) {
    LABEL *l1;

  •  l1 = NEW_LABEL(nd_line(node));
    
  •  l1 = NEW_LABEL(line);
     ADD_LABEL(body_seq, l1);
    
  •  ADD_INSN(body_seq, nd_line(node), pop);
    
  •  ADD_INSN(body_seq, line, pop);
     COMPILE_(body_seq, "when body", node->nd_body, poped);
    
  •  ADD_INSNL(body_seq, nd_line(node), jump, endlabel);
    
  •  ADD_INSNL(body_seq, line, jump, endlabel);
    
     vals = node->nd_head;
     if (vals) {
    

@@ -3289,13 +3291,14 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
https://github.com/ruby/ruby/blob/trunk/compile.c#L3291
break;
}
type = nd_type(node);

  •  line = nd_line(node);
    
    }
    /* else */
    if (node) {
    ADD_LABEL(cond_seq, elselabel);
  •  ADD_INSN(cond_seq, nd_line(node), pop);
    
  •  ADD_INSN(cond_seq, line, pop);
     COMPILE_(cond_seq, "else", node, poped);
    
  •  ADD_INSNL(cond_seq, nd_line(node), jump, endlabel);
    
  • endlabel = NEW_LABEL(nd_line(node));
  • endlabel = NEW_LABEL(line);

    while (node && nd_type(node) == NODE_WHEN) {

  •  LABEL *l1 = NEW_LABEL(nd_line(node));
    
  •  LABEL *l1 = NEW_LABEL(line = nd_line(node));
     ADD_LABEL(body_seq, l1);
     COMPILE_(body_seq, "when", node->nd_body, poped);
    
  •  ADD_INSNL(body_seq, nd_line(node), jump, endlabel);
    
  •  ADD_INSNL(body_seq, line, jump, endlabel);
    
     vals = node->nd_head;
     if (!vals) {
    

@@ -3381,28 +3384,28 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
https://github.com/ruby/ruby/blob/trunk/compile.c#L3384

struct iseq_compile_data_ensure_node_stack enl;

  • LABEL next_label = iseq->compile_data->start_label =
    NEW_LABEL(nd_line(node)); /
    next */
  • LABEL redo_label = iseq->compile_data->redo_label =
    NEW_LABEL(nd_line(node)); /
    redo */
  • LABEL break_label = iseq->compile_data->end_label =
    NEW_LABEL(nd_line(node)); /
    break */
  • LABEL *end_label = NEW_LABEL(nd_line(node));
  • LABEL next_label = iseq->compile_data->start_label =
    NEW_LABEL(line); /
    next */
  • LABEL redo_label = iseq->compile_data->redo_label = NEW_LABEL(line);
    /
    redo */
  • LABEL break_label = iseq->compile_data->end_label = NEW_LABEL(line);
    /
    break */
  • LABEL *end_label = NEW_LABEL(line);
  • LABEL *next_catch_label = NEW_LABEL(nd_line(node));
  • LABEL *next_catch_label = NEW_LABEL(line);
    LABEL *tmp_label = NULL;

    iseq->compile_data->loopval_popped = 0;
    push_ensure_entry(iseq, &enl, 0, 0);

    if (type == NODE_OPT_N || node->nd_state == 1) {

  •  ADD_INSNL(ret, nd_line(node), jump, next_label);
    
  •  ADD_INSNL(ret, line, jump, next_label);
    
    }
    else {
  •  tmp_label = NEW_LABEL(nd_line(node));
    
  •  ADD_INSNL(ret, nd_line(node), jump, tmp_label);
    
  •  tmp_label = NEW_LABEL(line);
    
  •  ADD_INSNL(ret, line, jump, tmp_label);
    
    }
  • ADD_INSN(ret, nd_line(node), putnil);
  • ADD_INSN(ret, line, putnil);
    ADD_LABEL(ret, next_catch_label);
  • ADD_INSN(ret, nd_line(node), pop);
  • ADD_INSNL(ret, nd_line(node), jump, next_label);
  • ADD_INSN(ret, line, pop);

  • ADD_INSNL(ret, line, jump, next_label);
    if (tmp_label) ADD_LABEL(ret, tmp_label);

    ADD_LABEL(ret, redo_label);
    @@ -3419,26 +3422,26 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
    https://github.com/ruby/ruby/blob/trunk/compile.c#L3422
    end_label, redo_label);
    }
    else {

  •  ADD_CALL_RECEIVER(ret, nd_line(node));
    
  •  ADD_CALL(ret, nd_line(node), ID2SYM(idGets), INT2FIX(0));
    
  •  ADD_INSNL(ret, nd_line(node), branchif, redo_label);
    
  •  ADD_CALL_RECEIVER(ret, line);
    
  •  ADD_CALL(ret, line, ID2SYM(idGets), INT2FIX(0));
    
  •  ADD_INSNL(ret, line, branchif, redo_label);
     /* opt_n */
    

    }

    ADD_LABEL(ret, end_label);

    if (node->nd_state == Qundef) {

  •  /* ADD_INSN(ret, nd_line(node), putundef); */
    
  •  /* ADD_INSN(ret, line, putundef); */
     rb_bug("unsupported: putundef");
    
    }
    else {
  •  ADD_INSN(ret, nd_line(node), putnil);
    
  •  ADD_INSN(ret, line, putnil);
    

    }

    ADD_LABEL(ret, break_label); /* break */

    if (poped) {

  •  ADD_INSN(ret, nd_line(node), pop);
    
  •  ADD_INSN(ret, line, pop);
    

    }

    ADD_CATCH_ENTRY(CATCH_TYPE_BREAK, redo_label, break_label,
    @@ -3458,8 +3461,8 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
    https://github.com/ruby/ruby/blob/trunk/compile.c#L3461
    case NODE_ITER:
    case NODE_FOR:{
    VALUE prevblock = iseq->compile_data->current_block;

  • LABEL *retry_label = NEW_LABEL(nd_line(node));
  • LABEL *retry_end_l = NEW_LABEL(nd_line(node));
  • LABEL *retry_label = NEW_LABEL(line);

  • LABEL *retry_end_l = NEW_LABEL(line);

    ADD_LABEL(ret, retry_label);
    if (nd_type(node) == NODE_FOR) {
    @@ -3467,21 +3470,21 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
    https://github.com/ruby/ruby/blob/trunk/compile.c#L3470

    iseq->compile_data->current_block =
    

    NEW_CHILD_ISEQVAL(node->nd_body, make_name_for_block(iseq),

  •      ISEQ_TYPE_BLOCK, nd_line(node));
    
  •      ISEQ_TYPE_BLOCK, line);
    
  •  ADD_SEND_R(ret, nd_line(node), ID2SYM(idEach), INT2FIX(0),
    
  •  ADD_SEND_R(ret, line, ID2SYM(idEach), INT2FIX(0),
          iseq->compile_data->current_block, INT2FIX(0));
    
    }
    else {
    iseq->compile_data->current_block =
    NEW_CHILD_ISEQVAL(node->nd_body, make_name_for_block(iseq),
  •      ISEQ_TYPE_BLOCK, nd_line(node));
    
  •      ISEQ_TYPE_BLOCK, line);
     COMPILE(ret, "iter caller", node->nd_iter);
    

    }
    ADD_LABEL(ret, retry_end_l);

    if (poped) {

  •  ADD_INSN(ret, nd_line(node), pop);
    
  •  ADD_ADJUST(ret, nd_line(node), iseq->compile_data->redo_label);
    
  •  ADD_ADJUST(ret, line, iseq->compile_data->redo_label);
     COMPILE_(ret, "break val (while/until)", node->nd_stts,
    

iseq->compile_data->loopval_popped);
add_ensure_iseq(ret, iseq, 0);

  •  ADD_INSNL(ret, nd_line(node), jump, 
    

iseq->compile_data->end_label);

  •  ADD_INSNL(ret, line, jump, iseq->compile_data->end_label);
     ADD_ADJUST_RESTORE(ret, splabel);
    
     if (!poped) {
    
  • ADD_INSN(ret, nd_line(node), putnil);
  • ADD_INSN(ret, line, putnil);
    }
    }
    else if (iseq->type == ISEQ_TYPE_BLOCK) {
    break_by_insn:
    /* escape from block */
    COMPILE(ret, “break val (block)”, node->nd_stts);
  •  ADD_INSN1(ret, nd_line(node), throw, INT2FIX(level | 0x02) /*
    

TAG_BREAK */ );

  •  ADD_INSN1(ret, line, throw, INT2FIX(level | 0x02) /* TAG_BREAK */ 
    

);
if (poped) {

  • ADD_INSN(ret, nd_line(node), pop);
  • ADD_INSN(ret, line, pop);
    }
    }
    else if (iseq->type == ISEQ_TYPE_EVAL) {
    @@ -3560,25 +3563,25 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
    https://github.com/ruby/ruby/blob/trunk/compile.c#L3563
    ADD_LABEL(ret, splabel);
    COMPILE(ret, “next val/valid syntax?”, node->nd_stts);
    add_ensure_iseq(ret, iseq, 0);
  •  ADD_ADJUST(ret, nd_line(node), iseq->compile_data->redo_label);
    
  •  ADD_INSNL(ret, nd_line(node), jump, 
    

iseq->compile_data->start_label);

  •  ADD_ADJUST(ret, line, iseq->compile_data->redo_label);
    
  •  ADD_INSNL(ret, line, jump, iseq->compile_data->start_label);
     ADD_ADJUST_RESTORE(ret, splabel);
     if (!poped) {
    
  • ADD_INSN(ret, nd_line(node), putnil);
  • ADD_INSN(ret, line, putnil);
    }
    }
    else if (iseq->compile_data->end_label) {
    LABEL *splabel = NEW_LABEL(0);
    debugs(“next in block\n”);
    ADD_LABEL(ret, splabel);
  •  ADD_ADJUST(ret, nd_line(node), iseq->compile_data->start_label);
    
  •  ADD_ADJUST(ret, line, iseq->compile_data->start_label);
     COMPILE(ret, "next val", node->nd_stts);
     add_ensure_iseq(ret, iseq, 0);
    
  •  ADD_INSNL(ret, nd_line(node), jump, 
    

iseq->compile_data->end_label);

  •  ADD_INSNL(ret, line, jump, iseq->compile_data->end_label);
     ADD_ADJUST_RESTORE(ret, splabel);
    
     if (!poped) {
    
  • ADD_INSN(ret, nd_line(node), putnil);
  • ADD_INSN1(ret, nd_line(node), throw, INT2FIX(level | 0x03) /*
    TAG_NEXT */ );
  • ADD_INSN1(ret, line, throw, INT2FIX(level | 0x03) /* TAG_NEXT */ );

    if (poped) {

  •    ADD_INSN(ret, nd_line(node), pop);
    
  •  ADD_ADJUST(ret, nd_line(node), iseq->compile_data->redo_label);
    
  •  ADD_ADJUST(ret, line, iseq->compile_data->redo_label);
     add_ensure_iseq(ret, iseq, 0);
    
  •  ADD_INSNL(ret, nd_line(node), jump, 
    

iseq->compile_data->redo_label);

  •  ADD_INSNL(ret, line, jump, iseq->compile_data->redo_label);
     ADD_ADJUST_RESTORE(ret, splabel);
     if (!poped) {
    
  • ADD_INSN(ret, nd_line(node), putnil);
  • ADD_INSN(ret, line, putnil);
    }
    }
    else if (iseq->type == ISEQ_TYPE_EVAL) {
    @@ -3645,12 +3648,12 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
    https://github.com/ruby/ruby/blob/trunk/compile.c#L3648
    debugs(“redo in block”);
    ADD_LABEL(ret, splabel);
    add_ensure_iseq(ret, iseq, 0);
  •  ADD_ADJUST(ret, nd_line(node), iseq->compile_data->start_label);
    
  •  ADD_INSNL(ret, nd_line(node), jump, 
    

iseq->compile_data->start_label);

  •  ADD_ADJUST(ret, line, iseq->compile_data->start_label);
    
  •  ADD_INSNL(ret, line, jump, iseq->compile_data->start_label);
     ADD_ADJUST_RESTORE(ret, splabel);
    
     if (!poped) {
    
  • ADD_INSN(ret, nd_line(node), putnil);
  • ADD_INSN(ret, nd_line(node), putnil);
  • ADD_INSN1(ret, nd_line(node), throw, INT2FIX(level | 0x05) /*
    TAG_REDO */ );
  • ADD_INSN(ret, line, putnil);

  • ADD_INSN1(ret, line, throw, INT2FIX(level | 0x05) /* TAG_REDO */ );

    if (poped) {

  •    ADD_INSN(ret, nd_line(node), pop);
    
  •  ADD_INSN(ret, nd_line(node), putnil);
    
  •  ADD_INSN1(ret, nd_line(node), throw, INT2FIX(0x04) /* TAG_RETRY 
    

*/ );

  •  ADD_INSN(ret, line, putnil);
    
  •  ADD_INSN1(ret, line, throw, INT2FIX(0x04) /* TAG_RETRY */ );
    
     if (poped) {
    
  • ADD_INSN(ret, nd_line(node), pop);
  • LABEL *lstart = NEW_LABEL(nd_line(node));
  • LABEL *lend = NEW_LABEL(nd_line(node));
  • LABEL *lcont = NEW_LABEL(nd_line(node));
  • LABEL *lstart = NEW_LABEL(line);
  • LABEL *lend = NEW_LABEL(line);
  • LABEL *lcont = NEW_LABEL(line);
    VALUE rescue = NEW_CHILD_ISEQVAL(
    node->nd_resq,
    rb_str_concat(rb_str_new2("rescue in "), iseq->location.label),
  •  ISEQ_TYPE_RESCUE, nd_line(node));
    
  •  ISEQ_TYPE_RESCUE, line);
    

    ADD_LABEL(ret, lstart);
    COMPILE(ret, “rescue head”, node->nd_head);
    ADD_LABEL(ret, lend);
    if (node->nd_else) {

  •  ADD_INSN(ret, nd_line(node), pop);
    
  •  ADD_INSN(ret, line, pop);
     COMPILE(ret, "rescue else", node->nd_else);
    
    }
  • ADD_INSN(ret, nd_line(node), nop);
  • ADD_INSN(ret, line, nop);
    ADD_LABEL(ret, lcont);

    if (poped) {

  •  ADD_INSN(ret, nd_line(node), pop);
    
  •  label_miss = NEW_LABEL(nd_line(node));
    
  •  label_hit = NEW_LABEL(nd_line(node));
    
  •  label_miss = NEW_LABEL(line);
    
  •  label_hit = NEW_LABEL(line);
    
     narg = resq->nd_args;
     if (narg) {
    
    switch (nd_type(narg)) {
    case NODE_ARRAY:
    while (narg) {
  •  ADD_INSN2(ret, nd_line(node), getlocal, INT2FIX(2), INT2FIX(0));
    
  •  ADD_INSN2(ret, line, getlocal, INT2FIX(2), INT2FIX(0));
     COMPILE(ret, "rescue arg", narg->nd_head);
    
  •  ADD_INSN1(ret, nd_line(node), checkmatch,
    

INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));

  •  ADD_INSNL(ret, nd_line(node), branchif, label_hit);
    
  •  ADD_INSN1(ret, line, checkmatch, 
    

INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));

  •  ADD_INSNL(ret, line, branchif, label_hit);
     narg = narg->nd_next;
       }
       break;
     case NODE_SPLAT:
     case NODE_ARGSCAT:
     case NODE_ARGSPUSH:
    
  •    ADD_INSN2(ret, nd_line(node), getlocal, INT2FIX(2), 
    

INT2FIX(0));

  •    ADD_INSN2(ret, line, getlocal, INT2FIX(2), INT2FIX(0));
       COMPILE(ret, "rescue/cond splat", narg);
    
  •    ADD_INSN1(ret, nd_line(node), checkmatch,
    

INT2FIX(VM_CHECKMATCH_TYPE_RESCUE | VM_CHECKMATCH_ARRAY));

  •    ADD_INSNL(ret, nd_line(node), branchif, label_hit);
    
  •    ADD_INSN1(ret, line, checkmatch,
    

INT2FIX(VM_CHECKMATCH_TYPE_RESCUE | VM_CHECKMATCH_ARRAY));

  •    ADD_INSNL(ret, line, branchif, label_hit);
       break;
     default:
       rb_bug("NODE_RESBODY: unknown node (%s)",
    

@@ -3771,18 +3774,18 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
https://github.com/ruby/ruby/blob/trunk/compile.c#L3774
}
}
else {

  • ADD_INSN2(ret, nd_line(node), getlocal, INT2FIX(2), INT2FIX(0));
  • ADD_INSN1(ret, nd_line(node), putobject, rb_eStandardError);
  • ADD_INSN1(ret, nd_line(node), checkmatch,
    INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
  • ADD_INSNL(ret, nd_line(node), branchif, label_hit);
  • ADD_INSN2(ret, line, getlocal, INT2FIX(2), INT2FIX(0));
  • ADD_INSN1(ret, line, putobject, rb_eStandardError);
  • ADD_INSN1(ret, line, checkmatch,
    INT2FIX(VM_CHECKMATCH_TYPE_RESCUE));
  • ADD_INSNL(ret, line, branchif, label_hit);
    }
  •  ADD_INSNL(ret, nd_line(node), jump, label_miss);
    
  •  ADD_INSNL(ret, line, jump, label_miss);
     ADD_LABEL(ret, label_hit);
     COMPILE(ret, "resbody body", resq->nd_body);
     if (iseq->compile_data->option->tailcall_optimization) {
    
  • ADD_INSN(ret, nd_line(node), nop);
  • ADD_INSN(ret, line, nop);
    }
  •  ADD_INSN(ret, nd_line(node), leave);
    
  •       ISEQ_TYPE_ENSURE, nd_line(node));
    
  • LABEL *lstart = NEW_LABEL(nd_line(node));
  • LABEL *lend = NEW_LABEL(nd_line(node));
  • LABEL *lcont = NEW_LABEL(nd_line(node));
  •       ISEQ_TYPE_ENSURE, line);
    
  • LABEL *lstart = NEW_LABEL(line);
  • LABEL *lend = NEW_LABEL(line);
  • LABEL *lcont = NEW_LABEL(line);
    struct ensure_range er;
    struct iseq_compile_data_ensure_node_stack enl;
    struct ensure_range *erange;
    @@ -3814,7 +3817,7 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
    https://github.com/ruby/ruby/blob/trunk/compile.c#L3817
    COMPILE_(ret, “ensure head”, node->nd_head, poped);
    ADD_LABEL(ret, lend);
    if (ensr->anchor.next == 0) {
  •  ADD_INSN(ret, nd_line(node), nop);
    
  • LABEL *end_label = NEW_LABEL(nd_line(node));
  • LABEL *end_label = NEW_LABEL(line);
    COMPILE(ret, “nd_1st”, node->nd_1st);
    if (!poped) {
  •  ADD_INSN(ret, nd_line(node), dup);
    
  •  ADD_INSN(ret, line, dup);
    
    }
    if (type == NODE_AND) {
  •  ADD_INSNL(ret, nd_line(node), branchunless, end_label);
    
  •  ADD_INSNL(ret, line, branchunless, end_label);
    
    }
    else {
  •  ADD_INSNL(ret, nd_line(node), branchif, end_label);
    
  •  ADD_INSNL(ret, line, branchif, end_label);
    
    }
    if (!poped) {
  •  ADD_INSN(ret, nd_line(node), pop);
    
  •  ADD_INSN(ret, line, pop);
    

    }
    COMPILE_(ret, “nd_2nd”, node->nd_2nd, poped);
    ADD_LABEL(ret, end_label);
    @@ -3866,9 +3869,9 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
    https://github.com/ruby/ruby/blob/trunk/compile.c#L3869
    COMPILE(ret, “rvalue”, node->nd_value);

    if (!poped) {

  •  ADD_INSN(ret, nd_line(node), dup);
    
  •  ADD_INSN(ret, line, dup);
    
    }
  • ADD_INSN2(ret, nd_line(node), setlocal, INT2FIX(idx),
    INT2FIX(get_lvar_level(iseq)));
  • ADD_INSN2(ret, line, setlocal, INT2FIX(idx),
    INT2FIX(get_lvar_level(iseq)));

    break;
    }
    @@ -3879,7 +3882,7 @@ iseq_compile_each(rb_iseq_t iseq, LINK_
    https://github.com/ruby/ruby/blob/trunk/compile.c#L3882
    debugp_param(“dassn id”, rb_str_new2(rb_id2name(node->nd_vid) ?
    rb_id2name(node->nd_vid) : "
    "));

    if (!poped) {

  •  ADD_INSN(ret, nd_line(node), dup);
    
  •  ADD_INSN(ret, line, dup);
    

    }

    idx = get_dyna_var_idx(iseq, node->nd_vid, &lv, &ls);
    @@ -3888,16 +3891,16 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_
    https://github.com/ruby/ruby/blob/trunk/compile.c#L3891
    rb_bug(“NODE_DASGN(_CURR): unknown id (%s)”,
    rb_id2name(node->nd_vid));
    }

  • ADD_INSN2(ret, nd_line(node), set (… truncated)

(13/03/12 17:18), SASADA Koichi wrote:

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs