Class: StringIO (Ruby 2.5.7)
Description: Class : StringIO - Ruby 2.5.7

### Home Classes Methods

### In Files

- stringio/stringio.c

### Parent

Data

### Methods

- ::new
- ::open
- #binmode
- #bytes
- #chars
- #close
- #close_read
- #close_write
- #closed?
- #closed_read?
- #closed_write?
- #codepoints
- #each
- #each_byte
- #each_char
- #each_codepoint
- #each_line
- #eof
- #eof?
- #external_encoding
- #fcntl
- #fileno
- #flush
- #fsync
- #getbyte
- #getc
- #gets
- #internal_encoding
- #isatty
- #length
- #lineno
- #lineno=
- #lines
- #pid
- #pos
- #pos=
- #putc
- #read
- #readlines
- #reopen
- #rewind
- #seek
- #set_encoding
- #size
- #string
- #string=
- #sync
- #sync=
- #tell
- #truncate
- #tty?
- #ungetbyte
- #ungetc
- #write

### Included Modules

- Enumerable
- IO::generic_readable
- IO::generic_writable

### Class/Module Index

Quicksearch

- IO
- IO::generic_readable
- IO::generic_writable
- StringIO

No matching classes.

# StringIO

Pseudo I/O on String object.

Commonly used to simulate `$stdio` or `$stderr`

### Examples¶ ↑

    require 'stringio'

    io = StringIO.new
    io.puts "Hello World"
    io.string #=> "Hello World\n"

### Public Class Methods

new(string=""[, mode]) click to toggle source

Creates new `StringIO` instance from with string and mode.

                   static VALUE
    strio_initialize(int argc, VALUE *argv, VALUE self)
    {
        struct StringIO *ptr = check_strio(self);

        if (!ptr) {
            DATA_PTR(self) = ptr = strio_alloc();
        }
        rb_call_super(0, 0);
        return strio_init(argc, argv, ptr, self);
    }

open(string=""[, mode]) {|strio| ...} click to toggle source

Equivalent to `StringIO.new` except that when it is called with a block, it yields with the new instance and closes it, and returns the result which returned from the block.

                   static VALUE
    strio_s_open(int argc, VALUE *argv, VALUE klass)
    {
        VALUE obj = rb_class_new_instance(argc, argv, klass);
        if (!rb_block_given_p()) return obj;
        return rb_ensure(rb_yield, obj, strio_finalize, obj);
    }

### Public Instance Methods

binmode() click to toggle source

                   static VALUE
    strio_binmode(VALUE self)
    {
        struct StringIO *ptr = StringIO(self);
        rb_encoding *enc = rb_ascii8bit_encoding();

        ptr->enc = enc;
        if (WRITABLE(self)) {
            rb_enc_associate(ptr->string, enc);
        }
        return self;
    }

bytes() click to toggle source

This is a deprecated alias for `each_byte`.

                   static VALUE
    strio_bytes(VALUE self)
    {
        rb_warn("StringIO#bytes is deprecated; use #each_byte instead");
        if (!rb_block_given_p())
            return rb_enumeratorize(self, ID2SYM(rb_intern("each_byte")), 0, 0);
        return strio_each_byte(self);
    }

chars() click to toggle source

This is a deprecated alias for `each_char`.

                   static VALUE
    strio_chars(VALUE self)
    {
        rb_warn("StringIO#chars is deprecated; use #each_char instead");
        if (!rb_block_given_p())
            return rb_enumeratorize(self, ID2SYM(rb_intern("each_char")), 0, 0);
        return strio_each_char(self);
    }

close → nil click to toggle source

Closes strio. The strio is unavailable for any further data operations; an `IOError` is raised if such an attempt is made.

                   static VALUE
    strio_close(VALUE self)
    {
        StringIO(self);
        RBASIC(self)->flags &= ~STRIO_READWRITE;
        return Qnil;
    }

close_read → nil click to toggle source

Closes the read end of a `StringIO`. Will raise an `IOError` if the strio is not readable.

                   static VALUE
    strio_close_read(VALUE self)
    {
        struct StringIO *ptr = StringIO(self);
        if (!(ptr->flags & FMODE_READABLE)) {
            rb_raise(rb_eIOError, "closing non-duplex IO for reading");
        }
        RBASIC(self)->flags &= ~STRIO_READABLE;
        return Qnil;
    }

close_write → nil click to toggle source

Closes the write end of a `StringIO`. Will raise an `IOError` if the strio is not writeable.

                   static VALUE
    strio_close_write(VALUE self)
    {
        struct StringIO *ptr = StringIO(self);
        if (!(ptr->flags & FMODE_WRITABLE)) {
            rb_raise(rb_eIOError, "closing non-duplex IO for writing");
        }
        RBASIC(self)->flags &= ~STRIO_WRITABLE;
        return Qnil;
    }

closed? → true or false click to toggle source

Returns `true` if strio is completely closed, `false` otherwise.

                   static VALUE
    strio_closed(VALUE self)
    {
        StringIO(self);
        if (!CLOSED(self)) return Qfalse;
        return Qtrue;
    }

closed_read? → true or false click to toggle source

Returns `true` if strio is not readable, `false` otherwise.

                   static VALUE
    strio_closed_read(VALUE self)
    {
        StringIO(self);
        if (READABLE(self)) return Qfalse;
        return Qtrue;
    }

closed_write? → true or false click to toggle source

Returns `true` if strio is not writable, `false` otherwise.

                   static VALUE
    strio_closed_write(VALUE self)
    {
        StringIO(self);
        if (WRITABLE(self)) return Qfalse;
        return Qtrue;
    }

codepoints() click to toggle source

This is a deprecated alias for `each_codepoint`.

                   static VALUE
    strio_codepoints(VALUE self)
    {
        rb_warn("StringIO#codepoints is deprecated; use #each_codepoint instead");
        if (!rb_block_given_p())
            return rb_enumeratorize(self, ID2SYM(rb_intern("each_codepoint")), 0, 0);
        return strio_each_codepoint(self);
    }

each(sep=$/) {|line| block } → strio click to toggle source
each(limit) {|line| block } → strio
each(sep, limit) {|line| block } → strio
each(...) → anEnumerator
each_line(sep=$/) {|line| block } → strio
each_line(limit) {|line| block } → strio
each_line(sep,limit) {|line| block } → strio
each_line(...) → anEnumerator

See IO#each.

                   static VALUE
    strio_each(int argc, VALUE *argv, VALUE self)
    {
        VALUE line;
        struct getline_arg arg;

        StringIO(self);
        RETURN_ENUMERATOR(self, argc, argv);

        if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
            rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
        }

        while (!NIL_P(line = strio_getline(&arg, readable(self)))) {
            rb_yield(line);
        }
        return self;
    }

each_byte {|byte| block } → strio click to toggle source
each_byte → anEnumerator

See IO#each_byte.

                   static VALUE
    strio_each_byte(VALUE self)
    {
        struct StringIO *ptr = readable(self);

        RETURN_ENUMERATOR(self, 0, 0);

        while (ptr->pos < RSTRING_LEN(ptr->string)) {
            char c = RSTRING_PTR(ptr->string)[ptr->pos++];
            rb_yield(CHR2FIX(c));
        }
        return self;
    }

each_char {|char| block } → strio click to toggle source
each_char → anEnumerator

See IO#each_char.

                   static VALUE
    strio_each_char(VALUE self)
    {
        VALUE c;

        RETURN_ENUMERATOR(self, 0, 0);

        while (!NIL_P(c = strio_getc(self))) {
            rb_yield(c);
        }
        return self;
    }

each_codepoint {|c| block } → strio click to toggle source
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(self);
        enc = get_enc(ptr);
        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;
    }

each_line(sep=$/) {|line| block } → strio click to toggle source
each_line(limit) {|line| block } → strio
each_line(sep,limit) {|line| block } → strio
each_line(...) → anEnumerator

See IO#each.

                   static VALUE
    strio_each(int argc, VALUE *argv, VALUE self)
    {
        VALUE line;
        struct getline_arg arg;

        StringIO(self);
        RETURN_ENUMERATOR(self, argc, argv);

        if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
            rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
        }

        while (!NIL_P(line = strio_getline(&arg, readable(self)))) {
            rb_yield(line);
        }
        return self;
    }

eof → true or false click to toggle source
eof? → true or false

Returns true if strio is at end of file. The stringio must be opened for reading or an `IOError` will be raised.

                   static VALUE
    strio_eof(VALUE self)
    {
        struct StringIO *ptr = readable(self);
        if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
        return Qtrue;
    }

eof? → true or false click to toggle source

Returns true if strio is at end of file. The stringio must be opened for reading or an `IOError` will be raised.

                   static VALUE
    strio_eof(VALUE self)
    {
        struct StringIO *ptr = readable(self);
        if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
        return Qtrue;
    }

external_encoding => encoding click to toggle source

Returns the Encoding object that represents the encoding of the file. If strio is write mode and no encoding is specified, returns `nil`.

                   static VALUE
    strio_external_encoding(VALUE self)
    {
        struct StringIO *ptr = StringIO(self);
        return rb_enc_from_encoding(get_enc(ptr));
    }

fcntl(*args) click to toggle source

Raises NotImplementedError.

                   static VALUE
    strio_unimpl(int argc, VALUE *argv, VALUE self)
    {
        StringIO(self);
        rb_notimplement();

        UNREACHABLE;
    }

fileno() click to toggle source

Returns `nil`. Just for compatibility to `IO`.

                   static VALUE
    strio_nil(VALUE self)
    {
        StringIO(self);
        return Qnil;
    }

flush() click to toggle source

Returns strio itself. Just for compatibility to `IO`.

                   static VALUE
    strio_self(VALUE self)
    {
        StringIO(self);
        return self;
    }

fsync() click to toggle source

Returns 0. Just for compatibility to `IO`.

                   static VALUE
    strio_0(VALUE self)
    {
        StringIO(self);
        return INT2FIX(0);
    }

getbyte → fixnum or nil click to toggle source

See IO#getbyte.

                   static VALUE
    strio_getbyte(VALUE self)
    {
        struct StringIO *ptr = readable(self);
        int c;
        if (ptr->pos >= RSTRING_LEN(ptr->string)) {
            return Qnil;
        }
        c = RSTRING_PTR(ptr->string)[ptr->pos++];
        return CHR2FIX(c);
    }

getc → string or nil click to toggle source

See IO#getc.

                   static VALUE
    strio_getc(VALUE self)
    {
        struct StringIO *ptr = readable(self);
        rb_encoding *enc = get_enc(ptr);
        VALUE str = ptr->string;
        long pos = ptr->pos;
        int len;
        char *p;

        if (pos >= RSTRING_LEN(str)) {
            return Qnil;
        }
        p = RSTRING_PTR(str)+pos;
        len = rb_enc_mbclen(p, RSTRING_END(str), enc);
        ptr->pos += len;
        return enc_subseq(str, pos, len, enc);
    }

gets(sep=$/) → string or nil click to toggle source
gets(limit) → string or nil
gets(sep, limit) → string or nil

See IO#gets.

                   static VALUE
    strio_gets(int argc, VALUE *argv, VALUE self)
    {
        struct getline_arg arg;
        VALUE str;

        if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
            struct StringIO *ptr = readable(self);
            return rb_enc_str_new(0, 0, get_enc(ptr));
        }

        str = strio_getline(&arg, readable(self));
        rb_lastline_set(str);
        return str;
    }

internal_encoding => encoding click to toggle source

Returns the Encoding of the internal string if conversion is specified. Otherwise returns nil.

                   static VALUE
    strio_internal_encoding(VALUE self)
    {
        return Qnil;
    }

isatty() click to toggle source

Returns `false`. Just for compatibility to `IO`.

                   static VALUE
    strio_false(VALUE self)
    {
        StringIO(self);
        return Qfalse;
    }

length → integer click to toggle source

Returns the size of the buffer string.

                   static VALUE
    strio_size(VALUE self)
    {
        VALUE string = StringIO(self)->string;
        if (NIL_P(string)) {
            rb_raise(rb_eIOError, "not opened");
        }
        return ULONG2NUM(RSTRING_LEN(string));
    }

lineno → integer click to toggle source

Returns the current line number in strio. The stringio must be opened for reading. `lineno` counts the number of times `gets` is called, rather than the number of newlines encountered. The two values will differ if `gets` is called with a separator other than newline. See also the `$.` variable.

                   static VALUE
    strio_get_lineno(VALUE self)
    {
        return LONG2NUM(StringIO(self)->lineno);
    }

lineno = integer → integer click to toggle source

Manually sets the current line number to the given value. `$.` is updated only on the next read.

                   static VALUE
    strio_set_lineno(VALUE self, VALUE lineno)
    {
        StringIO(self)->lineno = NUM2LONG(lineno);
        return lineno;
    }

lines(*args) click to toggle source

This is a deprecated alias for `each_line`.

                   static VALUE
    strio_lines(int argc, VALUE *argv, VALUE self)
    {
        rb_warn("StringIO#lines is deprecated; use #each_line instead");
        if (!rb_block_given_p())
            return rb_enumeratorize(self, ID2SYM(rb_intern("each_line")), argc, argv);
        return strio_each(argc, argv, self);
    }

pid() click to toggle source

Returns `nil`. Just for compatibility to `IO`.

                   static VALUE
    strio_nil(VALUE self)
    {
        StringIO(self);
        return Qnil;
    }

pos → integer click to toggle source
tell → integer

Returns the current offset (in bytes) of strio.

                   static VALUE
    strio_get_pos(VALUE self)
    {
        return LONG2NUM(StringIO(self)->pos);
    }

pos = integer → integer click to toggle source

Seeks to the given position (in bytes) in strio.

                   static VALUE
    strio_set_pos(VALUE self, VALUE pos)
    {
        struct StringIO *ptr = StringIO(self);
        long p = NUM2LONG(pos);
        if (p < 0) {
            error_inval(0);
        }
        ptr->pos = p;
        return pos;
    }

putc(obj) → obj click to toggle source

See IO#putc.

                   static VALUE
    strio_putc(VALUE self, VALUE ch)
    {
        struct StringIO *ptr = writable(self);
        VALUE str;

        check_modifiable(ptr);
        if (RB_TYPE_P(ch, T_STRING)) {
            str = rb_str_substr(ch, 0, 1);
        }
        else {
            char c = NUM2CHR(ch);
            str = rb_str_new(&c, 1);
        }
        strio_write(self, str);
        return ch;
    }

read([length [, outbuf]]) → string, outbuf, or nil click to toggle source

See IO#read.

                   static VALUE
    strio_read(int argc, VALUE *argv, VALUE self)
    {
        struct StringIO *ptr = readable(self);
        VALUE str = Qnil;
        long len;
        int binary = 0;

        rb_check_arity(argc, 0, 2);
        switch (argc) {
          case 2:
            str = argv[1];
            if (!NIL_P(str)) {
                StringValue(str);
                rb_str_modify(str);
            }
            /* fall through */
          case 1:
            if (!NIL_P(argv[0])) {
                len = NUM2LONG(argv[0]);
                if (len < 0) {
                    rb_raise(rb_eArgError, "negative length %ld given", len);
                }
                if (len > 0 && ptr->pos >= RSTRING_LEN(ptr->string)) {
                    if (!NIL_P(str)) rb_str_resize(str, 0);
                    return Qnil;
                }
                binary = 1;
                break;
            }
            /* fall through */
          case 0:
            len = RSTRING_LEN(ptr->string);
            if (len <= ptr->pos) {
                rb_encoding *enc = binary ? rb_ascii8bit_encoding() : get_enc(ptr);
                if (NIL_P(str)) {
                    str = rb_str_new(0, 0);
                }
                else {
                    rb_str_resize(str, 0);
                }
                rb_enc_associate(str, enc);
                return str;
            }
            else {
                len -= ptr->pos;
            }
            break;
        }
        if (NIL_P(str)) {
            rb_encoding *enc = binary ? rb_ascii8bit_encoding() : get_enc(ptr);
            str = strio_substr(ptr, ptr->pos, len, enc);
        }
        else {
            long rest = RSTRING_LEN(ptr->string) - ptr->pos;
            if (len > rest) len = rest;
            rb_str_resize(str, len);
            MEMCPY(RSTRING_PTR(str), RSTRING_PTR(ptr->string) + ptr->pos, char, len);
            if (binary)
                rb_enc_associate(str, rb_ascii8bit_encoding());
            else
                rb_enc_copy(str, ptr->string);
        }
        ptr->pos += RSTRING_LEN(str);
        return str;
    }

readlines(sep=$/) → array click to toggle source
readlines(limit) → array
readlines(sep,limit) → array

See IO#readlines.

                   static VALUE
    strio_readlines(int argc, VALUE *argv, VALUE self)
    {
        VALUE ary, line;
        struct getline_arg arg;

        StringIO(self);
        ary = rb_ary_new();
        if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
            rb_raise(rb_eArgError, "invalid limit: 0 for readlines");
        }

        while (!NIL_P(line = strio_getline(&arg, readable(self)))) {
            rb_ary_push(ary, line);
        }
        return ary;
    }

reopen(other_StrIO) → strio click to toggle source
reopen(string, mode) → strio

Reinitializes strio with the given other_StrIO or string and mode (see StringIO#new).

                   static VALUE
    strio_reopen(int argc, VALUE *argv, VALUE self)
    {
        rb_io_taint_check(self);
        if (argc == 1 && !RB_TYPE_P(*argv, T_STRING)) {
            return strio_copy(self, *argv);
        }
        return strio_init(argc, argv, StringIO(self), self);
    }

rewind → 0 click to toggle source

Positions strio to the beginning of input, resetting `lineno` to zero.

                   static VALUE
    strio_rewind(VALUE self)
    {
        struct StringIO *ptr = StringIO(self);
        ptr->pos = 0;
        ptr->lineno = 0;
        return INT2FIX(0);
    }

seek(amount, whence=SEEK_SET) → 0 click to toggle source

Seeks to a given offset amount in the stream according to the value of whence (see IO#seek).

                   static VALUE
    strio_seek(int argc, VALUE *argv, VALUE self)
    {
        VALUE whence;
        struct StringIO *ptr = StringIO(self);
        long amount, offset;

        rb_scan_args(argc, argv, "11", NULL, &whence);
        amount = NUM2LONG(argv[0]);
        if (CLOSED(self)) {
            rb_raise(rb_eIOError, "closed stream");
        }
        switch (NIL_P(whence) ? 0 : NUM2LONG(whence)) {
          case 0:
            offset = 0;
            break;
          case 1:
            offset = ptr->pos;
            break;
          case 2:
            offset = RSTRING_LEN(ptr->string);
            break;
          default:
            error_inval("invalid whence");
        }
        if (amount > LONG_MAX - offset || amount + offset < 0) {
            error_inval(0);
        }
        ptr->pos = amount + offset;
        return INT2FIX(0);
    }

set_encoding(ext_enc, [int_enc[, opt]]) => strio click to toggle source

Specify the encoding of the `StringIO` as ext_enc. Use the default external encoding if ext_enc is nil. 2nd argument int_enc and optional hash opt argument are ignored; they are for API compatibility to `IO`.

                   static VALUE
    strio_set_encoding(int argc, VALUE *argv, VALUE self)
    {
        rb_encoding* enc;
        struct StringIO *ptr = StringIO(self);
        VALUE ext_enc, int_enc, opt;

        argc = rb_scan_args(argc, argv, "11:", &ext_enc, &int_enc, &opt);

        if (NIL_P(ext_enc)) {
            enc = rb_default_external_encoding();
        }
        else {
            enc = rb_to_encoding(ext_enc);
        }
        ptr->enc = enc;
        if (WRITABLE(self)) {
            rb_enc_associate(ptr->string, enc);
        }

        return self;
    }

size → integer click to toggle source

Returns the size of the buffer string.

                   static VALUE
    strio_size(VALUE self)
    {
        VALUE string = StringIO(self)->string;
        if (NIL_P(string)) {
            rb_raise(rb_eIOError, "not opened");
        }
        return ULONG2NUM(RSTRING_LEN(string));
    }

string → string click to toggle source

Returns underlying String object, the subject of `IO`.

                   static VALUE
    strio_get_string(VALUE self)
    {
        return StringIO(self)->string;
    }

string = string → string click to toggle source

Changes underlying String object, the subject of `IO`.

                   static VALUE
    strio_set_string(VALUE self, VALUE string)
    {
        struct StringIO *ptr = StringIO(self);

        rb_io_taint_check(self);
        ptr->flags &= ~FMODE_READWRITE;
        StringValue(string);
        ptr->flags = OBJ_FROZEN(string) ? FMODE_READABLE : FMODE_READWRITE;
        ptr->pos = 0;
        ptr->lineno = 0;
        return ptr->string = string;
    }

sync → true click to toggle source

Returns `true` always.

                   static VALUE
    strio_get_sync(VALUE self)
    {
        StringIO(self);
        return Qtrue;
    }

sync=(p1) click to toggle source

Returns the argument unchanged. Just for compatibility to `IO`.

                   static VALUE
    strio_first(VALUE self, VALUE arg)
    {
        StringIO(self);
        return arg;
    }

pos → integer click to toggle source
tell → integer

Returns the current offset (in bytes) of strio.

                   static VALUE
    strio_get_pos(VALUE self)
    {
        return LONG2NUM(StringIO(self)->pos);
    }

truncate(integer) → 0 click to toggle source

Truncates the buffer string to at most integer bytes. The strio must be opened for writing.

                   static VALUE
    strio_truncate(VALUE self, VALUE len)
    {
        VALUE string = writable(self)->string;
        long l = NUM2LONG(len);
        long plen = RSTRING_LEN(string);
        if (l < 0) {
            error_inval("negative length");
        }
        rb_str_resize(string, l);
        if (plen < l) {
            MEMZERO(RSTRING_PTR(string) + plen, char, l - plen);
        }
        return len;
    }

tty?() click to toggle source

Returns `false`. Just for compatibility to `IO`.

                   static VALUE
    strio_false(VALUE self)
    {
        StringIO(self);
        return Qfalse;
    }

ungetbyte(fixnum) → nil click to toggle source

See IO#ungetbyte

                   static VALUE
    strio_ungetbyte(VALUE self, VALUE c)
    {
        struct StringIO *ptr = readable(self);
        char buf[1], *cp = buf;
        long cl = 1;

        check_modifiable(ptr);
        if (NIL_P(c)) return Qnil;
        if (FIXNUM_P(c)) {
            buf[0] = (char)FIX2INT(c);
            return strio_unget_bytes(ptr, buf, 1);
        }
        else {
            SafeStringValue(c);
            cp = RSTRING_PTR(c);
            cl = RSTRING_LEN(c);
            if (cl == 0) return Qnil;
            strio_unget_bytes(ptr, cp, cl);
            RB_GC_GUARD(c);
            return Qnil;
        }
    }

ungetc(string) → nil click to toggle source

Pushes back one character (passed as a parameter) onto strio 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)
    {
        struct StringIO *ptr = readable(self);
        rb_encoding *enc, *enc2;

        check_modifiable(ptr);
        if (NIL_P(c)) return Qnil;
        if (RB_INTEGER_TYPE_P(c)) {
            int len, cc = NUM2INT(c);
            char buf[16];

            enc = rb_enc_get(ptr->string);
            len = rb_enc_codelen(cc, enc);
            if (len <= 0) rb_enc_uint_chr(cc, enc);
            rb_enc_mbcput(cc, buf, enc);
            return strio_unget_bytes(ptr, buf, len);
        }
        else {
            SafeStringValue(c);
            enc = rb_enc_get(ptr->string);
            enc2 = rb_enc_get(c);
            if (enc != enc2 && enc != rb_ascii8bit_encoding()) {
                c = rb_str_conv_enc(c, enc2, enc);
            }
            strio_unget_bytes(ptr, RSTRING_PTR(c), RSTRING_LEN(c));
            RB_GC_GUARD(c);
            return Qnil;
        }
    }

write(string, ...) → integer click to toggle source
syswrite(string) → integer

Appends the given string to the underlying buffer string of strio. The stream must be opened for writing. If the argument is not a string, it will be converted to a string using `to_s`. Returns the number of bytes written. See IO#write.

                   static VALUE
    strio_write_m(int argc, VALUE *argv, VALUE self)
    {
        long len = 0;
        while (argc-- > 0) {
            /* StringIO can't exceed long limit */
            len += strio_write(self, *argv++);
        }
        return LONG2NUM(len);
    }