ruby-core

Hi,

the attached patch adds the function rb_iterate_proc() to eval.c (latest  
stable).

It works like rb_iterate(), but takes a Proc object instead of bl_proc and  
data2. It allows to call methods like instance_eval and define_method with  
a block argument from a C extension.

Could this please be applied for Ruby 1.8.5 (and also 1.9). It has been  
requested at least three times on ruby-talk recently and it would be very  
useful for my Ruby2CExtension project.

Dominik

Attachments (1)

rb_iterate_proc.patch (4.1 KB, text/x-diff)

diff -ruw ruby_stable_20060619/eval.c ruby_stable_it_proc/eval.c
--- ruby_stable_20060619/eval.c	2006-06-07 02:19:11.000000000 +0200
+++ ruby_stable_it_proc/eval.c	2006-06-19 02:16:37.000000000 +0200
@@ -5284,6 +5284,87 @@
     return retval;
 }
 
+static void proc_set_safe_level _((VALUE));
+static int block_orphan _((struct BLOCK*));
+static VALUE block_pass_proc_check _((VALUE));
+
+VALUE
+rb_iterate_proc(it_proc, data1, proc)
+    VALUE (*it_proc) _((VALUE));
+    VALUE data1, proc;
+{
+    struct BLOCK * volatile old_block;
+    struct BLOCK _block;
+    struct BLOCK *data;
+    int state;
+    volatile VALUE retval = Qnil;
+    volatile int orphan;
+    volatile int safe = ruby_safe_level;
+
+    if (NIL_P(proc)) {
+	PUSH_ITER(ITER_NOT);
+	retval = (*it_proc)(data1);
+	POP_ITER();
+	return retval;
+    }
+
+    proc = block_pass_proc_check(proc);
+
+    if (ruby_block && ruby_block->block_obj == proc) {
+	PUSH_ITER(ITER_PAS);
+	retval = (*it_proc)(data1);
+	POP_ITER();
+	return retval;
+    }
+
+    Data_Get_Struct(proc, struct BLOCK, data);
+    orphan = block_orphan(data);
+
+    /* PUSH BLOCK from data */
+    old_block = ruby_block;
+    _block = *data;
+    _block.outer = ruby_block;
+    if (orphan) _block.uniq = block_unique++;
+    ruby_block = &_block;
+    PUSH_ITER(ITER_PRE);
+    if (ruby_frame->iter == ITER_NOT)
+	ruby_frame->iter = ITER_PRE;
+
+    PUSH_TAG(PROT_LOOP);
+    state = EXEC_TAG();
+    if (state == 0) {
+  iter_retry:
+	proc_set_safe_level(proc);
+	if (safe > ruby_safe_level)
+	    ruby_safe_level = safe;
+	retval = (*it_proc)(data1);
+    }
+    else if (state == TAG_BREAK && TAG_DST()) {
+	retval = prot_tag->retval;
+	state = 0;
+    }
+    else if (state == TAG_RETRY) {
+	state = 0;
+	goto iter_retry;
+    }
+    POP_TAG();
+    POP_ITER();
+    ruby_block = old_block;
+    ruby_safe_level = safe;
+
+    switch (state) {/* escape from orphan block */
+      case 0:
+	break;
+      case TAG_RETURN:
+	if (orphan) {
+	    proc_jump_error(state, prot_tag->retval);
+	}
+      default:
+	JUMP_TAG(state);
+    }
+    return retval;
+}
+
 static int
 handle_rescue(self, node)
     VALUE self;
@@ -8722,12 +8803,33 @@
 }
 
 static VALUE
+block_pass_proc_check(proc)
+    VALUE proc;
+{
+    VALUE b;
+    if (!rb_obj_is_proc(proc)) {
+	b = rb_check_convert_type(proc, T_DATA, "Proc", "to_proc");
+	if (!rb_obj_is_proc(b)) {
+	    rb_raise(rb_eTypeError, "wrong argument type %s (expected Proc)",
+		     rb_obj_classname(proc));
+	}
+	proc = b;
+    }
+
+    if (ruby_safe_level >= 1 && OBJ_TAINTED(proc) &&
+	ruby_safe_level > proc_get_safe_level(proc)) {
+	rb_raise(rb_eSecurityError, "Insecure: tainted block value");
+    }
+
+    return proc;
+}
+
+static VALUE
 block_pass(self, node)
     VALUE self;
     NODE *node;
 {
     VALUE proc = rb_eval(self, node->nd_body);	/* OK */
-    VALUE b;
     struct BLOCK * volatile old_block;
     struct BLOCK _block;
     struct BLOCK *data;
@@ -8742,19 +8844,8 @@
 	POP_ITER();
 	return result;
     }
-    if (!rb_obj_is_proc(proc)) {
-	b = rb_check_convert_type(proc, T_DATA, "Proc", "to_proc");
-	if (!rb_obj_is_proc(b)) {
-	    rb_raise(rb_eTypeError, "wrong argument type %s (expected Proc)",
-		     rb_obj_classname(proc));
-	}
-	proc = b;
-    }
 
-    if (ruby_safe_level >= 1 && OBJ_TAINTED(proc) &&
-	ruby_safe_level > proc_get_safe_level(proc)) {
-	rb_raise(rb_eSecurityError, "Insecure: tainted block value");
-    }
+    proc = block_pass_proc_check(proc);
 
     if (ruby_block && ruby_block->block_obj == proc) {
 	PUSH_ITER(ITER_PAS);
diff -ruw ruby_stable_20060619/ruby.h ruby_stable_it_proc/ruby.h
--- ruby_stable_20060619/ruby.h	2006-06-14 16:10:39.000000000 +0200
+++ ruby_stable_it_proc/ruby.h	2006-06-19 01:55:51.000000000 +0200
@@ -557,6 +557,7 @@
 int rb_block_given_p _((void));
 void rb_need_block _((void));
 VALUE rb_iterate _((VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE));
+VALUE rb_iterate_proc _((VALUE(*)(VALUE),VALUE,VALUE));
 VALUE rb_rescue _((VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE));
 VALUE rb_rescue2 __((VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...));
 VALUE rb_ensure _((VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE));

Thread

Prev Next

In This Thread

Prev Next