rhodes 3.2.0.beta.4 → 3.2.0.beta.5

data/platform/shared/ruby/ext/stringio/stringio.c

@@ -28,15 +28,13 @@ struct StringIO {
     int count;
 };
 
-static void strio_mark _((struct StringIO *));
-static void strio_free _((struct StringIO *));
 static void strio_init(int, VALUE *, struct StringIO *);
 
-#define IS_STRIO(obj) (RDATA(obj)->dmark == (RUBY_DATA_FUNC)strio_mark)
+#define IS_STRIO(obj) (rb_typeddata_is_kind_of(obj, &strio_data_type))
 #define error_inval(msg) (errno = EINVAL, rb_sys_fail(msg))
 
 static struct StringIO *
-strio_alloc()
+strio_alloc(void)
 {
     struct StringIO *ptr = ALLOC(struct StringIO);
     ptr->string = Qnil;
@@ -48,36 +46,44 @@ strio_alloc()
 }
 
 static void
-strio_mark(struct StringIO *ptr)
+strio_mark(void *p)
 {
+    struct StringIO *ptr = p;
     if (ptr) {
 	rb_gc_mark(ptr->string);
     }
 }
 
 static void
-strio_free(struct StringIO *ptr)
+strio_free(void *p)
 {
+    struct StringIO *ptr = p;
     if (--ptr->count <= 0) {
 	xfree(ptr);
     }
 }
 
-static struct StringIO*
-check_strio(VALUE self)
+static size_t
+strio_memsize(const void *p)
 {
-    Check_Type(self, T_DATA);
-    if (!IS_STRIO(self)) {
-	rb_raise(rb_eTypeError, "wrong argument type %s (expected StringIO)",
-		 rb_class2name(CLASS_OF(self)));
-    }
-    return DATA_PTR(self);
+    const struct StringIO *ptr = p;
+    if (!ptr) return 0;
+    return sizeof(struct StringIO);
 }
 
+static const rb_data_type_t strio_data_type = {
+    "strio",
+    strio_mark,
+    strio_free,
+    strio_memsize,
+};
+
+#define check_strio(self) ((struct StringIO*)rb_check_typeddata(self, &strio_data_type))
+
 static struct StringIO*
 get_strio(VALUE self)
 {
-    struct StringIO *ptr = check_strio(self);
+    struct StringIO *ptr = check_strio(rb_io_taint_check(self));
 
     if (!ptr) {
 	rb_raise(rb_eIOError, "uninitialized stream");
@@ -86,11 +92,11 @@ get_strio(VALUE self)
 }
 
 static VALUE
-strio_substr(struct StringIO *ptr, int pos, int len)
+strio_substr(struct StringIO *ptr, long pos, long len)
 {
     VALUE str = ptr->string;
     rb_encoding *enc = rb_enc_get(str);
-    int rlen = RSTRING_LEN(str) - pos;
+    long rlen = RSTRING_LEN(str) - pos;
 
     if (len > rlen) len = rlen;
     if (len < 0) len = 0;
@@ -135,7 +141,7 @@ check_modifiable(struct StringIO *ptr)
 static VALUE
 strio_s_allocate(VALUE klass)
 {
-    return Data_Wrap_Struct(klass, strio_mark, strio_free, 0);
+    return TypedData_Wrap_Struct(klass, &strio_data_type, 0);
 }
 
 /*
@@ -160,7 +166,7 @@ static void
 strio_init(int argc, VALUE *argv, struct StringIO *ptr)
 {
     VALUE string, mode;
-    int trunc = Qfalse;
+    int trunc = 0;
 
     switch (rb_scan_args(argc, argv, "02", &string, &mode)) {
       case 2:
@@ -304,7 +310,7 @@ strio_set_string(VALUE self, VALUE string)
 {
     struct StringIO *ptr = StringIO(self);
 
-    if (!OBJ_TAINTED(self)) rb_secure(4);
+    rb_io_taint_check(self);
     ptr->flags &= ~FMODE_READWRITE;
     StringValue(string);
     ptr->flags = OBJ_FROZEN(string) ? FMODE_READABLE : FMODE_READWRITE;
@@ -317,7 +323,7 @@ strio_set_string(VALUE self, VALUE string)
  * call-seq:
  *   strio.close  -> nil
  *
- * Closes strio.  The *strio* is unavailable for any further data 
+ * Closes strio.  The *strio* is unavailable for any further data
  * operations; an +IOError+ is raised if such an attempt is made.
  */
 static VALUE
@@ -414,7 +420,7 @@ strio_closed_write(VALUE self)
  *   strio.eof     -> true or false
  *   strio.eof?    -> true or false
  *
- * Returns true if *strio* is at end of file. The stringio must be  
+ * Returns true if *strio* is at end of file. The stringio must be
  * opened for reading or an +IOError+ will be raised.
  */
 static VALUE
@@ -490,13 +496,13 @@ strio_set_lineno(VALUE self, VALUE lineno)
  *   strio.reopen(other_StrIO)     -> strio
  *   strio.reopen(string, mode)    -> strio
  *
- * Reinitializes *strio* with the given <i>other_StrIO</i> or _string_ 
+ * Reinitializes *strio* with the given <i>other_StrIO</i> or _string_
  * and _mode_ (see StringIO#new).
  */
 static VALUE
 strio_reopen(int argc, VALUE *argv, VALUE self)
 {
-    if (!OBJ_TAINTED(self)) rb_secure(4);
+    rb_io_taint_check(self);
     if (argc == 1 && TYPE(*argv) != T_STRING) {
 	return strio_copy(self, *argv);
     }
@@ -609,7 +615,11 @@ strio_get_sync(VALUE self)
 
 /*
  * call-seq:
+ *   strio.bytes {|byte| block }      -> strio
+ *   strio.bytes                      -> anEnumerator
+ *
  *   strio.each_byte {|byte| block }  -> strio
+ *   strio.each_byte                  -> anEnumerator
  *
  * See IO#each_byte.
  */
@@ -690,10 +700,9 @@ strio_extend(struct StringIO *ptr, long pos, long len)
  *   strio.ungetc(string)   -> nil
  *
  * Pushes back one character (passed as a parameter) onto *strio*
- * such that a subsequent buffered read will return it.  Pushing back 
- * behind the beginning of the buffer string is not possible.  Nothing
- * will be done if such an attempt is made.
- * In other case, there is no limitation for multiple pushbacks.
+ * such that a subsequent buffered read will return it.  There is no
+ * limitation for multiple pushbacks including pushing back behind the
+ * beginning of the buffer string.
  */
 static VALUE
 strio_ungetc(VALUE self, VALUE c)
@@ -720,17 +729,26 @@ strio_ungetc(VALUE self, VALUE c)
 	    c = rb_str_conv_enc(c, enc2, enc);
 	}
     }
-    /* get logical position */
-    lpos = 0; p = RSTRING_PTR(ptr->string); pend = p + ptr->pos;
-    for (;;) {
-	clen = rb_enc_mbclen(p, pend, enc);
-	if (p+clen >= pend) break;
-	p += clen;
-	lpos++;
+    if (RSTRING_LEN(ptr->string) < ptr->pos) {
+	long len = RSTRING_LEN(ptr->string);
+	rb_str_resize(ptr->string, ptr->pos - 1);
+	memset(RSTRING_PTR(ptr->string) + len, 0, ptr->pos - len - 1);
+	rb_str_concat(ptr->string, c);
+	ptr->pos--;
+    }
+    else {
+	/* get logical position */
+	lpos = 0; p = RSTRING_PTR(ptr->string); pend = p + ptr->pos;
+	for (;;) {
+	    clen = rb_enc_mbclen(p, pend, enc);
+	    if (p+clen >= pend) break;
+	    p += clen;
+	    lpos++;
+	}
+	clen = p - RSTRING_PTR(ptr->string);
+	rb_str_update(ptr->string, lpos, ptr->pos ? 1 : 0, c);
+	ptr->pos = clen;
     }
-    clen = p - RSTRING_PTR(ptr->string);
-    rb_str_update(ptr->string, lpos, ptr->pos ? 1 : 0, c);
-    ptr->pos = clen;
 
     return Qnil;
 }
@@ -744,8 +762,37 @@ strio_ungetc(VALUE self, VALUE c)
 static VALUE
 strio_ungetbyte(VALUE self, VALUE c)
 {
-    NUM2INT(c);
-    return strio_ungetc(self, c);
+    struct StringIO *ptr = readable(StringIO(self));
+    char buf[1], *cp = buf;
+    long pos = ptr->pos, cl = 1;
+    VALUE str = ptr->string;
+
+    if (NIL_P(c)) return Qnil;
+    if (FIXNUM_P(c)) {
+	buf[0] = (char)FIX2INT(c);
+    }
+    else {
+	SafeStringValue(c);
+	cp = RSTRING_PTR(c);
+	cl = RSTRING_LEN(c);
+	if (cl == 0) return Qnil;
+    }
+    rb_str_modify(str);
+    if (cl > pos) {
+	char *s;
+	long rest = RSTRING_LEN(str) - pos;
+	rb_str_resize(str, rest + cl);
+	s = RSTRING_PTR(str);
+	memmove(s + cl, s + pos, rest);
+	pos = 0;
+    }
+    else {
+	pos -= cl;
+    }
+    memcpy(RSTRING_PTR(str) + pos, cp, cl);
+    ptr->pos = pos;
+    RB_GC_GUARD(c);
+    return Qnil;
 }
 
 /*
@@ -778,7 +825,11 @@ strio_readbyte(VALUE self)
 
 /*
  * call-seq:
+ *   strio.chars {|char| block }      -> strio
+ *   strio.chars                      -> anEnumerator
+ *
  *   strio.each_char {|char| block }  -> strio
+ *   strio.each_char                  -> anEnumerator
  *
  * See IO#each_char.
  */
@@ -795,6 +846,41 @@ strio_each_char(VALUE self)
     return self;
 }
 
+/*
+ * call-seq:
+ *   strio.codepoints {|c| block }      -> strio
+ *   strio.codepoints                   -> anEnumerator
+ *
+ *   strio.each_codepoint {|c| block }  -> strio
+ *   strio.each_codepoint               -> anEnumerator
+ *
+ * See IO#each_codepoint.
+ */
+static VALUE
+strio_each_codepoint(VALUE self)
+{
+    struct StringIO *ptr;
+    rb_encoding *enc;
+    unsigned int c;
+    int n;
+
+    RETURN_ENUMERATOR(self, 0, 0);
+
+    ptr = readable(StringIO(self));
+    enc = rb_enc_get(ptr->string);
+    for (;;) {
+	if (ptr->pos >= RSTRING_LEN(ptr->string)) {
+	    return self;
+	}
+
+	c = rb_enc_codepoint_len(RSTRING_PTR(ptr->string)+ptr->pos,
+				 RSTRING_END(ptr->string), &n, enc);
+	rb_yield(UINT2NUM(c));
+	ptr->pos += n;
+    }
+    return self;
+}
+
 /* Boyer-Moore search: copied from regex.c */
 static void
 bm_init_skip(long *skip, const char *pat, long m)
@@ -833,18 +919,17 @@ strio_getline(int argc, VALUE *argv, struct StringIO *ptr)
 {
     const char *s, *e, *p;
     long n, limit = 0;
-    VALUE str;
+    VALUE str, lim;
 
-    if (argc == 0) {
+    rb_scan_args(argc, argv, "02", &str, &lim);
+    switch (argc) {
+      case 0:
 	str = rb_rs;
-    }
-    else {
-	VALUE lim, tmp;
+	break;
 
-	rb_scan_args(argc, argv, "11", &str, &lim);
-	if (!NIL_P(lim)) limit = NUM2LONG(lim);
-	else if (!NIL_P(str) && TYPE(str) != T_STRING) {
-	    tmp = rb_check_string_type(str);
+      case 1:
+	if (!NIL_P(str) && TYPE(str) != T_STRING) {
+	    VALUE tmp = rb_check_string_type(str);
 	    if (NIL_P(tmp)) {
 		limit = NUM2LONG(str);
 		if (limit == 0) return rb_str_new(0,0);
@@ -854,9 +939,12 @@ strio_getline(int argc, VALUE *argv, struct StringIO *ptr)
 		str = tmp;
 	    }
 	}
-	else if (!NIL_P(str)) {
-	    StringValue(str);
-	}
+	break;
+
+      case 2:
+	if (!NIL_P(str)) StringValue(str);
+	limit = NUM2LONG(lim);
+	break;
     }
 
     if (ptr->pos >= (n = RSTRING_LEN(ptr->string))) {
@@ -866,7 +954,7 @@ strio_getline(int argc, VALUE *argv, struct StringIO *ptr)
     e = s + RSTRING_LEN(ptr->string);
     s += ptr->pos;
     if (limit > 0 && s + limit < e) {
-	e = s + limit;
+	e = rb_enc_right_char_head(s, s + limit, e, rb_enc_get(ptr->string));
     }
     if (NIL_P(str)) {
 	str = strio_substr(ptr, ptr->pos, e - s);
@@ -885,7 +973,7 @@ strio_getline(int argc, VALUE *argv, struct StringIO *ptr)
 		break;
 	    }
 	}
-	str = strio_substr(ptr, s - RSTRING_PTR(ptr->string), e - s); 
+	str = strio_substr(ptr, s - RSTRING_PTR(ptr->string), e - s);
     }
     else if (n == 1) {
 	if ((p = memchr(s, RSTRING_PTR(str)[0], e - s)) != 0) {
@@ -957,9 +1045,17 @@ strio_readline(int argc, VALUE *argv, VALUE self)
  *   strio.each(sep=$/) {|line| block }         -> strio
  *   strio.each(limit) {|line| block }          -> strio
  *   strio.each(sep, limit) {|line| block }     -> strio
+ *   strio.each(...)                            -> anEnumerator
+ *
  *   strio.each_line(sep=$/) {|line| block }    -> strio
  *   strio.each_line(limit) {|line| block }     -> strio
  *   strio.each_line(sep,limit) {|line| block } -> strio
+ *   strio.each_line(...)                       -> anEnumerator
+ *
+ *   strio.lines(sep=$/) {|line| block }        -> strio
+ *   strio.lines(limit) {|line| block }         -> strio
+ *   strio.lines(sep,limit) {|line| block }     -> strio
+ *   strio.lines(...)                           -> anEnumerator
  *
  * See IO#each.
  */
@@ -1013,6 +1109,7 @@ strio_write(VALUE self, VALUE str)
     long len, olen;
     rb_encoding *enc, *enc2;
 
+    RB_GC_GUARD(str);
     if (TYPE(str) != T_STRING)
 	str = rb_obj_as_string(str);
     enc = rb_enc_get(ptr->string);
@@ -1108,7 +1205,7 @@ strio_read(int argc, VALUE *argv, VALUE self)
 {
     struct StringIO *ptr = readable(StringIO(self));
     VALUE str = Qnil;
-    long len, olen;
+    long len;
 
     switch (argc) {
       case 2:
@@ -1117,7 +1214,7 @@ strio_read(int argc, VALUE *argv, VALUE self)
 	rb_str_modify(str);
       case 1:
 	if (!NIL_P(argv[0])) {
-	    len = olen = NUM2LONG(argv[0]);
+	    len = NUM2LONG(argv[0]);
 	    if (len < 0) {
 		rb_raise(rb_eArgError, "negative length %ld given", len);
 	    }
@@ -1129,7 +1226,6 @@ strio_read(int argc, VALUE *argv, VALUE self)
 	}
 	/* fall through */
       case 0:
-	olen = -1;
 	len = RSTRING_LEN(ptr->string);
 	if (len <= ptr->pos) {
 	    if (NIL_P(str)) {
@@ -1149,6 +1245,7 @@ strio_read(int argc, VALUE *argv, VALUE self)
     }
     if (NIL_P(str)) {
 	str = strio_substr(ptr, ptr->pos, len);
+	if (argc > 0) rb_enc_associate(str, rb_ascii8bit_encoding());
     }
     else {
 	long rest = RSTRING_LEN(ptr->string) - ptr->pos;
@@ -1185,9 +1282,6 @@ strio_sysread(int argc, VALUE *argv, VALUE self)
 
 #define strio_syswrite strio_write
 
-/* call-seq: strio.path -> nil */
-#define strio_path strio_nil
-
 /*
  * call-seq:
  *   strio.isatty -> nil
@@ -1325,7 +1419,6 @@ Init_stringio()
     rb_define_method(StringIO, "sync", strio_get_sync, 0);
     rb_define_method(StringIO, "sync=", strio_set_sync, 1);
     rb_define_method(StringIO, "tell", strio_tell, 0);
-    rb_define_method(StringIO, "path", strio_path, 0);
 
     rb_define_method(StringIO, "each", strio_each, -1);
     rb_define_method(StringIO, "each_line", strio_each, -1);
@@ -1334,6 +1427,8 @@ Init_stringio()
     rb_define_method(StringIO, "bytes", strio_each_byte, 0);
     rb_define_method(StringIO, "each_char", strio_each_char, 0);
     rb_define_method(StringIO, "chars", strio_each_char, 0);
+    rb_define_method(StringIO, "each_codepoint", strio_each_codepoint, 0);
+    rb_define_method(StringIO, "codepoints", strio_each_codepoint, 0);
     rb_define_method(StringIO, "getc", strio_getc, 0);
     rb_define_method(StringIO, "ungetc", strio_ungetc, 1);
     rb_define_method(StringIO, "ungetbyte", strio_ungetbyte, 1);
@@ -1346,6 +1441,7 @@ Init_stringio()
     rb_define_method(StringIO, "read", strio_read, -1);
     rb_define_method(StringIO, "sysread", strio_sysread, -1);
     rb_define_method(StringIO, "readpartial", strio_sysread, -1);
+    rb_define_method(StringIO, "read_nonblock", strio_sysread, -1);
 
     rb_define_method(StringIO, "write", strio_write, 1);
     rb_define_method(StringIO, "<<", strio_addstr, 1);
@@ -1354,6 +1450,7 @@ Init_stringio()
     rb_define_method(StringIO, "putc", strio_putc, 1);
     rb_define_method(StringIO, "puts", strio_puts, -1);
     rb_define_method(StringIO, "syswrite", strio_syswrite, 1);
+    rb_define_method(StringIO, "write_nonblock", strio_syswrite, 1);
 
     rb_define_method(StringIO, "isatty", strio_isatty, 0);
     rb_define_method(StringIO, "tty?", strio_isatty, 0);