Class: StringIO

Inherits:
Object
  • Object
show all
Includes:
Enumerable, Readable, Writable
Defined in:
ext/stringio/stringio.c

Constant Summary collapse

VERSION = 
rb_str_new_cstr(STRINGIO_VERSION)

Class Method Summary collapse

Instance Method Summary collapse

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.

Yields:

  • (strio) 


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.

Returns:

  • (nil) 


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.

Returns:

  • (nil) 


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.

Returns:

  • (nil) 


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.

Returns:

  • (Boolean) 


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.

Returns:

  • (Boolean) 


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.

Returns:

  • (Boolean) 


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.

Overloads:

  • #each(sep = $/, chomp: false) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(limit, chomp: false) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(sep, limit, chomp: false) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(...) ⇒ Enumerator

    Returns:

    • (Enumerator) 


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.

Overloads:

  • #each_byte {|byte| ... } ⇒ Object

    Yields:

    • (byte)
  • #each_byte ⇒ Enumerator

    Returns:

    • (Enumerator) 


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.

Overloads:

  • #each_char {|char| ... } ⇒ Object

    Yields:

    • (char)
  • #each_char ⇒ Enumerator

    Returns:

    • (Enumerator) 


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.

Overloads:

  • #each_codepoint {|c| ... } ⇒ Object

    Yields:

    • (c)
  • #each_codepoint ⇒ Enumerator

    Returns:

    • (Enumerator) 


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.

Overloads:

  • #each(sep = $/, chomp: false) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(limit, chomp: false) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(sep, limit, chomp: false) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(...) ⇒ Enumerator

    Returns:

    • (Enumerator) 


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.

Overloads:

  • #eof ⇒ Boolean

    Returns:

    • (Boolean)
  • #eof? ⇒ Boolean

    Returns:

    • (Boolean) 


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.

Overloads:

  • #eof ⇒ Boolean

    Returns:

    • (Boolean)
  • #eof? ⇒ Boolean

    Returns:

    • (Boolean) 


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.

Returns:

  • (Encoding) 


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

Returns:

  • (nil)

#flush ⇒ Object

#fsync ⇒ 0

Returns:

  • (0)

#getbyte ⇒ Fixnum?

See IO#getbyte.

Returns:

  • (Fixnum, nil) 


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.

Returns:

  • (String, nil) 


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.

Overloads:

  • #gets(sep = $/, chomp: false) ⇒ String?

    Returns:

    • (String, nil)
  • #gets(limit, chomp: false) ⇒ String?

    Returns:

    • (String, nil)
  • #gets(sep, limit, chomp: false) ⇒ String?

    Returns:

    • (String, nil) 


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.

Returns:

  • (Encoding) 


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

Overloads:

  • #isatty ⇒ nil

    Returns:

    • (nil)
  • #tty? ⇒ nil

    Returns:

    • (nil)

#length ⇒ Integer #size ⇒ Integer

Returns the size of the buffer string.

Overloads:

  • #length ⇒ Integer

    Returns:

    • (Integer)
  • #size ⇒ Integer

    Returns:

    • (Integer) 


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.

Returns:

  • (Integer) 


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.

Returns:

  • (Integer) 


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

Returns:

  • (nil)

#pos ⇒ Integer #tell ⇒ Integer

Returns the current offset (in bytes).

Overloads:

  • #pos ⇒ Integer

    Returns:

    • (Integer)
  • #tell ⇒ Integer

    Returns:

    • (Integer) 


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).

Returns:

  • (Integer) 


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.

Returns:

  • (Object) 


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.

Returns:

  • (String, nil) 


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.

Overloads:

  • #readlines(sep = $/, chomp: false) ⇒ Array

    Returns:

    • (Array)
  • #readlines(limit, chomp: false) ⇒ Array

    Returns:

    • (Array)
  • #readlines(sep, limit, chomp: false) ⇒ Array

    Returns:

    • (Array) 


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.

Returns:

  • (0) 


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).

Returns:

  • (0) 


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.

Overloads:

  • #length ⇒ Integer

    Returns:

    • (Integer)
  • #size ⇒ Integer

    Returns:

    • (Integer) 


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.

Returns:

  • (String) 


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.

Returns:

  • (String) 


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.

Returns:

  • (true) 


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

Returns:

  • (Boolean)

#tell ⇒ Object

#truncate(integer) ⇒ 0

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

Returns:

  • (0) 


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

Returns:

  • (Boolean)

#ungetbyte(fixnum) ⇒ nil

See IO#ungetbyte

Returns:

  • (nil) 


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.

Returns:

  • (nil) 


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.

Overloads:

  • #write(string, ...) ⇒ Integer

    Returns:

    • (Integer)
  • #syswrite(string) ⇒ Integer

    Returns:

    • (Integer) 


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);
}