* numeric.c (num_step): better iteration condition for float

matz · matz · commit 4fa0cdea7838 · 2002-05-01T09:41:50.000Z
values;  suggested by Masahiro TANAKA &lt;masa@ir.isas.ac.jp&gt;.

* range.c (range_step): step (for Range#step method) &lt;= 0 makes no
  sence, thus ArgError will be raised.

* range.c (range_each): Range#each method is special case for
  Range#step(1)

* file.c (rb_find_file): load must be done from an abolute path if
  $SAFE &gt;= 4.

* enum.c (enum_partition): new method. [new]

* re.c (rb_reg_s_quote): quote whitespaces for /x cases.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2420 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
diff --git a/ChangeLog b/ChangeLog
@@ -1,7 +1,33 @@
+Tue Apr 30 09:23:05 2002  Yukihiro Matsumoto  <matz@ruby-lang.org>
+
+	* numeric.c (num_step): better iteration condition for float
+	  values;  suggested by Masahiro TANAKA <masa@ir.isas.ac.jp>.
+
+Tue Apr 30 05:59:42 2002  Michal Rokos  <m.rokos@sh.cvut.cz>
+
+	* range.c (range_step): step (for Range#step method) <= 0 makes no
+	  sence, thus ArgError will be raised.
+
+	* range.c (range_each): Range#each method is special case for
+	  Range#step(1)
+
+Mon Apr 29 18:46:42 2002  Yukihiro Matsumoto  <matz@ruby-lang.org>
+
+	* file.c (rb_find_file): load must be done from an abolute path if
+	  $SAFE >= 4.
+
 Sun Apr 28 17:01:56 2002  WATANABE Hirofumi  <eban@ruby-lang.org>
 
 	* win32/win32.c (insert): fix prototype for ANSI C.
 
+Fri Apr 26 13:47:15 2002  Yukihiro Matsumoto  <matz@ruby-lang.org>
+
+	* enum.c (enum_partition): new method. [new]
+
+Fri Apr 26 13:41:00 2002  Yukihiro Matsumoto  <matz@ruby-lang.org>
+
+	* re.c (rb_reg_s_quote): quote whitespaces for /x cases.
+
 Fri Apr 26 06:48:23 2002  Takaaki Tateishi <ttate@kt.jaist.ac.jp>
 
 	* ext/dl/ptr.c (cary2ary): missing break in switch statements.
diff --git a/enum.c b/enum.c
@@ -216,6 +216,32 @@ enum_inject(argc, argv, obj)
     return n;
 }
 
+static VALUE
+partition_i(i, ary)
+    VALUE i, *ary;
+{
+    if (RTEST(rb_yield(i))) {
+	rb_ary_push(ary[0], i);
+    }
+    else {
+	rb_ary_push(ary[1], i);
+    }
+    return Qnil;
+}
+
+static VALUE
+enum_partition(obj)
+    VALUE obj;
+{
+    VALUE ary[2];
+
+    ary[0] = rb_ary_new();
+    ary[1]  =  rb_ary_new();
+    rb_iterate(rb_each, obj, partition_i, (VALUE)ary);
+
+    return rb_assoc_new(ary[0], ary[1]);
+}
+
 static VALUE
 enum_sort(obj)
     VALUE obj;
@@ -475,6 +501,7 @@ Init_Enumerable()
     rb_define_method(rb_mEnumerable,"collect", enum_collect, 0);
     rb_define_method(rb_mEnumerable,"map", enum_collect, 0);
     rb_define_method(rb_mEnumerable,"inject", enum_inject, -1);
+    rb_define_method(rb_mEnumerable,"partition", enum_partition, 0);
     rb_define_method(rb_mEnumerable,"all?", enum_all, 0);
     rb_define_method(rb_mEnumerable,"any?", enum_any, 0);
     rb_define_method(rb_mEnumerable,"min", enum_min, 0);
diff --git a/eval.c b/eval.c
@@ -227,7 +227,7 @@ rb_add_method(klass, mid, node, noex)
     NODE *body;
 
     if (NIL_P(klass)) klass = rb_cObject;
-    if (rb_safe_level() >= 4 && (klass == rb_cObject || !OBJ_TAINTED(klass))) {
+    if (ruby_safe_level >= 4 && (klass == rb_cObject || !OBJ_TAINTED(klass))) {
 	rb_raise(rb_eSecurityError, "Insecure: can't define method");
     }
     if (OBJ_FROZEN(klass)) rb_error_frozen("class/module");
@@ -310,7 +310,7 @@ remove_method(klass, mid)
     if (klass == rb_cObject) {
 	rb_secure(4);
     }
-    if (rb_safe_level() >= 4 && !OBJ_TAINTED(klass)) {
+    if (ruby_safe_level >= 4 && !OBJ_TAINTED(klass)) {
 	rb_raise(rb_eSecurityError, "Insecure: can't remove method");
     }
     if (OBJ_FROZEN(klass)) rb_error_frozen("class/module");
@@ -1588,7 +1588,7 @@ rb_undef(klass, id)
     if (ruby_class == rb_cObject) {
 	rb_secure(4);
     }
-    if (rb_safe_level() >= 4 && !OBJ_TAINTED(klass)) {
+    if (ruby_safe_level >= 4 && !OBJ_TAINTED(klass)) {
 	rb_raise(rb_eSecurityError, "Insecure: can't undef");
 	if (id == __id__ || id == __send__ || id == init) {
 	    rb_name_error(id, "undefining `%s' prohibited", rb_id2name(id));
@@ -3166,7 +3166,7 @@ rb_eval(self, n)
 	    VALUE klass;
 	    NODE *body = 0, *defn;
 
-	    if (rb_safe_level() >= 4 && !OBJ_TAINTED(recv)) {
+	    if (ruby_safe_level >= 4 && !OBJ_TAINTED(recv)) {
 		rb_raise(rb_eSecurityError, "Insecure: can't define singleton method");
 	    }
 	    if (FIXNUM_P(recv) || SYMBOL_P(recv)) {
@@ -3179,7 +3179,7 @@ rb_eval(self, n)
 	    if (OBJ_FROZEN(recv)) rb_error_frozen("object");
 	    klass = rb_singleton_class(recv);
 	    if (st_lookup(RCLASS(klass)->m_tbl, node->nd_mid, &body)) {
-		if (rb_safe_level() >= 4) {
+		if (ruby_safe_level >= 4) {
 		    rb_raise(rb_eSecurityError, "redefining method prohibited");
 		}
 		if (RTEST(ruby_verbose)) {
@@ -3248,7 +3248,7 @@ rb_eval(self, n)
 			goto override_class;
 		    }
 		}
-		if (rb_safe_level() >= 4) {
+		if (ruby_safe_level >= 4) {
 		    rb_raise(rb_eSecurityError, "extending class prohibited");
 		}
 	    }
@@ -3288,7 +3288,7 @@ rb_eval(self, n)
 		    rb_raise(rb_eTypeError, "%s is not a module",
 			     rb_id2name(node->nd_cname));
 		}
-		if (rb_safe_level() >= 4) {
+		if (ruby_safe_level >= 4) {
 		    rb_raise(rb_eSecurityError, "extending module prohibited");
 		}
 	    }
@@ -3315,7 +3315,7 @@ rb_eval(self, n)
 		rb_raise(rb_eTypeError, "no virtual class for %s",
 			 rb_class2name(CLASS_OF(result)));
 	    }
-	    if (rb_safe_level() >= 4 && !OBJ_TAINTED(result))
+	    if (ruby_safe_level >= 4 && !OBJ_TAINTED(result))
 		rb_raise(rb_eSecurityError, "Insecure: can't extend object");
 	    klass = rb_singleton_class(result);
 	    
@@ -5603,7 +5603,7 @@ static void
 secure_visibility(self)
     VALUE self;
 {
-    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+    if (ruby_safe_level >= 4 && !OBJ_TAINTED(self)) {
 	rb_raise(rb_eSecurityError, "Insecure: can't change method visibility");
     }
 }
@@ -6315,15 +6315,15 @@ proc_save_safe_level(data)
     VALUE data;
 {
     if (OBJ_TAINTED(data)) {
-	switch (rb_safe_level()) {
+	switch (ruby_safe_level) {
 	  case 3:
 	    FL_SET(data, PROC_T3);
 	    break;
 	  case 4:
 	    FL_SET(data, PROC_T4);
 	    break;
 	  default:
-	    if (rb_safe_level() > 4) {
+	    if (ruby_safe_level > 4) {
 		FL_SET(data, PROC_TMAX);
 	    }
 	    break;
@@ -6621,8 +6621,8 @@ block_pass(self, node)
 	block = b;
     }
 
-    if (rb_safe_level() >= 1 && OBJ_TAINTED(block)) {
-	if (rb_safe_level() > proc_get_safe_level(block)) {
+    if (ruby_safe_level >= 1 && OBJ_TAINTED(block)) {
+	if (ruby_safe_level > proc_get_safe_level(block)) {
 	    rb_raise(rb_eSecurityError, "Insecure: tainted block value");
 	}
     }
@@ -8316,7 +8316,7 @@ rb_thread_safe_level(thread)
 
     th = rb_thread_check(thread);
     if (th == curr_thread) {
-	return INT2NUM(rb_safe_level());
+	return INT2NUM(ruby_safe_level);
     }
     return INT2NUM(th->safe);
 }
@@ -8859,7 +8859,7 @@ rb_thread_local_aref(thread, id)
     VALUE val;
 
     th = rb_thread_check(thread);
-    if (rb_safe_level() >= 4 && th != curr_thread) {
+    if (ruby_safe_level >= 4 && th != curr_thread) {
 	rb_raise(rb_eSecurityError, "Insecure: thread locals");
     }
     if (!th->locals) return Qnil;
@@ -8884,7 +8884,7 @@ rb_thread_local_aset(thread, id, val)
 {
     rb_thread_t th = rb_thread_check(thread);
 
-    if (rb_safe_level() >= 4 && th != curr_thread) {
+    if (ruby_safe_level >= 4 && th != curr_thread) {
 	rb_raise(rb_eSecurityError, "Insecure: can't modify thread locals");
     }
     if (OBJ_FROZEN(thread)) rb_error_frozen("thread locals");
diff --git a/file.c b/file.c
@@ -2482,6 +2482,10 @@ rb_find_file(path)
 	if (file_load_ok(f)) return path;
     }
 
+    if (rb_safe_level() >= 4) {
+	rb_raise(rb_eSecurityError, "loading from non-absolute path %s", f);
+    }
+
     if (rb_load_path) {
 	int i;
 
diff --git a/numeric.c b/numeric.c
@@ -788,6 +788,7 @@ num_step(argc, argv, from)
 	    while (i <= end) {
 		rb_yield(INT2FIX(i));
 		i += diff;
+		printf("<<%g>>\n", i - end);
 	    }
 	}
 	else {
@@ -798,21 +799,16 @@ num_step(argc, argv, from)
 	}
     }
     else if (TYPE(from) == T_FLOAT || TYPE(to) == T_FLOAT || TYPE(step) == T_FLOAT) {
+	const double epsilon = 2.2204460492503131E-16;
 	double beg = NUM2DBL(from);
 	double end = NUM2DBL(to);
 	double unit = NUM2DBL(step);
-	double n = beg;
-	long i = 0;
+	double n = (end - beg)/unit;
+	long i;
 
-	if (unit > 0) {
-	    for (i=0; n<=end; i++, n=beg+unit*i) {
-		rb_yield(rb_float_new(n));
-	    }
-	}
-	else {
-	    for (i=0; n>=end; i++, n=beg+unit*i) {
-		rb_yield(rb_float_new(n));
-	    }
+	n = floor(n + n*epsilon) + 1;
+	for (i=0; i<n; i++) {
+	    rb_yield(rb_float_new(i*unit+beg));
 	}
     }
     else {
diff --git a/range.c b/range.c
diff --git a/re.c b/re.c

Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ rb_add_method(klass, mid, node, noex)`
`227`	`227`	`NODE *body;`
`228`	`228`
`229`	`229`	`if (NIL_P(klass)) klass = rb_cObject;`
`230`		`- if (rb_safe_level() >= 4 && (klass == rb_cObject \|\| !OBJ_TAINTED(klass))) {`
	`230`	`+ if (ruby_safe_level >= 4 && (klass == rb_cObject \|\| !OBJ_TAINTED(klass))) {`
`231`	`231`	`rb_raise(rb_eSecurityError, "Insecure: can't define method");`
`232`	`232`	`}`
`233`	`233`	`if (OBJ_FROZEN(klass)) rb_error_frozen("class/module");`
`@@ -310,7 +310,7 @@ remove_method(klass, mid)`
`310`	`310`	`if (klass == rb_cObject) {`
`311`	`311`	`rb_secure(4);`
`312`	`312`	`}`
`313`		`- if (rb_safe_level() >= 4 && !OBJ_TAINTED(klass)) {`
	`313`	`+ if (ruby_safe_level >= 4 && !OBJ_TAINTED(klass)) {`
`314`	`314`	`rb_raise(rb_eSecurityError, "Insecure: can't remove method");`
`315`	`315`	`}`
`316`	`316`	`if (OBJ_FROZEN(klass)) rb_error_frozen("class/module");`
`@@ -1588,7 +1588,7 @@ rb_undef(klass, id)`
`1588`	`1588`	`if (ruby_class == rb_cObject) {`
`1589`	`1589`	`rb_secure(4);`
`1590`	`1590`	`}`
`1591`		`- if (rb_safe_level() >= 4 && !OBJ_TAINTED(klass)) {`
	`1591`	`+ if (ruby_safe_level >= 4 && !OBJ_TAINTED(klass)) {`
`1592`	`1592`	`rb_raise(rb_eSecurityError, "Insecure: can't undef");`
`1593`	`1593`	`if (id == __id__ \|\| id == __send__ \|\| id == init) {`
`1594`	`1594`	rb_name_error(id, "undefining `%s' prohibited", rb_id2name(id));
`@@ -3166,7 +3166,7 @@ rb_eval(self, n)`
`3166`	`3166`	`VALUE klass;`
`3167`	`3167`	`NODE body = 0, defn;`
`3168`	`3168`
`3169`		`- if (rb_safe_level() >= 4 && !OBJ_TAINTED(recv)) {`
	`3169`	`+ if (ruby_safe_level >= 4 && !OBJ_TAINTED(recv)) {`
`3170`	`3170`	`rb_raise(rb_eSecurityError, "Insecure: can't define singleton method");`
`3171`	`3171`	`}`
`3172`	`3172`	`if (FIXNUM_P(recv) \|\| SYMBOL_P(recv)) {`
`@@ -3179,7 +3179,7 @@ rb_eval(self, n)`
`3179`	`3179`	`if (OBJ_FROZEN(recv)) rb_error_frozen("object");`
`3180`	`3180`	`klass = rb_singleton_class(recv);`
`3181`	`3181`	`if (st_lookup(RCLASS(klass)->m_tbl, node->nd_mid, &body)) {`
`3182`		`- if (rb_safe_level() >= 4) {`
	`3182`	`+ if (ruby_safe_level >= 4) {`
`3183`	`3183`	`rb_raise(rb_eSecurityError, "redefining method prohibited");`
`3184`	`3184`	`}`
`3185`	`3185`	`if (RTEST(ruby_verbose)) {`
`@@ -3248,7 +3248,7 @@ rb_eval(self, n)`
`3248`	`3248`	`goto override_class;`
`3249`	`3249`	`}`
`3250`	`3250`	`}`
`3251`		`- if (rb_safe_level() >= 4) {`
	`3251`	`+ if (ruby_safe_level >= 4) {`
`3252`	`3252`	`rb_raise(rb_eSecurityError, "extending class prohibited");`
`3253`	`3253`	`}`
`3254`	`3254`	`}`
`@@ -3288,7 +3288,7 @@ rb_eval(self, n)`
`3288`	`3288`	`rb_raise(rb_eTypeError, "%s is not a module",`
`3289`	`3289`	`rb_id2name(node->nd_cname));`
`3290`	`3290`	`}`
`3291`		`- if (rb_safe_level() >= 4) {`
	`3291`	`+ if (ruby_safe_level >= 4) {`
`3292`	`3292`	`rb_raise(rb_eSecurityError, "extending module prohibited");`
`3293`	`3293`	`}`
`3294`	`3294`	`}`
`@@ -3315,7 +3315,7 @@ rb_eval(self, n)`
`3315`	`3315`	`rb_raise(rb_eTypeError, "no virtual class for %s",`
`3316`	`3316`	`rb_class2name(CLASS_OF(result)));`
`3317`	`3317`	`}`
`3318`		`- if (rb_safe_level() >= 4 && !OBJ_TAINTED(result))`
	`3318`	`+ if (ruby_safe_level >= 4 && !OBJ_TAINTED(result))`
`3319`	`3319`	`rb_raise(rb_eSecurityError, "Insecure: can't extend object");`
`3320`	`3320`	`klass = rb_singleton_class(result);`
`3321`	`3321`
`@@ -5603,7 +5603,7 @@ static void`
`5603`	`5603`	`secure_visibility(self)`
`5604`	`5604`	`VALUE self;`
`5605`	`5605`	`{`
`5606`		`- if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {`
	`5606`	`+ if (ruby_safe_level >= 4 && !OBJ_TAINTED(self)) {`
`5607`	`5607`	`rb_raise(rb_eSecurityError, "Insecure: can't change method visibility");`
`5608`	`5608`	`}`
`5609`	`5609`	`}`
`@@ -6315,15 +6315,15 @@ proc_save_safe_level(data)`
`6315`	`6315`	`VALUE data;`
`6316`	`6316`	`{`
`6317`	`6317`	`if (OBJ_TAINTED(data)) {`
`6318`		`- switch (rb_safe_level()) {`
	`6318`	`+ switch (ruby_safe_level) {`
`6319`	`6319`	`case 3:`
`6320`	`6320`	`FL_SET(data, PROC_T3);`
`6321`	`6321`	`break;`
`6322`	`6322`	`case 4:`
`6323`	`6323`	`FL_SET(data, PROC_T4);`
`6324`	`6324`	`break;`
`6325`	`6325`	`default:`
`6326`		`- if (rb_safe_level() > 4) {`
	`6326`	`+ if (ruby_safe_level > 4) {`
`6327`	`6327`	`FL_SET(data, PROC_TMAX);`
`6328`	`6328`	`}`
`6329`	`6329`	`break;`
`@@ -6621,8 +6621,8 @@ block_pass(self, node)`
`6621`	`6621`	`block = b;`
`6622`	`6622`	`}`
`6623`	`6623`
`6624`		`- if (rb_safe_level() >= 1 && OBJ_TAINTED(block)) {`
`6625`		`- if (rb_safe_level() > proc_get_safe_level(block)) {`
	`6624`	`+ if (ruby_safe_level >= 1 && OBJ_TAINTED(block)) {`
	`6625`	`+ if (ruby_safe_level > proc_get_safe_level(block)) {`
`6626`	`6626`	`rb_raise(rb_eSecurityError, "Insecure: tainted block value");`
`6627`	`6627`	`}`
`6628`	`6628`	`}`
`@@ -8316,7 +8316,7 @@ rb_thread_safe_level(thread)`
`8316`	`8316`
`8317`	`8317`	`th = rb_thread_check(thread);`
`8318`	`8318`	`if (th == curr_thread) {`
`8319`		`- return INT2NUM(rb_safe_level());`
	`8319`	`+ return INT2NUM(ruby_safe_level);`
`8320`	`8320`	`}`
`8321`	`8321`	`return INT2NUM(th->safe);`
`8322`	`8322`	`}`
`@@ -8859,7 +8859,7 @@ rb_thread_local_aref(thread, id)`
`8859`	`8859`	`VALUE val;`
`8860`	`8860`
`8861`	`8861`	`th = rb_thread_check(thread);`
`8862`		`- if (rb_safe_level() >= 4 && th != curr_thread) {`
	`8862`	`+ if (ruby_safe_level >= 4 && th != curr_thread) {`
`8863`	`8863`	`rb_raise(rb_eSecurityError, "Insecure: thread locals");`
`8864`	`8864`	`}`
`8865`	`8865`	`if (!th->locals) return Qnil;`
`@@ -8884,7 +8884,7 @@ rb_thread_local_aset(thread, id, val)`
`8884`	`8884`	`{`
`8885`	`8885`	`rb_thread_t th = rb_thread_check(thread);`
`8886`	`8886`
`8887`		`- if (rb_safe_level() >= 4 && th != curr_thread) {`
	`8887`	`+ if (ruby_safe_level >= 4 && th != curr_thread) {`
`8888`	`8888`	`rb_raise(rb_eSecurityError, "Insecure: can't modify thread locals");`
`8889`	`8889`	`}`
`8890`	`8890`	`if (OBJ_FROZEN(thread)) rb_error_frozen("thread locals");`
Original file line number	Diff line number	Diff line change
`@@ -2482,6 +2482,10 @@ rb_find_file(path)`
`2482`	`2482`	`if (file_load_ok(f)) return path;`
`2483`	`2483`	`}`
`2484`	`2484`
	`2485`	`+ if (rb_safe_level() >= 4) {`
	`2486`	`+ rb_raise(rb_eSecurityError, "loading from non-absolute path %s", f);`
	`2487`	`+ }`
	`2488`	`+`
`2485`	`2489`	`if (rb_load_path) {`
`2486`	`2490`	`int i;`
`2487`	`2491`
Original file line number	Diff line number	Diff line change
`@@ -788,6 +788,7 @@ num_step(argc, argv, from)`
`788`	`788`	`while (i <= end) {`
`789`	`789`	`rb_yield(INT2FIX(i));`
`790`	`790`	`i += diff;`
	`791`	`+ printf("<<%g>>\n", i - end);`
`791`	`792`	`}`
`792`	`793`	`}`
`793`	`794`	`else {`
`@@ -798,21 +799,16 @@ num_step(argc, argv, from)`
`798`	`799`	`}`
`799`	`800`	`}`
`800`	`801`	`else if (TYPE(from) == T_FLOAT \|\| TYPE(to) == T_FLOAT \|\| TYPE(step) == T_FLOAT) {`
	`802`	`+ const double epsilon = 2.2204460492503131E-16;`
`801`	`803`	`double beg = NUM2DBL(from);`
`802`	`804`	`double end = NUM2DBL(to);`
`803`	`805`	`double unit = NUM2DBL(step);`
`804`		`- double n = beg;`
`805`		`- long i = 0;`
	`806`	`+ double n = (end - beg)/unit;`
	`807`	`+ long i;`
`806`	`808`
`807`		`- if (unit > 0) {`
`808`		`- for (i=0; n<=end; i++, n=beg+unit*i) {`
`809`		`- rb_yield(rb_float_new(n));`
`810`		`- }`
`811`		`- }`
`812`		`- else {`
`813`		`- for (i=0; n>=end; i++, n=beg+unit*i) {`
`814`		`- rb_yield(rb_float_new(n));`
`815`		`- }`
	`809`	`+ n = floor(n + n*epsilon) + 1;`
	`810`	`+ for (i=0; i<n; i++) {`
	`811`	`+ rb_yield(rb_float_new(i*unit+beg));`
`816`	`812`	`}`
`817`	`813`	`}`
`818`	`814`	`else {`