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]) {|strio| ... } ⇒ Object
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.
Instance Method Summary collapse
-
#binmode ⇒ Object
Puts stream into binary mode.
-
#close ⇒ nil
Closes a StringIO.
-
#close_read ⇒ nil
Closes the read end of a StringIO.
-
#close_write ⇒ nil
Closes the write end of a StringIO.
-
#closed? ⇒ Boolean
Returns
true
if the stream is completely closed,false
otherwise. -
#closed_read? ⇒ Boolean
Returns
true
if the stream is not readable,false
otherwise. -
#closed_write? ⇒ Boolean
Returns
true
if the stream is not writable,false
otherwise. -
#each(*args) ⇒ Object
strio.each_line(sep=$/, chomp: false) {|line| block } -> strio strio.each_line(limit, chomp: false) {|line| block } -> strio strio.each_line(sep, limit, chomp: false) {|line| block } -> strio strio.each_line(…) -> anEnumerator.
-
#each_byte ⇒ Object
See IO#each_byte.
-
#each_char ⇒ Object
See IO#each_char.
-
#each_codepoint ⇒ Object
See IO#each_codepoint.
-
#each_line(*args) ⇒ Object
strio.each_line(sep=$/, chomp: false) {|line| block } -> strio strio.each_line(limit, chomp: false) {|line| block } -> strio strio.each_line(sep, limit, chomp: false) {|line| block } -> strio strio.each_line(…) -> anEnumerator.
-
#eof ⇒ Object
Returns true if the stream is at the end of the data (underlying string).
-
#eof? ⇒ Object
Returns true if the stream is at the end of the data (underlying string).
-
#external_encoding ⇒ Encoding
Returns the Encoding object that represents the encoding of the file.
- #fcntl ⇒ Object
- #fileno ⇒ nil
- #flush ⇒ Object
- #fsync ⇒ 0
-
#getbyte ⇒ Fixnum?
See IO#getbyte.
-
#getc ⇒ String?
See IO#getc.
-
#gets(*args) ⇒ Object
See IO#gets.
-
#new(string = ""[, mode]) ⇒ Object
constructor
Creates new StringIO instance from with string and mode.
-
#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 ⇒ Integer
Returns the current line number.
-
#lineno=(integer) ⇒ Integer
Manually sets the current line number to the given value.
- #pid ⇒ nil
-
#pos ⇒ Object
Returns the current offset (in bytes).
-
#pos=(integer) ⇒ Integer
Seeks to the given position (in bytes).
-
#putc(obj) ⇒ Object
See IO#putc.
-
#read([length [, outbuf]]) ⇒ String?
See IO#read.
-
#readlines(*args) ⇒ Object
See IO#readlines.
-
#reopen(*args) ⇒ Object
Reinitializes the stream with the given other_StrIO or string and mode (see StringIO#new).
-
#rewind ⇒ 0
Positions the stream to the beginning of input, resetting
lineno
to zero. -
#seek(amount, whence = SEEK_SET) ⇒ 0
Seeks to a given offset amount in the stream according to the value of whence (see IO#seek).
-
#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 object, the subject of IO.
-
#string=(string) ⇒ String
Changes underlying String object, the subject of IO.
-
#sync ⇒ true
Returns
true
always. - #sync=(boolean) ⇒ Boolean
- #tell ⇒ Object
-
#truncate(integer) ⇒ 0
Truncates the buffer string to at most integer bytes.
- #tty? ⇒ Boolean
-
#ungetbyte(fixnum) ⇒ nil
See IO#ungetbyte.
-
#ungetc(string) ⇒ nil
Pushes back one character (passed as a parameter) such that a subsequent buffered read will return it.
-
#write(*args) ⇒ Object
Appends the given string to the underlying buffer string.
Constructor Details
#new(string = ""[, mode]) ⇒ Object
Creates new StringIO instance from with string and mode.
259 260 261 262 263 264 265 266 267 268 269 |
# File 'ext/stringio/stringio.c', line 259
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:
405 406 407 408 409 410 411 412 413 414 415 |
# File 'ext/stringio/stringio.c', line 405
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]) {|strio| ... } ⇒ Object
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.
396 397 398 399 400 401 402 |
# File 'ext/stringio/stringio.c', line 396
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 ⇒ Object
Puts stream into binary mode. See IO#binmode.
682 683 684 685 686 687 688 689 690 691 692 693 |
# File 'ext/stringio/stringio.c', line 682
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 a StringIO. The stream is unavailable for any further data operations; an IOError
is raised if such an attempt is made.
517 518 519 520 521 522 523 |
# File 'ext/stringio/stringio.c', line 517
static VALUE
strio_close(VALUE self)
{
StringIO(self);
RBASIC(self)->flags &= ~STRIO_READWRITE;
return Qnil;
}
|
#close_read ⇒ nil
Closes the read end of a StringIO. Will raise an IOError
if the receiver is not readable.
532 533 534 535 536 537 538 539 540 541 |
# File 'ext/stringio/stringio.c', line 532
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 the write end of a StringIO. Will raise an IOError
if the receiver is not writeable.
550 551 552 553 554 555 556 557 558 559 |
# File 'ext/stringio/stringio.c', line 550
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 the stream is completely closed, false
otherwise.
567 568 569 570 571 572 573 |
# File 'ext/stringio/stringio.c', line 567
static VALUE
strio_closed(VALUE self)
{
StringIO(self);
if (!CLOSED(self)) return Qfalse;
return Qtrue;
}
|
#closed_read? ⇒ Boolean
Returns true
if the stream is not readable, false
otherwise.
581 582 583 584 585 586 587 |
# File 'ext/stringio/stringio.c', line 581
static VALUE
strio_closed_read(VALUE self)
{
StringIO(self);
if (READABLE(self)) return Qfalse;
return Qtrue;
}
|
#closed_write? ⇒ Boolean
Returns true
if the stream is not writable, false
otherwise.
595 596 597 598 599 600 601 |
# File 'ext/stringio/stringio.c', line 595
static VALUE
strio_closed_write(VALUE self)
{
StringIO(self);
if (WRITABLE(self)) return Qfalse;
return Qtrue;
}
|
#each(sep = $/, chomp: false) {|line| ... } ⇒ Object #each(limit, chomp: false) {|line| ... } ⇒ Object #each(sep, limit, chomp: false) {|line| ... } ⇒ Object #each(...) ⇒ Enumerator
strio.each_line(sep=$/, chomp: false) {|line| block } -> strio
strio.each_line(limit, chomp: false) {|line| block } -> strio
strio.each_line(sep, limit, chomp: false) {|line| block } -> strio
strio.each_line(...) -> anEnumerator
See IO#each.
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 |
# File 'ext/stringio/stringio.c', line 1315
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| ... } ⇒ Object #each_byte ⇒ Enumerator
See IO#each_byte.
829 830 831 832 833 834 835 836 837 838 839 840 841 |
# File 'ext/stringio/stringio.c', line 829
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 {|char| ... } ⇒ Object #each_char ⇒ Enumerator
See IO#each_char.
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 |
# File 'ext/stringio/stringio.c', line 1043
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| ... } ⇒ Object #each_codepoint ⇒ Enumerator
See IO#each_codepoint.
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 |
# File 'ext/stringio/stringio.c', line 1063
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(sep = $/, chomp: false) {|line| ... } ⇒ Object #each(limit, chomp: false) {|line| ... } ⇒ Object #each(sep, limit, chomp: false) {|line| ... } ⇒ Object #each(...) ⇒ Enumerator
strio.each_line(sep=$/, chomp: false) {|line| block } -> strio
strio.each_line(limit, chomp: false) {|line| block } -> strio
strio.each_line(sep, limit, chomp: false) {|line| block } -> strio
strio.each_line(...) -> anEnumerator
See IO#each.
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 |
# File 'ext/stringio/stringio.c', line 1315
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 #eof? ⇒ Boolean
Returns true if the stream is at the end of the data (underlying string). The stream must be opened for reading or an IOError
will be raised.
619 620 621 622 623 624 |
# File 'ext/stringio/stringio.c', line 619
static VALUE
strio_eof(VALUE self)
{
if (strio_to_read(self)) return Qfalse;
return Qtrue;
}
|
#eof ⇒ Boolean #eof? ⇒ Boolean
Returns true if the stream is at the end of the data (underlying string). The stream must be opened for reading or an IOError
will be raised.
619 620 621 622 623 624 |
# File 'ext/stringio/stringio.c', line 619
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
.
1670 1671 1672 1673 1674 1675 |
# File 'ext/stringio/stringio.c', line 1670
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 ⇒ Fixnum?
See IO#getbyte.
874 875 876 877 878 879 880 881 882 883 884 |
# File 'ext/stringio/stringio.c', line 874
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?
See IO#getc.
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 |
# File 'ext/stringio/stringio.c', line 849
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?
See IO#gets.
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 |
# File 'ext/stringio/stringio.c', line 1269
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:
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 |
# File 'ext/stringio/stringio.c', line 627
static VALUE
strio_copy(VALUE copy, VALUE orig)
{
struct StringIO *ptr;
orig = rb_convert_type(orig, T_DATA, "StringIO", "to_strio");
if (copy == orig) return copy;
ptr = StringIO(orig);
if (check_strio(copy)) {
strio_free(DATA_PTR(copy));
}
DATA_PTR(copy) = ptr;
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
.
1685 1686 1687 1688 1689 |
# File 'ext/stringio/stringio.c', line 1685
static VALUE
strio_internal_encoding(VALUE self)
{
return Qnil;
}
|
#isatty ⇒ nil #tty? ⇒ nil
#length ⇒ Integer #size ⇒ Integer
Returns the size of the buffer string.
1628 1629 1630 1631 1632 1633 1634 1635 1636 |
# File 'ext/stringio/stringio.c', line 1628
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
Returns the current line number. The stream 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.
655 656 657 658 659 |
# File 'ext/stringio/stringio.c', line 655
static VALUE
strio_get_lineno(VALUE self)
{
return LONG2NUM(StringIO(self)->lineno);
}
|
#lineno=(integer) ⇒ Integer
Manually sets the current line number to the given value. $.
is updated only on the next read.
668 669 670 671 672 673 |
# File 'ext/stringio/stringio.c', line 668
static VALUE
strio_set_lineno(VALUE self, VALUE lineno)
{
StringIO(self)->lineno = NUM2LONG(lineno);
return lineno;
}
|
#pid ⇒ nil
#pos ⇒ Integer #tell ⇒ Integer
Returns the current offset (in bytes).
726 727 728 729 730 |
# File 'ext/stringio/stringio.c', line 726
static VALUE
strio_get_pos(VALUE self)
{
return LONG2NUM(StringIO(self)->pos);
}
|
#pos=(integer) ⇒ Integer
Seeks to the given position (in bytes).
738 739 740 741 742 743 744 745 746 747 748 |
# File 'ext/stringio/stringio.c', line 738
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) ⇒ Object
See IO#putc.
1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 |
# File 'ext/stringio/stringio.c', line 1456
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.
1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 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 |
# File 'ext/stringio/stringio.c', line 1488
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.
1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 |
# File 'ext/stringio/stringio.c', line 1342
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) ⇒ Object #reopen(string, mode) ⇒ Object
Reinitializes the stream with the given other_StrIO or string and mode (see StringIO#new).
709 710 711 712 713 714 715 716 717 |
# File 'ext/stringio/stringio.c', line 709
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
Positions the stream to the beginning of input, resetting lineno
to zero.
757 758 759 760 761 762 763 764 |
# File 'ext/stringio/stringio.c', line 757
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
Seeks to a given offset amount in the stream according to the value of whence (see IO#seek).
773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 |
# File 'ext/stringio/stringio.c', line 773
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.
1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 |
# File 'ext/stringio/stringio.c', line 1701
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;
}
|
#set_encoding_by_bom ⇒ Object
1724 1725 1726 1727 1728 1729 1730 1731 |
# File 'ext/stringio/stringio.c', line 1724
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.
1628 1629 1630 1631 1632 1633 1634 1635 1636 |
# File 'ext/stringio/stringio.c', line 1628
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
Returns underlying String object, the subject of IO.
484 485 486 487 488 |
# File 'ext/stringio/stringio.c', line 484
static VALUE
strio_get_string(VALUE self)
{
return StringIO(self)->string;
}
|
#string=(string) ⇒ String
Changes underlying String object, the subject of IO.
496 497 498 499 500 501 502 503 504 505 506 507 508 |
# File 'ext/stringio/stringio.c', line 496
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
Returns true
always.
811 812 813 814 815 816 |
# File 'ext/stringio/stringio.c', line 811
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.
1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 |
# File 'ext/stringio/stringio.c', line 1645
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? ⇒ Boolean
#ungetbyte(fixnum) ⇒ nil
See IO#ungetbyte
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 |
# File 'ext/stringio/stringio.c', line 952
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(string) ⇒ nil
Pushes back one character (passed as a parameter) 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.
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 |
# File 'ext/stringio/stringio.c', line 915
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.
1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 |
# File 'ext/stringio/stringio.c', line 1370
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);
}
|