Class: StringIO
- Inherits:
-
Object
- Object
- StringIO
- Includes:
- Enumerable, Readable, Writable
- Defined in:
- ext/stringio/stringio.c
Constant Summary collapse
- VERSION =
rb_str_new_cstr(STRINGIO_VERSION)
Class Method Summary collapse
-
.new(*args) ⇒ Object
:nodoc:.
-
.open(string = '', mode = 'r+') {|strio| ... } ⇒ Object
Note that
mode
defaults to'r'
ifstring
is frozen.
Instance Method Summary collapse
-
#binmode ⇒ self
Sets the data mode in
self
to binary mode; see Data Mode. -
#close ⇒ nil
Closes
self
for both reading and writing. -
#close_read ⇒ nil
Closes
self
for reading; closed-write setting remains unchanged. -
#close_write ⇒ nil
Closes
self
for writing; closed-read setting remains unchanged. -
#closed? ⇒ Boolean
Returns
true
ifself
is closed for both reading and writing,false
otherwise. -
#closed_read? ⇒ Boolean
Returns
true
ifself
is closed for reading,false
otherwise. -
#closed_write? ⇒ Boolean
Returns
true
ifself
is closed for writing,false
otherwise. -
#each(*args) ⇒ Object
Calls the block with each remaining line read from the stream; does nothing if already at end-of-file; returns
self
. -
#each_byte {|byte| ... } ⇒ self
With a block given, calls the block with each remaining byte in the stream; see Byte IO.
-
#each_char {|c| ... } ⇒ self
With a block given, calls the block with each remaining character in the stream; see Character IO.
-
#each_codepoint {|codepoint| ... } ⇒ self
With a block given, calls the block with each remaining codepoint in the stream; see Codepoint IO.
-
#each_line(*args) ⇒ Object
Calls the block with each remaining line read from the stream; does nothing if already at end-of-file; returns
self
. -
#eof? ⇒ Boolean
Returns
true
if positioned at end-of-stream,false
otherwise; see Position. -
#eof? ⇒ Boolean
Returns
true
if positioned at end-of-stream,false
otherwise; see Position. -
#external_encoding ⇒ Encoding
Returns the Encoding object that represents the encoding of the file.
- #fcntl ⇒ Object
- #fileno ⇒ nil
- #flush ⇒ Object
- #fsync ⇒ 0
-
#getbyte ⇒ nil
Reads and returns the next 8-bit byte from the stream; see Byte IO.
-
#getc ⇒ nil
Reads and returns the next character from the stream; see Character IO.
-
#gets(*args) ⇒ Object
Reads and returns a line from the stream; assigns the return value to
$_
; see Line IO. -
#new(string = '', mode = 'r+') ⇒ Object
constructor
Note that
mode
defaults to'r'
ifstring
is frozen. -
#initialize_copy(orig) ⇒ Object
:nodoc:.
-
#internal_encoding ⇒ Encoding
Returns the Encoding of the internal string if conversion is specified.
- #isatty ⇒ Object
-
#length ⇒ Object
Returns the size of the buffer string.
-
#lineno ⇒ Object
Returns the current line number in
self
; see Line Number. -
#lineno=(new_line_number) ⇒ Object
Sets the current line number in
self
to the givennew_line_number
; see Line Number. - #pid ⇒ nil
-
#pos ⇒ Object
Returns the current position (in bytes); see Position.
-
#pos=(new_position) ⇒ Object
Sets the current position (in bytes); see Position.
-
#pread(*args) ⇒ Object
See IO#pread.
-
#putc(obj) ⇒ Object
See IO#putc.
-
#read([length [, outbuf]]) ⇒ String?
See IO#read.
-
#readlines(*args) ⇒ Object
See IO#readlines.
-
#reopen(other, mode = 'r+') ⇒ self
Reinitializes the stream with the given
other
(string or StringIO) andmode
; see IO.new:. -
#rewind ⇒ 0
Sets the current position and line number to zero; see Position and Line Number.
-
#seek(offset, whence = SEEK_SET) ⇒ 0
Sets the current position to the given integer
offset
(in bytes), with respect to a given constantwhence
; see Position. -
#set_encoding(ext_enc, [int_enc[, opt]]) ⇒ Object
Specify the encoding of the StringIO as ext_enc.
- #set_encoding_by_bom ⇒ Object
-
#size ⇒ Object
Returns the size of the buffer string.
-
#string ⇒ String
Returns underlying string:.
-
#string=(other_string) ⇒ Object
Assigns the underlying string as
other_string
, and sets position to zero; returnsother_string
:. -
#sync ⇒ true
Returns
true
; implemented only for compatibility with other stream classes. - #sync=(boolean) ⇒ Boolean
- #tell ⇒ Object
-
#truncate(integer) ⇒ 0
Truncates the buffer string to at most integer bytes.
- #tty? ⇒ Boolean
-
#ungetbyte(byte) ⇒ nil
Pushes back (“unshifts”) an 8-bit byte onto the stream; see Byte IO.
-
#ungetc(character) ⇒ nil
Pushes back (“unshifts”) a character or integer onto the stream; see Character IO.
-
#write(*args) ⇒ Object
Appends the given string to the underlying buffer string.
Constructor Details
#new(string = '', mode = 'r+') ⇒ Object
Note that mode
defaults to 'r'
if string
is frozen.
Returns a new StringIO instance formed from string
and mode
; see Access Modes:
strio = StringIO.new # => #<StringIO>
strio.close
The instance should be closed when no longer needed.
Related: StringIO.open (accepts block; closes automatically).
195 196 197 198 199 200 201 202 203 204 205 |
# File 'ext/stringio/stringio.c', line 195
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);
}
|
Class Method Details
.new(*args) ⇒ Object
:nodoc:
356 357 358 359 360 361 362 363 364 365 366 |
# File 'ext/stringio/stringio.c', line 356
static VALUE
strio_s_new(int argc, VALUE *argv, VALUE klass)
{
if (rb_block_given_p()) {
VALUE cname = rb_obj_as_string(klass);
rb_warn("%"PRIsVALUE"::new() does not take block; use %"PRIsVALUE"::open() instead",
cname, cname);
}
return rb_class_new_instance_kw(argc, argv, klass, RB_PASS_CALLED_KEYWORDS);
}
|
.open(string = '', mode = 'r+') {|strio| ... } ⇒ Object
Note that mode
defaults to 'r'
if string
is frozen.
Creates a new StringIO instance formed from string
and mode
; see Access Modes.
With no block, returns the new instance:
strio = StringIO.open # => #<StringIO>
With a block, calls the block with the new instance and returns the block’s value; closes the instance on block exit.
StringIO.open {|strio| p strio }
# => #<StringIO>
Related: StringIO.new.
347 348 349 350 351 352 353 |
# File 'ext/stringio/stringio.c', line 347
static VALUE
strio_s_open(int argc, VALUE *argv, VALUE klass)
{
VALUE obj = rb_class_new_instance_kw(argc, argv, klass, RB_PASS_CALLED_KEYWORDS);
if (!rb_block_given_p()) return obj;
return rb_ensure(rb_yield, obj, strio_finalize, obj);
}
|
Instance Method Details
#binmode ⇒ self
Sets the data mode in self
to binary mode; see Data Mode.
675 676 677 678 679 680 681 682 683 684 685 686 |
# File 'ext/stringio/stringio.c', line 675
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;
}
|
#close ⇒ nil
Closes self
for both reading and writing.
Raises IOError if reading or writing is attempted.
Related: StringIO#close_read, StringIO#close_write.
500 501 502 503 504 505 506 |
# File 'ext/stringio/stringio.c', line 500
static VALUE
strio_close(VALUE self)
{
StringIO(self);
RBASIC(self)->flags &= ~STRIO_READWRITE;
return Qnil;
}
|
#close_read ⇒ nil
Closes self
for reading; closed-write setting remains unchanged.
Raises IOError if reading is attempted.
Related: StringIO#close, StringIO#close_write.
518 519 520 521 522 523 524 525 526 527 |
# File 'ext/stringio/stringio.c', line 518
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
Closes self
for writing; closed-read setting remains unchanged.
Raises IOError if writing is attempted.
Related: StringIO#close, StringIO#close_read.
539 540 541 542 543 544 545 546 547 548 |
# File 'ext/stringio/stringio.c', line 539
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? ⇒ Boolean
Returns true
if self
is closed for both reading and writing, false
otherwise.
557 558 559 560 561 562 563 |
# File 'ext/stringio/stringio.c', line 557
static VALUE
strio_closed(VALUE self)
{
StringIO(self);
if (!CLOSED(self)) return Qfalse;
return Qtrue;
}
|
#closed_read? ⇒ Boolean
Returns true
if self
is closed for reading, false
otherwise.
571 572 573 574 575 576 577 |
# File 'ext/stringio/stringio.c', line 571
static VALUE
strio_closed_read(VALUE self)
{
StringIO(self);
if (READABLE(self)) return Qfalse;
return Qtrue;
}
|
#closed_write? ⇒ Boolean
Returns true
if self
is closed for writing, false
otherwise.
585 586 587 588 589 590 591 |
# File 'ext/stringio/stringio.c', line 585
static VALUE
strio_closed_write(VALUE self)
{
StringIO(self);
if (WRITABLE(self)) return Qfalse;
return Qtrue;
}
|
#each_line(sep = $/, chomp: false) {|line| ... } ⇒ self #each_line(limit, chomp: false) {|line| ... } ⇒ self #each_line(sep, limit, chomp: false) {|line| ... } ⇒ self
Calls the block with each remaining line read from the stream; does nothing if already at end-of-file; returns self
. See Line IO.
1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 |
# File 'ext/stringio/stringio.c', line 1345
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| ... } ⇒ self
With a block given, calls the block with each remaining byte in the stream; see Byte IO.
With no block given, returns an enumerator.
843 844 845 846 847 848 849 850 851 852 853 854 855 |
# File 'ext/stringio/stringio.c', line 843
static VALUE
strio_each_byte(VALUE self)
{
struct StringIO *ptr;
RETURN_ENUMERATOR(self, 0, 0);
while ((ptr = strio_to_read(self)) != NULL) {
char c = RSTRING_PTR(ptr->string)[ptr->pos++];
rb_yield(CHR2FIX(c));
}
return self;
}
|
#each_char {|c| ... } ⇒ self
With a block given, calls the block with each remaining character in the stream; see Character IO.
With no block given, returns an enumerator.
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 |
# File 'ext/stringio/stringio.c', line 1062
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 {|codepoint| ... } ⇒ self
With a block given, calls the block with each remaining codepoint in the stream; see Codepoint IO.
With no block given, returns an enumerator.
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 |
# File 'ext/stringio/stringio.c', line 1084
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);
while ((ptr = strio_to_read(self)) != NULL) {
c = rb_enc_codepoint_len(RSTRING_PTR(ptr->string)+ptr->pos,
RSTRING_END(ptr->string), &n, enc);
ptr->pos += n;
rb_yield(UINT2NUM(c));
}
return self;
}
|
#each_line(sep = $/, chomp: false) {|line| ... } ⇒ self #each_line(limit, chomp: false) {|line| ... } ⇒ self #each_line(sep, limit, chomp: false) {|line| ... } ⇒ self
Calls the block with each remaining line read from the stream; does nothing if already at end-of-file; returns self
. See Line IO.
1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 |
# File 'ext/stringio/stringio.c', line 1345
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? ⇒ Boolean
Returns true
if positioned at end-of-stream, false
otherwise; see Position.
Raises IOError if the stream is not opened for reading.
610 611 612 613 614 615 |
# File 'ext/stringio/stringio.c', line 610
static VALUE
strio_eof(VALUE self)
{
if (strio_to_read(self)) return Qfalse;
return Qtrue;
}
|
#eof? ⇒ Boolean
Returns true
if positioned at end-of-stream, false
otherwise; see Position.
Raises IOError if the stream is not opened for reading.
610 611 612 613 614 615 |
# File 'ext/stringio/stringio.c', line 610
static VALUE
strio_eof(VALUE self)
{
if (strio_to_read(self)) return Qfalse;
return Qtrue;
}
|
#external_encoding ⇒ Encoding
Returns the Encoding object that represents the encoding of the file. If the stream is write mode and no encoding is specified, returns nil
.
1742 1743 1744 1745 1746 1747 |
# File 'ext/stringio/stringio.c', line 1742
static VALUE
strio_external_encoding(VALUE self)
{
struct StringIO *ptr = StringIO(self);
return rb_enc_from_encoding(get_enc(ptr));
}
|
#fcntl ⇒ Object
#fileno ⇒ nil
#flush ⇒ Object
#fsync ⇒ 0
#getbyte ⇒ nil
Reads and returns the next 8-bit byte from the stream; see Byte IO.
890 891 892 893 894 895 896 897 898 899 900 |
# File 'ext/stringio/stringio.c', line 890
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 ⇒ nil
Reads and returns the next character from the stream; see Character IO.
864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 |
# File 'ext/stringio/stringio.c', line 864
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 = $/, chomp: false) ⇒ String? #gets(limit, chomp: false) ⇒ String? #gets(sep, limit, chomp: false) ⇒ String?
Reads and returns a line from the stream; assigns the return value to $_
; see Line IO.
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 |
# File 'ext/stringio/stringio.c', line 1301
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;
}
|
#initialize_copy(orig) ⇒ Object
:nodoc:
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 |
# File 'ext/stringio/stringio.c', line 618
static VALUE
strio_copy(VALUE copy, VALUE orig)
{
struct StringIO *ptr, *old_ptr;
VALUE old_string = Qundef;
orig = rb_convert_type(orig, T_DATA, "StringIO", "to_strio");
if (copy == orig) return copy;
ptr = StringIO(orig);
old_ptr = check_strio(copy);
if (old_ptr) {
old_string = old_ptr->string;
strio_free(old_ptr);
}
DATA_PTR(copy) = ptr;
RB_OBJ_WRITTEN(copy, old_string, ptr->string);
RBASIC(copy)->flags &= ~STRIO_READWRITE;
RBASIC(copy)->flags |= RBASIC(orig)->flags & STRIO_READWRITE;
++ptr->count;
return copy;
}
|
#internal_encoding ⇒ Encoding
Returns the Encoding of the internal string if conversion is specified. Otherwise returns nil
.
1757 1758 1759 1760 1761 |
# File 'ext/stringio/stringio.c', line 1757
static VALUE
strio_internal_encoding(VALUE self)
{
return Qnil;
}
|
#isatty ⇒ nil #tty? ⇒ nil
#length ⇒ Integer #size ⇒ Integer
Returns the size of the buffer string.
1700 1701 1702 1703 1704 1705 1706 1707 1708 |
# File 'ext/stringio/stringio.c', line 1700
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 ⇒ Object
Returns the current line number in self
; see Line Number.
647 648 649 650 651 |
# File 'ext/stringio/stringio.c', line 647
static VALUE
strio_get_lineno(VALUE self)
{
return LONG2NUM(StringIO(self)->lineno);
}
|
#lineno=(new_line_number) ⇒ Object
Sets the current line number in self
to the given new_line_number
; see Line Number.
660 661 662 663 664 665 |
# File 'ext/stringio/stringio.c', line 660
static VALUE
strio_set_lineno(VALUE self, VALUE lineno)
{
StringIO(self)->lineno = NUM2LONG(lineno);
return lineno;
}
|
#pid ⇒ nil
#pos ⇒ Object
Returns the current position (in bytes); see Position.
735 736 737 738 739 |
# File 'ext/stringio/stringio.c', line 735
static VALUE
strio_get_pos(VALUE self)
{
return LONG2NUM(StringIO(self)->pos);
}
|
#pos=(new_position) ⇒ Object
Sets the current position (in bytes); see Position.
748 749 750 751 752 753 754 755 756 757 758 |
# File 'ext/stringio/stringio.c', line 748
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;
}
|
#pread(maxlen, offset) ⇒ String #pread(maxlen, offset, out_string) ⇒ String
See IO#pread.
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 |
# File 'ext/stringio/stringio.c', line 1593
static VALUE
strio_pread(int argc, VALUE *argv, VALUE self)
{
VALUE rb_len, rb_offset, rb_buf;
rb_scan_args(argc, argv, "21", &rb_len, &rb_offset, &rb_buf);
long len = NUM2LONG(rb_len);
long offset = NUM2LONG(rb_offset);
if (len < 0) {
rb_raise(rb_eArgError, "negative string size (or size too big): %" PRIsVALUE, rb_len);
}
if (offset < 0) {
rb_syserr_fail_str(EINVAL, rb_sprintf("pread: Invalid offset argument: %" PRIsVALUE, rb_offset));
}
struct StringIO *ptr = readable(self);
if (offset >= RSTRING_LEN(ptr->string)) {
rb_eof_error();
}
if (NIL_P(rb_buf)) {
return strio_substr(ptr, offset, len, rb_ascii8bit_encoding());
}
long rest = RSTRING_LEN(ptr->string) - offset;
if (len > rest) len = rest;
rb_str_resize(rb_buf, len);
rb_enc_associate(rb_buf, rb_ascii8bit_encoding());
MEMCPY(RSTRING_PTR(rb_buf), RSTRING_PTR(ptr->string) + offset, char, len);
return rb_buf;
}
|
#putc(obj) ⇒ Object
See IO#putc.
1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 |
# File 'ext/stringio/stringio.c', line 1486
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?
See IO#read.
1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 |
# File 'ext/stringio/stringio.c', line 1518
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);
}
/* 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 = 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;
default:
rb_error_arity(argc, 0, 2);
}
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 = $/, chomp: false) ⇒ Array #readlines(limit, chomp: false) ⇒ Array #readlines(sep, limit, chomp: false) ⇒ Array
See IO#readlines.
1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 |
# File 'ext/stringio/stringio.c', line 1372
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, mode = 'r+') ⇒ self
718 719 720 721 722 723 724 725 726 |
# File 'ext/stringio/stringio.c', line 718
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
Sets the current position and line number to zero; see Position and Line Number.
768 769 770 771 772 773 774 775 |
# File 'ext/stringio/stringio.c', line 768
static VALUE
strio_rewind(VALUE self)
{
struct StringIO *ptr = StringIO(self);
ptr->pos = 0;
ptr->lineno = 0;
return INT2FIX(0);
}
|
#seek(offset, whence = SEEK_SET) ⇒ 0
Sets the current position to the given integer offset
(in bytes), with respect to a given constant whence
; see Position.
785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 |
# File 'ext/stringio/stringio.c', line 785
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]]) ⇒ Object
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.
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 |
# File 'ext/stringio/stringio.c', line 1773
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_find_encoding(ext_enc);
if (!enc) {
rb_io_enc_t convconfig;
int oflags, fmode;
VALUE vmode = rb_str_append(rb_str_new_cstr("r:"), ext_enc);
rb_io_extract_modeenc(&vmode, 0, Qnil, &oflags, &fmode, &convconfig);
enc = convconfig.enc2;
}
}
ptr->enc = enc;
if (WRITABLE(self)) {
rb_enc_associate(ptr->string, enc);
}
return self;
}
|
#set_encoding_by_bom ⇒ Object
1803 1804 1805 1806 1807 1808 1809 1810 |
# File 'ext/stringio/stringio.c', line 1803
static VALUE
strio_set_encoding_by_bom(VALUE self)
{
struct StringIO *ptr = StringIO(self);
if (!set_encoding_by_bom(ptr)) return Qnil;
return rb_enc_from_encoding(ptr->enc);
}
|
#length ⇒ Integer #size ⇒ Integer
Returns the size of the buffer string.
1700 1701 1702 1703 1704 1705 1706 1707 1708 |
# File 'ext/stringio/stringio.c', line 1700
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
449 450 451 452 453 |
# File 'ext/stringio/stringio.c', line 449
static VALUE
strio_get_string(VALUE self)
{
return StringIO(self)->string;
}
|
#string=(other_string) ⇒ Object
475 476 477 478 479 480 481 482 483 484 485 486 487 488 |
# File 'ext/stringio/stringio.c', line 475
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;
RB_OBJ_WRITE(self, &ptr->string, string);
return string;
}
|
#sync ⇒ true
Returns true
; implemented only for compatibility with other stream classes.
823 824 825 826 827 828 |
# File 'ext/stringio/stringio.c', line 823
static VALUE
strio_get_sync(VALUE self)
{
StringIO(self);
return Qtrue;
}
|
#sync=(boolean) ⇒ Boolean
#tell ⇒ Object
#truncate(integer) ⇒ 0
Truncates the buffer string to at most integer bytes. The stream must be opened for writing.
1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 |
# File 'ext/stringio/stringio.c', line 1717
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 INT2FIX(0);
}
|
#tty? ⇒ Boolean
#ungetbyte(byte) ⇒ nil
Pushes back (“unshifts”) an 8-bit byte onto the stream; see Byte IO.
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 |
# File 'ext/stringio/stringio.c', line 967
static VALUE
strio_ungetbyte(VALUE self, VALUE c)
{
struct StringIO *ptr = readable(self);
check_modifiable(ptr);
if (NIL_P(c)) return Qnil;
if (RB_INTEGER_TYPE_P(c)) {
/* rb_int_and() not visible from exts */
VALUE v = rb_funcall(c, '&', 1, INT2FIX(0xff));
const char cc = NUM2INT(v) & 0xFF;
strio_unget_bytes(ptr, &cc, 1);
}
else {
long cl;
SafeStringValue(c);
cl = RSTRING_LEN(c);
if (cl > 0) {
strio_unget_bytes(ptr, RSTRING_PTR(c), cl);
RB_GC_GUARD(c);
}
}
return Qnil;
}
|
#ungetc(character) ⇒ nil
Pushes back (“unshifts”) a character or integer onto the stream; see Character IO.
929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 |
# File 'ext/stringio/stringio.c', line 929
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 #syswrite(string) ⇒ Integer
Appends the given string to the underlying buffer string. 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.
1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 |
# File 'ext/stringio/stringio.c', line 1400
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);
}
|