[ruby-dev:5099] [PATCH] infinite loop of inspect (ruby-1.2.2)

ごとけんです

ruby 1.2.2(99/01/21) の話ですが，inspect が無限ループした
ときエラーメッセージが分かりにくいままになってます．
# ハマった ^^;;

class C
  def initialize; @v = [self]; end
end

[C.new].xyz  #==> エラー
  ../coerce/bug.rb:5:in `inspect': stack level too deep (SystemStackError)
	  from ../coerce/bug.rb:5:in `inspect'
	  from ../coerce/bug.rb:5:in `inspect'
	  from ../coerce/bug.rb:5:in `inspect'
	  from ../coerce/bug.rb:5:in `inspect'
	  from ../coerce/bug.rb:5:in `inspect'
	  from ../coerce/bug.rb:5:in `inspect'
	  from ../coerce/bug.rb:5:in `inspect'
	  from ../coerce/bug.rb:5:in `inspect'
	   ... 8049 levels...
	  from ../coerce/bug.rb:5:in `inspect'
	  from ../coerce/bug.rb:5:in `inspect'
	  from ../coerce/bug.rb:5:in `method_missing'
	  from ../coerce/bug.rb:5

1.3.1-990210 から拾ってパッチをあててみました．
1.3.1 で rb_inspecting_p() を使った検査をしている
array.c, hash.c, io.c, object.c, struct.c が対象です．

[C.new].xyz  #==> エラー
../coerce/bug.rb:5: undefined method `xyz' for [...] (NameError)

-- gotoken

--- ruby-1.2.2/array.c-orig	Thu Jan 21 18:04:50 1999
+++ ruby-1.2.2/array.c	Mon Feb 15 09:03:00 1999
@@ -635,24 +635,41 @@
 
 extern VALUE OFS;
 
+static VALUE
+inspect_join(ary, arg)
+    VALUE ary;
+    VALUE *arg;
+{
+    return ary_join(arg[0], arg[1]);
+}
+
 VALUE
 ary_join(ary, sep)
-    VALUE ary;
-    VALUE sep;
+    VALUE ary, sep;
 {
     int i;
     VALUE result, tmp;
     if (RARRAY(ary)->len == 0) return str_new(0, 0);
 
-    switch (TYPE(RARRAY(ary)->ptr[0])) {
+    tmp = RARRAY(ary)->ptr[0];
+    switch (TYPE(tmp)) {
       case T_STRING:
-	result = str_dup(RARRAY(ary)->ptr[0]);
+	result = str_dup(tmp);
 	break;
       case T_ARRAY:
-	result = ary_join(RARRAY(ary)->ptr[0], sep);
+	if (rb_inspecting_p(tmp)) {
+	    result = str_new2("[...]");
+	}
+	else {
+	    VALUE args[2];
+
+	    args[0] = tmp;
+	    args[1] = sep;
+	    result = rb_protect_inspect(inspect_join, ary, (VALUE)args);
+	}
 	break;
       default:
-	result = obj_as_string(RARRAY(ary)->ptr[0]);
+	result = obj_as_string(tmp);
 	break;
     }
 
@@ -662,14 +679,22 @@
 	  case T_STRING:
 	    break;
 	  case T_ARRAY:
-	    tmp = ary_join(tmp, sep);
+	    if (rb_inspecting_p(tmp)) {
+		tmp = str_new2("[...]");
+	    }
+	    else {
+		VALUE args[2];
+
+		args[0] = tmp;
+		args[1] = sep;
+		tmp = rb_protect_inspect(inspect_join, ary, (VALUE)args);
+	    }
 	    break;
 	  default:
 	    tmp = obj_as_string(tmp);
 	}
 	if (!NIL_P(sep)) str_concat(result, sep);
 	str_cat(result, RSTRING(tmp)->ptr, RSTRING(tmp)->len);
-	if (str_tainted(tmp)) str_taint(result);
     }
 
     return result;
@@ -685,7 +710,6 @@
 
     rb_scan_args(argc, argv, "01", &sep);
     if (NIL_P(sep)) sep = OFS;
-
     return ary_join(ary, sep);
 }
 
@@ -693,32 +717,90 @@
 ary_to_s(ary)
     VALUE ary;
 {
-    VALUE str = ary_join(ary, OFS);
+    VALUE str;
+
+    if (RARRAY(ary)->len == 0) return str_new(0, 0);
+    str = ary_join(ary, OFS);
     if (NIL_P(str)) return str_new(0, 0);
     return str;
 }
 
+static VALUE inspect_tbl;
+
+struct inspect_arg {
+    VALUE (*func)();
+    VALUE arg1, arg2;
+};
+
+VALUE
+inspect_call(arg)
+    struct inspect_arg *arg;
+{
+    return (*arg->func)(arg->arg1, arg->arg2);
+}
+
 static VALUE
-ary_inspect(ary)
+inspect_ensure(obj)
+    VALUE obj;
+{
+    ary_pop(inspect_tbl);
+    return 0;
+}
+
+VALUE
+rb_protect_inspect(func, obj, arg)
+    VALUE (*func)();
+    VALUE obj, arg;
+{
+    struct inspect_arg iarg;
+
+    if (!inspect_tbl) {
+	inspect_tbl = ary_new();
+	rb_global_variable(&inspect_tbl);
+    }
+    ary_push(inspect_tbl, obj);
+    iarg.func = func;
+    iarg.arg1 = obj;
+    iarg.arg2 = arg;
+    return rb_ensure(inspect_call, (VALUE)&iarg, inspect_ensure, obj);
+}
+
+VALUE
+rb_inspecting_p(obj)
+    VALUE obj;
+{
+    if (!inspect_tbl) return Qnil;
+    return ary_includes(inspect_tbl, obj);
+}
+
+static VALUE
+inspect_ary(ary)
     VALUE ary;
 {
-    int i, len;
+    int i = 0;
     VALUE s, str;
 
-    if (RARRAY(ary)->len == 0) return str_new2("[]");
     str = str_new2("[");
-    len = 1;
 
     for (i=0; i<RARRAY(ary)->len; i++) {
 	s = rb_inspect(RARRAY(ary)->ptr[i]);
 	if (i > 0) str_cat(str, ", ", 2);
 	str_cat(str, RSTRING(s)->ptr, RSTRING(s)->len);
-	len += RSTRING(s)->len + 2;
     }
     str_cat(str, "]", 1);
 
     return str;
 }
+
+static VALUE
+ary_inspect(ary)
+    VALUE ary;
+{
+    if (RARRAY(ary)->len == 0) return str_new2("[]");
+    if (rb_inspecting_p(ary)) return str_new2("[...]");
+    return rb_protect_inspect(inspect_ary, ary, 0);
+}
+
 
 static VALUE
 ary_to_a(ary)
--- ruby-1.2.2/hash.c-orig	Mon Jan 18 18:08:50 1999
+++ ruby-1.2.2/hash.c	Mon Feb 15 09:03:00 1999
@@ -614,7 +614,7 @@
 }
 
 static VALUE
-hash_inspect(hash)
+inspect_hash(hash)
     VALUE hash;
 {
     VALUE str;
@@ -627,10 +627,28 @@
 }
 
 static VALUE
-hash_to_s(hash)
+hash_inspect(hash)
+    VALUE hash;
+{
+    if (RHASH(hash)->tbl->num_entries == 0) return str_new2("{}");
+    if (rb_inspecting_p(hash)) return str_new2("{...}");
+    return rb_protect_inspect(inspect_hash, hash, 0);
+}
+
+static VALUE
+to_s_hash(hash)
     VALUE hash;
 {
+    if (rb_inspecting_p(hash)) return str_new2("{...}");
     return ary_to_s(hash_to_a(hash));
+}
+
+static VALUE
+hash_to_s(hash)
+    VALUE hash;
+{
+    if (rb_inspecting_p(hash)) return str_new2("{...}");
+    return rb_protect_inspect(to_s_hash, hash, 0);
 }
 
 static VALUE
--- ruby-1.2.2/intern.h-orig	Tue Dec  1 11:53:02 1998
+++ ruby-1.2.2/intern.h	Mon Feb 15 08:35:20 1999
@@ -31,6 +31,8 @@
 VALUE ary_assoc _((VALUE, VALUE));
 VALUE ary_rassoc _((VALUE, VALUE));
 VALUE ary_includes _((VALUE, VALUE));
+VALUE rb_protect_inspect _((VALUE(*)(),VALUE,VALUE));
+VALUE rb_inspecting_p _((VALUE));
 /* bignum.c */
 VALUE big_clone _((VALUE));
 void big_2comp _((VALUE));
--- ruby-1.2.2/io.c-orig	Thu Nov 26 17:25:44 1998
+++ ruby-1.2.2/io.c	Mon Feb 15 09:03:00 1999
@@ -1560,6 +1560,25 @@
     return io_putc(rb_defout, ch);
 }
 
+static VALUE io_puts _((int, VALUE*, VALUE));
+
+static VALUE
+io_puts_ary(ary, out)
+    VALUE ary, out;
+{
+    VALUE tmp;
+    int i;
+
+    for (i=0; i<RARRAY(ary)->len; i++) {
+	tmp = RARRAY(ary)->ptr[i];
+	if (rb_inspecting_p(tmp)) {
+	    tmp = str_new2("[...]");
+	}
+	io_puts(1, &tmp, out);
+    }
+    return Qnil;
+}
+
 static VALUE
 io_puts(argc, argv, out)
     int argc;
@@ -1580,9 +1599,7 @@
 	    line = str_new2("nil");
 	    break;
 	  case T_ARRAY:
-	    for (j=0; j<RARRAY(argv[i])->len; j++) {
-		io_puts(1, &RARRAY(argv[i])->ptr[j], out);
-	    }
+	    rb_protect_inspect(io_puts_ary, argv[i], out);
 	    continue;
 	  default:
 	    line = argv[i];
--- ruby-1.2.2/object.c-orig	Thu Aug 27 12:55:21 1998
+++ ruby-1.2.2/object.c	Mon Feb 15 09:03:00 1999
@@ -173,6 +173,16 @@
 }
 
 static VALUE
+inspect_obj(obj, str)
+    VALUE obj, str;
+{
+    st_foreach(ROBJECT(obj)->iv_tbl, inspect_i, str);
+    str_cat(str, ">", 1);
+
+    return str;
+}
+
+static VALUE
 obj_inspect(obj)
     VALUE obj;
 {
@@ -184,11 +194,16 @@
 
 	str = str_new2("-<");
 	b = rb_class2name(CLASS_OF(obj));
+	if (rb_inspecting_p(obj)) {
+	    char *buf = ALLOCA_N(char, strlen(b)+8);
+	    sprintf(buf, "#<%s:...>", b);
+	    return str_new2(buf);
+	}
 	str_cat(str, b, strlen(b));
 	st_foreach(ROBJECT(obj)->iv_tbl, inspect_i, str);
 	str_cat(str, ">", 1);
 
-	return str;
+	return rb_protect_inspect(inspect_obj, obj, str);
     }
     return rb_funcall(obj, rb_intern("to_s"), 0, 0);
 }
--- ruby-1.2.2/struct.c-orig	Thu Aug 27 12:55:34 1998
+++ ruby-1.2.2/struct.c	Mon Feb 15 09:03:00 1999
@@ -299,10 +299,10 @@
 }
 
 static VALUE
-struct_inspect(s)
+inspect_struct(s)
     VALUE s;
 {
-    char *name = rb_class2name(CLASS_OF(s));
+    char *cname = rb_class2name(CLASS_OF(s));
     VALUE str, member;
     int i;
 
@@ -312,7 +312,7 @@
     }
 
     str = str_new2("#<");
-    str_cat(str, name, strlen(name));
+    str_cat(str, cname, strlen(cname));
     str_cat(str, " ", 1);
     for (i=0; i<RSTRUCT(s)->len; i++) {
 	VALUE str2, slot;
@@ -331,6 +331,20 @@
     str_cat(str, ">", 1);
 
     return str;
+}
+
+static VALUE
+struct_inspect(s)
+    VALUE s;
+{
+    if (rb_inspecting_p(s)) {
+	char *cname = rb_class2name(CLASS_OF(s));
+	char *buf = ALLOCA_N(char, strlen(cname) + 8);
+
+	sprintf(buf, "#<%s:...>", cname);
+	return str_new2(buf);
+    }
+    return rb_protect_inspect(inspect_struct, s, 0);
 }
 
 static VALUE