[macruby-changes] [3717] MacRuby/branches/icu/ext

9 Mar 2010

Revision: 3717
          http://trac.macosforge.org/projects/ruby/changeset/3717
Author:   lsansonetti@apple.com
Date:     2010-03-09 15:04:10 -0800 (Tue, 09 Mar 2010)
Log Message:
-----------
port to new bstr APIs

Modified Paths:
--------------
    MacRuby/branches/icu/ext/bigdecimal/bigdecimal.c
    MacRuby/branches/icu/ext/digest/bubblebabble/bubblebabble.c
    MacRuby/branches/icu/ext/digest/digest.c
    MacRuby/branches/icu/ext/libyaml/rubyext.c
    MacRuby/branches/icu/ext/openssl/ossl.c
    MacRuby/branches/icu/ext/openssl/ossl_bio.c
    MacRuby/branches/icu/ext/openssl/ossl_digest.c
    MacRuby/branches/icu/ext/openssl/ossl_ssl.c
    MacRuby/branches/icu/ext/ripper/extconf.rb
    MacRuby/branches/icu/ext/socket/socket.c
    MacRuby/branches/icu/ext/zlib/zlib.c

Modified: MacRuby/branches/icu/ext/bigdecimal/bigdecimal.c
===================================================================

--- MacRuby/branches/icu/ext/bigdecimal/bigdecimal.c	2010-03-09 23:03:42 UTC (rev 3716)
+++ MacRuby/branches/icu/ext/bigdecimal/bigdecimal.c	2010-03-09 23:04:10 UTC (rev 3717)
@@ -2523,9 +2523,7 @@
 
     /* Skip all '_' after digit: 2006-6-30 */
     ni = 0;
-    VALUE bstr = rb_bytestring_new();
-    rb_bytestring_resize(bstr, strlen(szVal)+1);
-    psz = (char *)rb_bytestring_byte_pointer(bstr);
+    psz = (char *)xmalloc(strlen(szVal)+1);
     i   = 0;
     ipn = 0;
     while((psz[i]=szVal[ipn])!=0) {

Modified: MacRuby/branches/icu/ext/digest/bubblebabble/bubblebabble.c
===================================================================
--- MacRuby/branches/icu/ext/digest/bubblebabble/bubblebabble.c	2010-03-09 23:03:42 UTC (rev 3716)
+++ MacRuby/branches/icu/ext/digest/bubblebabble/bubblebabble.c	2010-03-09 23:04:10 UTC (rev 3717)
@@ -40,7 +40,7 @@
     }
 
     const size_t p_len = (digest_len | 1) * 3 + 2;
-    p = (UInt8 *)alloca(p_len + 1);
+    p = (UInt8 *)malloc(p_len + 1);
 
     i = j = 0;
     p[j++] = 'x';
@@ -74,7 +74,9 @@
 
     p[j] = 'x';
 
-    return rb_bytestring_new_with_data(p, p_len);
+    VALUE bstr = rb_bstr_new_with_data(p, p_len);
+    free(p);
+    return bstr;
 }
 
 /*

Modified: MacRuby/branches/icu/ext/digest/digest.c
===================================================================
--- MacRuby/branches/icu/ext/digest/digest.c	2010-03-09 23:03:42 UTC (rev 3716)
+++ MacRuby/branches/icu/ext/digest/digest.c	2010-03-09 23:04:10 UTC (rev 3717)
@@ -52,7 +52,7 @@
     }
 
     const size_t p_len = digest_len * 2;
-    p = (UInt8 *)alloca(p_len + 1);
+    p = (UInt8 *)malloc(p_len + 1);
 
     for (i = 0; i < digest_len; i++) {
         unsigned char byte = digest[i];
@@ -61,7 +61,9 @@
         p[i + i + 1] = hex[byte & 0x0f];
     }
 
-    return rb_bytestring_new_with_data(p, p_len);
+    VALUE bstr = rb_bstr_new_with_data(p, p_len);
+    free(p);
+    return bstr;
 }
 
 /*

Modified: MacRuby/branches/icu/ext/libyaml/rubyext.c
===================================================================
--- MacRuby/branches/icu/ext/libyaml/rubyext.c	2010-03-09 23:03:42 UTC (rev 3716)
+++ MacRuby/branches/icu/ext/libyaml/rubyext.c	2010-03-09 23:04:10 UTC (rev 3717)
@@ -157,12 +157,7 @@
 
     if (!NIL_P(input)) {
 	assert(parser != NULL);
-	if (CLASS_OF(input) == rb_cByteString) {
-	    yaml_parser_set_input_string(parser,
-		    (const unsigned char *)rb_bytestring_byte_pointer(input),
-		    rb_bytestring_length(input));
-	}
-	else if (TYPE(input) == T_STRING) {
+	if (TYPE(input) == T_STRING) {
 	    const char * instring = RSTRING_PTR(input);
 	    yaml_parser_set_input_string(parser,
 		    (const unsigned char *)(instring),
@@ -524,10 +519,7 @@
 	tag = "tag:yaml.org,2002:str";
     }
     VALUE handler = handler_for_tag(parser, (yaml_char_t *)tag);
-    VALUE scalarval = (VALUE)CFStringCreateWithBytes(NULL, (const UInt8 *)val,
-	    parser->event.data.scalar.length,
-	    kCFStringEncodingUTF8, true);
-    CFMakeCollectable((CFTypeRef)scalarval);
+    VALUE scalarval = rb_str_new(val, parser->event.data.scalar.length);
     return interpret_value(parser, scalarval, handler);
 }
 
@@ -635,9 +627,7 @@
 {
     VALUE argv[2];
 
-    argv[0] = (VALUE)CFStringCreateWithBytes(NULL, (const UInt8 *)tag,
-					     strlen(tag),
-					     kCFStringEncodingUTF8, true);
+    argv[0] = rb_str_new2(tag);
     argv[1] = value;
 
     return rb_class_new_instance(2, argv, rb_cYamlNode);
@@ -655,9 +645,7 @@
     if (tag == NULL) {
 	tag = "str";
     }
-    VALUE scalarval = (VALUE)CFStringCreateWithBytes(NULL, (const UInt8 *)val,
-	    parser->event.data.scalar.length,
-	    kCFStringEncodingUTF8, true);
+    VALUE scalarval = rb_str_new(val, parser->event.data.scalar.length);
     return make_yaml_node(tag, scalarval);
 }
 
@@ -848,10 +836,9 @@
 }
 
 static int
-rb_yaml_bytestring_output_handler(void *bs, unsigned char *buffer, size_t size)
+rb_yaml_str_output_handler(void *str, unsigned char *buffer, size_t size)
 {
-    CFMutableDataRef data = rb_bytestring_wrapped_data((VALUE)bs);
-    CFDataAppendBytes(data, (const UInt8*)buffer, (CFIndex)size);
+    rb_str_cat((VALUE)str, (char *)buffer, size);
     return 1;
 }
 
@@ -870,18 +857,21 @@
     GC_WB(&remitter->output, output);
     yaml_emitter_t *emitter = &remitter->emitter;
     if (!NIL_P(output)) {
-	if (CLASS_OF(output) == rb_cByteString) {
-	    yaml_emitter_set_output(emitter, rb_yaml_bytestring_output_handler,
-		    (void *)output);
-	}
-	else if (TYPE(output) == T_FILE) {
-	    yaml_emitter_set_output(emitter, rb_yaml_io_output_handler,
-		    (void *)output);
-	}
-	else {
-	    rb_raise(rb_eArgError, "unsupported YAML output type %s",
-		    rb_obj_classname(output));
-	}
+	switch (TYPE(output)) {
+	    case T_FILE:
+		yaml_emitter_set_output(emitter, rb_yaml_io_output_handler,
+			(void *)output);
+		break;
+
+	    case T_STRING:
+		yaml_emitter_set_output(emitter, rb_yaml_str_output_handler,
+			(void *)output);
+		break;
+
+	    default:
+		rb_raise(rb_eArgError, "unsupported YAML output type %s",
+			rb_obj_classname(output));
+	}	
     }
     return output;
 }
@@ -892,7 +882,7 @@
     VALUE output = Qnil;
     rb_scan_args(argc, argv, "01", &output);
     if (NIL_P(output)) {
-	output = rb_bytestring_new();
+	output = rb_str_new(NULL, 0);
     }
     rb_yaml_emitter_set_output(self, 0, output);
     return self;
@@ -991,8 +981,7 @@
     yaml_event_t ev;
     yaml_emitter_t *emitter = &RYAMLEmitter(self)->emitter;
     yaml_char_t *output = (yaml_char_t *)RSTRING_PTR(val);
-    const size_t length = *(VALUE *)val == rb_cByteString
-	? RSTRING_LEN(val) : strlen((const char *)output);
+    const size_t length = RSTRING_LEN(val);
 
     int can_omit_tag = 0;
     int string_tag   = 0;

Modified: MacRuby/branches/icu/ext/openssl/ossl.c
===================================================================
--- MacRuby/branches/icu/ext/openssl/ossl.c	2010-03-09 23:03:42 UTC (rev 3716)
+++ MacRuby/branches/icu/ext/openssl/ossl.c	2010-03-09 23:04:10 UTC (rev 3717)
@@ -121,7 +121,7 @@
 VALUE
 ossl_buf2str(char *buf, int len)
 {
-    return rb_bytestring_new_with_data((UInt8 *)buf, len);
+    return rb_bstr_new_with_data((UInt8 *)buf, len);
 }
 
 /*

Modified: MacRuby/branches/icu/ext/openssl/ossl_bio.c
===================================================================
--- MacRuby/branches/icu/ext/openssl/ossl_bio.c	2010-03-09 23:03:42 UTC (rev 3716)
+++ MacRuby/branches/icu/ext/openssl/ossl_bio.c	2010-03-09 23:04:10 UTC (rev 3717)
@@ -39,11 +39,8 @@
     }
     else {
 	StringValue(obj);
-	if (CLASS_OF(obj) != rb_cByteString) {
-	    rb_raise(rb_eArgError, "expected ByteString object");
-	}
-	bio = BIO_new_mem_buf(rb_bytestring_byte_pointer(obj),
-		rb_bytestring_length(obj));
+	obj = rb_str_bstr(obj);
+	bio = BIO_new_mem_buf(rb_bstr_bytes(obj), rb_bstr_length(obj));
 	if (!bio) ossl_raise(eOSSLError, NULL);
     }
 

Modified: MacRuby/branches/icu/ext/openssl/ossl_digest.c
===================================================================
--- MacRuby/branches/icu/ext/openssl/ossl_digest.c	2010-03-09 23:03:42 UTC (rev 3716)
+++ MacRuby/branches/icu/ext/openssl/ossl_digest.c	2010-03-09 23:04:10 UTC (rev 3717)
@@ -175,17 +175,15 @@
     GetDigest(self, ctx);
 
     if (NIL_P(str)) {
-        str = rb_bytestring_new();
+        str = rb_bstr_new();
     }
     else {
         StringValue(str);
-	if (CLASS_OF(str) != rb_cByteString) {
-	    rb_raise(rb_eArgError, "expected ByteString object");
-	}
+	str = rb_str_bstr(str);
     }
-    rb_bytestring_resize(str, EVP_MD_CTX_size(ctx));
+    rb_bstr_resize(str, EVP_MD_CTX_size(ctx));
 
-    EVP_DigestFinal_ex(ctx, rb_bytestring_byte_pointer(str), NULL);
+    EVP_DigestFinal_ex(ctx, rb_bstr_bytes(str), NULL);
 
     return str;
 }

Modified: MacRuby/branches/icu/ext/openssl/ossl_ssl.c
===================================================================
--- MacRuby/branches/icu/ext/openssl/ossl_ssl.c	2010-03-09 23:03:42 UTC (rev 3716)
+++ MacRuby/branches/icu/ext/openssl/ossl_ssl.c	2010-03-09 23:04:10 UTC (rev 3717)
@@ -1167,16 +1167,14 @@
     rb_scan_args(argc, argv, "11", &len, &str);
     ilen = NUM2INT(len);
     if(NIL_P(str)) {
-	str = rb_bytestring_new();
+	str = rb_bstr_new();
     }
     else{
         StringValue(str);
-        rb_str_modify(str);
-	if (CLASS_OF(str) != rb_cByteString) {
-	    rb_raise(rb_eArgError, "expected ByteString object");
-	}
+	rb_str_modify(str);
+	str = rb_str_bstr(str);
     }
-    rb_bytestring_resize(str, ilen);
+    rb_bstr_resize(str, ilen);
     if(ilen == 0) return str;
 
     Data_Get_Struct(self, SSL, ssl);
@@ -1185,8 +1183,8 @@
 	if(!nonblock && SSL_pending(ssl) <= 0)
 	    rb_thread_wait_fd(FPTR_TO_FD(fptr));
 	for (;;){
-	    nread = SSL_read(ssl, rb_bytestring_byte_pointer(str),
-		    rb_bytestring_length(str));
+	    nread = SSL_read(ssl, rb_bstr_bytes(str),
+		    rb_bstr_length(str));
 	    switch(ssl_get_error(ssl, nread)){
 	    case SSL_ERROR_NONE:
 		goto end;

Modified: MacRuby/branches/icu/ext/ripper/extconf.rb
===================================================================
--- MacRuby/branches/icu/ext/ripper/extconf.rb	2010-03-09 23:03:42 UTC (rev 3716)
+++ MacRuby/branches/icu/ext/ripper/extconf.rb	2010-03-09 23:04:10 UTC (rev 3717)
@@ -16,6 +16,7 @@
   $defs << '-DRIPPER_DEBUG' if $debug
   $VPATH << '$(topdir)' << '$(top_srcdir)'
   $INCFLAGS << ' -I$(topdir) -I$(top_srcdir) -I$(top_srcdir)/onig'
+  $CFLAGS << ' -std=c99'
   create_makefile 'ripper'
 end
 

Modified: MacRuby/branches/icu/ext/socket/socket.c
===================================================================
--- MacRuby/branches/icu/ext/socket/socket.c	2010-03-09 23:03:42 UTC (rev 3716)
+++ MacRuby/branches/icu/ext/socket/socket.c	2010-03-09 23:04:10 UTC (rev 3717)
@@ -597,17 +597,17 @@
     }
     fd = fptr->fd;
 
-    str = rb_bytestring_new();
-    rb_bytestring_resize(str, buflen);
+    str = rb_bstr_new();
+    rb_bstr_resize(str, buflen);
 
   retry:
     rb_thread_wait_fd(fd);
     rb_io_check_closed(fptr);
-    if (rb_bytestring_length(str) != buflen) {
+    if (rb_bstr_length(str) != buflen) {
 	rb_raise(rb_eRuntimeError, "buffer string modified");
     }
     TRAP_BEG;
-    slen = recvfrom(fd, rb_bytestring_byte_pointer(str), buflen, flags,
+    slen = recvfrom(fd, rb_bstr_bytes(str), buflen, flags,
 	    (struct sockaddr *)buf, &alen);
     TRAP_END;
 
@@ -617,8 +617,8 @@
 	}
 	rb_sys_fail("recvfrom(2)");
     }
-    if (slen < rb_bytestring_length(str)) {
-	rb_bytestring_resize(str, slen);
+    if (slen < rb_bstr_length(str)) {
+	rb_bstr_resize(str, slen);
     }
     rb_obj_taint(str);
     switch (from) {
@@ -677,19 +677,19 @@
     }
     fd = fptr->fd;
 
-    str = rb_bytestring_new();
-    rb_bytestring_resize(str, buflen);
+    str = rb_bstr_new();
+    rb_bstr_resize(str, buflen);
 
     rb_io_check_closed(fptr);
     rb_io_set_nonblock(fptr);
-    slen = recvfrom(fd, rb_bytestring_byte_pointer(str), buflen, flags,
+    slen = recvfrom(fd, rb_bstr_bytes(str), buflen, flags,
 	    (struct sockaddr *)buf, &alen);
 
     if (slen < 0) {
 	rb_sys_fail("recvfrom(2)");
     }
-    if (slen < rb_bytestring_length(str)) {
-	rb_bytestring_resize(str, slen);
+    if (slen < rb_bstr_length(str)) {
+	rb_bstr_resize(str, slen);
     }
     rb_obj_taint(str);
     switch (from) {

Modified: MacRuby/branches/icu/ext/zlib/zlib.c
===================================================================
--- MacRuby/branches/icu/ext/zlib/zlib.c	2010-03-09 23:03:42 UTC (rev 3716)
+++ MacRuby/branches/icu/ext/zlib/zlib.c	2010-03-09 23:04:10 UTC (rev 3717)
@@ -187,9 +187,9 @@
 
 void Init_zlib _((void));
 
-#define BSTRING_LEN(s) rb_bytestring_length(s)
-#define BSTRING_PTR(s) (rb_bytestring_byte_pointer(s))
-#define BSTRING_PTR_BYTEF(s) ((Bytef*)rb_bytestring_byte_pointer(s))
+#define BSTRING_LEN(s) rb_bstr_length(s)
+#define BSTRING_PTR(s) (rb_bstr_bytes(s))
+#define BSTRING_PTR_BYTEF(s) ((Bytef*)rb_bstr_bytes(s))
 
 
 /*--------- Exceptions --------*/
@@ -403,8 +403,8 @@
     long inc;
 
     if (NIL_P(z->buf)) {
-        GC_WB(&z->buf, rb_bytestring_new());
-        rb_bytestring_resize(z->buf, ZSTREAM_INITIAL_BUFSIZE);
+        GC_WB(&z->buf, rb_bstr_new());
+        rb_bstr_resize(z->buf, ZSTREAM_INITIAL_BUFSIZE);
         z->buf_filled = 0;
         z->stream.next_out = BSTRING_PTR_BYTEF(z->buf);
         z->stream.avail_out = ZSTREAM_INITIAL_BUFSIZE;
@@ -419,7 +419,7 @@
         if (inc < ZSTREAM_AVAIL_OUT_STEP_MIN) {
             inc = ZSTREAM_AVAIL_OUT_STEP_MIN;
         }
-        rb_bytestring_resize(z->buf, z->buf_filled + inc);
+        rb_bstr_resize(z->buf, z->buf_filled + inc);
         z->stream.avail_out = (inc < ZSTREAM_AVAIL_OUT_STEP_MAX) ?
             inc : ZSTREAM_AVAIL_OUT_STEP_MAX;
     }
@@ -430,13 +430,13 @@
 zstream_expand_buffer_into(struct zstream *z, int size)
 {
     if (NIL_P(z->buf)) {
-        GC_WB(&z->buf, rb_bytestring_new());
+        GC_WB(&z->buf, rb_bstr_new());
         z->buf_filled = 0;
         z->stream.next_out = BSTRING_PTR_BYTEF(z->buf);
         z->stream.avail_out = size;
     }
     else if (z->stream.avail_out != size) {
-        rb_bytestring_resize(z->buf, z->buf_filled + size);
+        rb_bstr_resize(z->buf, z->buf_filled + size);
         z->stream.next_out = BSTRING_PTR_BYTEF(z->buf) + z->buf_filled;
         z->stream.avail_out = size;
     }
@@ -446,30 +446,29 @@
 zstream_append_buffer(struct zstream *z, const Bytef *src, int len)
 {
     if (NIL_P(z->buf)) {
-	GC_WB(&z->buf, rb_bytestring_new_with_data((UInt8*)src, len));
+	GC_WB(&z->buf, rb_bstr_new_with_data((UInt8*)src, len));
 	z->buf_filled = len;
 	z->stream.next_out = BSTRING_PTR_BYTEF(z->buf);
 	z->stream.avail_out = 0;
 	return;
     }
     
-    CFMutableDataRef data = rb_bytestring_wrapped_data(z->buf);
-    if (CFDataGetLength(data) < (z->buf_filled + len)) {
-	CFDataSetLength(data, z->buf_filled + len);
+    if (rb_bstr_length(z->buf) < (z->buf_filled + len)) {
+	rb_bstr_resize(z->buf, z->buf_filled + len);
 	z->stream.avail_out = 0;
     } else if (z->stream.avail_out >= len) {
         z->stream.avail_out -= len;
     } else {
         z->stream.avail_out = 0;
     }
-    
-    CFDataAppendBytes(data, (const UInt8*)src, len);
+
+    rb_bstr_concat(z->buf, (const UInt8 *)src, len);
     z->buf_filled += len;
     z->stream.next_out = BSTRING_PTR_BYTEF(z->buf) + z->buf_filled;
 }
 
 #define zstream_append_buffer2(z,v) \
-    zstream_append_buffer((z),(Bytef*)rb_bytestring_byte_pointer(v),rb_bytestring_length(v))
+    zstream_append_buffer((z),(Bytef*)rb_bstr_bytes(v),rb_bstr_length(v))
 
 static VALUE
 zstream_detach_buffer(struct zstream *z)
@@ -477,11 +476,11 @@
     VALUE dst;
 
     if (NIL_P(z->buf)) {
-        dst = rb_bytestring_new();
+        dst = rb_bstr_new();
     }
     else {
         dst = z->buf;
-        rb_bytestring_resize(dst, z->buf_filled);
+        rb_bstr_resize(dst, z->buf_filled);
     }
 
     z->buf = Qnil;
@@ -500,7 +499,7 @@
         return zstream_detach_buffer(z);
     }
 
-    rb_bytestring_resize(z->buf, len);
+    rb_bstr_resize(z->buf, len);
     dst = z->buf;
     z->buf_filled -= len;
     UInt8 *buf = BSTRING_PTR(z->buf);
@@ -536,17 +535,15 @@
     if (len <= 0) return;
 
     if (NIL_P(z->input)) {
-	GC_WB(&z->input, rb_bytestring_new_with_data((UInt8*)src, len));
+	GC_WB(&z->input, rb_bstr_new_with_data((UInt8*)src, len));
     } else {
-	rb_bytestring_append_bytes(z->input, (const UInt8*)src, len);
+	rb_bstr_concat(z->input, (const UInt8*)src, len);
     }
 }
 
 #define zstream_append_input2(z,v) \
     do { \
-	if (*(VALUE *)v != rb_cByteString) { \
-	    v = rb_coerce_to_bytestring(v); \
-	} \
+	v = rb_str_bstr(v); \
 	zstream_append_input((z), BSTRING_PTR_BYTEF(v), BSTRING_LEN(v)); \
     } \
     while(0)
@@ -559,7 +556,7 @@
     } else {
         UInt8 *buf = BSTRING_PTR(z->input);
         memmove(buf, buf+len, BSTRING_LEN(z->input) - len);
-	    rb_bytestring_resize(z->input, BSTRING_LEN(z->input) - len);
+	    rb_bstr_resize(z->input, BSTRING_LEN(z->input) - len);
     }
 }
 
@@ -584,9 +581,9 @@
     VALUE dst;
 
     if (NIL_P(z->input)) {
-        dst = rb_bytestring_new();
+        dst = rb_bstr_new();
     } else {
-	    dst = z->input;
+	dst = z->input;
     }
     z->input = Qnil;
     return dst;
@@ -1115,9 +1112,7 @@
     lev = ARG_LEVEL(level);
     CFShow((CFStringRef)src);
     StringValue(src);
-    if (CLASS_OF(src) != rb_cByteString) {
-        src = rb_coerce_to_bytestring(src);
-    }
+    src = rb_str_bstr(src);
     zstream_init_deflate(z);
     err = deflateInit(&z->stream, lev);
     if (err != Z_OK) {
@@ -1141,9 +1136,7 @@
 	return;
     }
     StringValue(src);
-    if (CLASS_OF(src) != rb_cByteString) {
-        src = rb_coerce_to_bytestring(src);
-    }
+    src = rb_str_bstr(src);
     if (flush != Z_NO_FLUSH || BSTRING_LEN(src) > 0) { /* prevent BUF_ERROR */
 	zstream_run(z, BSTRING_PTR_BYTEF(src), BSTRING_LEN(src), flush);
     }
@@ -1270,9 +1263,7 @@
 
     OBJ_INFECT(obj, dic);
     StringValue(src);
-    if (CLASS_OF(src) != rb_cByteString) {
-        src = rb_coerce_to_bytestring(src);
-    }
+    src = rb_str_bstr(src);
     err = deflateSetDictionary(&z->stream,
 			       BSTRING_PTR(src), BSTRING_LEN(src));
     if (err != Z_OK) {
@@ -1421,11 +1412,9 @@
 	}
 	else {
 	    StringValue(src);
-	    if (CLASS_OF(src) != rb_cByteString) {
-            src = rb_coerce_to_bytestring(src);
-	    }
+	    src = rb_str_bstr(src);
 	    zstream_append_buffer2(z, src);
-	    dst = rb_bytestring_new(0, 0);
+	    dst = rb_bstr_new();
 	}
     }
     else {
@@ -2000,7 +1989,7 @@
     if (len < 0)
         rb_raise(rb_eArgError, "negative length %d given", len);
     if (len == 0)
-	return rb_bytestring_new(0, 0);
+	return rb_bstr_new();
     while (!ZSTREAM_IS_FINISHED(&gz->z) && gz->z.buf_filled < len) {
 	gzfile_read_more(gz);
     }
@@ -2031,9 +2020,9 @@
 
     if (len == 0) {
         if (NIL_P(outbuf))
-            return rb_bytestring_new(0, 0);
+            return rb_bstr_new();
         else {
-            rb_bytestring_resize(outbuf, 0);
+            rb_bstr_resize(outbuf, 0);
             return outbuf;
         }
     }
@@ -2057,7 +2046,7 @@
         return dst;
     }
     else {
-        rb_bytestring_resize(outbuf, BSTRING_LEN(dst));
+        rb_bstr_resize(outbuf, BSTRING_LEN(dst));
         UInt8 *buf = BSTRING_PTR(outbuf);
         memcpy(buf, BSTRING_PTR(dst), BSTRING_LEN(dst));
         return outbuf;
@@ -2076,7 +2065,7 @@
 	if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
 	    gzfile_check_footer(gz);
 	}
-	return rb_bytestring_new(0, 0);
+	return rb_bstr_new();
     }
 
     dst = zstream_detach_buffer(&gz->z);
@@ -2623,12 +2612,8 @@
 {
     struct gzfile *gz = get_gzfile(obj);
 
-    if (TYPE(str) != T_STRING) {
-	str = rb_obj_as_string(str);
-    }
-    if (CLASS_OF(str) != rb_cByteString) {
-        str = rb_coerce_to_bytestring(str);
-    }
+    StringValue(str);
+    str = rb_str_bstr(str);
     gzfile_write(gz, BSTRING_PTR_BYTEF(str), BSTRING_LEN(str));
     return INT2FIX(BSTRING_LEN(str));
 }

    

[macruby-changes] [3717] MacRuby/branches/icu/ext

source_changes＠macosforge.org