[macruby-changes] [190] MacRuby/trunk

11 May 2008

Revision: 190
          http://trac.macosforge.org/projects/ruby/changeset/190
Author:   lsansonetti@apple.com
Date:     2008-05-10 17:16:55 -0700 (Sat, 10 May 2008)

Log Message:
-----------
lots of misc fixes and performance/memory usage improvements

Modified Paths:
--------------
    MacRuby/trunk/array.c
    MacRuby/trunk/bignum.c
    MacRuby/trunk/enumerator.c
    MacRuby/trunk/error.c
    MacRuby/trunk/eval.c
    MacRuby/trunk/eval_error.c
    MacRuby/trunk/ext/readline/readline.c
    MacRuby/trunk/ext/syck/rubyext.c
    MacRuby/trunk/ext/syck/syck.c
    MacRuby/trunk/ext/syck/syck.h
    MacRuby/trunk/ext/syck/token.c
    MacRuby/trunk/file.c
    MacRuby/trunk/gc.c
    MacRuby/trunk/hash.c
    MacRuby/trunk/include/ruby/ruby.h
    MacRuby/trunk/io.c
    MacRuby/trunk/iseq.c
    MacRuby/trunk/load.c
    MacRuby/trunk/marshal.c
    MacRuby/trunk/objc.m
    MacRuby/trunk/object.c
    MacRuby/trunk/pack.c
    MacRuby/trunk/process.c
    MacRuby/trunk/re.c
    MacRuby/trunk/ruby.c
    MacRuby/trunk/signal.c
    MacRuby/trunk/sprintf.c
    MacRuby/trunk/string.c
    MacRuby/trunk/util.c

Modified: MacRuby/trunk/array.c
===================================================================

--- MacRuby/trunk/array.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/array.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -43,8 +43,6 @@
 #if WITH_OBJC
 /* TODO optimize this */
 struct rb_objc_ary_struct {
-    bool frozen;
-    bool tainted;
     bool named_args;
     void *cptr;
 };
@@ -67,27 +65,11 @@
     if (s == NULL) {
 	s = xmalloc(sizeof(struct rb_objc_ary_struct));
 	rb_objc_set_associative_ref((void *)ary, &rb_objc_ary_assoc_key, s);
-	s->frozen = false;
-	s->tainted = false;
 	s->named_args = false;
 	s->cptr = NULL;
     }
     return s;
 }
-
-static void
-rb_objc_ary_copy_struct(VALUE old, VALUE new)
-{
-    struct rb_objc_ary_struct *s;
-
-    s = rb_objc_ary_get_struct(old);
-    if (s != NULL) {
-	struct rb_objc_ary_struct *n;
-
-	n = rb_objc_ary_get_struct2(new);
-	memcpy(n, s, sizeof(struct rb_objc_ary_struct));
-    }
-}
 #else
 #define ARY_SHARED_P(a) FL_TEST(a, ELTS_SHARED)
 
@@ -109,14 +91,12 @@
 {
 #if WITH_OBJC
     bool _CFArrayIsMutable(void *);
-    if (rb_ary_frozen_p(ary) == Qtrue) rb_error_frozen("hash");
     if (!_CFArrayIsMutable((void *)ary))
 	rb_raise(rb_eRuntimeError, "can't modify immutable array");
-#else
+#endif
     if (OBJ_FROZEN(ary)) rb_error_frozen("array");
     if (!OBJ_TAINTED(ary) && rb_safe_level() >= 4)
 	rb_raise(rb_eSecurityError, "Insecure: can't modify array");
-#endif
 }
 
 static void
@@ -139,40 +119,9 @@
 VALUE
 rb_ary_freeze(VALUE ary)
 {
-#if WITH_OBJC
-    rb_objc_ary_get_struct2(ary)->frozen = true;
-    return ary;
-#else
     return rb_obj_freeze(ary);
-#endif
 }
 
-#if WITH_OBJC
-VALUE
-rb_ary_taint(VALUE ary)
-{
-    rb_objc_ary_get_struct2(ary)->tainted = true;
-    return ary;
-}
-
-VALUE 
-rb_ary_untaint(VALUE ary)
-{
-    struct rb_objc_ary_struct *s;
-    s = rb_objc_ary_get_struct(ary);
-    if (s != NULL)
-        s->tainted = false;
-    return ary;
-}
-
-VALUE
-rb_ary_tainted(VALUE ary)
-{
-    struct rb_objc_ary_struct *s = rb_objc_ary_get_struct(ary);
-    return s != NULL && s->tainted ? Qtrue : Qfalse;
-}
-#endif
-
 /*
  *  call-seq:
  *     array.frozen?  -> true or false
@@ -184,13 +133,8 @@
 VALUE
 rb_ary_frozen_p(VALUE ary)
 {
-#if WITH_OBJC
-    struct rb_objc_ary_struct *s = rb_objc_ary_get_struct(ary);
-    return s != NULL && s->frozen ? Qtrue : Qfalse;
-#else
     if (OBJ_FROZEN(ary)) return Qtrue;
     return Qfalse;
-#endif
 }
 
 #if WITH_OBJC
@@ -236,7 +180,8 @@
         *(Class *)ary = RCLASS_OCID(klass);
 
     CFMakeCollectable((CFTypeRef)ary);
-
+    rb_gc_malloc_increase(sizeof(void *));
+    
     return ary;
 #else
     NEWOBJ(ary, struct RArray);
@@ -1591,14 +1536,6 @@
 		CFRangeMake(0, n));
     return dup;
 }
-
-VALUE
-rb_ary_clone(VALUE ary)
-{
-    VALUE dup = rb_ary_dup2(ary);
-    rb_objc_ary_copy_struct(ary, dup);
-    return dup;
-}
 #endif
 
 VALUE
@@ -4033,9 +3970,6 @@
 	rb_objc_import_class((Class)objc_getClass("NSMutableArray"));
     FL_UNSET(rb_cArrayRuby, RCLASS_OBJC_IMPORTED);
     rb_const_set(rb_cObject, rb_intern("Array"), rb_cArrayRuby);
-    rb_define_method(rb_cArray, "freeze", rb_ary_freeze, 0);
-    rb_define_method(rb_cArray, "taint", rb_ary_taint, 0);
-    rb_define_method(rb_cArray, "tainted?", rb_ary_tainted, 0);
 #else
     rb_cArray  = rb_define_class("Array", rb_cObject);
 #endif

Modified: MacRuby/trunk/bignum.c
===================================================================
--- MacRuby/trunk/bignum.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/bignum.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -574,7 +574,7 @@
 VALUE
 rb_str_to_inum(VALUE str, int base, int badcheck)
 {
-    char *s;
+    const char *s;
     long len;
 
     StringValue(str);
@@ -880,7 +880,7 @@
 
     if (FIXNUM_P(x)) {
         VALUE str = rb_fix2str(x, base);
-        char* str_ptr = RSTRING_CPTR(str);
+        const char* str_ptr = RSTRING_CPTR(str);
         long str_len = RSTRING_CLEN(str);
         if (trim) {
             if (FIX2INT(x) == 0) return 0;

Modified: MacRuby/trunk/enumerator.c
===================================================================
--- MacRuby/trunk/enumerator.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/enumerator.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -320,7 +320,7 @@
 {
     struct enumerator *e;
     int argc = 0;
-    VALUE *argv = 0;
+    const VALUE *argv = 0;
 
     if (!rb_block_given_p()) return obj;
     e = enumerator_ptr(obj);
@@ -353,7 +353,7 @@
     struct enumerator *e = enumerator_ptr(obj);
     VALUE memo = 0;
     int argc = 0;
-    VALUE *argv = 0;
+    const VALUE *argv = 0;
 
     RETURN_ENUMERATOR(obj, 0, 0);
     if (e->args) {

Modified: MacRuby/trunk/error.c
===================================================================
--- MacRuby/trunk/error.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/error.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -447,7 +447,7 @@
 
     klass = CLASS_OF(exc);
     exc = rb_obj_as_string(exc);
-    if (RSTRING_LEN(exc) == 0) {
+    if (RSTRING_CLEN(exc) == 0) {
 	return rb_str_dup(rb_class_name(klass));
     }
 
@@ -768,7 +768,7 @@
 	    break;
 	  default:
 	    d = rb_protect(rb_inspect, obj, 0);
-	    if (NIL_P(d) || RSTRING_LEN(d) > 65) {
+	    if (NIL_P(d) || RSTRING_CLEN(d) > 65) {
 		d = rb_any_to_s(obj);
 	    }
 	    desc = RSTRING_CPTR(d);

Modified: MacRuby/trunk/eval.c
===================================================================
--- MacRuby/trunk/eval.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/eval.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -1798,7 +1798,7 @@
 		mesg = rb_attr_get(errinfo, rb_intern("mesg"));
 		if (!NIL_P(errat) && TYPE(errat) == T_ARRAY &&
 		    (bt2 = backtrace(-2), RARRAY_LEN(bt2) > 0)) {
-		    if (!NIL_P(mesg) && TYPE(mesg) == T_STRING && !RSTRING_LEN(mesg)) {
+		    if (!NIL_P(mesg) && TYPE(mesg) == T_STRING && !RSTRING_CLEN(mesg)) {
 			rb_str_update(mesg, 0, 0, rb_str_new2(": "));
 			rb_str_update(mesg, 0, 0, RARRAY_AT(errat, 0));
 		    }
@@ -1835,7 +1835,7 @@
 rb_f_eval(int argc, VALUE *argv, VALUE self)
 {
     VALUE src, scope, vfile, vline;
-    char *file = "(eval)";
+    const char *file = "(eval)";
     int line = 1;
 
     rb_scan_args(argc, argv, "13", &src, &scope, &vfile, &vline);

Modified: MacRuby/trunk/eval_error.c
===================================================================
--- MacRuby/trunk/eval_error.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/eval_error.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -91,7 +91,7 @@
     VALUE errat = Qnil;		/* OK */
     VALUE errinfo = GET_THREAD()->errinfo;
     volatile VALUE eclass, e;
-    char *einfo;
+    const char *einfo;
     long elen;
 
     if (NIL_P(errinfo))

Modified: MacRuby/trunk/ext/readline/readline.c
===================================================================
--- MacRuby/trunk/ext/readline/readline.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/ext/readline/readline.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -76,7 +76,7 @@
     rb_secure(4);
     if (rb_scan_args(argc, argv, "02", &tmp, &add_hist) > 0) {
 	SafeStringValue(tmp);
-	prompt = RSTRING_PTR(tmp);
+	prompt = RSTRING_CPTR(tmp);
     }
 
     if (!isatty(0) && errno == EBADF) rb_raise(rb_eIOError, "stdin closed");
@@ -189,8 +189,8 @@
     result = ALLOC_N(char *, matches + 2);
     for (i = 0; i < matches; i++) {
 	temp = rb_obj_as_string(RARRAY_AT(ary, i));
-	result[i + 1] = ALLOC_N(char, RSTRING_LEN(temp) + 1);
-	strcpy(result[i + 1], RSTRING_PTR(temp));
+	result[i + 1] = ALLOC_N(char, RSTRING_CLEN(temp) + 1);
+	strcpy(result[i + 1], RSTRING_CPTR(temp));
     }
     result[matches + 1] = NULL;
 
@@ -265,10 +265,10 @@
     }
     else {
 	SafeStringValue(str);
-	if (RSTRING_LEN(str) == 0) {
+	if (RSTRING_CLEN(str) == 0) {
 	    rl_completion_append_character = '\0';
 	} else {
-	    rl_completion_append_character = RSTRING_PTR(str)[0];
+	    rl_completion_append_character = RSTRING_CPTR(str)[0];
 	}
     }
     return self;
@@ -288,8 +288,7 @@
     if (rl_completion_append_character == '\0')
 	return Qnil;
 
-    str = rb_str_new("", 1);
-    RSTRING_PTR(str)[0] = rl_completion_append_character;
+    str = rb_str_new(&rl_completion_append_character, 1);
     return str;
 #else
     rb_notimplement();
@@ -307,14 +306,14 @@
     SafeStringValue(str);
     if (basic_word_break_characters == NULL) {
 	basic_word_break_characters =
-	    ALLOC_N(char, RSTRING_LEN(str) + 1);
+	    ALLOC_N(char, RSTRING_CLEN(str) + 1);
     }
     else {
-	REALLOC_N(basic_word_break_characters, char, RSTRING_LEN(str) + 1);
+	REALLOC_N(basic_word_break_characters, char, RSTRING_CLEN(str) + 1);
     }
     strncpy(basic_word_break_characters,
-	    RSTRING_PTR(str), RSTRING_LEN(str));
-    basic_word_break_characters[RSTRING_LEN(str)] = '\0';
+	    RSTRING_CPTR(str), RSTRING_CLEN(str));
+    basic_word_break_characters[RSTRING_CLEN(str)] = '\0';
     rl_basic_word_break_characters = basic_word_break_characters;
     return self;
 #else
@@ -347,14 +346,14 @@
     SafeStringValue(str);
     if (completer_word_break_characters == NULL) {
 	completer_word_break_characters =
-	    ALLOC_N(char, RSTRING_LEN(str) + 1);
+	    ALLOC_N(char, RSTRING_CLEN(str) + 1);
     }
     else {
-	REALLOC_N(completer_word_break_characters, char, RSTRING_LEN(str) + 1);
+	REALLOC_N(completer_word_break_characters, char, RSTRING_CLEN(str) + 1);
     }
     strncpy(completer_word_break_characters,
-	    RSTRING_PTR(str), RSTRING_LEN(str));
-    completer_word_break_characters[RSTRING_LEN(str)] = '\0';
+	    RSTRING_CPTR(str), RSTRING_CLEN(str));
+    completer_word_break_characters[RSTRING_CLEN(str)] = '\0';
     rl_completer_word_break_characters = completer_word_break_characters;
     return self;
 #else
@@ -387,14 +386,14 @@
     SafeStringValue(str);
     if (basic_quote_characters == NULL) {
 	basic_quote_characters =
-	    ALLOC_N(char, RSTRING_LEN(str) + 1);
+	    ALLOC_N(char, RSTRING_CLEN(str) + 1);
     }
     else {
-	REALLOC_N(basic_quote_characters, char, RSTRING_LEN(str) + 1);
+	REALLOC_N(basic_quote_characters, char, RSTRING_CLEN(str) + 1);
     }
     strncpy(basic_quote_characters,
-	    RSTRING_PTR(str), RSTRING_LEN(str));
-    basic_quote_characters[RSTRING_LEN(str)] = '\0';
+	    RSTRING_CPTR(str), RSTRING_CLEN(str));
+    basic_quote_characters[RSTRING_CLEN(str)] = '\0';
     rl_basic_quote_characters = basic_quote_characters;
 
     return self;
@@ -428,13 +427,13 @@
     SafeStringValue(str);
     if (completer_quote_characters == NULL) {
 	completer_quote_characters =
-	    ALLOC_N(char, RSTRING_LEN(str) + 1);
+	    ALLOC_N(char, RSTRING_CLEN(str) + 1);
     }
     else {
-	REALLOC_N(completer_quote_characters, char, RSTRING_LEN(str) + 1);
+	REALLOC_N(completer_quote_characters, char, RSTRING_CLEN(str) + 1);
     }
-    strncpy(completer_quote_characters, RSTRING_PTR(str), RSTRING_LEN(str));
-    completer_quote_characters[RSTRING_LEN(str)] = '\0';
+    strncpy(completer_quote_characters, RSTRING_CPTR(str), RSTRING_CLEN(str));
+    completer_quote_characters[RSTRING_CLEN(str)] = '\0';
     rl_completer_quote_characters = completer_quote_characters;
 
     return self;
@@ -468,13 +467,13 @@
     SafeStringValue(str);
     if (filename_quote_characters == NULL) {
 	filename_quote_characters =
-	    ALLOC_N(char, RSTRING_LEN(str) + 1);
+	    ALLOC_N(char, RSTRING_CLEN(str) + 1);
     }
     else {
-	REALLOC_N(filename_quote_characters, char, RSTRING_LEN(str) + 1);
+	REALLOC_N(filename_quote_characters, char, RSTRING_CLEN(str) + 1);
     }
-    strncpy(filename_quote_characters, RSTRING_PTR(str), RSTRING_LEN(str));
-    filename_quote_characters[RSTRING_LEN(str)] = '\0';
+    strncpy(filename_quote_characters, RSTRING_CPTR(str), RSTRING_CLEN(str));
+    filename_quote_characters[RSTRING_CLEN(str)] = '\0';
     rl_filename_quote_characters = filename_quote_characters;
 
     return self;
@@ -535,7 +534,7 @@
     if (i < 0) {
         i += history_length;
     }
-    entry = replace_history_entry(i, RSTRING_PTR(str), NULL);
+    entry = replace_history_entry(i, RSTRING_CPTR(str), NULL);
     if (entry == NULL) {
 	rb_raise(rb_eIndexError, "invalid index");
     }
@@ -551,7 +550,7 @@
 {
     rb_secure(4);
     SafeStringValue(str);
-    add_history(RSTRING_PTR(str));
+    add_history(RSTRING_CPTR(str));
     return self;
 }
 
@@ -564,7 +563,7 @@
     while (argc--) {
 	str = *argv++;
 	SafeStringValue(str);
-	add_history(RSTRING_PTR(str));
+	add_history(RSTRING_CPTR(str));
     }
     return self;
 }

Modified: MacRuby/trunk/ext/syck/rubyext.c
===================================================================
--- MacRuby/trunk/ext/syck/rubyext.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/ext/syck/rubyext.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -56,7 +56,7 @@
 static VALUE sym_scalar, sym_seq, sym_map;
 static VALUE sym_1quote, sym_2quote, sym_fold, sym_literal, sym_plain, sym_inline;
 static VALUE cDate, cNode, cMap, cSeq, cScalar, cOut, cParser, cResolver, cPrivateType, cDomainType, cYObject, cBadAlias, cDefaultKey, cMergeKey, cEmitter;
-static VALUE oDefaultResolver, oGenericResolver;
+static VALUE oDefaultResolver, oGenericResolver, oColon, oDoubleColon;
 
 /*
  * my private collection of numerical oddities.
@@ -1026,9 +1026,9 @@
 syck_const_find(VALUE const_name)
 {
     VALUE tclass = rb_cObject;
-    VALUE tparts = rb_str_split( const_name, "::" );
-    int i = 0;
-    for ( i = 0; i < RARRAY_LEN(tparts); i++ ) {
+    VALUE tparts = rb_str_split2( const_name, oDoubleColon );
+    int i = 0, count;
+    for ( i = 0, count = RARRAY_LEN(tparts); i < count; i++ ) {
         VALUE tpart = rb_to_id( rb_ary_entry( tparts, i ) );
         if ( !rb_const_defined( tclass, tpart ) ) return Qnil;
         tclass = rb_const_get( tclass, tpart );
@@ -1050,7 +1050,6 @@
     if ( ! (NIL_P(type) || RSTRING_CLEN(StringValue(type)) == 0) )
     {
         VALUE str_xprivate = rb_str_new2( "x-private" );
-        VALUE colon = rb_str_new2( ":" );
         VALUE tags = rb_attr_get(self, s_tags);
         VALUE target_class = rb_hash_aref( tags, type );
         VALUE subclass = target_class;
@@ -1062,17 +1061,18 @@
         if ( NIL_P( target_class ) )
         {
             VALUE subclass_parts = rb_ary_new();
-            VALUE parts = rb_str_split( type, ":" );
+            VALUE parts = rb_str_split2( type, oColon );
 
             while ( RARRAY_LEN(parts) > 1 )
             {
                 VALUE partial;
                 rb_ary_unshift( subclass_parts, rb_ary_pop( parts ) );
-                partial = rb_ary_join( parts, colon );
+                partial = rb_ary_join( parts, oColon );
+		//printf("partial %p parts %p\n", partial, parts);
                 target_class = rb_hash_aref( tags, partial );
                 if ( NIL_P( target_class ) )
                 {
-                    rb_str_append( partial, colon );
+                    rb_str_append( partial, oColon );
                     target_class = rb_hash_aref( tags, partial );
                 }
 
@@ -1086,7 +1086,7 @@
                          RTEST( rb_funcall( target_class, s_tag_subclasses, 0 ) ) )
                     {
                         VALUE subclass_v;
-                        subclass = rb_ary_join( subclass_parts, colon );
+                        subclass = rb_ary_join( subclass_parts, oColon );
                         subclass = rb_funcall( target_class, s_tag_read_class, 1, subclass );
                         subclass_v = syck_const_find( subclass );
 
@@ -1146,17 +1146,17 @@
             }
             else 
             {
-                VALUE parts = rb_str_split( type, ":" );
+                VALUE parts = rb_str_split2( type, oColon );
                 VALUE scheme = rb_ary_shift( parts );
                 if ( rb_str_cmp( scheme, str_xprivate ) == 0 )
                 {
-                    VALUE name = rb_ary_join( parts, colon );
+                    VALUE name = rb_ary_join( parts, oColon );
                     obj = rb_funcall( cPrivateType, s_new, 2, name, val );
                 }
                 else
                 {
                     VALUE domain = rb_ary_shift( parts );
-                    VALUE name = rb_ary_join( parts, colon );
+                    VALUE name = rb_ary_join( parts, oColon );
                     obj = rb_funcall( cDomainType, s_new, 3, domain, name, val );
                 }
             }
@@ -2158,6 +2158,11 @@
     oGenericResolver = rb_funcall( cResolver, rb_intern( "new" ), 0 );
     rb_define_singleton_method( oGenericResolver, "node_import", syck_genericresolver_node_import, 1 );
     rb_define_const( rb_syck, "GenericResolver", oGenericResolver );
+    
+    oColon = rb_str_new2( ":" );
+    rb_global_variable( &oColon );
+    oDoubleColon = rb_str_new2( "::" );
+    rb_global_variable( &oDoubleColon );
 
     /*
      * Define YAML::Syck::Parser class

Modified: MacRuby/trunk/ext/syck/syck.c
===================================================================
--- MacRuby/trunk/ext/syck/syck.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/ext/syck/syck.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -354,7 +354,7 @@
     if ( p->lvl_idx <= 1 ) return;
 
     p->lvl_idx -= 1;
-    xfree( p->levels[p->lvl_idx].domain );
+    free( p->levels[p->lvl_idx].domain );
 }
 
 void 

Modified: MacRuby/trunk/ext/syck/syck.h
===================================================================
--- MacRuby/trunk/ext/syck/syck.h	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/ext/syck/syck.h	2008-05-11 00:16:55 UTC (rev 190)
@@ -48,7 +48,7 @@
 
 #define ALLOC_CT 8
 #define SYCK_BUFFERSIZE 4096
-#if WITH_OBJC
+#if 0//WITH_OBJC
 #define S_ALLOC_N(type,n) (type*)xmalloc(sizeof(type)*(n))
 #define S_ALLOC(type) (type*)xmalloc(sizeof(type))
 #define S_REALLOC_N(var,type,n) (var)=(type*)xrealloc((char*)(var),sizeof(type)*(n))

Modified: MacRuby/trunk/ext/syck/token.c
===================================================================
--- MacRuby/trunk/ext/syck/token.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/ext/syck/token.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -2111,7 +2111,7 @@
                         char *chr_text = syck_strndup( YYTOKEN, 4 );
                         chr_text[0] = '0';
                         ch = strtol( chr_text, NULL, 16 );
-                        xfree( chr_text );
+                        free( chr_text );
                         QUOTECAT(qstr, qcapa, qidx, ch);
                         goto DoubleQuote2; 
                     }
@@ -2173,7 +2173,7 @@
                         YYCURSOR = YYTOKTMP;
                         if ( YYCURSOR == YYTOKEN + 1 )
                         {
-                            xfree( qstr );
+                            free( qstr );
                             return YAML_ITRANSFER;
                         }
 
@@ -2188,7 +2188,7 @@
                             sycklval->name[0] = '\0';
                             strcat( sycklval->name, lvl->domain );
                             strncat( sycklval->name, qstr + 1, qidx - 1 );
-                            xfree( qstr );
+                            free( qstr );
                         }
                         else
                         {
@@ -2202,13 +2202,13 @@
 
                             if ( carat < qend )
                             {
-                                xfree( lvl->domain );
+                                free( lvl->domain );
                                 lvl->domain = syck_strndup( qstr, carat - qstr );
                                 sycklval->name = S_ALLOC_N( char, ( qend - carat ) + strlen( lvl->domain ) );
                                 sycklval->name[0] = '\0';
                                 strcat( sycklval->name, lvl->domain );
                                 strncat( sycklval->name, carat + 1, ( qend - carat ) - 1 );
-                                xfree( qstr );
+                                free( qstr );
                             }
                             else
                             {
@@ -2314,7 +2314,7 @@
                         char *chr_text = syck_strndup( YYTOKTMP, 4 );
                         chr_text[0] = '0';
                         ch = strtol( chr_text, NULL, 16 );
-                        xfree( chr_text );
+                        free( chr_text );
                         QUOTECAT(qstr, qcapa, qidx, ch);
                         goto TransferMethod2;
                     }

Modified: MacRuby/trunk/file.c
===================================================================
--- MacRuby/trunk/file.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/file.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -829,7 +829,7 @@
     rb_secure(2);
     FilePathValue(fname);
     if (lstat(StringValueCStr(fname), &st) == -1) {
-	rb_sys_fail(RSTRING_PTR(fname));
+	rb_sys_fail(RSTRING_CPTR(fname));
     }
     return stat_new(&st);
 #else
@@ -1565,13 +1565,13 @@
     FilePathValue(fname1);
     fname1 = rb_str_new4(fname1);
     FilePathValue(fname2);
-    if (access(RSTRING_PTR(fname1), 0)) return Qfalse;
-    if (access(RSTRING_PTR(fname2), 0)) return Qfalse;
+    if (access(RSTRING_CPTR(fname1), 0)) return Qfalse;
+    if (access(RSTRING_CPTR(fname2), 0)) return Qfalse;
 #endif
     fname1 = rb_file_expand_path(fname1, Qnil);
     fname2 = rb_file_expand_path(fname2, Qnil);
-    if (RSTRING_LEN(fname1) != RSTRING_LEN(fname2)) return Qfalse;
-    if (rb_memcicmp(RSTRING_PTR(fname1), RSTRING_PTR(fname2), RSTRING_LEN(fname1)))
+    if (RSTRING_CLEN(fname1) != RSTRING_CLEN(fname2)) return Qfalse;
+    if (rb_memcicmp(RSTRING_CPTR(fname1), RSTRING_CPTR(fname2), RSTRING_CLEN(fname1)))
 	return Qfalse;
 #endif
     return Qtrue;
@@ -1658,7 +1658,7 @@
     rb_secure(2);
     FilePathValue(fname);
     if (lstat(StringValueCStr(fname), &st) == -1) {
-	rb_sys_fail(RSTRING_PTR(fname));
+	rb_sys_fail(RSTRING_CPTR(fname));
     }
 
     return rb_file_ftype(&st);
@@ -1724,7 +1724,7 @@
     struct stat st;
 
     if (rb_stat(fname, &st) < 0)
-	rb_sys_fail(RSTRING_PTR(fname));
+	rb_sys_fail(RSTRING_CPTR(fname));
     return stat_mtime(&st);
 }
 
@@ -1769,7 +1769,7 @@
     struct stat st;
 
     if (rb_stat(fname, &st) < 0)
-	rb_sys_fail(RSTRING_PTR(fname));
+	rb_sys_fail(RSTRING_CPTR(fname));
     return stat_ctime(&st);
 }
 
@@ -2159,7 +2159,7 @@
 #endif
     const char *e1, *e2;
     int len = 5;
-    int l1 = RSTRING_LEN(s1), l2 = RSTRING_LEN(s2);
+    int l1 = RSTRING_CLEN(s1), l2 = RSTRING_CLEN(s2);
 
     e1 = e2 = "";
     if (l1 > max_pathlen) {
@@ -2175,8 +2175,8 @@
     len += l1 + l2;
     buf = ALLOCA_N(char, len);
     snprintf(buf, len, "(%.*s%s, %.*s%s)",
-	     l1, RSTRING_PTR(s1), e1,
-	     l2, RSTRING_PTR(s2), e2);
+	     l1, RSTRING_CPTR(s1), e1,
+	     l2, RSTRING_CPTR(s2), e2);
     rb_sys_fail(buf);
 }
 
@@ -2263,7 +2263,7 @@
     rb_secure(2);
     FilePathValue(path);
     buf = xmalloc(size);
-    while ((rv = readlink(RSTRING_PTR(path), buf, size)) == size
+    while ((rv = readlink(RSTRING_CPTR(path), buf, size)) == size
 #ifdef _AIX
 	    || (rv < 0 && errno == ERANGE) /* quirky behavior of GPFS */
 #endif
@@ -2273,7 +2273,7 @@
     }
     if (rv < 0) {
 	free(buf);
-	rb_sys_fail(RSTRING_PTR(path));
+	rb_sys_fail(RSTRING_CPTR(path));
     }
     v = rb_tainted_str_new(buf, rv);
     xfree(buf);
@@ -2835,7 +2835,7 @@
 rb_file_s_basename(int argc, VALUE *argv)
 {
     VALUE fname, fext, basename;
-    char *name, *p;
+    const char *name, *p;
 #if defined DOSISH_DRIVE_LETTER || defined DOSISH_UNC
     char *root;
 #endif
@@ -3139,7 +3139,7 @@
     FilePathValue(path);
 #ifdef HAVE_TRUNCATE
     if (truncate(StringValueCStr(path), pos) < 0)
-	rb_sys_fail(RSTRING_PTR(path));
+	rb_sys_fail(RSTRING_CPTR(path));
 #else
 # ifdef HAVE_CHSIZE
     {
@@ -3147,16 +3147,16 @@
 
 #  ifdef _WIN32
 	if ((tmpfd = open(StringValueCStr(path), O_RDWR)) < 0) {
-	    rb_sys_fail(RSTRING_PTR(path));
+	    rb_sys_fail(RSTRING_CPTR(path));
 	}
 #  else
 	if ((tmpfd = open(StringValueCStr(path), 0)) < 0) {
-	    rb_sys_fail(RSTRING_PTR(path));
+	    rb_sys_fail(RSTRING_CPTR(path));
 	}
 #  endif
 	if (chsize(tmpfd, pos) < 0) {
 	    close(tmpfd);
-	    rb_sys_fail(RSTRING_PTR(path));
+	    rb_sys_fail(RSTRING_CPTR(path));
 	}
 	close(tmpfd);
     }
@@ -3481,7 +3481,7 @@
 
 	CHECK(1);
 	if (rb_stat(argv[1], &st) == -1) {
-	    rb_sys_fail(RSTRING_PTR(argv[1]));
+	    rb_sys_fail(RSTRING_CPTR(argv[1]));
 	}
 
 	switch (cmd) {
@@ -3570,7 +3570,7 @@
     rb_secure(2);
     FilePathValue(fname);
     if (stat(StringValueCStr(fname), &st) == -1) {
-	rb_sys_fail(RSTRING_PTR(fname));
+	rb_sys_fail(RSTRING_CPTR(fname));
     }
     if (DATA_PTR(obj)) {
 	free(DATA_PTR(obj));
@@ -4212,7 +4212,7 @@
 path_check_0(VALUE path, int execpath)
 {
     struct stat st;
-    char *p0 = StringValueCStr(path);
+    const char *p0 = StringValueCStr(path);
     char *p = 0, *s;
 
     if (!is_absolute_path(p0)) {
@@ -4225,7 +4225,7 @@
 	rb_str_cat2(newpath, "/");
 	rb_str_cat2(newpath, p0);
 	path = newpath;
-	p0 = RSTRING_PTR(path);
+	p0 = RSTRING_CPTR(path);
     }
     for (;;) {
 #ifndef S_IWOTH
@@ -4307,8 +4307,8 @@
 int
 rb_find_file_ext(VALUE *filep, const char *const *ext)
 {
-    char *path, *found;
-    char *f = RSTRING_PTR(*filep);
+    const char *path, *found;
+    const char *f = RSTRING_CPTR(*filep);
     VALUE fname;
     long i, j;
 
@@ -4346,8 +4346,8 @@
 	    VALUE str = RARRAY_AT(rb_load_path, i);
 
 	    FilePathValue(str);
-	    if (RSTRING_LEN(str) == 0) continue;
-	    path = RSTRING_PTR(str);
+	    if (RSTRING_CLEN(str) == 0) continue;
+	    path = RSTRING_CPTR(str);
 	    found = dln_find_file(StringValueCStr(fname), path);
 	    if (found && file_load_ok(found)) {
 		*filep = rb_str_new2(found);
@@ -4363,7 +4363,7 @@
 {
     VALUE tmp;
     char *f = StringValueCStr(path);
-    char *lpath;
+    const char *lpath;
 
     if (f[0] == '~') {
 	path = rb_file_expand_path(path, Qnil);
@@ -4402,16 +4402,16 @@
 	for (i=0, count=RARRAY_LEN(rb_load_path);i < count;i++) {
 	    VALUE str = RARRAY_AT(rb_load_path, i);
 	    FilePathValue(str);
-	    if (RSTRING_LEN(str) > 0) {
+	    if (RSTRING_CLEN(str) > 0) {
 		rb_ary_push(tmp, str);
 	    }
 	}
 	tmp = rb_ary_join(tmp, rb_str_new2(PATH_SEP));
-	if (RSTRING_LEN(tmp) == 0) {
+	if (RSTRING_CLEN(tmp) == 0) {
 	    lpath = 0;
 	}
 	else {
-	    lpath = RSTRING_PTR(tmp);
+	    lpath = RSTRING_CPTR(tmp);
 	}
     }
     else {

Modified: MacRuby/trunk/gc.c
===================================================================
--- MacRuby/trunk/gc.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/gc.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -1,4 +1,4 @@
-  /**********************************************************************
+/**********************************************************************
 
   gc.c -
 
@@ -36,7 +36,7 @@
 #endif
 
 #if WITH_OBJC
-# if HAVE_AUTO_ZONE_H
+# if 1//HAVE_AUTO_ZONE_H
 #  include <auto_zone.h>
 # else
 #  include <malloc/malloc.h>
@@ -45,7 +45,9 @@
 #define AUTO_MEMORY_UNSCANNED 1
 #define AUTO_OBJECT_SCANNED   2
 #define AUTO_OBJECT_UNSCANNED 3 
+#define AUTO_COLLECT_RATIO_COLLECTION (0 << 0)
 #define AUTO_COLLECT_GENERATIONAL_COLLECTION (1 << 0)
+#define AUTO_COLLECT_FULL_COLLECTION (1 << 0)
 #define AUTO_LOG_COLLECTIONS (1 << 1)
 #define AUTO_LOG_REGIONS (1 << 4)
 #define AUTO_LOG_UNUSUAL (1 << 5)
@@ -76,9 +78,18 @@
     size_t unused11;
 } auto_collection_control_t;
 extern auto_collection_control_t *auto_collection_parameters(auto_zone_t *);
+typedef struct {
+    malloc_statistics_t malloc_statistics;
+    uint32_t            version;
+    size_t              num_collections[2];
+    boolean_t           last_collection_was_generational;
+    size_t              bytes_in_use_after_last_collection[2];
+    size_t              bytes_allocated_after_last_collection[2];
+    size_t              bytes_freed_during_last_collection[2];
+    // durations not included
+} auto_statistics_t;
 # endif
 static auto_zone_t *__auto_zone = NULL;
-static long gc_count = 0;
 static long xmalloc_count = 0;
 #endif
 
@@ -283,6 +294,14 @@
     return flag;
 }
 
+void
+rb_gc_malloc_increase(size_t size)
+{
+    malloc_increase += size;
+    if (!dont_gc && (ruby_gc_stress || malloc_increase > malloc_limit))
+	garbage_collect();
+}
+
 void *
 ruby_xmalloc(size_t size)
 {
@@ -292,11 +311,7 @@
 	rb_raise(rb_eNoMemError, "negative allocation size (or too big)");
     }
     if (size == 0) size = 1;
-    malloc_increase += size;
-
-    if (ruby_gc_stress || malloc_increase > malloc_limit) {
-	garbage_collect();
-    }
+    rb_gc_malloc_increase(size);
 #if WITH_OBJC
     if (__auto_zone == NULL) {
     	fprintf(stderr,
@@ -403,7 +418,6 @@
 #endif
 }
 
-
 /*
  *  call-seq:
  *     GC.enable    => true or false
@@ -628,73 +642,7 @@
 
 #else /* !WITH_OBJC */
 
-struct finalize_at_exit {
-    VALUE v;
-    struct finalize_at_exit *next;
-};
-
-static struct finalize_at_exit *finalize_at_exit_head = NULL;
-
 void
-rb_objc_keep_for_exit_finalize(VALUE v)
-{
-    if (finalize_at_exit_head == NULL) {
-	finalize_at_exit_head = (struct finalize_at_exit *)malloc(
-	    sizeof(struct finalize_at_exit));
-	finalize_at_exit_head->v = v;
-	finalize_at_exit_head->next = NULL;
-    }
-    else {
-	struct finalize_at_exit *entry;
-	entry = (struct finalize_at_exit *)malloc(
-	    sizeof(struct finalize_at_exit));
-	entry->v = v;
-	entry->next = finalize_at_exit_head;
-	finalize_at_exit_head = entry;
-    }
-}
-
-static inline void
-rb_objc_finalize(VALUE obj) 
-{
-    struct finalize_at_exit *entry;
-    
-    //printf("rb_objc_finalize %p\n", (void *)obj);
-
-    for (entry = finalize_at_exit_head; entry != NULL; entry = entry->next) {
-	if (obj == entry->v)
-	    entry->v = Qnil;
-    }
-
-    switch (RBASIC(obj)->flags & T_MASK) {
-    	case T_FILE:
-	    if (RFILE(obj)->fptr != NULL)
-		rb_io_fptr_finalize(RFILE(obj)->fptr);
-	    break;
-	default:
-	    rb_bug("rb_objc_finalize: unhandled object type 0x%X",
-		   RBASIC(obj)->flags & T_MASK);
-    }
-}
-
-static id
-rb_objc_imp_finalize(id rcv, SEL sel)
-{
-    void *p;
-
-    assert(!rb_objc_is_non_native((VALUE)rcv));
-    rb_objc_finalize((VALUE)rcv);    
-}
-
-static void
-rb_objc_define_finalizer(VALUE klass)
-{
-    Class ocklass = (Class)RCLASS(klass)->ocklass;
-    assert(class_addMethod(ocklass, sel_registerName("finalize"), 
-			   (IMP)rb_objc_imp_finalize, "@@:")); 
-}
-
-void
 rb_objc_wb(void *dst, void *newval)
 {
     if (!SPECIAL_CONST_P(newval)) {
@@ -782,9 +730,7 @@
 rb_objc_newobj(size_t size)
 {
     void *obj;
-    malloc_increase += size;
-    if (!dont_gc && (ruby_gc_stress || malloc_increase > malloc_limit))
-	garbage_collect();
+    rb_gc_malloc_increase(size);
 #if USE_OBJECTS_POOL
     if (objects_pool == NULL) 
 	objects_pool = malloc(sizeof(void *) * OBJECTS_POOL_SIZE);
@@ -1873,24 +1819,8 @@
 {
     if (dont_gc)
 	return Qtrue;
-
     auto_collect(__auto_zone, AUTO_COLLECT_GENERATIONAL_COLLECTION, NULL);
-
-    gc_count++;
-#if 0
-    if (malloc_increase > malloc_limit) {
-	auto_statistics_t stats;
-	size_t live, freed;
-	auto_zone_statistics(__auto_zone, &stats);
-	live = stats.bytes_in_use_after_last_collection[1] / sizeof(RVALUE);
-	freed = stats.bytes_freed_during_last_collection[1] / sizeof(RVALUE);
-	malloc_limit += (malloc_increase - malloc_limit) * (double)live / (live + freed);
-	if (malloc_limit < GC_MALLOC_LIMIT) malloc_limit = GC_MALLOC_LIMIT;
-	printf("malloc_increase was %ld, malloc_limit is now %ld\n", malloc_increase, malloc_limit);
-    }
-#endif
     malloc_increase = 0;
-
     return Qtrue;
 }
 #endif
@@ -2403,15 +2333,46 @@
 }
 
 #if WITH_OBJC
+static CFMutableArrayRef __exit_finalize = NULL;
 
+static void
+rb_objc_finalize_pure_ruby_obj(VALUE obj)
+{
+    switch (RBASIC(obj)->flags & T_MASK) {
+	case T_FILE:
+	    if (RFILE(obj)->fptr != NULL) {
+		rb_io_fptr_finalize(RFILE(obj)->fptr);
+	    }
+	    break;
+    }
+}
+
 void
-rb_gc_call_finalizer_at_exit(void)
+rb_objc_keep_for_exit_finalize(VALUE v)
 {
-    struct finalize_at_exit *entry;
+    if (__exit_finalize == NULL) {
+	__exit_finalize = CFArrayCreateMutable(NULL, 0, 
+	    &kCFTypeArrayCallBacks);
+    }
+    CFArrayAppendValue(__exit_finalize, (void *)v);
+}
 
-    for (entry = finalize_at_exit_head; entry != NULL; entry = entry->next)
-	if (entry->v != Qnil)
-	    rb_objc_finalize(entry->v);
+void
+rb_gc_call_finalizer_at_exit(void)
+{
+    if (__exit_finalize != NULL) {
+	long i, count;
+	for (i = 0, count = CFArrayGetCount((CFArrayRef)__exit_finalize); 
+	     i < count; 
+	     i++) {
+	    VALUE v;
+	    v = (VALUE)CFArrayGetValueAtIndex((CFArrayRef)__exit_finalize, i);
+	    rb_objc_finalize_pure_ruby_obj(v);
+	}
+    }
+    CFArrayRemoveAllValues(__exit_finalize);
+    CFRelease(__exit_finalize);
+    auto_collect(__auto_zone, AUTO_COLLECT_FULL_COLLECTION, NULL);
 }
 
 #else /* WITH_OBJC */
@@ -2720,6 +2681,34 @@
  *  are also available via the <code>ObjectSpace</code> module.
  */
 
+#if WITH_OBJC
+static void (*old_batch_invalidate)(auto_zone_t *, auto_zone_foreach_object_t, 
+    auto_zone_cursor_t, size_t);
+
+static void
+__rb_objc_finalize(void *obj, void *data)
+{
+    if (rb_objc_is_non_native((VALUE)obj)) {
+	static SEL sel = NULL;
+	rb_objc_remove_keys(obj);
+	if (sel == NULL)
+	    sel = sel_registerName("finalize");
+	objc_msgSend(obj, sel);
+    }
+    else {
+	/* TODO: call ObjectSpace finalizers, if any */
+    }
+}
+
+static void 
+rb_objc_batch_invalidate(auto_zone_t *zone, 
+			 auto_zone_foreach_object_t foreach, 
+			 auto_zone_cursor_t cursor, size_t cursor_size) 
+{
+    foreach(cursor, __rb_objc_finalize, NULL);
+}
+#endif
+
 void
 Init_PreGC(void)
 {
@@ -2733,6 +2722,8 @@
     if (getenv("GC_DEBUG"))
 	auto_collection_parameters(__auto_zone)->log = 
 	    AUTO_LOG_COLLECTIONS | AUTO_LOG_REGIONS | AUTO_LOG_UNUSUAL;
+    old_batch_invalidate = auto_collection_parameters(__auto_zone)->batch_invalidate;
+    auto_collection_parameters(__auto_zone)->batch_invalidate = rb_objc_batch_invalidate;
 #endif
 }
 
@@ -2740,7 +2731,6 @@
 Init_PostGC(void)
 {
 #if WITH_OBJC
-    rb_objc_define_finalizer(rb_cIO);
 # if 0
     /* It is better to let Foundation start the dedicated collection thread
      * when necessary. 

Modified: MacRuby/trunk/hash.c
===================================================================
--- MacRuby/trunk/hash.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/hash.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -25,13 +25,11 @@
 #define HASH_DELETED  FL_USER1
 #define HASH_PROC_DEFAULT FL_USER2
 
-#if !WITH_OBJC
 VALUE
 rb_hash_freeze(VALUE hash)
 {
     return rb_obj_freeze(hash);
 }
-#endif
 
 VALUE rb_cHash;
 #if WITH_OBJC
@@ -269,8 +267,6 @@
 struct rb_objc_hash_struct {
     VALUE ifnone;
     bool has_proc_default; 
-    bool frozen;
-    bool tainted;
 };
 
 /* This variable will always stay NULL, we only use its address. */
@@ -293,61 +289,10 @@
 	rb_objc_set_associative_ref((void *)hash, &rb_objc_hash_assoc_key, s);
 	s->ifnone = Qnil;
 	s->has_proc_default = false;
-	s->frozen = false;
-	s->tainted = false;
     }
     return s;
 }
 
-VALUE
-rb_hash_freeze(VALUE hash)
-{
-    struct rb_objc_hash_struct *s;
-
-    s = rb_objc_hash_get_struct2(hash);
-    s->frozen = true;
-
-    return hash;
-}
-
-VALUE
-rb_hash_frozen(VALUE hash)
-{
-    struct rb_objc_hash_struct *s;
-
-    s = rb_objc_hash_get_struct(hash);
-
-    return s != NULL && s->frozen ? Qtrue : Qfalse;
-}
-
-VALUE
-rb_hash_taint(VALUE hash)
-{
-    rb_objc_hash_get_struct2(hash)->tainted = true;
-    return hash;
-}
-
-VALUE
-rb_hash_untaint(VALUE hash)
-{
-    struct rb_objc_hash_struct *s;
-    s = rb_objc_hash_get_struct(hash);
-    if (s != NULL)
-        s->tainted = false;
-    return hash;
-}
-
-
-VALUE
-rb_hash_tainted(VALUE hash)
-{
-    struct rb_objc_hash_struct *s;
-
-    s = rb_objc_hash_get_struct(hash);
-
-    return s != NULL && s->tainted ? Qtrue : Qfalse;
-}
-
 static void
 rb_objc_hash_set_struct(VALUE hash, VALUE ifnone, bool has_proc_default)
 {
@@ -358,20 +303,6 @@
     GC_WB(&s->ifnone, ifnone);
     s->has_proc_default = has_proc_default;
 }
-
-static void
-rb_objc_ary_copy_struct(VALUE old, VALUE new)
-{
-    struct rb_objc_hash_struct *s;
-
-    s = rb_objc_hash_get_struct(old);
-    if (s != NULL) {
-	struct rb_objc_hash_struct *n;
-
-	n = rb_objc_hash_get_struct2(new);
-	memcpy(n, s, sizeof(struct rb_objc_hash_struct));
-    }
-}
 #endif
 
 static VALUE
@@ -398,6 +329,7 @@
 	*(Class *)hash = RCLASS_OCID(klass);
 
     CFMakeCollectable((CFTypeRef)hash);
+    rb_gc_malloc_increase(sizeof(void *));
 
     return hash;
 #else
@@ -420,36 +352,17 @@
 #endif
 }
 
-#if WITH_OBJC
-static VALUE rb_hash_replace(VALUE, VALUE);
-
-VALUE
-rb_hash_clone(VALUE hash)
-{
-    VALUE klass, dup;
-    long n;
-
-    klass = rb_obj_class(hash);
-    dup = hash_alloc(klass);
-    rb_hash_replace(dup, hash);
-    rb_objc_ary_copy_struct(hash, dup);
-    return dup;
-}
-#endif
-
 static void
 rb_hash_modify_check(VALUE hash)
 {
 #if WITH_OBJC
     bool _CFDictionaryIsMutable(void *);
-    if (rb_hash_frozen(hash) == Qtrue) rb_error_frozen("hash");
     if (!_CFDictionaryIsMutable((void *)hash)) 
 	rb_raise(rb_eRuntimeError, "can't modify immutable hash");
-#else
+#endif
     if (OBJ_FROZEN(hash)) rb_error_frozen("hash");
     if (!OBJ_TAINTED(hash) && rb_safe_level() >= 4)
 	rb_raise(rb_eSecurityError, "Insecure: can't modify hash");
-#endif
 }
 
 struct st_table *
@@ -1313,8 +1226,8 @@
 {
     rb_hash_modify(hash);
 #if WITH_OBJC
-    if (TYPE(key) == T_STRING)
-	key = rb_obj_dup(key); /* FIXME temporary fix. */
+//    if (TYPE(key) == T_STRING)
+//	key = rb_obj_dup(key); /* FIXME temporary fix. */
     CFDictionarySetValue((CFMutableDictionaryRef)hash, (const void *)key,
 	(const void *)val);
 #else
@@ -2208,12 +2121,12 @@
 static VALUE
 env_delete(VALUE obj, VALUE name)
 {
-    char *nam, *val;
+    const char *nam, *val;
 
     rb_secure(4);
     SafeStringValue(name);
-    nam = RSTRING_PTR(name);
-    if (strlen(nam) != RSTRING_LEN(name)) {
+    nam = RSTRING_CPTR(name);
+    if (strlen(nam) != RSTRING_CLEN(name)) {
 	rb_raise(rb_eArgError, "bad environment variable name");
     }
     val = getenv(nam);
@@ -2247,12 +2160,12 @@
 static VALUE
 rb_f_getenv(VALUE obj, VALUE name)
 {
-    char *nam, *env;
+    const char *nam, *env;
 
     rb_secure(4);
     SafeStringValue(name);
-    nam = RSTRING_PTR(name);
-    if (strlen(nam) != RSTRING_LEN(name)) {
+    nam = RSTRING_CPTR(name);
+    if (strlen(nam) != RSTRING_CLEN(name)) {
 	rb_raise(rb_eArgError, "bad environment variable name");
     }
     env = getenv(nam);
@@ -2278,7 +2191,7 @@
 {
     VALUE key, if_none;
     long block_given;
-    char *nam, *env;
+    const char *nam, *env;
 
     rb_secure(4);
     rb_scan_args(argc, argv, "11", &key, &if_none);
@@ -2287,8 +2200,8 @@
 	rb_warn("block supersedes default value argument");
     }
     SafeStringValue(key);
-    nam = RSTRING_PTR(key);
-    if (strlen(nam) != RSTRING_LEN(key)) {
+    nam = RSTRING_CPTR(key);
+    if (strlen(nam) != RSTRING_CLEN(key)) {
 	rb_raise(rb_eArgError, "bad environment variable name");
     }
     env = getenv(nam);
@@ -2309,7 +2222,7 @@
 }
 
 static void
-path_tainted_p(char *path)
+path_tainted_p(const char *path)
 {
     path_tainted = rb_path_check(path)?0:1;
 }
@@ -2435,7 +2348,7 @@
 static VALUE
 env_aset(VALUE obj, VALUE nm, VALUE val)
 {
-    char *name, *value;
+    const char *name, *value;
 
     if (rb_safe_level() >= 4) {
 	rb_raise(rb_eSecurityError, "can't change environment variable");
@@ -2446,11 +2359,11 @@
     }
     StringValue(nm);
     StringValue(val);
-    name = RSTRING_PTR(nm);
-    value = RSTRING_PTR(val);
-    if (strlen(name) != RSTRING_LEN(nm))
+    name = RSTRING_CPTR(nm);
+    value = RSTRING_CPTR(val);
+    if (strlen(name) != RSTRING_CLEN(nm))
 	rb_raise(rb_eArgError, "bad environment variable name");
-    if (strlen(value) != RSTRING_LEN(val))
+    if (strlen(value) != RSTRING_CLEN(val))
 	rb_raise(rb_eArgError, "bad environment variable value");
 
     ruby_setenv(name, value);
@@ -2756,7 +2669,7 @@
 
     rb_secure(4);
     s = StringValuePtr(key);
-    if (strlen(s) != RSTRING_LEN(key))
+    if (strlen(s) != RSTRING_CLEN(key))
 	rb_raise(rb_eArgError, "bad environment variable name");
     if (getenv(s)) return Qtrue;
     return Qfalse;
@@ -2769,7 +2682,7 @@
 
     rb_secure(4);
     s = StringValuePtr(key);
-    if (strlen(s) != RSTRING_LEN(key))
+    if (strlen(s) != RSTRING_CLEN(key))
 	rb_raise(rb_eArgError, "bad environment variable name");
     e = getenv(s);
     if (e) return rb_assoc_new(key, rb_tainted_str_new2(e));
@@ -2789,7 +2702,7 @@
 	char *s = strchr(*env, '=');
 	if (s++) {
 	    long len = strlen(s);
-	    if (RSTRING_LEN(obj) == len && strncmp(s, RSTRING_PTR(obj), len) == 0) {
+	    if (RSTRING_CLEN(obj) == len && strncmp(s, RSTRING_CPTR(obj), len) == 0) {
 		FREE_ENVIRON(environ);
 		return Qtrue;
 	    }
@@ -2813,7 +2726,7 @@
 	char *s = strchr(*env, '=');
 	if (s++) {
 	    long len = strlen(s);
-	    if (RSTRING_LEN(obj) == len && strncmp(s, RSTRING_PTR(obj), len) == 0) {
+	    if (RSTRING_CLEN(obj) == len && strncmp(s, RSTRING_CPTR(obj), len) == 0) {
 		VALUE result = rb_assoc_new(rb_tainted_str_new(*env, s-*env-1), obj);
 		FREE_ENVIRON(environ);
 		return result;
@@ -2838,7 +2751,7 @@
 	char *s = strchr(*env, '=');
 	if (s++) {
 	    long len = strlen(s);
-	    if (RSTRING_LEN(value) == len && strncmp(s, RSTRING_PTR(value), len) == 0) {
+	    if (RSTRING_CLEN(value) == len && strncmp(s, RSTRING_CPTR(value), len) == 0) {
 		str = env_str_new(*env, s-*env-1);
 		FREE_ENVIRON(environ);
 		return str;
@@ -2895,7 +2808,7 @@
 	char *s = strchr(*env, '=');
 	if (s) {
 	    VALUE key = env_str_new(*env, s-*env);
-	    VALUE val = env_str_new2(getenv(RSTRING_PTR(key)));
+	    VALUE val = env_str_new2(getenv(RSTRING_CPTR(key)));
 	    env_delete(Qnil, key);
 	    return rb_assoc_new(key, val);
 	}
@@ -3115,10 +3028,6 @@
     rb_cHashRuby = rb_objc_import_class((Class)objc_getClass("NSMutableDictionary"));
     FL_UNSET(rb_cHashRuby, RCLASS_OBJC_IMPORTED);
     rb_const_set(rb_cObject, rb_intern("Hash"), rb_cHashRuby);
-    rb_define_method(rb_cHash, "freeze", rb_hash_freeze, 0);
-    rb_define_method(rb_cHash, "frozen?", rb_hash_frozen, 0);
-    rb_define_method(rb_cHash, "taint", rb_hash_taint, 0);
-    rb_define_method(rb_cHash, "tainted?", rb_hash_tainted, 0);
 #else
     rb_cHash = rb_define_class("Hash", rb_cObject);
 #endif

Modified: MacRuby/trunk/include/ruby/ruby.h
===================================================================
--- MacRuby/trunk/include/ruby/ruby.h	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/include/ruby/ruby.h	2008-05-11 00:16:55 UTC (rev 190)
@@ -369,7 +369,7 @@
 #define NUM2DBL(x) rb_num2dbl((VALUE)(x))
 
 /* obsolete API - use StringValue() */
-char *rb_str2cstr(VALUE,long*);
+const char *rb_str2cstr(VALUE,long*);
 /* obsolete API - use StringValuePtr() */
 #define STR2CSTR(x) rb_str2cstr((VALUE)(x),0)
 
@@ -389,14 +389,10 @@
     if (rb_safe_level() >= 3) FL_SET(obj, FL_TAINT);\
 } while (0)
 #if WITH_OBJC
-void rb_objc_keep_for_exit_finalize(VALUE v);
 # define OBJSETUP(obj,c,t) do {\
     __OBJSETUP(obj,c,t);\
     if (c != 0) \
 	RBASIC(obj)->isa = (void *)RCLASS_OCID(c); \
-    if (!SPECIAL_CONST_P(obj) \
-	&& (BUILTIN_TYPE(obj) == T_FILE /*|| BUILTIN_TYPE(obj) == T_DATA*/)) \
-	rb_objc_keep_for_exit_finalize((VALUE)obj); \
 } while (0)
 #else
 # define OBJSETUP(obj,c,t) __OBJSETUP(obj,c,t)

Modified: MacRuby/trunk/io.c
===================================================================
--- MacRuby/trunk/io.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/io.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -464,6 +464,11 @@
 
     io->fptr = 0;
 
+#if WITH_OBJC
+    void rb_objc_keep_for_exit_finalize(VALUE);
+    rb_objc_keep_for_exit_finalize((VALUE)io);
+#endif
+
     return (VALUE)io;
 }
 

Modified: MacRuby/trunk/iseq.c
===================================================================
--- MacRuby/trunk/iseq.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/iseq.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -811,7 +811,7 @@
     rb_str_cat2(str, "== disasm: ");
 
     rb_str_concat(str, iseq_inspect(iseqdat->self));
-    if ((i = RSTRING_LEN(str)) < header_minlen) {
+    if ((i = RSTRING_CLEN(str)) < header_minlen) {
 	rb_str_resize(str, header_minlen);
 	memset(RSTRING_PTR(str) + i, '=', header_minlen - i);
 	RSTRING_SYNC(str);

Modified: MacRuby/trunk/load.c
===================================================================
--- MacRuby/trunk/load.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/load.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -58,7 +58,7 @@
     for (i = 0; i < RARRAY_LEN(load_path); ++i) {
 	VALUE p = RARRAY_AT(load_path, i);
 	const char *s = StringValuePtr(p);
-	long n = RSTRING_LEN(p);
+	long n = RSTRING_CLEN(p);
 
 	if (vlen < n + len + 1) continue;
 	if (n && (strncmp(name, s, n) || name[n] != '/')) continue;
@@ -123,13 +123,13 @@
     for (i = 0, count = RARRAY_LEN(features); i < count; ++i) {
 	v = RARRAY_AT(features, i);
 	f = StringValueCStr(v);
-	if ((n = RSTRING_LEN(v)) < len) continue;
+	if ((n = RSTRING_CLEN(v)) < len) continue;
 	if (strncmp(f, feature, len) != 0) {
 	    if (expanded) continue;
 	    if (!load_path) load_path = get_load_path();
 	    if (!(p = loaded_feature_path(f, n, feature, len, type, load_path)))
 		continue;
-	    f += RSTRING_LEN(p) + 1;
+	    f += RSTRING_CLEN(p) + 1;
 	}
 	if (!*(e = f + len)) {
 	    if (ext) continue;

Modified: MacRuby/trunk/marshal.c
===================================================================
--- MacRuby/trunk/marshal.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/marshal.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -182,7 +182,7 @@
 {
     VALUE buf = arg->str;
     rb_str_buf_cat(buf, s, n);
-    if (arg->dest && RSTRING_LEN(buf) >= BUFSIZ) {
+    if (arg->dest && RSTRING_CLEN(buf) >= BUFSIZ) {
 	if (arg->taint) OBJ_TAINT(buf);
 	rb_io_write(arg->dest, buf);
 	rb_str_resize(buf, 0);
@@ -916,7 +916,7 @@
     int c;
 
     if (TYPE(arg->src) == T_STRING) {
-	if (RSTRING_LEN(arg->src) > arg->offset) {
+	if (RSTRING_CLEN(arg->src) > arg->offset) {
 	    c = (unsigned char)RSTRING_CPTR(arg->src)[arg->offset++];
 	}
 	else {
@@ -989,7 +989,7 @@
 
     if (len == 0) return rb_str_new(0, 0);
     if (TYPE(arg->src) == T_STRING) {
-	if (RSTRING_LEN(arg->src) - arg->offset >= len) {
+	if (RSTRING_CLEN(arg->src) - arg->offset >= len) {
 	    str = rb_str_new(RSTRING_CPTR(arg->src)+arg->offset, len);
 	    arg->offset += len;
 	}
@@ -1004,7 +1004,7 @@
 	str = rb_funcall2(src, s_read, 1, &n);
 	if (NIL_P(str)) goto too_short;
 	StringValue(str);
-	if (RSTRING_LEN(str) != len) goto too_short;
+	if (RSTRING_CLEN(str) != len) goto too_short;
 	if (OBJ_TAINTED(str)) arg->taint = Qtrue;
     }
     return str;
@@ -1269,7 +1269,7 @@
 	    else {
 		char *e;
 		d = strtod(ptr, &e);
-		d = load_mantissa(d, e, RSTRING_LEN(str) - (e - ptr));
+		d = load_mantissa(d, e, RSTRING_CLEN(str) - (e - ptr));
 	    }
 	    v = DOUBLE2NUM(d);
 	    v = r_entry(v, arg);

Modified: MacRuby/trunk/objc.m
===================================================================
--- MacRuby/trunk/objc.m	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/objc.m	2008-05-11 00:16:55 UTC (rev 190)
@@ -2506,11 +2506,10 @@
 }
 #endif
 
+#if 0
 /* XXX the ivar cluster API is not used yet, and may not simply be used. 
  */
-
 #define IVAR_CLUSTER_NAME "__rivars__"
-
 void
 rb_objc_install_ivar_cluster(Class klass)
 {
@@ -2531,7 +2530,49 @@
 {
     assert(object_setInstanceVariable((id)obj, IVAR_CLUSTER_NAME, v) != NULL);
 }
+#endif
 
+static CFMutableDictionaryRef __obj_flags;
+
+bool
+rb_objc_flag_check(const void *obj, int flag)
+{
+    long v;
+
+    if (__obj_flags == NULL)
+	return false;
+ 
+    v = (long)CFDictionaryGetValue(__obj_flags, obj);
+    if (v == 0)
+	return false;
+
+    return (v & flag) == flag;
+}
+
+void
+rb_objc_flag_set(const void *obj, int flag, bool val)
+{
+    long v;
+
+    if (__obj_flags == NULL) {
+	__obj_flags = CFDictionaryCreateMutable(NULL, 0, NULL, NULL);
+    }
+    v = (long)CFDictionaryGetValue(__obj_flags, obj);
+    if (val) {
+	v |= flag;
+    }
+    else {
+	v ^= flag;
+    }
+    CFDictionarySetValue(__obj_flags, obj, (void *)v);
+}
+
+void
+rb_objc_remove_keys(const void *obj)
+{
+    CFDictionaryRemoveValue(__obj_flags, obj);
+}
+
 static void
 rb_objc_get_types_for_format_str(char **octypes, const int len, 
 				 const char *format_str)

Modified: MacRuby/trunk/object.c
===================================================================
--- MacRuby/trunk/object.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/object.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -159,19 +159,8 @@
 {
 #if WITH_OBJC
     if (rb_objc_is_non_native(obj)) {
-	int type = TYPE(obj);
-	if (type == T_ARRAY) {
-	    if (rb_ary_tainted(obj)) 
-		rb_ary_taint(dest);
-	}
-	else if (type == T_HASH) {
-	    if (rb_hash_tainted(obj)) 
-		rb_hash_taint(dest);
-	}
-	else if (type == T_STRING) {
-	    if (rb_str_tainted(obj)) 
-		rb_str_taint(dest);
-	}
+	if (rb_objc_flag_check(obj, FL_TAINT))
+	    rb_objc_flag_set(dest, FL_TAINT);
 	goto call_init_copy;
     }
 #endif
@@ -253,15 +242,10 @@
     }
 #if WITH_OBJC
     if (rb_objc_is_non_native(obj)) {
-	int type = TYPE(obj);
-	if (type == T_ARRAY)
-	    return rb_ary_clone(obj);
-	if (type == T_HASH)
-	    return rb_hash_clone(obj);
-	if (type == T_STRING)
-	    return rb_str_clone(obj);
         clone = rb_obj_alloc(rb_obj_class(obj));
         init_copy(clone, obj);
+	if (OBJ_FROZEN(obj))
+	    OBJ_FREEZE(clone);
 	return clone;
     }
 #endif
@@ -354,12 +338,20 @@
 {
     VALUE str2;
     const char *ivname;
+    const char *cstr;
 
+    cstr = RSTRING_CPTR(str);
+
     /* need not to show internal data */
     if (CLASS_OF(value) == 0) return ST_CONTINUE;
     if (!rb_is_instance_id(id)) return ST_CONTINUE;
-    if (RSTRING_PTR(str)[0] == '-') { /* first element */
+
+    if (cstr[0] == '-') { /* first element */
+#if WITH_OBJC
+	rb_str_update(str, 0, 0, rb_str_new2("#"));
+#else
 	RSTRING_PTR(str)[0] = '#';
+#endif
 	rb_str_cat2(str, " ");
     }
     else {
@@ -385,7 +377,11 @@
 	rb_ivar_foreach(obj, inspect_i, str);
     }
     rb_str_cat2(str, ">");
+#if WITH_OBJC
+    rb_str_update(str, 0, 0, rb_str_new2("#"));
+#else
     RSTRING_PTR(str)[0] = '#';
+#endif
     OBJ_INFECT(str, obj);
 
     return str;
@@ -683,14 +679,7 @@
 {
 #if WITH_OBJC
     if (!SPECIAL_CONST_P(obj) && rb_objc_is_non_native(obj)) {
-	int type = TYPE(obj);
-	if (type == T_ARRAY)
-	    return rb_ary_tainted(obj);
-	if (type == T_HASH)
-	    return rb_hash_tainted(obj);
-	if (type == T_STRING)
-	    return rb_str_tainted(obj);
-	return Qfalse;
+	return rb_objc_flag_check(obj, FL_TAINT) ? Qtrue : Qfalse;
     }
 #endif
     if (FL_TEST(obj, FL_TAINT))
@@ -713,14 +702,8 @@
     rb_secure(4);
 #if WITH_OBJC
     if (!SPECIAL_CONST_P(obj) && rb_objc_is_non_native(obj)) {
-	int type = TYPE(obj);
-	if (type == T_ARRAY)
-	    return rb_ary_taint(obj);
-	if (type == T_HASH)
-	    return rb_hash_taint(obj);
-	if (type == T_STRING)
-	    return rb_str_taint(obj);
-	rb_raise(rb_eRuntimeError, "can't taint pure objc objects");
+	rb_objc_flag_set(obj, FL_TAINT, true);
+	return obj;
     }
 #endif
     if (!OBJ_TAINTED(obj)) {
@@ -746,16 +729,8 @@
     rb_secure(3);
 #if WITH_OBJC
     if (!SPECIAL_CONST_P(obj) && rb_objc_is_non_native(obj)) {
-	int type = TYPE(obj);
-	if (type == T_ARRAY)
-	    return rb_ary_untaint(obj);
-	else if (type == T_HASH)
-	    return rb_hash_untaint(obj);
-	else if (type == T_STRING)
-	    return rb_str_untaint(obj);
-	else
-	    rb_raise(rb_eRuntimeError, "can't untaint pure objc object `%s'",
-		    RSTRING_PTR(rb_inspect(obj)));
+	rb_objc_flag_set(obj, FL_TAINT, false);
+	return obj;
     }
 #endif
     if (OBJ_TAINTED(obj)) {
@@ -810,18 +785,7 @@
 	}
 #if WITH_OBJC
 	else if (rb_objc_is_non_native(obj)) {
-	    int type = TYPE(obj);
-	    if (type == T_ARRAY)
-		return rb_ary_freeze(obj);
-	    else if (type == T_HASH)
-		return rb_hash_freeze(obj);
-	    else if (type == T_STRING)
-		return rb_str_freeze(obj);
-	    else {
-		if (rb_cString != 0 && rb_cArray != 0 && rb_cHash != 0)
-		    rb_raise(rb_eRuntimeError, "can't freeze pure objc " \
-			     "object `%p'", RSTRING_CPTR(rb_inspect(obj)));
-	    }
+	    rb_objc_flag_set(obj, FL_FREEZE, true);
 	}
 #endif
 	else {
@@ -851,14 +815,7 @@
     }
 #if WITH_OBJC
     if (rb_objc_is_non_native(obj)) {
-	int type = TYPE(obj);
-	if (type == T_ARRAY)
-	    return rb_ary_frozen_p(obj);
-	if (type == T_HASH)
-	    return rb_hash_frozen(obj);
-	if (type == T_STRING)
-	    return rb_str_frozen(obj);
-	return Qfalse;
+	return rb_objc_flag_check(obj, FL_FREEZE) ? Qtrue : Qfalse;
     }
 #endif
     if (FL_TEST(obj, FL_FREEZE)) return Qtrue;
@@ -1522,15 +1479,9 @@
 #if WITH_OBJC
     if (FL_TEST(klass, RCLASS_OBJC_IMPORTED)) {
 	static SEL sel_new = 0;
-	id ocid;
 	if (sel_new == 0)
 	    sel_new = sel_registerName("new");
-	ocid = objc_msgSend((id)RCLASS_OCID(klass), sel_new);
-	/* FIXME this is a temporary solution until the Ruby primitive classes
-	 * are re-implemented using their CF equivalents.
-	 */
-	unsigned rb_objc_ocid_to_rval(void **ocval, VALUE *rbval);
-	rb_objc_ocid_to_rval((void **)&ocid, &obj);
+	obj = (VALUE)objc_msgSend((id)RCLASS_OCID(klass), sel_new);
 	return obj;
     }
 #endif
@@ -2229,12 +2180,12 @@
 double
 rb_str_to_dbl(VALUE str, int badcheck)
 {
-    char *s;
+    const char *s;
     long len;
 
     StringValue(str);
-    s = RSTRING_PTR(str);
-    len = RSTRING_LEN(str);
+    s = RSTRING_CPTR(str);
+    len = RSTRING_CLEN(str);
     if (s) {
 	if (s[len]) {		/* no sentinel somehow */
 	    char *p = ALLOCA_N(char, len+1);
@@ -2321,15 +2272,15 @@
     return RFLOAT_VALUE(rb_Float(val));
 }
 
-char*
+const char*
 rb_str2cstr(VALUE str, long *len)
 {
     StringValue(str);
-    if (len) *len = RSTRING_LEN(str);
-    else if (RTEST(ruby_verbose) && RSTRING_LEN(str) != strlen(RSTRING_PTR(str))) {
+    if (len) *len = RSTRING_CLEN(str);
+    else if (RTEST(ruby_verbose) && RSTRING_CLEN(str) != strlen(RSTRING_CPTR(str))) {
 	rb_warn("string contains \\0 character");
     }
-    return RSTRING_PTR(str);
+    return RSTRING_CPTR(str);
 }
 
 VALUE

Modified: MacRuby/trunk/pack.c
===================================================================
--- MacRuby/trunk/pack.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/pack.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -841,14 +841,14 @@
 
 	  case 'X':		/* back up byte */
 	  shrink:
-	    plen = RSTRING_LEN(res);
+	    plen = RSTRING_CLEN(res);
 	    if (plen < len)
 		rb_raise(rb_eArgError, "X outside of string");
 	    rb_str_set_len(res, plen - len);
 	    break;
 
 	  case '@':		/* null fill to absolute position */
-	    len -= RSTRING_LEN(res);
+	    len -= RSTRING_CLEN(res);
 	    if (len > 0) goto grow;
 	    len = -len;
 	    if (len > 0) goto shrink;
@@ -910,9 +910,9 @@
 	    from = THISFROM;
 	    if (!NIL_P(from)) {
 		StringValue(from);
-		if (RSTRING_LEN(from) < len) {
+		if (RSTRING_CLEN(from) < len) {
 		    rb_raise(rb_eArgError, "too short buffer for P(%ld for %ld)",
-			     RSTRING_LEN(from), len);
+			     RSTRING_CLEN(from), len);
 		}
 	    }
 	    len = 1;
@@ -1895,7 +1895,7 @@
 		    for (i = 0; i < count; i++) {
 			VALUE p = RARRAY_AT(a, i);
 			if (TYPE(p) == T_STRING && RSTRING_CPTR(p) == t) {
-			    if (len < RSTRING_LEN(p)) {
+			    if (len < RSTRING_CLEN(p)) {
 				tmp = rb_tainted_str_new(t, len);
 				rb_str_associate(tmp, a);
 			    }
@@ -1918,7 +1918,7 @@
 		    pend = p + RARRAY_LEN(a);
 		    while (p < pend) {
 			if (TYPE(*p) == T_STRING && RSTRING_CPTR(*p) == t) {
-			    if (len < RSTRING_LEN(*p)) {
+			    if (len < RSTRING_CLEN(*p)) {
 				tmp = rb_tainted_str_new(t, len);
 				rb_str_associate(tmp, a);
 			    }

Modified: MacRuby/trunk/process.c
===================================================================
--- MacRuby/trunk/process.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/process.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -1022,7 +1022,7 @@
 
     args = ALLOCA_N(char*, argc+1);
     for (i=0; i<argc; i++) {
-	args[i] = RSTRING_CPTR(argv[i]);
+	args[i] = (char *)RSTRING_CPTR(argv[i]);
     }
     args[i] = 0;
     if (args[0]) {

Modified: MacRuby/trunk/re.c
===================================================================
--- MacRuby/trunk/re.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/re.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -309,9 +309,15 @@
 rb_reg_source(VALUE re)
 {
     VALUE str;
+    const char *cstr;
+    long clen;
 
     rb_reg_check(re);
-    str = rb_enc_str_new(RREGEXP(re)->str,RREGEXP(re)->len, rb_enc_get(re));
+    cstr = RREGEXP(re)->str;
+    clen = RREGEXP(re)->len;
+    if (clen == 0)
+	cstr = NULL;
+    str = rb_enc_str_new(cstr, clen, rb_enc_get(re));
     if (OBJ_TAINTED(re)) OBJ_TAINT(str);
     return str;
 }
@@ -1127,12 +1133,12 @@
 	range = -pos;
     }
     else {
-	range = RSTRING_LEN(str) - pos;
+	range = RSTRING_CLEN(str) - pos;
     }
 
     enc = (RREGEXP(re)->ptr)->enc;
 
-    if (pos > 0 && ONIGENC_MBC_MAXLEN(enc) != 1 && pos < RSTRING_LEN(str)) {
+    if (pos > 0 && ONIGENC_MBC_MAXLEN(enc) != 1 && pos < RSTRING_CLEN(str)) {
 	 string = (UChar*)RSTRING_CPTR(str);
 
 	 if (range > 0) {
@@ -1324,7 +1330,7 @@
     if (BEG(0) == -1) return Qnil;
     str = RMATCH(match)->str;
     pos = END(0);
-    str = rb_str_subseq(str, pos, RSTRING_LEN(str) - pos);
+    str = rb_str_subseq(str, pos, RSTRING_CLEN(str) - pos);
     if (OBJ_TAINTED(match)) OBJ_TAINT(str);
     return str;
 }
@@ -2295,7 +2301,7 @@
 rb_reg_regcomp(VALUE str)
 {
     volatile VALUE save_str = str;
-    if (reg_cache && RREGEXP(reg_cache)->len == RSTRING_LEN(str)
+    if (reg_cache && RREGEXP(reg_cache)->len == RSTRING_CLEN(str)
 	&& ENCODING_GET(reg_cache) == ENCODING_GET(str)
         && memcmp(RREGEXP(reg_cache)->str, RSTRING_CPTR(str), RSTRING_CLEN(str)) == 0)
 	return reg_cache;
@@ -2647,7 +2653,7 @@
 	str = argv[0];
 	ptr = StringValuePtr(str);
 	if (enc
-	    ? rb_reg_initialize(self, ptr, RSTRING_LEN(str), enc, flags, err)
+	    ? rb_reg_initialize(self, ptr, RSTRING_CLEN(str), enc, flags, err)
 	    : rb_reg_initialize_str(self, str, flags, err)) {
 	    rb_reg_raise_str(str, flags, err);
 	}

Modified: MacRuby/trunk/ruby.c
===================================================================
--- MacRuby/trunk/ruby.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/ruby.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -303,7 +303,7 @@
 static VALUE
 expand_include_path(VALUE path)
 {
-    char *p = RSTRING_CPTR(path);
+    const char *p = RSTRING_CPTR(path);
     if (!p)
 	return path;
     if (*p == '.' && p[1] == '/')
@@ -1324,7 +1324,8 @@
 static void
 set_arg0(VALUE val, ID id)
 {
-    char *s, *t;
+    const char *s;
+    char *t;
     long i;
 
     if (origarg.argv == 0)

Modified: MacRuby/trunk/signal.c
===================================================================
--- MacRuby/trunk/signal.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/signal.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -714,7 +714,7 @@
 	command = rb_check_string_type(*cmd);
 	if (!NIL_P(command)) {
 	    SafeStringValue(command);	/* taint check */
-	    switch (RSTRING_LEN(command)) {
+	    switch (RSTRING_CLEN(command)) {
 	      case 0:
                 goto sig_ign;
 		break;

Modified: MacRuby/trunk/sprintf.c
===================================================================
--- MacRuby/trunk/sprintf.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/sprintf.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -282,7 +282,7 @@
     StringValue(fmt);
     enc = rb_enc_get(fmt);
     fmt = rb_str_new4(fmt);
-    p = RSTRING_PTR(fmt);
+    p = RSTRING_PTR(fmt); /* ok */
     end = p + RSTRING_LEN(fmt);
     blen = 0;
     bsiz = 120;

Modified: MacRuby/trunk/string.c
===================================================================
--- MacRuby/trunk/string.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/string.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -97,61 +97,19 @@
 
 #else
 
-struct rb_objc_str_struct {
-    void *cfdata;
-    bool tainted;
-    bool frozen;
-};
+static void *rb_str_cfdata_key;
 
-/* This variable will always stay NULL, we only use its address. */
-static void *rb_objc_str_assoc_key = NULL;
-
-static struct rb_objc_str_struct *
-rb_objc_str_get_struct(VALUE str)
+static inline void
+rb_str_cfdata_set(VALUE str, void *cfdata)
 {
-    return rb_objc_get_associative_ref((void *)str, &rb_objc_str_assoc_key);
+    rb_objc_set_associative_ref((void *)str, &rb_str_cfdata_key,
+	    cfdata);
 }
 
-static struct rb_objc_str_struct *
-rb_objc_str_get_struct2(VALUE str)
-{
-    struct rb_objc_str_struct *s;
-
-    s = rb_objc_str_get_struct(str);
-    if (s == NULL) {
-	s = xmalloc(sizeof(struct rb_objc_str_struct));
-	rb_objc_set_associative_ref((void *)str, &rb_objc_str_assoc_key, s);
-	s->cfdata = NULL;
-    }
-    return s;
-}
-
-static void
-rb_objc_str_copy_struct(VALUE old, VALUE new)
-{
-    struct rb_objc_str_struct *s;
-
-    s = rb_objc_str_get_struct(old);
-    if (s != NULL) {
-	struct rb_objc_str_struct *n;
-
-	n = rb_objc_str_get_struct2(new);
-	memcpy(n, s, sizeof(struct rb_objc_str_struct));
-	if (n->cfdata != NULL) {
-	    GC_WB(&n->cfdata, CFDataCreateMutableCopy(NULL, 0, 
-		(CFDataRef)n->cfdata));
-	    CFMakeCollectable(n->cfdata);
-	}
-    }
-}
-
 static inline void *
 rb_str_cfdata2(VALUE str) 
 {
-    struct rb_objc_str_struct *s;
-
-    s = rb_objc_str_get_struct(str);
-    return s != NULL ? s->cfdata : NULL;
+    return rb_objc_get_associative_ref((void *)str, &rb_str_cfdata_key);
 }
 
 static inline bool
@@ -163,10 +121,10 @@
 static void *
 rb_str_cfdata(VALUE str)
 {
-    struct rb_objc_str_struct *s;
+    void *cfdata;
 
-    s = rb_objc_str_get_struct2(str);
-    if (s->cfdata == NULL) {
+    cfdata = rb_str_cfdata2(str);
+    if (cfdata == NULL) {
 	CFDataRef data;
 	CFMutableDataRef mdata;
 	long len;
@@ -185,11 +143,12 @@
 	CFDataSetLength(mdata, len + 1); 
 	CFDataSetLength(mdata, len);
 	//assert(strcmp(CFDataGetBytePtr(mdata), CFStringGetCStringPtr((CFStringRef)str, 0))==0);
-	GC_WB(&s->cfdata, mdata);
+	cfdata = (void *)mdata;
+	rb_str_cfdata_set(str, cfdata);
 	CFRelease((CFTypeRef)data);
-	CFMakeCollectable(s->cfdata);
+	CFMakeCollectable(cfdata);
     }
-    return s->cfdata;    
+    return cfdata;    
 }
 
 char *
@@ -208,17 +167,17 @@
 void
 rb_str_bytesync(VALUE str)
 {
-    struct rb_objc_str_struct *s;
+    void *cfdata;
 
-    s = rb_objc_str_get_struct2(str);
-    if (s != NULL && s->cfdata != NULL) {
+    cfdata = rb_str_cfdata2(str);
+    if (cfdata != NULL) {
 	CFDataRef data;
 	CFIndex datalen;
 	const UInt8 *dataptr;
 	CFStringRef bytestr;
 	const char *strptr;
 
-	data = (CFDataRef)s->cfdata;
+	data = (CFDataRef)cfdata;
 	datalen = CFDataGetLength(data);
 	dataptr = CFDataGetBytePtr(data);
 	bytestr = CFStringCreateWithBytesNoCopy(
@@ -236,7 +195,7 @@
 		&& ((const char *)dataptr == strptr
 		    || dataptr == NULL
 		    || memcmp((const char *)dataptr, strptr, datalen) == 0)) {
-		s->cfdata = NULL;
+		rb_str_cfdata_set(str, NULL);
 	    }
 	}
     }
@@ -245,51 +204,10 @@
 VALUE
 rb_str_freeze(VALUE str)
 {
-    rb_objc_str_get_struct2(str)->frozen = true;
+    rb_obj_freeze(str);
     return str;
 }
 
-VALUE
-rb_str_frozen(VALUE str)
-{
-    struct rb_objc_str_struct *s;
-    s = rb_objc_str_get_struct(str);
-    return s != NULL && s->frozen ? Qtrue : Qfalse;
-}
-
-VALUE
-rb_str_taint(VALUE str)
-{
-    rb_objc_str_get_struct2(str)->tainted = true;
-    return str;
-}
-
-VALUE
-rb_str_untaint(VALUE str)
-{
-    struct rb_objc_str_struct *s;
-    s = rb_objc_str_get_struct(str);
-    if (s != NULL)
-	s->tainted = false;
-    return str;
-}
-
-VALUE
-rb_str_tainted(VALUE str)
-{
-    struct rb_objc_str_struct *s;
-    s = rb_objc_str_get_struct(str);
-    return s != NULL && s->tainted ? Qtrue : Qfalse;
-}
-
-VALUE
-rb_str_clone(VALUE str)
-{
-    VALUE dup = rb_str_dup(str);
-    rb_objc_str_copy_struct(str, dup);
-    return dup;
-}
-
 static VALUE
 rb_str_bytestring_m(VALUE str)
 {
@@ -546,11 +464,7 @@
 static inline void
 str_frozen_check(VALUE s)
 {
-#if WITH_OBJC
-    if (rb_str_frozen(s) == Qtrue) {
-#else
     if (OBJ_FROZEN(s)) {
-#endif
 	rb_raise(rb_eRuntimeError, "string frozen");
     }
 }
@@ -602,13 +516,11 @@
 	CFRelease(substr);
     }
     else {
-	struct rb_objc_str_struct *s;
 	CFMutableDataRef data;
 
-	s = rb_objc_str_get_struct2(str);
 	data = CFDataCreateMutable(NULL, 0);
 	CFDataAppendBytes(data, (const UInt8 *)dataptr, datalen);
-	GC_WB(&s->cfdata, (void *)data);
+	rb_str_cfdata_set(str, data);
 	CFMakeCollectable(data);
     }
 }
@@ -646,6 +558,7 @@
     }
     if (need_padding)
 	CFStringPad((CFMutableStringRef)str, CFSTR(" "), len, 0);
+    rb_gc_malloc_increase(sizeof(UniChar) * len);
 #else
     if (len > RSTRING_EMBED_LEN_MAX) {
 	RSTRING(str)->as.heap.aux.capa = len;
@@ -708,12 +621,7 @@
 rb_tainted_str_new(const char *ptr, long len)
 {
     VALUE str = rb_str_new(ptr, len);
-
-#if WITH_OBJC 
-    rb_str_taint(str);
-#else
     OBJ_TAINT(str);
-#endif
     return str;
 }
 
@@ -721,12 +629,7 @@
 rb_tainted_str_new2(const char *ptr)
 {
     VALUE str = rb_str_new2(ptr);
-
-#if WITH_OBJC 
-    rb_str_taint(str);
-#else
     OBJ_TAINT(str);
-#endif
     return str;
 }
 
@@ -982,18 +885,9 @@
 VALUE
 rb_str_dup(VALUE str)
 {
-#if WITH_OBJC
-    CFMutableStringRef copy = CFStringCreateMutableCopy(NULL, 0, 
-	(CFStringRef)str);
-    CFMakeCollectable(copy);
-    if (OBJ_TAINTED(str)) 
-	OBJ_TAINT(copy);
-    return (VALUE)copy;
-#else
     VALUE dup = str_alloc(rb_obj_class(str));
     rb_str_replace(dup, str);
     return dup;
-#endif
 }
 
 
@@ -1318,18 +1212,14 @@
     bool _CFStringIsMutable(void *);
     if (!__CFStringIsMutable(str)) 
 	rb_raise(rb_eRuntimeError, "can't modify immutable string");
-    if (rb_str_frozen(str) == Qtrue)
-	rb_error_frozen("string");
-    if (rb_str_tainted(str) == Qfalse && rb_safe_level() >= 4)
-	rb_raise(rb_eSecurityError, "Insecure: can't modify string");
 #else
     if (FL_TEST(str, STR_TMPLOCK)) {
 	rb_raise(rb_eRuntimeError, "can't modify string; temporarily locked");
     }
+#endif
     if (OBJ_FROZEN(str)) rb_error_frozen("string");
     if (!OBJ_TAINTED(str) && rb_safe_level() >= 4)
 	rb_raise(rb_eSecurityError, "Insecure: can't modify string");
-#endif
 }
 
 #if !WITH_OBJC
@@ -1447,8 +1337,14 @@
     data = (CFDataRef)rb_str_cfdata2(ptr);
     if (data == NULL) {
 	cptr = CFStringGetCStringPtr((CFStringRef)ptr, 0);
-    	if (cptr == NULL && CFStringGetLength((CFStringRef)ptr) > 0)
-	    data = (CFDataRef)rb_str_cfdata(ptr);
+    	if (cptr == NULL) {
+	    long len;
+	    len = CFStringGetLength((CFStringRef)ptr);
+	    if (len == 0)
+		return "";
+	    else 
+		data = (CFDataRef)rb_str_cfdata(ptr);
+	}
     }
     return data == NULL ? cptr : (const char *)CFDataGetBytePtr(data);
 }
@@ -1639,25 +1535,26 @@
 {
 #if WITH_OBJC
     long n = CFStringGetLength((CFStringRef)str);
-    CFStringRef substr, msubstr;
+    CFMutableStringRef substr;
     if (beg < 0)
 	beg += n;
     if (beg > n || beg < 0)
 	return Qnil;
     if (beg + len > n)
 	return (VALUE)CFSTR("");
+    substr = CFStringCreateMutable(NULL, 0);
     if (len == 1) {
 	UniChar c = CFStringGetCharacterAtIndex((CFStringRef)str, beg);
-	substr = CFStringCreateWithCharacters(NULL, &c, 1);
+	CFStringAppendCharacters(substr, &c, 1);
     }
     else {
-	substr = CFStringCreateWithSubstring(NULL, (CFStringRef)str, 
-	    CFRangeMake(beg, len));
+	UniChar *buffer = alloca(sizeof(UniChar) * len);
+	CFStringGetCharacters((CFStringRef)str, CFRangeMake(beg, len), buffer);
+	CFStringAppendCharacters(substr, buffer, len);
     }
-    msubstr = (CFStringRef)CFStringCreateMutableCopy(NULL, 0, substr);
-    CFRelease(substr);
-    CFMakeCollectable(msubstr);
-    return (VALUE)msubstr;
+    rb_gc_malloc_increase(sizeof(UniChar) * len);
+    CFMakeCollectable(substr);
+    return (VALUE)substr;
 #else
     VALUE str2 = rb_str_new5(str, RSTRING_PTR(str)+beg, len);
 
@@ -1824,13 +1721,13 @@
 #if WITH_OBJC
     slen = CFStringGetLength((CFStringRef)str);
     if (slen != len) {
-	struct rb_objc_str_struct *s;
+	void *cfdata;
 
 	CFStringPad((CFMutableStringRef)str, CFSTR(" "), len, 0);
 
-	s = rb_objc_str_get_struct(str);
-	if (s != NULL && s->cfdata != NULL)
-	    CFDataSetLength((CFMutableDataRef)s->cfdata, len); 
+	cfdata = rb_str_cfdata2(str);
+	if (cfdata != NULL)
+	    CFDataSetLength((CFMutableDataRef)cfdata, len); 
     }
 #else
     slen = RSTRING_LEN(str);
@@ -2139,8 +2036,11 @@
 #if WITH_OBJC
     CFMutableDataRef mdata;
     CFDataRef data;
+    long str2len;
 
-    if (RSTRING_CLEN(str2) == 0)
+    str2len = RSTRING_CLEN(str2);
+
+    if (str2len == 0)
 	return str;
 
     data = (CFDataRef)rb_str_cfdata2(str2);
@@ -2160,6 +2060,7 @@
 		CFDataGetLength(data));
 	}
     }
+    rb_gc_malloc_increase(sizeof(UniChar) * str2len);
 #else
     int str2_cr;
 
@@ -2230,6 +2131,7 @@
 	rb_str_modify(str1);
         CFStringAppendCharacters((CFMutableStringRef)str1, (const UniChar *)&c, 
 	    1);
+	rb_gc_malloc_increase(sizeof(UniChar));
 #else
 	rb_encoding *enc = STR_ENC_GET(str1);
 	int c = FIX2INT(str2);
@@ -4005,7 +3907,7 @@
 	CFStringReplaceAll((CFMutableStringRef)str, (CFStringRef)dest);
     }
     else {
-    	if (!tainted && rb_str_tainted(str) == Qtrue)
+    	if (!tainted && OBJ_TAINTED(str))
 	    tainted = 1;
 	str = dest;
     }
@@ -4021,7 +3923,7 @@
     }
 #endif
 
-    if (tainted) rb_str_taint(str);
+    if (tainted) OBJ_TAINT(str);
     return str;
 }
 
@@ -4101,8 +4003,8 @@
 #if WITH_OBJC
     rb_str_modify(str);
     CFStringReplaceAll((CFMutableStringRef)str, (CFStringRef)str2);
-    if (rb_str_tainted(str2) == Qtrue)
-	rb_str_taint(str);
+    if (OBJ_TAINTED(str2))
+	OBJ_TAINT(str);
 #else
     StringValue(str2);
     len = RSTRING_LEN(str2);
@@ -4875,6 +4777,7 @@
 	return Qnil;
     tmp = CFStringCreateWithCharacters(NULL, buffer, n);
     CFStringReplaceAll((CFMutableStringRef)str, tmp);
+    CFRelease(tmp);
     return str;
 #else
     rb_encoding *enc;
@@ -6138,6 +6041,7 @@
 #else
     enc = STR_ENC_GET(str);
 #endif
+    result = rb_ary_new();
     if (NIL_P(spat)) {
 	if (!NIL_P(rb_fs)) {
 	    spat = rb_fs;
@@ -6148,22 +6052,22 @@
     else {
       fs_set:
 	if (TYPE(spat) == T_STRING) {
+	    const char *spat_cstr;
+	    long spat_clen;
 #if WITH_OBJC
 	    rb_encoding *enc2 = rb_ascii8bit_encoding();
 #else
 	    rb_encoding *enc2 = STR_ENC_GET(spat);
 #endif
-	    const char *spat_cstr;
-	    long spat_clen;
 
 	    spat_cstr = RSTRING_CPTR(spat);
 	    spat_clen = RSTRING_CLEN(spat);
 
 	    if (rb_enc_mbminlen(enc2) == 1) {
 		if (spat_clen == 1 && spat_cstr[0] == ' '){
-		awk_split = Qtrue;
+		    awk_split = Qtrue;
+		}
 	    }
-	    }
 	    else {
 		int l;
 		if (rb_enc_ascget(spat_cstr, spat_cstr+spat_clen, &l, enc2) == ' ' &&
@@ -6172,7 +6076,39 @@
 		}
 	    }
 	    if (!awk_split) {
+#if WITH_OBJC
+		CFRange search_range;
+		search_range = CFRangeMake(0, clen);
+		do {
+		    CFRange result_range;
+		    CFRange substr_range;
+		    if (!CFStringFindWithOptions((CFStringRef)str, 
+			(CFStringRef)spat,
+			search_range,
+			0,
+			&result_range))
+			break;
+
+		    substr_range.location = search_range.location;
+		    substr_range.length = result_range.location 
+			- search_range.location;
+
+		    rb_ary_push(result,
+			rb_str_subseq(str, substr_range.location,
+			    substr_range.length));
+
+		    search_range.location = result_range.location 
+			+ result_range.length;
+		    search_range.length = clen - search_range.location;
+		}
+		while ((limit == Qnil || --lim > 1));
+		rb_ary_push(result, 
+		    rb_str_subseq(str, search_range.location, 
+			search_range.length));
+		goto done;
+#else
 		spat = rb_reg_regcomp(rb_reg_quote(spat));
+#endif
 	    }
 	}
 	else {
@@ -6180,7 +6116,6 @@
 	}
     }
 
-    result = rb_ary_new();
     beg = 0;
     if (awk_split) {
 	const char *ptr = cstr;
@@ -6269,6 +6204,7 @@
 	    tmp = rb_str_subseq(str, beg, clen-beg);
 	rb_ary_push(result, tmp);
     }
+done:
     if (NIL_P(limit) && lim == 0) {
 	while (RARRAY_LEN(result) > 0 &&
 	       RSTRING_CLEN(RARRAY_AT(result, RARRAY_LEN(result)-1)) == 0)
@@ -6288,6 +6224,13 @@
     return rb_str_split_m(1, &sep, str);
 }
 
+VALUE
+rb_str_split2(VALUE str, VALUE sep)
+{
+    StringValue(str);
+    StringValue(sep);
+    return rb_str_split_m(1, &sep, str);
+}
 
 /*
  *  Document-method: lines
@@ -7104,9 +7047,12 @@
 	    CFRangeMake(*start, strlen - *start),
 	    0,
 	    &result_range)) {
-	    result = (VALUE)CFStringCreateWithSubstring(NULL, 
+	    CFStringRef str = CFStringCreateWithSubstring(NULL, 
 		(CFStringRef)str, result_range);
 	    *start = result_range.location + result_range.length + 1;
+	    result = (VALUE)CFStringCreateMutableCopy(NULL, 0, str);
+	    CFRelease(str);
+	    CFMakeCollectable((CFTypeRef)result);
 	}
 	else {
 	    result = Qnil;
@@ -7431,6 +7377,7 @@
 		    NULL,
 		    (CFStringRef)pad,
 		    CFRangeMake(0, width));
+	    CFMakeCollectable((CFTypeRef)pad);
 	}
 	CFStringInsert((CFMutableStringRef)str, index, (CFStringRef)pad);
 	width -= padwidth;	
@@ -8291,10 +8238,6 @@
         rb_objc_import_class((Class)objc_getClass("NSMutableString"));
     FL_UNSET(rb_cStringRuby, RCLASS_OBJC_IMPORTED);
     rb_const_set(rb_cObject, rb_intern("String"), rb_cStringRuby);
-    rb_define_method(rb_cString, "taint", rb_str_taint, 0);
-    rb_define_method(rb_cString, "tainted?", rb_str_tainted, 0);
-    rb_define_method(rb_cString, "freeze", rb_str_freeze, 0);
-    rb_define_method(rb_cString, "frozen?", rb_str_frozen, 0);
     rb_define_method(rb_cString, "__bytestring__?", rb_str_bytestring_m, 0);
 #else
     rb_cString  = rb_define_class("String", rb_cObject);

Modified: MacRuby/trunk/util.c
===================================================================
--- MacRuby/trunk/util.c	2008-05-06 23:07:11 UTC (rev 189)
+++ MacRuby/trunk/util.c	2008-05-11 00:16:55 UTC (rev 190)
@@ -279,13 +279,13 @@
     long slen;
     char buf[1024];
 
-    if (RSTRING_LEN(str) > 1000)
+    if (RSTRING_CLEN(str) > 1000)
         rb_fatal("Cannot do inplace edit on long filename (%ld characters)",
-		 RSTRING_LEN(str));
+		 RSTRING_CLEN(str));
 
 #if defined(DJGPP) || defined(__CYGWIN32__) || defined(_WIN32)
     /* Style 0 */
-    slen = RSTRING_LEN(str);
+    slen = RSTRING_CLEN(str);
     rb_str_cat(str, suffix, extlen);
 #if defined(DJGPP)
     if (_USE_LFN) return;

    

[macruby-changes] [190] MacRuby/trunk

source_changes＠macosforge.org