[macruby-changes] [189] MacRuby/trunk

6 May 2008

Revision: 189
          http://trac.macosforge.org/projects/ruby/changeset/189
Author:   lsansonetti@apple.com
Date:     2008-05-06 16:07:11 -0700 (Tue, 06 May 2008)

Log Message:
-----------
improving perfs, passing more tests, rubygems support wip

Modified Paths:
--------------
    MacRuby/trunk/array.c
    MacRuby/trunk/blockinlining.c
    MacRuby/trunk/dir.c
    MacRuby/trunk/error.c
    MacRuby/trunk/eval.c
    MacRuby/trunk/eval_error.c
    MacRuby/trunk/eval_jump.c
    MacRuby/trunk/ext/syck/rubyext.c
    MacRuby/trunk/include/ruby/encoding.h
    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/parse.y
    MacRuby/trunk/proc.c
    MacRuby/trunk/process.c
    MacRuby/trunk/range.c
    MacRuby/trunk/re.c
    MacRuby/trunk/string.c
    MacRuby/trunk/test/ruby/test_string.rb

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

--- MacRuby/trunk/array.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/array.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -1640,14 +1640,15 @@
 VALUE
 rb_ary_join(VALUE ary, VALUE sep)
 {
-    long len = 1, i;
+    long len = 1, i, count;
     int taint = Qfalse;
     VALUE result, tmp;
 
     if (RARRAY_LEN(ary) == 0) return rb_str_new(0, 0);
     if (OBJ_TAINTED(ary) || OBJ_TAINTED(sep)) taint = Qtrue;
-#if !WITH_OBJC
-    /* TODO should use CFStringCreateByCombiningStrings */
+#if WITH_OBJC
+    result = rb_str_buf_new(0);
+#else
     for (i=0; i<RARRAY_LEN(ary); i++) {
 	tmp = rb_check_string_type(RARRAY_AT(ary, i));
 	len += NIL_P(tmp) ? 10 : RSTRING_LEN(tmp);
@@ -1656,10 +1657,10 @@
 	StringValue(sep);
 	len += RSTRING_LEN(sep) * (RARRAY_LEN(ary) - 1);
     }
+    result = rb_str_buf_new(len);
 #endif
-    result = rb_str_buf_new(len);
 
-    for (i=0; i<RARRAY_LEN(ary); i++) {
+    for (i=0, count=RARRAY_LEN(ary); i<count; i++) {
 	tmp = RARRAY_AT(ary, i);
 	switch (TYPE(tmp)) {
 	  case T_STRING:

Modified: MacRuby/trunk/blockinlining.c
===================================================================
--- MacRuby/trunk/blockinlining.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/blockinlining.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -43,7 +43,7 @@
 				      parent, iseq->type,
 				      GC_GUARDED_PTR(builder));
     if (0) {
-	printf("%s\n", RSTRING_PTR(ruby_iseq_disasm(iseqval)));
+	printf("%s\n", RSTRING_CPTR(ruby_iseq_disasm(iseqval)));
     }
     iseq->cached_special_block = iseqval;
     iseq->cached_special_block_builder = builder;

Modified: MacRuby/trunk/dir.c
===================================================================
--- MacRuby/trunk/dir.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/dir.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -386,6 +386,7 @@
 dir_initialize(VALUE dir, VALUE dirname)
 {
     struct dir_data *dp;
+    const char *dirname_cstr;
 
     FilePathValue(dirname);
     Data_Get_Struct(dir, struct dir_data, dp);
@@ -393,17 +394,18 @@
     if (dp->path) free(dp->path);
     dp->dir = NULL;
     dp->path = NULL;
-    dp->dir = opendir(RSTRING_PTR(dirname));
+    dirname_cstr = RSTRING_CPTR(dirname);
+    dp->dir = opendir(dirname_cstr);
     if (dp->dir == NULL) {
 	if (errno == EMFILE || errno == ENFILE) {
 	    rb_gc();
-	    dp->dir = opendir(RSTRING_PTR(dirname));
+	    dp->dir = opendir(dirname_cstr);
 	}
 	if (dp->dir == NULL) {
-	    rb_sys_fail(RSTRING_PTR(dirname));
+	    rb_sys_fail(dirname_cstr);
 	}
     }
-    dp->path = strdup(RSTRING_PTR(dirname));
+    dp->path = strdup(dirname_cstr);
 
     return dir;
 }
@@ -470,6 +472,7 @@
 	int len = strlen(c) + strlen(dirp->path) + 4;
 	VALUE s = rb_str_new(0, len);
 	snprintf(RSTRING_PTR(s), len+1, "#<%s:%s>", c, dirp->path);
+	RSTRING_SYNC(s);
 	return s;
     }
     return rb_funcall(dir, rb_intern("to_s"), 0, 0);
@@ -829,11 +832,11 @@
 static void
 check_dirname(volatile VALUE *dir)
 {
-    char *path, *pend;
+    const char *path, *pend;
 
     rb_secure(2);
     FilePathValue(*dir);
-    path = RSTRING_PTR(*dir);
+    path = RSTRING_CPTR(*dir);
     if (path && *(pend = rb_path_end(rb_path_skip_prefix(path)))) {
 	*dir = rb_str_new(path, pend - path);
     }
@@ -852,10 +855,12 @@
 dir_s_chroot(VALUE dir, VALUE path)
 {
 #if defined(HAVE_CHROOT) && !defined(__CHECKER__)
+    const char *path_cstr = RSTRING_CPTR(path);
+
     check_dirname(&path);
 
-    if (chroot(RSTRING_PTR(path)) == -1)
-	rb_sys_fail(RSTRING_PTR(path));
+    if (chroot(path_cstr) == -1)
+	rb_sys_fail(path_cstr);
 
     return INT2FIX(0);
 #else
@@ -882,6 +887,7 @@
 {
     VALUE path, vmode;
     int mode;
+    const char *path_cstr;
 
     if (rb_scan_args(argc, argv, "11", &path, &vmode) == 2) {
 	mode = NUM2INT(vmode);
@@ -891,8 +897,9 @@
     }
 
     check_dirname(&path);
-    if (mkdir(RSTRING_PTR(path), mode) == -1)
-	rb_sys_fail(RSTRING_PTR(path));
+    path_cstr = RSTRING_CPTR(path);
+    if (mkdir(path_cstr, mode) == -1)
+	rb_sys_fail(path_cstr);
 
     return INT2FIX(0);
 }
@@ -909,9 +916,12 @@
 static VALUE
 dir_s_rmdir(VALUE obj, VALUE dir)
 {
+    const char *dir_cstr;
+
     check_dirname(&dir);
-    if (rmdir(RSTRING_PTR(dir)) < 0)
-	rb_sys_fail(RSTRING_PTR(dir));
+    dir_cstr = RSTRING_CPTR(dir);
+    if (rmdir(dir_cstr) < 0)
+	rb_sys_fail(dir_cstr);
 
     return INT2FIX(0);
 }
@@ -1550,23 +1560,27 @@
 static VALUE
 rb_push_glob(VALUE str, int flags) /* '\0' is delimiter */
 {
+    const char *cstr;
+    long clen;
     long offset = 0;
     VALUE ary;
 
     StringValue(str);
     ary = rb_ary_new();
+    cstr = RSTRING_CPTR(str);
+    clen = RSTRING_CLEN(str);
 
-    while (offset < RSTRING_LEN(str)) {
-	int status = push_glob(ary, RSTRING_PTR(str) + offset, flags);
-	char *p, *pend;
+    while (offset < clen) {
+	int status = push_glob(ary, cstr + offset, flags);
+	const char *p, *pend;
 	if (status) GLOB_JUMP_TAG(status);
-	if (offset >= RSTRING_LEN(str)) break;
-	p = RSTRING_PTR(str) + offset;
+	if (offset >= clen) break;
+	p = cstr + offset;
 	p += strlen(p) + 1;
-	pend = RSTRING_PTR(str) + RSTRING_LEN(str);
+	pend = cstr + clen;
 	while (p < pend && !*p)
 	    p++;
-	offset = p - RSTRING_PTR(str);
+	offset = p - cstr;
     }
 
     return ary;
@@ -1582,7 +1596,7 @@
 	int status;
 	VALUE str = argv[i];
 	StringValue(str);
-	status = push_glob(ary, RSTRING_PTR(str), flags);
+	status = push_glob(ary, RSTRING_CPTR(str), flags);
 	if (status) GLOB_JUMP_TAG(status);
     }
 
@@ -1684,7 +1698,7 @@
 	ary = rb_push_glob(str, flags);
     }
     else {
-	volatile VALUE v = ary;
+	VALUE v = ary;
 	ary = dir_globs(RARRAY_LEN(v), RARRAY_PTR(v), flags);
     }
 
@@ -1853,7 +1867,7 @@
     StringValue(pattern);
     FilePathStringValue(path);
 
-    if (fnmatch(RSTRING_PTR(pattern), RSTRING_PTR(path), flags) == 0)
+    if (fnmatch(RSTRING_CPTR(pattern), RSTRING_CPTR(path), flags) == 0)
 	return Qtrue;
 
     return Qfalse;

Modified: MacRuby/trunk/error.c
===================================================================
--- MacRuby/trunk/error.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/error.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -290,7 +290,7 @@
 		    etype = "Symbol";
 		}
 		else if (rb_special_const_p(x)) {
-		    etype = RSTRING_PTR(rb_obj_as_string(x));
+		    etype = RSTRING_CPTR(rb_obj_as_string(x));
 		}
 		else {
 		    etype = rb_obj_classname(x);
@@ -771,7 +771,7 @@
 	    if (NIL_P(d) || RSTRING_LEN(d) > 65) {
 		d = rb_any_to_s(obj);
 	    }
-	    desc = RSTRING_PTR(d);
+	    desc = RSTRING_CPTR(d);
 	    break;
 	}
 	if (desc && desc[0] != '#') {
@@ -814,7 +814,7 @@
 {
     VALUE s = rb_str_inspect(rb_str_new2(str));
 
-    rb_raise(rb_eArgError, "invalid value for %s: %s", type, RSTRING_PTR(s));
+    rb_raise(rb_eArgError, "invalid value for %s: %s", type, RSTRING_CPTR(s));
 }
 
 /* 
@@ -925,7 +925,7 @@
 
 	StringValue(str);
 	mesg = rb_sprintf("%s - %.*s", err,
-			  (int)RSTRING_LEN(str), RSTRING_PTR(str));
+			  (int)RSTRING_CLEN(str), RSTRING_CPTR(str));
     }
     else {
 	mesg = rb_str_new2(err);

Modified: MacRuby/trunk/eval.c
===================================================================
--- MacRuby/trunk/eval.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/eval.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -697,12 +697,12 @@
 	    if (file) {
 		warn_printf("Exception `%s' at %s:%d - %s\n",
 			    rb_obj_classname(th->errinfo),
-			    file, line, RSTRING_PTR(e));
+			    file, line, RSTRING_CPTR(e));
 	    }
 	    else {
 		warn_printf("Exception `%s' - %s\n",
 			    rb_obj_classname(th->errinfo),
-			    RSTRING_PTR(e));
+			    RSTRING_CPTR(e));
 	    }
 	}
 	POP_TAG();
@@ -1650,7 +1650,7 @@
 
     ary = backtrace(-1);
     for (i = 0; i < RARRAY_LEN(ary); i++) {
-	printf("\tfrom %s\n", RSTRING_PTR(RARRAY_AT(ary, i)));
+	printf("\tfrom %s\n", RSTRING_CPTR(RARRAY_AT(ary, i)));
     }
 }
 
@@ -1763,7 +1763,7 @@
 
 	if (0) {		/* for debug */
 	    extern VALUE ruby_iseq_disasm(VALUE);
-	    printf("%s\n", RSTRING_PTR(ruby_iseq_disasm(iseqval)));
+	    printf("%s\n", RSTRING_CPTR(ruby_iseq_disasm(iseqval)));
 	}
 
 	/* save new env */
@@ -1857,7 +1857,7 @@
     }
 
     if (!NIL_P(vfile))
-	file = RSTRING_PTR(vfile);
+	file = RSTRING_CPTR(vfile);
     return eval(self, src, scope, file, line);
 }
 

Modified: MacRuby/trunk/eval_error.c
===================================================================
--- MacRuby/trunk/eval_error.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/eval_error.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -10,7 +10,7 @@
     rb_control_frame_t *cfp = vm_get_ruby_level_cfp(th, th->cfp);
 
     if (cfp) {
-	return RSTRING_PTR(cfp->iseq->filename);
+	return RSTRING_CPTR(cfp->iseq->filename);
     }
     else {
 	return 0;
@@ -123,7 +123,7 @@
 	if (NIL_P(mesg))
 	    error_pos();
 	else {
-	    warn_print2(RSTRING_PTR(mesg), RSTRING_LEN(mesg));
+	    warn_print2(RSTRING_CPTR(mesg), RSTRING_CLEN(mesg));
 	}
     }
 
@@ -131,8 +131,8 @@
     if (EXEC_TAG() == 0) {
 	e = rb_funcall(errinfo, rb_intern("message"), 0, 0);
 	StringValue(e);
-	einfo = RSTRING_PTR(e);
-	elen = RSTRING_LEN(e);
+	einfo = RSTRING_CPTR(e);
+	elen = RSTRING_CLEN(e);
     }
     else {
 	einfo = "";
@@ -149,14 +149,14 @@
 	epath = rb_class_name(eclass);
 	if (elen == 0) {
 	    warn_print(": ");
-	    warn_print2(RSTRING_PTR(epath), RSTRING_LEN(epath));
+	    warn_print2(RSTRING_CPTR(epath), RSTRING_CLEN(epath));
 	    warn_print("\n");
 	}
 	else {
 	    char *tail = 0;
 	    long len = elen;
 
-	    if (RSTRING_PTR(epath)[0] == '#')
+	    if (RSTRING_CPTR(epath)[0] == '#')
 		epath = 0;
 	    if ((tail = memchr(einfo, '\n', elen)) != 0) {
 		len = tail - einfo;
@@ -166,7 +166,7 @@
 	    warn_print2(einfo, len);
 	    if (epath) {
 		warn_print(" (");
-		warn_print2(RSTRING_PTR(epath), RSTRING_LEN(epath));
+		warn_print2(RSTRING_CPTR(epath), RSTRING_CLEN(epath));
 		warn_print(")\n");
 	    }
 	    if (tail) {
@@ -188,7 +188,7 @@
 	for (i = 1; i < len; i++) {
 	    VALUE v = RARRAY_AT(errat, i);
 	    if (TYPE(v) == T_STRING) {
-		warn_printf("\tfrom %s\n", RSTRING_PTR(v));
+		warn_printf("\tfrom %s\n", RSTRING_CPTR(v));
 	    }
 	    if (skip && i == TRACE_HEAD && len > TRACE_MAX) {
 		warn_printf("\t ... %ld levels...\n",

Modified: MacRuby/trunk/eval_jump.c
===================================================================
--- MacRuby/trunk/eval_jump.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/eval_jump.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -36,7 +36,7 @@
     }
     if (!tt) {
 	VALUE desc = rb_inspect(tag);
-	rb_raise(rb_eArgError, "uncaught throw %s", RSTRING_PTR(desc));
+	rb_raise(rb_eArgError, "uncaught throw %s", RSTRING_CPTR(desc));
     }
     rb_trap_restore_mask();
     th->errinfo = NEW_THROW_OBJECT(tag, 0, TAG_THROW);

Modified: MacRuby/trunk/ext/syck/rubyext.c
===================================================================
--- MacRuby/trunk/ext/syck/rubyext.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/ext/syck/rubyext.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -150,8 +150,8 @@
         if (!NIL_P(str2))
         {
             StringValue(str2);
-            len = RSTRING_LEN(str2);
-            memcpy( buf + skip, RSTRING_PTR(str2), len );
+            len = RSTRING_CLEN(str2);
+            memcpy( buf + skip, RSTRING_CPTR(str2), len );
         }
     }
     len += skip;
@@ -171,7 +171,7 @@
     if (!NIL_P(tmp = rb_check_string_type(port))) {
         taint = OBJ_TAINTED(port); /* original taintedness */
         port = tmp;
-        syck_parser_str( parser, RSTRING_PTR(port), RSTRING_LEN(port), NULL );
+        syck_parser_str( parser, RSTRING_CPTR(port), RSTRING_CLEN(port), NULL );
     }
     else if (rb_respond_to(port, s_read)) {
         if (rb_respond_to(port, s_binmode)) {
@@ -1011,10 +1011,10 @@
     VALUE ivname = rb_ary_entry( vars, 0 );
     char *ivn;
     StringValue( ivname );
-    ivn = S_ALLOCA_N( char, RSTRING_LEN(ivname) + 2 );
+    ivn = S_ALLOCA_N( char, RSTRING_CLEN(ivname) + 2 );
     ivn[0] = '@';
     ivn[1] = '\0';
-    strncat( ivn, RSTRING_PTR(ivname), RSTRING_LEN(ivname) );
+    strncat( ivn, RSTRING_CPTR(ivname), RSTRING_CLEN(ivname) );
     rb_iv_set( obj, ivn, rb_ary_entry( vars, 1 ) );
     return Qnil;
 }
@@ -1042,12 +1042,12 @@
 VALUE
 syck_resolver_transfer(VALUE self, VALUE type, VALUE val)
 {
-    if (NIL_P(type) || RSTRING_LEN(StringValue(type)) == 0) 
+    if (NIL_P(type) || RSTRING_CLEN(StringValue(type)) == 0) 
     {
         type = rb_funcall( self, s_detect_implicit, 1, val );
     }
 
-    if ( ! (NIL_P(type) || RSTRING_LEN(StringValue(type)) == 0) )
+    if ( ! (NIL_P(type) || RSTRING_CLEN(StringValue(type)) == 0) )
     {
         VALUE str_xprivate = rb_str_new2( "x-private" );
         VALUE colon = rb_str_new2( ":" );
@@ -1177,7 +1177,7 @@
 
     if ( !NIL_P(tmp) )
     {
-        char *taguri = syck_type_id_to_uri( RSTRING_PTR(tmp) );
+        char *taguri = syck_type_id_to_uri( RSTRING_CPTR(tmp) );
         val = rb_str_new2( taguri );
         S_FREE( taguri );
     }
@@ -1197,7 +1197,7 @@
     if ( !NIL_P(tmp) )
     {
         val = tmp;
-        type_id = syck_match_implicit( RSTRING_PTR(val), RSTRING_LEN(val) );
+        type_id = syck_match_implicit( RSTRING_CPTR(val), RSTRING_CLEN(val) );
         return rb_str_new2( type_id );
     }
 
@@ -1456,8 +1456,8 @@
     Data_Get_Struct( self, SyckNode, node );
 
     StringValue( val );
-    node->data.str->ptr = syck_strndup( RSTRING_PTR(val), RSTRING_LEN(val) );
-    node->data.str->len = RSTRING_LEN(val);
+    node->data.str->ptr = syck_strndup( RSTRING_CPTR(val), RSTRING_CLEN(val) );
+    node->data.str->len = RSTRING_CLEN(val);
     node->data.str->style = scalar_none;
 
     rb_iv_set( self, "@value", val );
@@ -1716,7 +1716,7 @@
 
     if ( !NIL_P( type_id ) ) {
         StringValue( type_id );
-        node->type_id = syck_strndup( RSTRING_PTR(type_id), RSTRING_LEN(type_id) );
+        node->type_id = syck_strndup( RSTRING_CPTR(type_id), RSTRING_CLEN(type_id) );
     }
 
     rb_iv_set( self, "@type_id", type_id );

Modified: MacRuby/trunk/include/ruby/encoding.h
===================================================================
--- MacRuby/trunk/include/ruby/encoding.h	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/include/ruby/encoding.h	2008-05-06 23:07:11 UTC (rev 189)
@@ -42,7 +42,11 @@
      ENCODING_GET_INLINED(obj) : \
      rb_enc_internal_get_index(obj))
 
-#define ENCODING_IS_ASCII8BIT(obj) (ENCODING_GET_INLINED(obj) == 0)
+#if WITH_OBJC
+# define ENCODING_IS_ASCII8BIT(obj) (1)
+#else
+# define ENCODING_IS_ASCII8BIT(obj) (ENCODING_GET_INLINED(obj) == 0)
+#endif
 
 #define ENCODING_MAXNAMELEN 42
 

Modified: MacRuby/trunk/include/ruby/ruby.h
===================================================================
--- MacRuby/trunk/include/ruby/ruby.h	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/include/ruby/ruby.h	2008-05-06 23:07:11 UTC (rev 189)
@@ -732,12 +732,23 @@
 #define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0)
 #define FL_REVERSE(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags ^= (f);} while (0)
 
-#define OBJ_TAINTED(x) FL_TEST((x), FL_TAINT)
-#define OBJ_TAINT(x) FL_SET((x), FL_TAINT)
+#if WITH_OBJC
+# define OBJ_TAINTED(x) (rb_obj_tainted((VALUE)x))
+# define OBJ_TAINT(x)   (rb_obj_taint((VALUE)x))
+#else
+# define OBJ_TAINTED(x) FL_TEST((x), FL_TAINT)
+# define OBJ_TAINT(x) FL_SET((x), FL_TAINT)
+#endif
+
 #define OBJ_INFECT(x,s) do {if (FL_ABLE(x) && FL_ABLE(s)) RBASIC(x)->flags |= RBASIC(s)->flags & FL_TAINT;} while (0)
 
-#define OBJ_FROZEN(x) FL_TEST((x), FL_FREEZE)
-#define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE)
+#if WITH_OBJC
+# define OBJ_FROZEN(x) (rb_obj_frozen_p((VALUE)x))
+# define OBJ_FREEZE(x) (rb_obj_freeze((VALUE)x))
+#else
+# define OBJ_FROZEN(x) FL_TEST((x), FL_FREEZE)
+# define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE)
+#endif
 
 #define ALLOC_N(type,n) (type*)xmalloc2((n),sizeof(type))
 #define ALLOC(type) (type*)xmalloc(sizeof(type))

Modified: MacRuby/trunk/io.c
===================================================================
--- MacRuby/trunk/io.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/io.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -1470,6 +1470,7 @@
         }
     }
     rb_str_resize(str, n);
+    RSTRING_SYNC(str);
 
     if (n == 0)
         return Qnil;
@@ -2999,6 +3000,7 @@
     }
     rb_str_resize(str, n);
     OBJ_TAINT(str);
+    RSTRING_SYNC(str);
 
     return str;
 }

Modified: MacRuby/trunk/iseq.c
===================================================================
--- MacRuby/trunk/iseq.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/iseq.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -49,8 +49,8 @@
     if (ptr) {
 	iseq = ptr;
 	/* It's possible that strings are freed
-         * GC_INFO("%s @ %s\n", RSTRING_PTR(iseq->name),
-         *                      RSTRING_PTR(iseq->filename));
+         * GC_INFO("%s @ %s\n", RSTRING_CPTR(iseq->name),
+         *                      RSTRING_CPTR(iseq->filename));
 	 */
 	if (iseq->iseq != iseq->iseq_encoded) {
 	    RUBY_FREE_UNLESS_NULL(iseq->iseq_encoded);
@@ -75,7 +75,7 @@
 
     if (ptr) {
 	iseq = ptr;
-	RUBY_GC_INFO("%s @ %s\n", RSTRING_PTR(iseq->name), RSTRING_PTR(iseq->filename));
+	RUBY_GC_INFO("%s @ %s\n", RSTRING_CPTR(iseq->name), RSTRING_CPTR(iseq->filename));
 	RUBY_MARK_UNLESS_NULL(iseq->mark_ary);
 	RUBY_MARK_UNLESS_NULL(iseq->name);
 	RUBY_MARK_UNLESS_NULL(iseq->filename);
@@ -533,7 +533,7 @@
     rb_iseq_t *iseq = iseq_check(self);
 
     snprintf(buff, sizeof(buff), "<ISeq:%s@%s>",
-	     RSTRING_PTR(iseq->name), RSTRING_PTR(iseq->filename));
+	     RSTRING_CPTR(iseq->name), RSTRING_CPTR(iseq->filename));
 
     return rb_str_new2(buff);
 }
@@ -745,7 +745,7 @@
 	int line_no = find_line_no(iseqdat, pos);
 	int prev = find_prev_line_no(iseqdat, pos);
 	if (line_no && line_no != prev) {
-	    snprintf(buff, sizeof(buff), "%-70s(%4d)", RSTRING_PTR(str),
+	    snprintf(buff, sizeof(buff), "%-70s(%4d)", RSTRING_CPTR(str),
 		     line_no);
 	    str = rb_str_new2(buff);
 	}
@@ -754,7 +754,7 @@
 	/* for debug */
 	struct iseq_insn_info_entry *entry = get_insn_info(iseqdat, pos);
 	snprintf(buff, sizeof(buff), "%-60s(line: %d, sp: %d)",
-		 RSTRING_PTR(str), entry->line_no, entry->sp);
+		 RSTRING_CPTR(str), entry->line_no, entry->sp);
 	str = rb_str_new2(buff);
     }
 
@@ -763,7 +763,7 @@
 	rb_str_concat(ret, str);
     }
     else {
-	printf("%s\n", RSTRING_PTR(str));
+	printf("%s\n", RSTRING_CPTR(str));
     }
     return len;
 }
@@ -814,6 +814,7 @@
     if ((i = RSTRING_LEN(str)) < header_minlen) {
 	rb_str_resize(str, header_minlen);
 	memset(RSTRING_PTR(str) + i, '=', header_minlen - i);
+	RSTRING_SYNC(str);
     }
     rb_str_cat2(str, "\n");
 

Modified: MacRuby/trunk/load.c
===================================================================
--- MacRuby/trunk/load.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/load.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -171,7 +171,7 @@
 
 	    if (ext && *ext) return 0;
 	    bufstr = rb_str_tmp_new(len + DLEXT_MAXLEN);
-	    buf = RSTRING_PTR(bufstr);
+	    buf = RSTRING_PTR(bufstr); /* ok */
 	    MEMCPY(buf, feature, char, len);
 	    for (i = 0; (e = loadable_ext[i]) != 0; i++) {
 		strncpy(buf + len, e, DLEXT_MAXLEN + 1);
@@ -400,7 +400,7 @@
 search_required(VALUE fname, volatile VALUE *path)
 {
     VALUE tmp;
-    char *ext, *ftptr;
+    const char *ext, *ftptr;
     int type, ft = 0;
     const char *loading;
 

Modified: MacRuby/trunk/marshal.c
===================================================================
--- MacRuby/trunk/marshal.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/marshal.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -54,7 +54,7 @@
 #define TYPE_FALSE	'F'
 #define TYPE_FIXNUM	'i'
 
-#define TYPE_EXTENDED	'e'
+#define TYPE_EXTENDED_R	'e'
 #define TYPE_UCLASS	'C'
 #define TYPE_OBJECT	'o'
 #define TYPE_DATA       'd'
@@ -162,7 +162,7 @@
 class2path(VALUE klass)
 {
     VALUE path = rb_class_path(klass);
-    char *n = RSTRING_PTR(path);
+    const char *n = RSTRING_CPTR(path);
 
     if (n[0] == '#') {
 	rb_raise(rb_eTypeError, "can't dump anonymous %s %s",
@@ -417,7 +417,7 @@
     }
     while (BUILTIN_TYPE(klass) == T_ICLASS) {
 	path = rb_class2name(RBASIC(klass)->klass);
-	w_byte(TYPE_EXTENDED, arg);
+	w_byte(TYPE_EXTENDED_R, arg);
 	w_unique(path, arg);
 	klass = RCLASS_SUPER(klass);
     }
@@ -427,7 +427,7 @@
 w_class(char type, VALUE obj, struct dump_arg *arg, int check)
 {
     volatile VALUE p;
-    char *path;
+    const char *path;
     st_data_t real_obj;
     VALUE klass;
 
@@ -438,7 +438,7 @@
     w_extended(klass, arg, check);
     w_byte(type, arg);
     p = class2path(rb_class_real(klass));
-    path = RSTRING_PTR(p);
+    path = RSTRING_CPTR(p);
     w_unique(path, arg);
 }
 
@@ -452,7 +452,7 @@
 #if 0
     if (klass != super) {
 	w_byte(TYPE_UCLASS, arg);
-	w_unique(RSTRING_PTR(class2path(klass)), arg);
+	w_unique(RSTRING_CPTR(class2path(klass)), arg);
     }
 #endif
 }
@@ -620,7 +620,7 @@
 		w_byte(TYPE_IVAR, arg);
 	    }
 	    w_class(TYPE_USERDEF, obj, arg, Qfalse);
-	    w_bytes(RSTRING_PTR(v), RSTRING_LEN(v), arg);
+	    w_bytes(RSTRING_CPTR(v), RSTRING_CLEN(v), arg);
             if (hasiv2) {
 		w_ivar(v, ivtbl2, &c_arg);
             }
@@ -638,7 +638,7 @@
 	    w_byte(TYPE_CLASS, arg);
 	    {
 		volatile VALUE path = class2path(obj);
-		w_bytes(RSTRING_PTR(path), RSTRING_LEN(path), arg);
+		w_bytes(RSTRING_CPTR(path), RSTRING_CLEN(path), arg);
 	    }
 	    break;
 
@@ -646,7 +646,7 @@
 	    w_byte(TYPE_MODULE, arg);
 	    {
 		VALUE path = class2path(obj);
-		w_bytes(RSTRING_PTR(path), RSTRING_LEN(path), arg);
+		w_bytes(RSTRING_CPTR(path), RSTRING_CLEN(path), arg);
 	    }
 	    break;
 
@@ -685,7 +685,7 @@
 	  case T_STRING:
 	    w_uclass(obj, rb_cString, arg);
 	    w_byte(TYPE_STRING, arg);
-	    w_bytes(RSTRING_PTR(obj), RSTRING_LEN(obj), arg);
+	    w_bytes(RSTRING_CPTR(obj), RSTRING_CLEN(obj), arg);
 	    break;
 
 	  case T_REGEXP:
@@ -917,7 +917,7 @@
 
     if (TYPE(arg->src) == T_STRING) {
 	if (RSTRING_LEN(arg->src) > arg->offset) {
-	    c = (unsigned char)RSTRING_PTR(arg->src)[arg->offset++];
+	    c = (unsigned char)RSTRING_CPTR(arg->src)[arg->offset++];
 	}
 	else {
 	    rb_raise(rb_eArgError, "marshal data too short");
@@ -990,7 +990,7 @@
     if (len == 0) return rb_str_new(0, 0);
     if (TYPE(arg->src) == T_STRING) {
 	if (RSTRING_LEN(arg->src) - arg->offset >= len) {
-	    str = rb_str_new(RSTRING_PTR(arg->src)+arg->offset, len);
+	    str = rb_str_new(RSTRING_CPTR(arg->src)+arg->offset, len);
 	    arg->offset += len;
 	}
 	else {
@@ -1026,7 +1026,7 @@
 r_symreal(struct load_arg *arg)
 {
     volatile VALUE s = r_bytes(arg);
-    ID id = rb_intern(RSTRING_PTR(s));
+    ID id = rb_intern(RSTRING_CPTR(s));
 
     st_insert(arg->symbols, arg->symbols->num_entries, id);
 
@@ -1192,7 +1192,7 @@
 	}
 	break;
 
-      case TYPE_EXTENDED:
+      case TYPE_EXTENDED_R:
 	{
 	    VALUE m = path2module(r_unique(arg));
 
@@ -1255,7 +1255,7 @@
 	{
 	    double d, t = 0.0;
 	    VALUE str = r_bytes(arg);
-	    const char *ptr = RSTRING_PTR(str);
+	    const char *ptr = RSTRING_CPTR(str);
 
 	    if (strcmp(ptr, "nan") == 0) {
 		d = t / t;
@@ -1294,7 +1294,7 @@
             rb_big_resize((VALUE)big, (len + 1) * 2 / sizeof(BDIGIT));
 #endif
             digits = RBIGNUM_DIGITS(big);
-	    MEMCPY(digits, RSTRING_PTR(data), char, len * 2);
+	    MEMCPY(digits, RSTRING_CPTR(data), char, len * 2);
 #if SIZEOF_BDIGITS > SIZEOF_SHORT
 	    MEMZERO((char *)digits + len * 2, char,
 		    RBIGNUM_LEN(big) * sizeof(BDIGIT) - len * 2);
@@ -1497,7 +1497,7 @@
         {
 	    volatile VALUE str = r_bytes(arg);
 
-	    v = rb_path2class(RSTRING_PTR(str));
+	    v = rb_path2class(RSTRING_CPTR(str));
 	    v = r_entry(v, arg);
             v = r_leave(v, arg);
 	}
@@ -1507,7 +1507,7 @@
         {
 	    volatile VALUE str = r_bytes(arg);
 
-	    v = path2class(RSTRING_PTR(str));
+	    v = path2class(RSTRING_CPTR(str));
 	    v = r_entry(v, arg);
             v = r_leave(v, arg);
 	}
@@ -1517,7 +1517,7 @@
         {
 	    volatile VALUE str = r_bytes(arg);
 
-	    v = path2module(RSTRING_PTR(str));
+	    v = path2module(RSTRING_CPTR(str));
 	    v = r_entry(v, arg);
             v = r_leave(v, arg);
 	}

Modified: MacRuby/trunk/objc.m
===================================================================
--- MacRuby/trunk/objc.m	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/objc.m	2008-05-06 23:07:11 UTC (rev 189)
@@ -2120,7 +2120,7 @@
     if (bs_find_path(framework_path, path, sizeof path)) {
 	if (!bs_parse(path, 0, bs_parse_cb, NULL, &error))
 	    rb_raise(rb_eRuntimeError, error);
-#if 0
+#if 1
 	/* FIXME 'GC capability mismatch' with .dylib files */
 	p = strrchr(path, '.');
 	assert(p != NULL);

Modified: MacRuby/trunk/object.c
===================================================================
--- MacRuby/trunk/object.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/object.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -682,7 +682,7 @@
 rb_obj_tainted(VALUE obj)
 {
 #if WITH_OBJC
-    if (rb_objc_is_non_native(obj)) {
+    if (!SPECIAL_CONST_P(obj) && rb_objc_is_non_native(obj)) {
 	int type = TYPE(obj);
 	if (type == T_ARRAY)
 	    return rb_ary_tainted(obj);
@@ -693,7 +693,7 @@
 	return Qfalse;
     }
 #endif
-    if (OBJ_TAINTED(obj))
+    if (FL_TEST(obj, FL_TAINT))
 	return Qtrue;
     return Qfalse;
 }
@@ -712,7 +712,7 @@
 {
     rb_secure(4);
 #if WITH_OBJC
-    if (rb_objc_is_non_native(obj)) {
+    if (!SPECIAL_CONST_P(obj) && rb_objc_is_non_native(obj)) {
 	int type = TYPE(obj);
 	if (type == T_ARRAY)
 	    return rb_ary_taint(obj);
@@ -727,7 +727,7 @@
 	if (OBJ_FROZEN(obj)) {
 	    rb_error_frozen("object");
 	}
-	OBJ_TAINT(obj);
+	FL_SET(obj, FL_TAINT);
     }
     return obj;
 }
@@ -745,7 +745,7 @@
 {
     rb_secure(3);
 #if WITH_OBJC
-    if (rb_objc_is_non_native(obj)) {
+    if (!SPECIAL_CONST_P(obj) && rb_objc_is_non_native(obj)) {
 	int type = TYPE(obj);
 	if (type == T_ARRAY)
 	    return rb_ary_untaint(obj);
@@ -797,32 +797,36 @@
 VALUE
 rb_obj_freeze(VALUE obj)
 {
-#if WITH_OBJC
-    if (rb_objc_is_non_native(obj)) {
-	int type = TYPE(obj);
-	if (type == T_ARRAY)
-	    rb_ary_freeze(obj);
-	else if (type == T_HASH)
-	    rb_hash_freeze(obj);
-	else if (type == T_STRING)
-	    rb_str_freeze(obj);
-	else
-	    rb_raise(rb_eRuntimeError, "can't freeze pure objc object `%s'",
-		    RSTRING_PTR(rb_inspect(obj)));
-    }
-#endif
     if (!OBJ_FROZEN(obj)) {
 	if (rb_safe_level() >= 4 && !OBJ_TAINTED(obj)) {
 	    rb_raise(rb_eSecurityError, "Insecure: can't freeze object");
 	}
-	OBJ_FREEZE(obj);
-	if (SPECIAL_CONST_P(obj)) {
+	else if (SPECIAL_CONST_P(obj)) {
 	    if (!immediate_frozen_tbl) {
 		immediate_frozen_tbl = st_init_numtable();
 		GC_ROOT(&immediate_frozen_tbl);
 	    }
 	    st_insert(immediate_frozen_tbl, obj, (st_data_t)Qtrue);
 	}
+#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)));
+	    }
+	}
+#endif
+	else {
+	    FL_SET(obj, FL_FREEZE);
+	}
     }
     return obj;
 }
@@ -857,7 +861,7 @@
 	return Qfalse;
     }
 #endif
-    if (OBJ_FROZEN(obj)) return Qtrue;
+    if (FL_TEST(obj, FL_FREEZE)) return Qtrue;
     return Qfalse;
 }
 

Modified: MacRuby/trunk/pack.c
===================================================================
--- MacRuby/trunk/pack.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/pack.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -446,8 +446,8 @@
 #endif
 
     StringValue(fmt);
-    p = RSTRING_PTR(fmt);
-    pend = p + RSTRING_LEN(fmt);
+    p = RSTRING_CPTR(fmt);
+    pend = p + RSTRING_CLEN(fmt);
     res = rb_str_buf_new(0);
 
     items = RARRAY_LEN(ary);
@@ -458,7 +458,7 @@
 #define NEXTFROM (items-- > 0 ? RARRAY_AT(ary, idx++) : TOO_FEW)
 
     while (p < pend) {
-	if (RSTRING_PTR(fmt) + RSTRING_LEN(fmt) != pend) {
+	if (RSTRING_CPTR(fmt) + RSTRING_CLEN(fmt) != pend) {
 	    rb_raise(rb_eRuntimeError, "format string modified");
 	}
 	type = *p++;		/* get data type */
@@ -508,8 +508,8 @@
 	    }
 	    else {
 		StringValue(from);
-		ptr = RSTRING_PTR(from);
-		plen = RSTRING_LEN(from);
+		ptr = RSTRING_CPTR(from);
+		plen = RSTRING_CLEN(from);
 		OBJ_INFECT(res, from);
 	    }
 
@@ -879,8 +879,8 @@
 	  case 'm':		/* base64 encoded string */
 	    from = NEXTFROM;
 	    StringValue(from);
-	    ptr = RSTRING_PTR(from);
-	    plen = RSTRING_LEN(from);
+	    ptr = RSTRING_CPTR(from);
+	    plen = RSTRING_CLEN(from);
 
 	    if (len <= 2)
 		len = 45;
@@ -1047,8 +1047,8 @@
 {
     char buff[1024];
     long i = 0, n = 0, prev = EOF;
-    unsigned char *s = (unsigned char*)RSTRING_PTR(from);
-    unsigned char *send = s + RSTRING_LEN(from);
+    const unsigned char *s = (unsigned char*)RSTRING_CPTR(from);
+    const unsigned char *send = s + RSTRING_CLEN(from);
 
     while (s < send) {
         if ((*s > 126) ||
@@ -1287,8 +1287,8 @@
 pack_unpack(VALUE str, VALUE fmt)
 {
     static const char *hexdigits = "0123456789abcdef0123456789ABCDEFx";
-    char *s, *send;
-    char *p, *pend;
+    const char *s, *send;
+    const char *p, *pend;
     VALUE ary;
     char type;
     long len;
@@ -1309,10 +1309,10 @@
 
     StringValue(str);
     StringValue(fmt);
-    s = RSTRING_PTR(str);
-    send = s + RSTRING_LEN(str);
-    p = RSTRING_PTR(fmt);
-    pend = p + RSTRING_LEN(fmt);
+    s = RSTRING_CPTR(str);
+    send = s + RSTRING_CLEN(str);
+    p = RSTRING_CPTR(fmt);
+    pend = p + RSTRING_CLEN(fmt);
 
     ary = block_p ? Qnil : rb_ary_new();
     while (p < pend) {
@@ -1365,7 +1365,7 @@
 	    if (len > send - s) len = send - s;
 	    {
 		long end = len;
-		char *t = s + len - 1;
+		const char *t = s + len - 1;
 
 		while (t >= s) {
 		    if (*t != ' ' && *t != '\0') break;
@@ -1378,7 +1378,7 @@
 
 	  case 'Z':
 	    {
-		char *t = s;
+		const char *t = s;
 
 		if (len > send-s) len = send-s;
 		while (t < s+len && *t) t++;
@@ -1411,6 +1411,7 @@
 		    else bits = *s++;
 		    *t++ = (bits & 1) ? '1' : '0';
 		}
+		RSTRING_SYNC(bitstr);
 	    }
 	    break;
 
@@ -1431,6 +1432,7 @@
 		    else bits = *s++;
 		    *t++ = (bits & 128) ? '1' : '0';
 		}
+		RSTRING_SYNC(bitstr);
 	    }
 	    break;
 
@@ -1453,6 +1455,7 @@
 			bits = *s++;
 		    *t++ = hexdigits[bits & 15];
 		}
+		RSTRING_SYNC(bitstr);
 	    }
 	    break;
 
@@ -1475,6 +1478,7 @@
 			bits = *s++;
 		    *t++ = hexdigits[(bits >> 4) & 15];
 		}
+		RSTRING_SYNC(bitstr);
 	    }
 	    break;
 
@@ -1770,6 +1774,7 @@
 
 		rb_str_set_len(buf, total);
 		UNPACK_PUSH(buf);
+		RSTRING_SYNC(buf);
 	    }
 	    break;
 
@@ -1820,6 +1825,7 @@
 		}
 		rb_str_set_len(buf, ptr - RSTRING_PTR(buf));
 		UNPACK_PUSH(buf);
+		RSTRING_SYNC(buf);
 	    }
 	    break;
 
@@ -1848,17 +1854,18 @@
 		}
 		rb_str_set_len(buf, ptr - RSTRING_PTR(buf));
 		UNPACK_PUSH(buf);
+		RSTRING_SYNC(buf);
 	    }
 	    break;
 
 	  case '@':
-	    if (len > RSTRING_LEN(str))
+	    if (len > RSTRING_CLEN(str))
 		rb_raise(rb_eArgError, "@ outside of string");
-	    s = RSTRING_PTR(str) + len;
+	    s = RSTRING_CPTR(str) + len;
 	    break;
 
 	  case 'X':
-	    if (len > s - RSTRING_PTR(str))
+	    if (len > s - RSTRING_CPTR(str))
 		rb_raise(rb_eArgError, "X outside of string");
 	    s -= len;
 	    break;
@@ -1887,7 +1894,7 @@
 		    count = RARRAY_LEN(a);
 		    for (i = 0; i < count; i++) {
 			VALUE p = RARRAY_AT(a, i);
-			if (TYPE(p) == T_STRING && RSTRING_PTR(p) == t) {
+			if (TYPE(p) == T_STRING && RSTRING_CPTR(p) == t) {
 			    if (len < RSTRING_LEN(p)) {
 				tmp = rb_tainted_str_new(t, len);
 				rb_str_associate(tmp, a);
@@ -1910,7 +1917,7 @@
 		    p = RARRAY_PTR(a);
 		    pend = p + RARRAY_LEN(a);
 		    while (p < pend) {
-			if (TYPE(*p) == T_STRING && RSTRING_PTR(*p) == t) {
+			if (TYPE(*p) == T_STRING && RSTRING_CPTR(*p) == t) {
 			    if (len < RSTRING_LEN(*p)) {
 				tmp = rb_tainted_str_new(t, len);
 				rb_str_associate(tmp, a);
@@ -1958,7 +1965,7 @@
 			count = RARRAY_LEN(a);
 			for (i = 0; i < count; i++) {
 			    VALUE p = RARRAY_AT(a, i);
-			    if (TYPE(p) == T_STRING && RSTRING_PTR(p) == t) {
+			    if (TYPE(p) == T_STRING && RSTRING_CPTR(p) == t) {
 				tmp = p;
 				break;
 			    }
@@ -1975,7 +1982,7 @@
 			p = RARRAY_PTR(a);
 			pend = p + RARRAY_LEN(a);
 			while (p < pend) {
-			    if (TYPE(*p) == T_STRING && RSTRING_PTR(*p) == t) {
+			    if (TYPE(*p) == T_STRING && RSTRING_CPTR(*p) == t) {
 				tmp = *p;
 				break;
 			    }

Modified: MacRuby/trunk/parse.y
===================================================================
--- MacRuby/trunk/parse.y	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/parse.y	2008-05-06 23:07:11 UTC (rev 189)
@@ -5015,7 +5015,7 @@
 #ifdef RIPPER
 	    ripper_flush(parser);
 #endif
-	    lex_lastline = v;
+	    lex_lastline =v;
 	}
     }
     c = (unsigned char)*lex_p++;
@@ -5931,9 +5931,9 @@
 {
     VALUE name = 0, val = 0;
     const char *beg, *end, *vbeg, *vend;
-#if 0// WITH_OBJC
+#if WITH_OBJC
 # define str_copy(_s, _p, _n) ((_s) \
-	? CFStringPad((CFMutableStringRef)_s, CFStringCreateWithCString(NULL, _p, kCFStringEncodingUTF8), _n, 0) \
+	? CFStringPad((CFMutableStringRef)_s, CFMakeCollectable(CFStringCreateWithCString(NULL, _p, kCFStringEncodingUTF8)), _n, 0) \
 	: ((_s) = STR_NEW((_p), (_n)))) 
 #else
 # define str_copy(_s, _p, _n) ((_s) \
@@ -6001,13 +6001,13 @@
 	str_copy(name, beg, n);
 #ifndef RIPPER
 	do {
-	    if (STRNCASECMP(p->name, RSTRING_PTR(name), n) == 0) {
+	    if (STRNCASECMP(p->name, RSTRING_CPTR(name), n) == 0) {
 		n = vend - vbeg;
 		if (p->length) {
 		    n = (*p->length)(parser, vbeg, n);
 		}
 		str_copy(val, vbeg, n);
-		(*p->func)(parser, RSTRING_PTR(name), RSTRING_PTR(val));
+		(*p->func)(parser, RSTRING_CPTR(name), RSTRING_CPTR(val));
 		break;
 	    }
 	} while (++p < magic_comments + sizeof(magic_comments) / sizeof(*p));
@@ -6058,7 +6058,7 @@
     beg = str;
     while ((*str == '-' || *str == '_' || ISALNUM(*str)) && ++str < send);
     s = rb_str_new(beg, parser_encode_length(parser, beg, str - beg));
-    parser_set_encode(parser, RSTRING_PTR(s));
+    parser_set_encode(parser, RSTRING_CPTR(s));
     rb_str_resize(s, 0);
 }
 

Modified: MacRuby/trunk/proc.c
===================================================================
--- MacRuby/trunk/proc.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/proc.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -680,7 +680,7 @@
 	    line_no = iseq->insn_info_table[0].line_no;
 	}
 	str = rb_sprintf("#<%s:%p@%s:%d%s>", cname, (void *)self,
-			 RSTRING_PTR(iseq->filename),
+			 RSTRING_CPTR(iseq->filename),
 			 line_no, is_lambda);
     }
     else {

Modified: MacRuby/trunk/process.c
===================================================================
--- MacRuby/trunk/process.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/process.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -1022,7 +1022,7 @@
 
     args = ALLOCA_N(char*, argc+1);
     for (i=0; i<argc; i++) {
-	args[i] = RSTRING_PTR(argv[i]);
+	args[i] = RSTRING_CPTR(argv[i]);
     }
     args[i] = 0;
     if (args[0]) {
@@ -1161,11 +1161,11 @@
 
     args = ALLOCA_N(char*, argc + 1);
     for (i = 0; i < argc; i++) {
-	args[i] = RSTRING_PTR(argv[i]);
+	args[i] = RSTRING_CPTR(argv[i]);
     }
     args[i] = (char*) 0;
     if (args[0])
-	return proc_spawn_v(args, prog ? RSTRING_PTR(prog) : 0);
+	return proc_spawn_v(args, prog ? RSTRING_CPTR(prog) : 0);
     return -1;
 }
 
@@ -1224,14 +1224,14 @@
 	SafeStringValue(prog);
 	StringValueCStr(prog);
 	prog = rb_str_new4(prog);
-	name = RSTRING_PTR(prog);
+	name = RSTRING_CPTR(prog);
     }
     for (i = 0; i < argc; i++) {
 	SafeStringValue(argv[i]);
 	argv[i] = rb_str_new4(argv[i]);
 	StringValueCStr(argv[i]);
     }
-    security(name ? name : RSTRING_PTR(argv[0]));
+    security(name ? name : RSTRING_CPTR(argv[0]));
     return prog;
 }
 
@@ -1273,12 +1273,12 @@
     if (!prog && argc == 1) {
 	e.argc = 0;
 	e.argv = 0;
-	e.prog = RSTRING_PTR(argv[0]);
+	e.prog = RSTRING_CPTR(argv[0]);
     }
     else {
 	e.argc = argc;
 	e.argv = argv;
-	e.prog = prog ? RSTRING_PTR(prog) : 0;
+	e.prog = prog ? RSTRING_CPTR(prog) : 0;
     }
     rb_exec(&e);
     rb_sys_fail(e.prog);
@@ -1727,13 +1727,13 @@
 	struct rb_exec_arg earg;
 	earg.argc = argc;
 	earg.argv = argv;
-	earg.prog = prog ? RSTRING_PTR(prog) : 0;
+	earg.prog = prog ? RSTRING_CPTR(prog) : 0;
 	status = rb_fork(&status, rb_exec_atfork, &earg);
 	if (prog && argc) argv[0] = prog;
     }
 #elif defined HAVE_SPAWNV
     if (!argc) {
-	status = proc_spawn(RSTRING_PTR(prog));
+	status = proc_spawn(RSTRING_CPTR(prog));
     }
     else {
 	status = proc_spawn_n(argc, argv, prog);
@@ -1816,7 +1816,7 @@
     rb_pid_t pid;
 
     pid = rb_spawn(argc, argv);
-    if (pid == -1) rb_sys_fail(RSTRING_PTR(argv[0]));
+    if (pid == -1) rb_sys_fail(RSTRING_CPTR(argv[0]));
 #if defined(HAVE_FORK) || defined(HAVE_SPAWNV)
     return PIDT2NUM(pid);
 #else
@@ -3004,10 +3004,10 @@
 		groups[i] = NUM2GIDT(g);
 	    }
 	    else {
-		gr = getgrnam(RSTRING_PTR(tmp));
+		gr = getgrnam(RSTRING_CPTR(tmp));
 		if (gr == NULL)
 		    rb_raise(rb_eArgError,
-			     "can't find group for %s", RSTRING_PTR(tmp));
+			     "can't find group for %s", RSTRING_CPTR(tmp));
 		groups[i] = gr->gr_gid;
 	    }
 	}

Modified: MacRuby/trunk/range.c
===================================================================
--- MacRuby/trunk/range.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/range.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -748,15 +748,15 @@
 	return Qfalse;
     }
     else if (TYPE(beg) == T_STRING && TYPE(end) == T_STRING &&
-	     RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) {
+	     RSTRING_CLEN(beg) == 1 && RSTRING_CLEN(end) == 1) {
 	if (NIL_P(val)) return Qfalse;
 	if (TYPE(val) == T_STRING) {
-	    if (RSTRING_LEN(val) == 0 || RSTRING_LEN(val) > 1)
+	    if (RSTRING_CLEN(val) == 0 || RSTRING_CLEN(val) > 1)
 		return Qfalse;
 	    else {
-		char b = RSTRING_PTR(beg)[0];
-		char e = RSTRING_PTR(end)[0];
-		char v = RSTRING_PTR(val)[0];
+		char b = RSTRING_CPTR(beg)[0];
+		char e = RSTRING_CPTR(end)[0];
+		char v = RSTRING_CPTR(val)[0];
 
 		if (ISASCII(b) && ISASCII(e) && ISASCII(v)) {
 		    if (b <= v && v < e) return Qtrue;

Modified: MacRuby/trunk/re.c
===================================================================
--- MacRuby/trunk/re.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/re.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -450,7 +450,7 @@
 {
     VALUE desc = rb_reg_desc(s, len, re);
 
-    rb_raise(rb_eRegexpError, "%s: %s", err, RSTRING_PTR(desc));
+    rb_raise(rb_eRegexpError, "%s: %s", err, RSTRING_CPTR(desc));
 }
 
 static VALUE
@@ -477,7 +477,7 @@
 static VALUE
 rb_reg_error_desc(VALUE str, int options, const char *err)
 {
-    return rb_enc_reg_error_desc(RSTRING_PTR(str), RSTRING_LEN(str),
+    return rb_enc_reg_error_desc(RSTRING_CPTR(str), RSTRING_CLEN(str),
 				 rb_enc_get(str), options, err);
 }
 
@@ -696,7 +696,7 @@
     struct re_registers *regs;
     int num_regs;
     int i, num_pos, c;
-    char *s, *p, *q, *e;
+    const char *s, *p, *q, *e;
     rb_encoding *enc;
     pair_t *pairs;
 
@@ -731,8 +731,8 @@
     }
     qsort(pairs, num_pos, sizeof(pair_t), pair_byte_cmp);
 
-    s = p = RSTRING_PTR(RMATCH(match)->str);
-    e = s + RSTRING_LEN(RMATCH(match)->str);
+    s = p = RSTRING_CPTR(RMATCH(match)->str);
+    e = s + RSTRING_CLEN(RMATCH(match)->str);
     c = 0;
     for (i = 0; i < num_pos; i++) {
         q = s + pairs[i].byte_pos;
@@ -1098,8 +1098,9 @@
             rb_raise(rb_eArgError, "regexp preprocess failed: %s", err);
         }
 
-	r = onig_new(®2, (UChar* )RSTRING_PTR(unescaped),
-		     (UChar* )(RSTRING_PTR(unescaped) + RSTRING_LEN(unescaped)),
+	r = onig_new(®2, (UChar* )RSTRING_CPTR(unescaped),
+		     (UChar* )(RSTRING_CPTR(unescaped) 
+			 + RSTRING_CLEN(unescaped)),
 		     reg->options, enc,
 		     OnigDefaultSyntax, &einfo);
 	if (r) {
@@ -1132,7 +1133,7 @@
     enc = (RREGEXP(re)->ptr)->enc;
 
     if (pos > 0 && ONIGENC_MBC_MAXLEN(enc) != 1 && pos < RSTRING_LEN(str)) {
-	 string = (UChar*)RSTRING_PTR(str);
+	 string = (UChar*)RSTRING_CPTR(str);
 
 	 if (range > 0) {
 	      p = onigenc_get_right_adjust_char_head(enc, string, string + pos);
@@ -1152,7 +1153,11 @@
     int result;
     VALUE match;
     struct re_registers *pregs;
-    char *range = RSTRING_PTR(str);
+    const char *cstr, *range;
+    long clen;
+
+    cstr = range = RSTRING_CPTR(str);
+    clen = RSTRING_CLEN(str);
 #if WITH_OBJC
     static struct re_registers *regs = NULL;
     if (regs == NULL) {
@@ -1165,7 +1170,7 @@
     pregs = ®s;
 #endif
 
-    if (pos > RSTRING_LEN(str) || pos < 0) {
+    if (pos > clen || pos < 0) {
 	rb_backref_set(Qnil);
 	return -1;
     }
@@ -1173,12 +1178,12 @@
     rb_reg_prepare_re(re, str, 1);
 
     if (!reverse) {
-	range += RSTRING_LEN(str);
+	range += RSTRING_CLEN(str);
     }
     result = onig_search(RREGEXP(re)->ptr,
-			 (UChar*)(RSTRING_PTR(str)),
-			 ((UChar*)(RSTRING_PTR(str)) + RSTRING_LEN(str)),
-			 ((UChar*)(RSTRING_PTR(str)) + pos),
+			 (UChar*)cstr,
+			 ((UChar*)cstr + clen),
+			 ((UChar*)cstr + pos),
 			 ((UChar*)range),
 			 pregs, ONIG_OPTION_NONE);
 
@@ -2065,12 +2070,12 @@
     rb_encoding *fixed_enc = 0;
     onig_errmsg_buffer err = "";
     VALUE buf;
-    char *p, *end;
+    const char *p, *end;
     rb_encoding *enc;
 
     StringValue(str);
-    p = RSTRING_PTR(str);
-    end = p + RSTRING_LEN(str);
+    p = RSTRING_CPTR(str);
+    end = p + RSTRING_CLEN(str);
     enc = rb_enc_get(str);
 
     buf = rb_reg_preprocess(p, end, enc, &fixed_enc, err);
@@ -2106,12 +2111,12 @@
         VALUE str = argv[i];
 #endif
         VALUE buf;
-        char *p, *end;
+        const char *p, *end;
         rb_encoding *src_enc;
 
         StringValue(str);
-        p = RSTRING_PTR(str);
-        end = p + RSTRING_LEN(str);
+        p = RSTRING_CPTR(str);
+        end = p + RSTRING_CLEN(str);
         src_enc = rb_enc_get(str);
 
         buf = rb_reg_preprocess(p, end, src_enc, &fixed_enc, err);
@@ -2185,7 +2190,8 @@
         re->basic.flags |= REG_ENCODING_NONE;
     }
     
-    GC_WB(&re->ptr, make_regexp(RSTRING_PTR(unescaped), RSTRING_LEN(unescaped), enc,
+    GC_WB(&re->ptr, make_regexp(RSTRING_CPTR(unescaped), 
+				RSTRING_CLEN(unescaped), enc,
                                 options & ARG_REG_OPTION_MASK, err));
     if (!re->ptr) return -1;
     GC_WB(&re->str, ALLOC_N(char, len+1));
@@ -2211,7 +2217,7 @@
             enc = ascii8bit;
         }
     }
-    ret = rb_reg_initialize(obj, RSTRING_PTR(str), RSTRING_LEN(str), enc,
+    ret = rb_reg_initialize(obj, RSTRING_CPTR(str), RSTRING_CLEN(str), enc,
 			    options, err);
     RB_GC_GUARD(str);
     return ret;
@@ -2291,7 +2297,7 @@
     volatile VALUE save_str = str;
     if (reg_cache && RREGEXP(reg_cache)->len == RSTRING_LEN(str)
 	&& ENCODING_GET(reg_cache) == ENCODING_GET(str)
-        && memcmp(RREGEXP(reg_cache)->str, RSTRING_PTR(str), RSTRING_LEN(str)) == 0)
+        && memcmp(RREGEXP(reg_cache)->str, RSTRING_CPTR(str), RSTRING_CLEN(str)) == 0)
 	return reg_cache;
 
     return reg_cache = rb_reg_new_str(save_str, 0);

Modified: MacRuby/trunk/string.c
===================================================================
--- MacRuby/trunk/string.c	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/string.c	2008-05-06 23:07:11 UTC (rev 189)
@@ -138,7 +138,8 @@
 	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));
+	    GC_WB(&n->cfdata, CFDataCreateMutableCopy(NULL, 0, 
+		(CFDataRef)n->cfdata));
 	    CFMakeCollectable(n->cfdata);
 	}
     }
@@ -501,6 +502,9 @@
 int
 rb_enc_str_coderange(VALUE str)
 {
+#if WITH_OBJC
+    return ENC_CODERANGE_VALID;
+#else
     int cr = ENC_CODERANGE(str);
 
     if (cr == ENC_CODERANGE_UNKNOWN) {
@@ -509,6 +513,7 @@
         ENC_CODERANGE_SET(str, cr);
     }
     return cr;
+#endif
 }
 
 int
@@ -981,20 +986,9 @@
     CFMutableStringRef copy = CFStringCreateMutableCopy(NULL, 0, 
 	(CFStringRef)str);
     CFMakeCollectable(copy);
+    if (OBJ_TAINTED(str)) 
+	OBJ_TAINT(copy);
     return (VALUE)copy;
-#if 0
-    struct rb_objc_str_struct *s = rb_objc_str_get_struct(str);
-    if (s != NULL && s->cfdata != NULL) {
-	rb_str_bytesync(str);
-	if (rb_str_cfdata2(str) != NULL) {
-	    struct rb_objc_str_struct *s2 = rb_objc_str_get_struct2(dup);
-	    CFMutableDataRef data = CFDataCreateMutableCopy(NULL, 0, 
-		    (CFDataRef)s->cfdata);	
-	    GC_WB(&s2->cfdata, data);
-	    CFMakeCollectable(data);
-	}
-    }
-#endif
 #else
     VALUE dup = str_alloc(rb_obj_class(str));
     rb_str_replace(dup, str);
@@ -1221,9 +1215,10 @@
 {
 #if WITH_OBJC
     VALUE str3 = rb_str_new(0, 0);
-    CFStringAppend((CFMutableStringRef)str3, (CFStringRef)str1);
-    CFStringAppend((CFMutableStringRef)str3, (CFStringRef)str2);
-    /* TODO copy taint flag if needed */
+    rb_str_buf_append(str3, str1);
+    rb_str_buf_append(str3, str2);
+    if (OBJ_TAINTED(str1) || OBJ_TAINTED(str2))
+	OBJ_TAINT(str3);
 #else
     VALUE str3;
     rb_encoding *enc;
@@ -1446,10 +1441,16 @@
 const char *
 rb_str_cstr(VALUE ptr)
 {
-    CFDataRef data = (CFDataRef)rb_str_cfdata2(ptr);
-    return data == NULL 
-	? CFStringGetCStringPtr((CFStringRef)ptr, 0) 
-	: (const char *)CFDataGetBytePtr(data);
+    CFDataRef data;
+    const char *cptr;
+   
+    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);
+    }
+    return data == NULL ? cptr : (const char *)CFDataGetBytePtr(data);
 }
 
 long
@@ -2107,7 +2108,7 @@
 rb_str_buf_cat_ascii(VALUE str, const char *ptr)
 {
 #if WITH_OBJC
-    CFStringAppendCString((CFMutableStringRef)str, ptr, kCFStringEncodingASCII);
+    rb_objc_str_cat(str, ptr, strlen(ptr), kCFStringEncodingASCII);
     return str;
 #else
     /* ptr must reference NUL terminated ASCII string. */
@@ -2136,7 +2137,29 @@
 rb_str_buf_append(VALUE str, VALUE str2)
 {
 #if WITH_OBJC
-    CFStringAppend((CFMutableStringRef)str, (CFStringRef)str2);
+    CFMutableDataRef mdata;
+    CFDataRef data;
+
+    if (RSTRING_CLEN(str2) == 0)
+	return str;
+
+    data = (CFDataRef)rb_str_cfdata2(str2);
+    if (data != NULL) {
+	mdata = (CFMutableDataRef)rb_str_cfdata(str);
+	CFDataAppendBytes(mdata, CFDataGetBytePtr(data),
+	    CFDataGetLength(data));
+    }
+    else {
+	mdata = (CFMutableDataRef)rb_str_cfdata2(str);
+	if (mdata == NULL) {
+	    CFStringAppend((CFMutableStringRef)str, (CFStringRef)str2);
+	}
+	else {
+	    data = (CFDataRef)rb_str_cfdata(str2);
+	    CFDataAppendBytes(mdata, CFDataGetBytePtr(data), 
+		CFDataGetLength(data));
+	}
+    }
 #else
     int str2_cr;
 
@@ -3801,11 +3824,9 @@
 #if WITH_OBJC
 	RSTRING_SYNC(str);
 	rb_str_splice_0(str, BEG(0), END(0) - BEG(0), repl);
-	if (rb_obj_tainted(repl))
-	    rb_str_taint(str);
+	if (OBJ_TAINTED(repl)) tainted = 1;
 #else
 	rb_enc_associate(str, enc);
-	if (OBJ_TAINTED(repl)) tainted = 1;
 	if (ENC_CODERANGE_UNKNOWN < cr && cr < ENC_CODERANGE_BROKEN) {
 	    int cr2 = ENC_CODERANGE(repl);
 	    if (cr2 == ENC_CODERANGE_UNKNOWN || cr2 > cr) cr = cr2;
@@ -3824,8 +3845,8 @@
 	STR_SET_LEN(str, RSTRING_LEN(str) + RSTRING_LEN(repl) - plen);
 	RSTRING_PTR(str)[RSTRING_LEN(str)] = '\0';
 	ENC_CODERANGE_SET(str, cr);
+#endif
 	if (tainted) OBJ_TAINT(str);
-#endif
 
 	return str;
     }
@@ -3880,7 +3901,7 @@
     long beg, n;
     long offset, blen, slen, len;
     int iter = 0;
-    char *sp, *cp;
+    const char *sp, *cp;
     int tainted = 0;
     rb_encoding *str_enc;
     
@@ -3911,8 +3932,8 @@
 
 #if WITH_OBJC
     dest = rb_str_new5(str, NULL, 0);
-    slen = RSTRING_LEN(str);
-    sp = RSTRING_PTR(str);
+    slen = RSTRING_CLEN(str);
+    sp = RSTRING_CPTR(str);
     cp = sp;
 #else
     blen = RSTRING_LEN(str) + 30; /* len + margin */
@@ -6095,12 +6116,17 @@
     long beg, end, i = 0;
     int lim = 0;
     VALUE result, tmp;
+    const char *cstr;
+    long clen;
 
+    cstr = RSTRING_CPTR(str);
+    clen = RSTRING_CLEN(str);
+
     if (rb_scan_args(argc, argv, "02", &spat, &limit) == 2) {
 	lim = NUM2INT(limit);
 	if (lim <= 0) limit = Qnil;
 	else if (lim == 1) {
-	    if (RSTRING_LEN(str) == 0)
+	    if (clen == 0)
 		return rb_ary_new2(0);
 	    return rb_ary_new3(1, str);
 	}
@@ -6127,16 +6153,21 @@
 #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 (RSTRING_LEN(spat) == 1 && RSTRING_PTR(spat)[0] == ' '){
+		if (spat_clen == 1 && spat_cstr[0] == ' '){
 		awk_split = Qtrue;
 	    }
 	    }
 	    else {
 		int l;
-		if (rb_enc_ascget(RSTRING_PTR(spat), RSTRING_END(spat), &l, enc2) == ' ' &&
-		    RSTRING_LEN(spat) == l) {
+		if (rb_enc_ascget(spat_cstr, spat_cstr+spat_clen, &l, enc2) == ' ' &&
+		    spat_clen == l) {
 		    awk_split = Qtrue;
 		}
 	    }
@@ -6152,9 +6183,9 @@
     result = rb_ary_new();
     beg = 0;
     if (awk_split) {
-	char *ptr = RSTRING_PTR(str);
-	char *eptr = RSTRING_END(str);
-	char *bptr = ptr;
+	const char *ptr = cstr;
+	const char *eptr = cstr+clen;
+	const char *bptr = ptr;
 	int skip = 1;
 	int c;
 
@@ -6194,22 +6225,22 @@
 	while ((end = rb_reg_search(spat, str, start, 0)) >= 0) {
 	    regs = RMATCH_REGS(rb_backref_get());
 	    if (start == end && BEG(0) == END(0)) {
-		if (!RSTRING_PTR(str)) {
-		    rb_ary_push(result, rb_str_new("", 0));
+		if (!cstr) {
+		    //rb_ary_push(result, rb_str_new("", 0));
 		    break;
 		}
 		else if (last_null == 1) {
 		    rb_ary_push(result, rb_str_subseq(str, beg,
-						      rb_enc_mbclen(RSTRING_PTR(str)+beg,
-								    RSTRING_END(str),
+						      rb_enc_mbclen(cstr+beg,
+								    cstr+clen,
 								    enc)));
 		    beg = start;
 		}
 		else {
-                    if (RSTRING_PTR(str)+start == RSTRING_END(str))
+                    if (cstr+start == cstr+clen)
                         start++;
                     else
-                        start += rb_enc_mbclen(RSTRING_PTR(str)+start,RSTRING_END(str),enc);
+                        start += rb_enc_mbclen(cstr+start,cstr+clen,enc);
 		    last_null = 1;
 		    continue;
 		}
@@ -6231,16 +6262,16 @@
 	    if (!NIL_P(limit) && lim <= ++i) break;
 	}
     }
-    if (RSTRING_LEN(str) > 0 && (!NIL_P(limit) || RSTRING_LEN(str) > beg || lim < 0)) {
-	if (RSTRING_LEN(str) == beg)
+    if (clen > 0 && (!NIL_P(limit) || clen > beg || lim < 0)) {
+	if (clen == beg)
 	    tmp = rb_str_new5(str, 0, 0);
 	else
-	    tmp = rb_str_subseq(str, beg, RSTRING_LEN(str)-beg);
+	    tmp = rb_str_subseq(str, beg, clen-beg);
 	rb_ary_push(result, tmp);
     }
     if (NIL_P(limit) && lim == 0) {
 	while (RARRAY_LEN(result) > 0 &&
-	       RSTRING_LEN(RARRAY_AT(result, RARRAY_LEN(result)-1)) == 0)
+	       RSTRING_CLEN(RARRAY_AT(result, RARRAY_LEN(result)-1)) == 0)
 	    rb_ary_pop(result);
     }
 
@@ -7767,7 +7798,7 @@
 {
     str_modifiable(str);
 #if WITH_OBJC
-    rb_notimplement();
+    /* TODO */
 #else
     rb_enc_associate(str, rb_to_encoding(enc));
 #endif

Modified: MacRuby/trunk/test/ruby/test_string.rb
===================================================================
--- MacRuby/trunk/test/ruby/test_string.rb	2008-05-05 21:13:55 UTC (rev 188)
+++ MacRuby/trunk/test/ruby/test_string.rb	2008-05-06 23:07:11 UTC (rev 189)
@@ -957,6 +957,8 @@
 
     assert_equal([S("a"), S(""), S("b"), S("c")], S("a||b|c|").split(S('|')))
     assert_equal([S("a"), S(""), S("b"), S("c"), S("")], S("a||b|c|").split(S('|'), -1))
+
+    assert_equal([], S("").split(//))
   end
 
   def test_squeeze

    

[macruby-changes] [189] MacRuby/trunk

source_changes＠macosforge.org