class StringIO
Pseudo I/O on String object.
Public Class Methods
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); strio_init(argc, argv, ptr, self); return self; }
Equivalent to ::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
static VALUE strio_binmode(VALUE self) { struct StringIO *ptr = StringIO(self); rb_encoding *enc = rb_ascii8bit_encoding(); if (WRITABLE(self)) { rb_enc_associate(ptr->string, enc); } return self; }
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); }
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); }
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); if (CLOSED(self)) { rb_raise(rb_eIOError, "closed stream"); } RBASIC(self)->flags &= ~STRIO_READWRITE; return Qnil; }
Closes the read end of a StringIO. Will raise
an IOError
if the strio is not readable.
static VALUE strio_close_read(VALUE self) { StringIO(self); if (!READABLE(self)) { rb_raise(rb_eIOError, "closing non-duplex IO for reading"); } RBASIC(self)->flags &= ~STRIO_READABLE; return Qnil; }
Closes the write end of a StringIO. Will raise
an IOError
if the strio is not writeable.
static VALUE strio_close_write(VALUE self) { StringIO(self); if (!WRITABLE(self)) { rb_raise(rb_eIOError, "closing non-duplex IO for writing"); } RBASIC(self)->flags &= ~STRIO_WRITABLE; return Qnil; }
Returns true
if strio is completely closed,
false
otherwise.
static VALUE strio_closed(VALUE self) { StringIO(self); if (!CLOSED(self)) return Qfalse; return Qtrue; }
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; }
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; }
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); }
See IO#each.
static VALUE strio_each(int argc, VALUE *argv, VALUE self) { VALUE line; StringIO(self); RETURN_ENUMERATOR(self, argc, argv); if (argc > 0 && !NIL_P(argv[argc-1]) && NIL_P(rb_check_string_type(argv[argc-1])) && NUM2LONG(argv[argc-1]) == 0) { rb_raise(rb_eArgError, "invalid limit: 0 for each_line"); } while (!NIL_P(line = strio_getline(argc, argv, readable(self)))) { rb_yield(line); } return self; }
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; }
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; }
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 = 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; }
See IO#each.
static VALUE strio_each(int argc, VALUE *argv, VALUE self) { VALUE line; StringIO(self); RETURN_ENUMERATOR(self, argc, argv); if (argc > 0 && !NIL_P(argv[argc-1]) && NIL_P(rb_check_string_type(argv[argc-1])) && NUM2LONG(argv[argc-1]) == 0) { rb_raise(rb_eArgError, "invalid limit: 0 for each_line"); } while (!NIL_P(line = strio_getline(argc, argv, readable(self)))) { rb_yield(line); } return self; }
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; }
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; }
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) { return rb_enc_from_encoding(rb_enc_get(StringIO(self)->string)); }
Raises NotImplementedError.
static VALUE strio_unimpl(int argc, VALUE *argv, VALUE self) { StringIO(self); rb_notimplement(); UNREACHABLE; }
Returns nil
. Just for compatibility to IO.
static VALUE strio_nil(VALUE self) { StringIO(self); return Qnil; }
Returns strio itself. Just for compatibility to IO.
static VALUE strio_self(VALUE self) { StringIO(self); return self; }
Returns 0. Just for compatibility to IO.
static VALUE strio_0(VALUE self) { StringIO(self); return INT2FIX(0); }
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); }
See IO#getc.
static VALUE strio_getc(VALUE self) { struct StringIO *ptr = readable(self); rb_encoding *enc = rb_enc_get(ptr->string); int len; char *p; if (ptr->pos >= RSTRING_LEN(ptr->string)) { return Qnil; } p = RSTRING_PTR(ptr->string)+ptr->pos; len = rb_enc_mbclen(p, RSTRING_END(ptr->string), enc); ptr->pos += len; return rb_enc_str_new(p, len, rb_enc_get(ptr->string)); }
See IO#gets.
static VALUE strio_gets(int argc, VALUE *argv, VALUE self) { VALUE str = strio_getline(argc, argv, readable(self)); rb_lastline_set(str); return str; }
Returns the Encoding of the internal string if conversion is specified. Otherwise returns nil.
static VALUE strio_internal_encoding(VALUE self) { return Qnil; }
Returns false
. Just for compatibility to IO.
static VALUE strio_false(VALUE self) { StringIO(self); return Qfalse; }
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)); }
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); }
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; }
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); }
Returns nil
. Just for compatibility to IO.
static VALUE strio_nil(VALUE self) { StringIO(self); return Qnil; }
Returns the current offset (in bytes) of strio.
static VALUE strio_get_pos(VALUE self) { return LONG2NUM(StringIO(self)->pos); }
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; }
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; }
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; switch (argc) { case 2: str = argv[1]; if (!NIL_P(str)) { StringValue(str); rb_str_modify(str); } 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) { if (NIL_P(str)) { str = rb_str_new(0, 0); } else { rb_str_resize(str, 0); } return str; } else { len -= ptr->pos; } break; default: rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc); } if (NIL_P(str)) { str = strio_substr(ptr, ptr->pos, len); if (binary) rb_enc_associate(str, rb_ascii8bit_encoding()); } 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; }
See IO#readlines.
static VALUE strio_readlines(int argc, VALUE *argv, VALUE self) { VALUE ary, line; StringIO(self); ary = rb_ary_new(); if (argc > 0 && !NIL_P(argv[argc-1]) && NIL_P(rb_check_string_type(argv[argc-1])) && NUM2LONG(argv[argc-1]) == 0) { rb_raise(rb_eArgError, "invalid limit: 0 for readlines"); } while (!NIL_P(line = strio_getline(argc, argv, readable(self)))) { rb_ary_push(ary, line); } return ary; }
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); } strio_init(argc, argv, StringIO(self), self); return self; }
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); }
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 offset; rb_scan_args(argc, argv, "11", NULL, &whence); offset = NUM2LONG(argv[0]); if (CLOSED(self)) { rb_raise(rb_eIOError, "closed stream"); } switch (NIL_P(whence) ? 0 : NUM2LONG(whence)) { case 0: break; case 1: offset += ptr->pos; break; case 2: offset += RSTRING_LEN(ptr->string); break; default: error_inval("invalid whence"); } if (offset < 0) { error_inval(0); } ptr->pos = offset; return INT2FIX(0); }
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; VALUE str = StringIO(self)->string; 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); } rb_enc_associate(str, enc); return self; }
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)); }
Returns underlying String object, the subject of IO.
static VALUE strio_get_string(VALUE self) { return StringIO(self)->string; }
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; }
Returns true
always.
static VALUE strio_get_sync(VALUE self) { StringIO(self); return Qtrue; }
Returns the argument unchanged. Just for compatibility to IO.
static VALUE strio_first(VALUE self, VALUE arg) { StringIO(self); return arg; }
Returns the current offset (in bytes) of strio.
static VALUE strio_get_pos(VALUE self) { return LONG2NUM(StringIO(self)->pos); }
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; }
Returns false
. Just for compatibility to IO.
static VALUE strio_false(VALUE self) { StringIO(self); return Qfalse; }
See IO#ungetbyte
static VALUE strio_ungetbyte(VALUE self, VALUE c) { struct StringIO *ptr = readable(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; } check_modifiable(ptr); 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; }
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); long lpos, clen; char *p, *pend; rb_encoding *enc, *enc2; if (NIL_P(c)) return Qnil; check_modifiable(ptr); if (FIXNUM_P(c)) { int cc = FIX2INT(c); char buf[16]; enc = rb_enc_get(ptr->string); rb_enc_mbcput(cc, buf, enc); c = rb_enc_str_new(buf, rb_enc_codelen(cc, enc), enc); } 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); } } 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; } return Qnil; }
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(VALUE self, VALUE str) { struct StringIO *ptr = writable(self); long len, olen; rb_encoding *enc, *enc2; rb_encoding *const ascii8bit = rb_ascii8bit_encoding(); if (!RB_TYPE_P(str, T_STRING)) str = rb_obj_as_string(str); enc = rb_enc_get(ptr->string); enc2 = rb_enc_get(str); if (enc != enc2 && enc != ascii8bit) { str = rb_str_conv_enc(str, enc2, enc); } len = RSTRING_LEN(str); if (len == 0) return INT2FIX(0); check_modifiable(ptr); olen = RSTRING_LEN(ptr->string); if (ptr->flags & FMODE_APPEND) { ptr->pos = olen; } if (ptr->pos == olen) { if (enc == ascii8bit || enc2 == ascii8bit) { rb_enc_str_buf_cat(ptr->string, RSTRING_PTR(str), len, enc); OBJ_INFECT(ptr->string, str); } else { rb_str_buf_append(ptr->string, str); } } else { strio_extend(ptr, ptr->pos, len); memmove(RSTRING_PTR(ptr->string)+ptr->pos, RSTRING_PTR(str), len); OBJ_INFECT(ptr->string, str); } OBJ_INFECT(ptr->string, self); RB_GC_GUARD(str); ptr->pos += len; return LONG2NUM(len); }