[前][次][番号順一覧][スレッド一覧]

ruby-changes:40779

From: ko1 <ko1@a...>
Date: Wed, 2 Dec 2015 16:52:21 +0900 (JST)
Subject: [ruby-changes:40779] ko1:r52858 (trunk): * iseq.h: introduce ISEQ_COMPILE_DATA() macro.

ko1	2015-12-02 16:52:12 +0900 (Wed, 02 Dec 2015)

  New Revision: 52858

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

  Log:
    * iseq.h: introduce ISEQ_COMPILE_DATA() macro.
    
    * compile.c, iseq.c: use ISEQ_COMPILE_DATA().
    
    * vm_core.h: rename compile_data field to support this fix.

  Modified files:
    trunk/ChangeLog
    trunk/compile.c
    trunk/iseq.c
    trunk/iseq.h
    trunk/vm_core.h
Index: ChangeLog
===================================================================
--- ChangeLog	(revision 52857)
+++ ChangeLog	(revision 52858)
@@ -1,3 +1,11 @@ https://github.com/ruby/ruby/blob/trunk/ChangeLog#L1
+Wed Dec  2 16:32:08 2015  Koichi Sasada  <ko1@a...>
+
+	* iseq.h: introduce ISEQ_COMPILE_DATA() macro.
+
+	* compile.c, iseq.c: use ISEQ_COMPILE_DATA().
+
+	* vm_core.h: rename compile_data field to support this fix.
+
 Wed Dec  2 16:27:19 2015  Nobuyoshi Nakada  <nobu@r...>
 
 	* encoding.c (enc_m_loader): defer finding encoding object not to
Index: vm_core.h
===================================================================
--- vm_core.h	(revision 52857)
+++ vm_core.h	(revision 52858)
@@ -399,7 +399,7 @@ struct rb_iseq_variable_body { https://github.com/ruby/ruby/blob/trunk/vm_core.h#L399
 /* typedef rb_iseq_t is in method.h */
 struct rb_iseq_struct {
     VALUE flags;
-    struct iseq_compile_data *compile_data; /* used at compile time */
+    struct iseq_compile_data *compile_data_; /* used at compile time */
     struct rb_iseq_constant_body *body;
     struct rb_iseq_variable_body *variable_body;
     VALUE dummy2;
Index: iseq.c
===================================================================
--- iseq.c	(revision 52857)
+++ iseq.c	(revision 52858)
@@ -91,7 +91,7 @@ rb_iseq_free(const rb_iseq_t *iseq) https://github.com/ruby/ruby/blob/trunk/iseq.c#L91
 	    ruby_xfree((void *)iseq->body->param.keyword->default_values);
 	    ruby_xfree((void *)iseq->body->param.keyword);
 	}
-	compile_data_free(iseq->compile_data);
+	compile_data_free(ISEQ_COMPILE_DATA(iseq));
 	ruby_xfree(iseq->variable_body->iseq);
 	ruby_xfree(iseq->variable_body);
 	ruby_xfree(iseq->body);
@@ -120,8 +120,8 @@ rb_iseq_mark(const rb_iseq_t *iseq) https://github.com/ruby/ruby/blob/trunk/iseq.c#L120
 	RUBY_MARK_UNLESS_NULL(iseq->variable_body->coverage);
     }
 
-    if (iseq->compile_data != 0) {
-	const struct iseq_compile_data *const compile_data = iseq->compile_data;
+    if (ISEQ_COMPILE_DATA(iseq) != 0) {
+	const struct iseq_compile_data *const compile_data = ISEQ_COMPILE_DATA(iseq);
 
 	RUBY_MARK_UNLESS_NULL(compile_data->mark_ary);
 	RUBY_MARK_UNLESS_NULL(compile_data->err_info);
@@ -199,7 +199,7 @@ iseq_memsize(const rb_iseq_t *iseq) https://github.com/ruby/ruby/blob/trunk/iseq.c#L199
 	}
     }
 
-    compile_data = iseq->compile_data;
+    compile_data = ISEQ_COMPILE_DATA(iseq);
     if (compile_data) {
 	struct iseq_compile_data_storage *cur;
 
@@ -294,22 +294,22 @@ prepare_iseq_build(rb_iseq_t *iseq, https://github.com/ruby/ruby/blob/trunk/iseq.c#L294
     }
     RB_OBJ_WRITE(iseq, &iseq->body->mark_ary, 0);
 
-    iseq->compile_data = ZALLOC(struct iseq_compile_data);
-    RB_OBJ_WRITE(iseq, &iseq->compile_data->err_info, Qnil);
-    RB_OBJ_WRITE(iseq, &iseq->compile_data->mark_ary, rb_ary_tmp_new(3));
+    ISEQ_COMPILE_DATA(iseq) = ZALLOC(struct iseq_compile_data);
+    RB_OBJ_WRITE(iseq, &ISEQ_COMPILE_DATA(iseq)->err_info, Qnil);
+    RB_OBJ_WRITE(iseq, &ISEQ_COMPILE_DATA(iseq)->mark_ary, rb_ary_tmp_new(3));
 
-    iseq->compile_data->storage_head = iseq->compile_data->storage_current =
+    ISEQ_COMPILE_DATA(iseq)->storage_head = ISEQ_COMPILE_DATA(iseq)->storage_current =
       (struct iseq_compile_data_storage *)
 	ALLOC_N(char, INITIAL_ISEQ_COMPILE_DATA_STORAGE_BUFF_SIZE +
 		SIZEOF_ISEQ_COMPILE_DATA_STORAGE);
 
-    RB_OBJ_WRITE(iseq, &iseq->compile_data->catch_table_ary, rb_ary_tmp_new(3));
-    iseq->compile_data->storage_head->pos = 0;
-    iseq->compile_data->storage_head->next = 0;
-    iseq->compile_data->storage_head->size =
+    RB_OBJ_WRITE(iseq, &ISEQ_COMPILE_DATA(iseq)->catch_table_ary, rb_ary_tmp_new(3));
+    ISEQ_COMPILE_DATA(iseq)->storage_head->pos = 0;
+    ISEQ_COMPILE_DATA(iseq)->storage_head->next = 0;
+    ISEQ_COMPILE_DATA(iseq)->storage_head->size =
       INITIAL_ISEQ_COMPILE_DATA_STORAGE_BUFF_SIZE;
-    iseq->compile_data->option = option;
-    iseq->compile_data->last_coverable_line = -1;
+    ISEQ_COMPILE_DATA(iseq)->option = option;
+    ISEQ_COMPILE_DATA(iseq)->last_coverable_line = -1;
 
     RB_OBJ_WRITE(iseq, &iseq->variable_body->coverage, Qfalse);
 
@@ -327,9 +327,9 @@ prepare_iseq_build(rb_iseq_t *iseq, https://github.com/ruby/ruby/blob/trunk/iseq.c#L327
 static VALUE
 cleanup_iseq_build(rb_iseq_t *iseq)
 {
-    struct iseq_compile_data *data = iseq->compile_data;
+    struct iseq_compile_data *data = ISEQ_COMPILE_DATA(iseq);
     VALUE err = data->err_info;
-    iseq->compile_data = 0;
+    ISEQ_COMPILE_DATA(iseq) = 0;
     compile_data_free(data);
 
     if (RTEST(err)) {
Index: iseq.h
===================================================================
--- iseq.h	(revision 52857)
+++ iseq.h	(revision 52858)
@@ -23,6 +23,8 @@ rb_call_info_kw_arg_bytes(int keyword_le https://github.com/ruby/ruby/blob/trunk/iseq.h#L23
     return sizeof(struct rb_call_info_kw_arg) + sizeof(VALUE) * (keyword_len - 1);
 }
 
+#define ISEQ_COMPILE_DATA(iseq) (iseq)->compile_data_
+
 RUBY_SYMBOL_EXPORT_BEGIN
 
 /* compile.c */
Index: compile.c
===================================================================
--- compile.c	(revision 52857)
+++ compile.c	(revision 52858)
@@ -101,7 +101,7 @@ struct iseq_compile_data_ensure_node_sta https://github.com/ruby/ruby/blob/trunk/compile.c#L101
 #if CPDEBUG >= 0
 #define compile_debug CPDEBUG
 #else
-#define compile_debug iseq->compile_data->option->debug_level
+#define compile_debug ISEQ_COMPILE_DATA(iseq)->option->debug_level
 #endif
 
 #if CPDEBUG
@@ -232,12 +232,12 @@ r_value(VALUE value) https://github.com/ruby/ruby/blob/trunk/compile.c#L232
 #define ADD_TRACE(seq, line, event) \
   do { \
       if ((event) == RUBY_EVENT_LINE && iseq->variable_body->coverage && \
-	  (line) != iseq->compile_data->last_coverable_line) { \
+	  (line) != ISEQ_COMPILE_DATA(iseq)->last_coverable_line) { \
 	  RARRAY_ASET(iseq->variable_body->coverage, (line) - 1, INT2FIX(0)); \
-	  iseq->compile_data->last_coverable_line = (line); \
+	  ISEQ_COMPILE_DATA(iseq)->last_coverable_line = (line); \
 	  ADD_INSN1((seq), (line), trace, INT2FIX(RUBY_EVENT_COVERAGE)); \
       } \
-      if (iseq->compile_data->option->trace_instruction) { \
+      if (ISEQ_COMPILE_DATA(iseq)->option->trace_instruction) { \
 	  ADD_INSN1((seq), (line), trace, INT2FIX(event)); \
       } \
   } while (0)
@@ -262,7 +262,7 @@ r_value(VALUE value) https://github.com/ruby/ruby/blob/trunk/compile.c#L262
     if (ls) LABEL_REF(ls);							\
     if (le) LABEL_REF(le);							\
     if (lc) LABEL_REF(lc);							\
-    rb_ary_push(iseq->compile_data->catch_table_ary, freeze_hide_obj(_e));	\
+    rb_ary_push(ISEQ_COMPILE_DATA(iseq)->catch_table_ary, freeze_hide_obj(_e));	\
 } while (0)
 
 /* compile node */
@@ -297,9 +297,9 @@ do { https://github.com/ruby/ruby/blob/trunk/compile.c#L297
   rb_thread_t *th = GET_THREAD();                  \
   VALUE tmp = th->errinfo;                         \
   if (compile_debug) rb_compile_bug strs;          \
-  th->errinfo = iseq->compile_data->err_info;      \
+  th->errinfo = ISEQ_COMPILE_DATA(iseq)->err_info;      \
   rb_compile_error strs;                           \
-  RB_OBJ_WRITE(iseq, &iseq->compile_data->err_info, th->errinfo); \
+  RB_OBJ_WRITE(iseq, &ISEQ_COMPILE_DATA(iseq)->err_info, th->errinfo); \
   th->errinfo = tmp;                               \
 } while (0)
 
@@ -364,7 +364,7 @@ freeze_hide_obj(VALUE obj) https://github.com/ruby/ruby/blob/trunk/compile.c#L364
 #endif
 
 #if CPDEBUG
-#define gl_node_level iseq->compile_data->node_level
+#define gl_node_level ISEQ_COMPILE_DATA(iseq)->node_level
 #endif
 
 static void dump_disasm_list(LINK_ELEMENT *elem);
@@ -471,7 +471,7 @@ static int https://github.com/ruby/ruby/blob/trunk/compile.c#L471
 iseq_add_mark_object_compile_time(const rb_iseq_t *iseq, VALUE v)
 {
     if (!SPECIAL_CONST_P(v)) {
-	rb_ary_push(iseq->compile_data->mark_ary, v);
+	rb_ary_push(ISEQ_COMPILE_DATA(iseq)->mark_ary, v);
     }
     return COMPILE_OK;
 }
@@ -496,8 +496,8 @@ validate_labels(rb_iseq_t *iseq, st_tabl https://github.com/ruby/ruby/blob/trunk/compile.c#L496
 {
     st_foreach(labels_table, validate_label, (st_data_t)iseq);
     st_free_table(labels_table);
-    if (!NIL_P(iseq->compile_data->err_info)) {
-	rb_exc_raise(iseq->compile_data->err_info);
+    if (!NIL_P(ISEQ_COMPILE_DATA(iseq)->err_info)) {
+	rb_exc_raise(ISEQ_COMPILE_DATA(iseq)->err_info);
     }
 }
 
@@ -519,8 +519,8 @@ rb_iseq_compile_node(rb_iseq_t *iseq, NO https://github.com/ruby/ruby/blob/trunk/compile.c#L519
 	switch (iseq->body->type) {
 	  case ISEQ_TYPE_BLOCK:
 	    {
-		LABEL *start = iseq->compile_data->start_label = NEW_LABEL(0);
-		LABEL *end = iseq->compile_data->end_label = NEW_LABEL(0);
+		LABEL *start = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(0);
+		LABEL *end = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(0);
 
 		ADD_TRACE(ret, FIX2INT(iseq->body->location.first_lineno), RUBY_EVENT_B_CALL);
 		ADD_LABEL(ret, start);
@@ -591,13 +591,13 @@ rb_iseq_compile_node(rb_iseq_t *iseq, NO https://github.com/ruby/ruby/blob/trunk/compile.c#L591
 	ADD_INSN1(ret, 0, throw, INT2FIX(0) /* continue throw */ );
     }
     else {
-	ADD_INSN(ret, iseq->compile_data->last_line, leave);
+	ADD_INSN(ret, ISEQ_COMPILE_DATA(iseq)->last_line, leave);
     }
 
 #if SUPPORT_JOKE
-    if (iseq->compile_data->labels_table) {
-	st_table *labels_table = iseq->compile_data->labels_table;
-	iseq->compile_data->labels_table = 0;
+    if (ISEQ_COMPILE_DATA(iseq)->labels_table) {
+	st_table *labels_table = ISEQ_COMPILE_DATA(iseq)->labels_table;
+	ISEQ_COMPILE_DATA(iseq)->labels_table = 0;
 	validate_labels(iseq, labels_table);
     }
 #endif
@@ -721,7 +721,7 @@ compile_data_alloc(rb_iseq_t *iseq, size https://github.com/ruby/ruby/blob/trunk/compile.c#L721
 {
     void *ptr = 0;
     struct iseq_compile_data_storage *storage =
-	iseq->compile_data->storage_current;
+	ISEQ_COMPILE_DATA(iseq)->storage_current;
 #ifdef STRICT_ALIGNMENT
     size_t padding = calc_padding((void *)&storage->buff[storage->pos], size);
 #else
@@ -738,7 +738,7 @@ compile_data_alloc(rb_iseq_t *iseq, size https://github.com/ruby/ruby/blob/trunk/compile.c#L738
 	}
 	storage->next = (void *)ALLOC_N(char, alloc_size +
 					SIZEOF_ISEQ_COMPILE_DATA_STORAGE);
-	storage = iseq->compile_data->storage_current = storage->next;
+	storage = ISEQ_COMPILE_DATA(iseq)->storage_current = storage->next;
 	storage->next = 0;
 	storage->pos = 0;
 	storage->size = alloc_size;
@@ -944,7 +944,7 @@ new_label_body(rb_iseq_t *iseq, long lin https://github.com/ruby/ruby/blob/trunk/compile.c#L944
     labelobj->link.type = ISEQ_ELEMENT_LABEL;
     labelobj->link.next = 0;
 
-    labelobj->label_no = iseq->compile_data->label_no++;
+    labelobj->label_no = ISEQ_COMPILE_DATA(iseq)->label_no++;
     labelobj->sc_state = 0;
     labelobj->sp = -1;
     labelobj->refcnt = 0;
@@ -1044,7 +1044,7 @@ new_child_iseq(rb_iseq_t *iseq, NODE *no https://github.com/ruby/ruby/blob/trunk/compile.c#L1044
     debugs("[new_child_iseq]> ---------------------------------------\n");
     ret_iseq = rb_iseq_new_with_opt(node, name,
 				    iseq_path(iseq), iseq_absolute_path(iseq),
-				    INT2FIX(line_no), parent, type, iseq->compile_data->option);
+				    INT2FIX(line_no), parent, type, ISEQ_COMPILE_DATA(iseq)->option);
     debugs("[new_child_iseq]< ---------------------------------------\n");
     iseq_add_mark_object(iseq, (VALUE)ret_iseq);
     return ret_iseq;
@@ -1064,14 +1064,14 @@ iseq_setup(rb_iseq_t *iseq, LINK_ANCHOR https://github.com/ruby/ruby/blob/trunk/compile.c#L1064
     if (compile_debug > 5)
 	dump_disasm_list(FIRST_ELEMENT(anchor));
 
-    if (iseq->compile_data->option->instructions_unification) {
+    if (ISEQ_COMPILE_DATA(iseq)->option->instructions_unification) {
 	debugs("[compile step 3.2 (iseq_insns_unification)]\n");
 	iseq_insns_unification(iseq, anchor);
 	if (compile_debug > 5)
 	    dump_disasm_list(FIRST_ELEMENT(anchor));
     }
 
-    if (iseq->compile_data->option->stack_caching) {
+    if (ISEQ_COMPILE_DATA(iseq)->option->stack_caching) {
 	debugs("[compile step 3.3 (iseq_set_sequence_stackcaching)]\n");
 	iseq_set_sequence_stackcaching(iseq, anchor);
 	if (compile_debug > 5)
@@ -1544,7 +1544,7 @@ iseq_set_sequence(rb_iseq_t *iseq, LINK_ https://github.com/ruby/ruby/blob/trunk/compile.c#L1544
 								 sizeof(struct rb_call_info_with_kwarg) * iseq->body->ci_kw_size);
     iseq->body->cc_entries = ZALLOC_N(struct rb_call_cache, iseq->body->ci_size + iseq->body->ci_kw_size);
 
-    iseq->compile_data->ci_index = iseq->compile_data->ci_kw_index = 0;
+    ISEQ_COMPILE_DATA(iseq)->ci_index = ISEQ_COMPILE_DATA(iseq)->ci_kw_index = 0;
 
     list = FIRST_ELEMENT(anchor);
     line_info_index = code_index = sp = 0;
@@ -1650,15 +1650,15 @@ iseq_set_sequence(rb_iseq_t *iseq, LINK_ https://github.com/ruby/ruby/blob/trunk/compile.c#L1650
 
 			    if (base_ci->flag & VM_CALL_KWARG) {
 				struct rb_call_info_with_kwarg *ci_kw_entries = (struct rb_call_info_with_kwarg *)&iseq->body->ci_entries[iseq->body->ci_size];
-				struct rb_call_info_with_kwarg *ci_kw = &ci_kw_entries[iseq->compile_data->ci_kw_index++];
+				struct rb_call_info_with_kwarg *ci_kw = &ci_kw_entries[ISEQ_COMPILE_DATA(iseq)->ci_kw_index++];
 				*ci_kw = *((struct rb_call_info_with_kwarg *)base_ci);
 				ci = (struct rb_call_info *)ci_kw;
-				assert(iseq->compile_data->ci_kw_index <= iseq->body->ci_kw_size);
+				assert(ISEQ_COMPILE_DATA(iseq)->ci_kw_index <= iseq->body->ci_kw_size);
 			    }
 			    else {
-				ci = &iseq->body->ci_entries[iseq->compile_data->ci_index++];
+				ci = &iseq->body->ci_entries[ISEQ_COMPILE_DATA(iseq)->ci_index++];
 				*ci = *base_ci;
-				assert(iseq->compile_data->ci_index <= iseq->body->ci_size);
+				assert(ISEQ_COMPILE_DATA(iseq)->ci_index <= iseq->body->ci_size);
 			    }
 
 			    generated_iseq[code_index + 1 + j] = (VALUE)ci;
@@ -1666,7 +1666,7 @@ iseq_set_sequence(rb_iseq_t *iseq, LINK_ https://github.com/ruby/ruby/blob/trunk/compile.c#L1666
 			}
 		      case TS_CALLCACHE:
 			{
-			    struct rb_call_cache *cc = &iseq->body->cc_entries[iseq->compile_data->ci_index + iseq->compile_data->ci_kw_index - 1];
+			    struct rb_call_cache *cc = &iseq->body->cc_entries[ISEQ_COMPILE_DATA(iseq)->ci_index + ISEQ_COMPILE_DATA(iseq)->ci_kw_index - 1];
 			    generated_iseq[code_index + 1 + j] = (VALUE)cc;
 			    break;
 			}
@@ -1786,8 +1786,8 @@ iseq_set_exception_table(rb_iseq_t *iseq https://github.com/ruby/ruby/blob/trunk/compile.c#L1786
     unsigned int tlen, i;
     struct iseq_catch_table_entry *entry;
 
-    tlen = (int)RARRAY_LEN(iseq->compile_data->catch_table_ary);
-    tptr = RARRAY_CONST_PTR(iseq->compile_data->catch_table_ary);
+    tlen = (int)RARRAY_LEN(ISEQ_COMPILE_DATA(iseq)->catch_table_ary);
+    tptr = RARRAY_CONST_PTR(ISEQ_COMPILE_DATA(iseq)->catch_table_ary);
 
     if (tlen > 0) {
 	struct iseq_catch_table *table = xmalloc(iseq_catch_table_bytes(tlen));
@@ -1824,7 +1824,7 @@ iseq_set_exception_table(rb_iseq_t *iseq https://github.com/ruby/ruby/blob/trunk/compile.c#L1824
 	    }
 	}
 	iseq->body->catch_table = table;
-	RB_OBJ_WRITE(iseq, &iseq->compile_data->catch_table_ary, 0); /* free */
+	RB_OBJ_WRITE(iseq, &ISEQ_COMPILE_DATA(iseq)->catch_table_ary, 0); /* free */
     }
     else {
 	iseq->body->catch_table = NULL;
@@ -2283,10 +2283,10 @@ static int https://github.com/ruby/ruby/blob/trunk/compile.c#L2283
 iseq_optimize(rb_iseq_t *iseq, LINK_ANCHOR *anchor)
 {
     LINK_ELEMENT *list;
-    const int do_peepholeopt = iseq->compile_data->option->peephole_optimization;
-    const int do_tailcallopt = iseq->compile_data->option->tailcall_optimization;
-    const int do_si = iseq->compile_data->option->specialized_instruction;
-    const int do_ou = iseq->compile_data->option->operands_unification;
+    const int do_peepholeopt = ISEQ_COMPILE_DATA(iseq)->option->peephole_optimization;
+    const int do_tailcallopt = ISEQ_COMPILE_DATA(iseq)->option->tailcall_optimization;
+    const int do_si = ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction;
+    const int do_ou = ISEQ_COMPILE_DATA(iseq)->option->operands_unification;
     list = FIRST_ELEMENT(anchor);
 
     while (list) {
@@ -3429,9 +3429,9 @@ push_ensure_entry(rb_iseq_t *iseq, https://github.com/ruby/ruby/blob/trunk/compile.c#L3429
 		  struct ensure_range *er, NODE *node)
 {
     enl->ensure_node = node;
-    enl->prev = iseq->compile_data->ensure_node_stack;	/* prev */
+    enl->prev = ISEQ_COMPILE_DATA(iseq)->ensure_node_stack;	/* prev */
     enl->erange = er;
-    iseq->compile_data->ensure_node_stack = enl;
+    ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enl;
 }
 
 static void
@@ -3456,7 +3456,7 @@ static void https://github.com/ruby/ruby/blob/trunk/compile.c#L3456
 add_ensure_iseq(LINK_ANCHOR *ret, rb_iseq_t *iseq, int is_return)
 {
     struct iseq_compile_data_ensure_node_stack *enlp =
-	iseq->compile_data->ensure_node_stack;
+	ISEQ_COMPILE_DATA(iseq)->ensure_node_stack;
     struct iseq_compile_data_ensure_node_stack *prev_enlp = enlp;
     DECL_ANCHOR(ensure);
 
@@ -3470,7 +3470,7 @@ add_ensure_iseq(LINK_ANCHOR *ret, rb_ise https://github.com/ruby/ruby/blob/trunk/compile.c#L3470
 
 	    add_ensure_range(iseq, enlp->erange, lstart, lend);
 
-	    iseq->compile_data->ensure_node_stack = enlp->prev;
+	    ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = enlp->prev;
 	    ADD_LABEL(ensure_part, lstart);
 	    COMPILE_POPED(ensure_part, "ensure part", enlp->ensure_node);
 	    ADD_LABEL(ensure_part, lend);
@@ -3483,7 +3483,7 @@ add_ensure_iseq(LINK_ANCHOR *ret, rb_ise https://github.com/ruby/ruby/blob/trunk/compile.c#L3483
 	}
 	enlp = enlp->prev;
     }
-    iseq->compile_data->ensure_node_stack = prev_enlp;
+    ISEQ_COMPILE_DATA(iseq)->ensure_node_stack = prev_enlp;
     ADD_SEQ(ret, ensure);
 }
 
@@ -3598,19 +3598,19 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_ https://github.com/ruby/ruby/blob/trunk/compile.c#L3598
     if (node == 0) {
 	if (!poped) {
 	    debugs("node: NODE_NIL(implicit)\n");
-	    ADD_INSN(ret, iseq->compile_data->last_line, putnil);
+	    ADD_INSN(ret, ISEQ_COMPILE_DATA(iseq)->last_line, putnil);
 	}
 	return COMPILE_OK;
     }
 
     line = (int)nd_line(node);
 
-    if (iseq->compile_data->last_line == line) {
+    if (ISEQ_COMPILE_DATA(iseq)->last_line == line) {
 	/* ignore */
     }
     else {
 	if (node->flags & NODE_FL_NEWLINE) {
-	    iseq->compile_data->last_line = line;
+	    ISEQ_COMPILE_DATA(iseq)->last_line = line;
 	    ADD_TRACE(ret, line, RUBY_EVENT_LINE);
 	    saved_last_element = ret->last;
 	}
@@ -3823,23 +3823,23 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_ https://github.com/ruby/ruby/blob/trunk/compile.c#L3823
       case NODE_OPT_N:
       case NODE_WHILE:
       case NODE_UNTIL:{
-	LABEL *prev_start_label = iseq->compile_data->start_label;
-	LABEL *prev_end_label = iseq->compile_data->end_label;
-	LABEL *prev_redo_label = iseq->compile_data->redo_label;
-	int prev_loopval_popped = iseq->compile_data->loopval_popped;
+	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;
+	int prev_loopval_popped = ISEQ_COMPILE_DATA(iseq)->loopval_popped;
 
 	struct iseq_compile_data_ensure_node_stack enl;
 
-	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 *next_label = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(line);	/* next  */
+	LABEL *redo_label = ISEQ_COMPILE_DATA(iseq)->redo_label = NEW_LABEL(line);	/* redo  */
+	LABEL *break_label = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(line);	/* break */
 	LABEL *end_label = NEW_LABEL(line);
 	LABEL *adjust_label = NEW_LABEL(line);
 
 	LABEL *next_catch_label = NEW_LABEL(line);
 (... truncated)

--
ML: ruby-changes@q...
Info: http://www.atdot.net/~ko1/quickml/

[前][次][番号順一覧][スレッド一覧]