Class: StringIO

Inherits:
Data
  • Object
show all
Includes:
Enumerable, IO::readable, IO::writable
Defined in:
stringio.c

Class Method Summary collapse

Instance Method Summary collapse

Methods included from IO::readable

#read_nonblock, #readbyte, #readchar, #readline, #readpartial, #sysread

Methods included from IO::writable

#<<, #print, #printf, #puts, #syswrite, #write_nonblock

Constructor Details

#new(string = ""[, mode]) ⇒ Object

Creates new StringIO instance from with string and mode.


163
164
165
166
167
168
169
170
171
172
173
174
# File 'stringio.c', line 163

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

Class Method Details

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

234
235
236
237
238
239
240
# File 'stringio.c', line 234

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

Instance Method Details

#binmodeObject

#bytesObject

This is a deprecated alias for each_byte.


655
656
657
658
659
660
661
662
# File 'stringio.c', line 655

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

#charsObject

This is a deprecated alias for each_char.


875
876
877
878
879
880
881
882
# File 'stringio.c', line 875

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

#closenil

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

Returns:

  • (nil)

342
343
344
345
346
347
348
349
350
351
# File 'stringio.c', line 342

static VALUE
strio_close(VALUE self)
{
    StringIO(self);
    if (CLOSED(self)) {
	rb_raise(rb_eIOError, "closed stream");
    }
    RBASIC(self)->flags &= ~STRIO_READWRITE;
    return Qnil;
}

#close_readnil

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

Returns:

  • (nil)

360
361
362
363
364
365
366
367
368
369
# File 'stringio.c', line 360

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

#close_writenil

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

Returns:

  • (nil)

378
379
380
381
382
383
384
385
386
387
# File 'stringio.c', line 378

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

#closed?Boolean

Returns true if strio is completely closed, false otherwise.

Returns:

  • (Boolean)

Returns:

  • (Boolean)

395
396
397
398
399
400
401
# File 'stringio.c', line 395

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

#closed_read?Boolean

Returns true if strio is not readable, false otherwise.

Returns:

  • (Boolean)

Returns:

  • (Boolean)

409
410
411
412
413
414
415
# File 'stringio.c', line 409

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

#closed_write?Boolean

Returns true if strio is not writable, false otherwise.

Returns:

  • (Boolean)

Returns:

  • (Boolean)

423
424
425
426
427
428
429
# File 'stringio.c', line 423

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

#codepointsObject

This is a deprecated alias for each_codepoint.


919
920
921
922
923
924
925
926
# File 'stringio.c', line 919

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

#each(sep = $/) {|line| ... } ⇒ Object #each(limit) {|line| ... } ⇒ Object #each(sep, limit) {|line| ... } ⇒ Object #each(...) ⇒ Enumerator

strio.each_line(sep=$/) {|line| block } -> strio

strio.each_line(limit) {|line| block }     -> strio
strio.each_line(sep,limit) {|line| block } -> strio
strio.each_line(...)                       -> anEnumerator

See IO#each.

Overloads:

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

    Yields:

    • (line)
  • #each(limit) {|line| ... } ⇒ Object

    Yields:

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

    Yields:

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

    Returns:

    • (Enumerator)

1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
# File 'stringio.c', line 1101

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

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

See IO#each_byte.

Overloads:

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

    Yields:

    • (byte)
  • #each_byteEnumerator

    Returns:

    • (Enumerator)

638
639
640
641
642
643
644
645
646
647
648
649
650
# File 'stringio.c', line 638

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

    RETURN_ENUMERATOR(self, 0, 0);

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

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

See IO#each_char.

Overloads:

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

    Yields:

    • (char)
  • #each_charEnumerator

    Returns:

    • (Enumerator)

859
860
861
862
863
864
865
866
867
868
869
870
# File 'stringio.c', line 859

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_codepointEnumerator

See IO#each_codepoint.

Overloads:

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

    Yields:

    • (c)
  • #each_codepointEnumerator

    Returns:

    • (Enumerator)

891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
# File 'stringio.c', line 891

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

#each(sep = $/) {|line| ... } ⇒ Object #each(limit) {|line| ... } ⇒ Object #each(sep, limit) {|line| ... } ⇒ Object #each(...) ⇒ Enumerator

strio.each_line(sep=$/) {|line| block } -> strio

strio.each_line(limit) {|line| block }     -> strio
strio.each_line(sep,limit) {|line| block } -> strio
strio.each_line(...)                       -> anEnumerator

See IO#each.

Overloads:

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

    Yields:

    • (line)
  • #each(limit) {|line| ... } ⇒ Object

    Yields:

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

    Yields:

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

    Returns:

    • (Enumerator)

1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
# File 'stringio.c', line 1101

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

#eofBoolean #eof?Boolean

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

Overloads:

  • #eofBoolean

    Returns:

    • (Boolean)
  • #eof?Boolean

    Returns:

    • (Boolean)

439
440
441
442
443
444
445
# File 'stringio.c', line 439

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

#eofBoolean #eof?Boolean

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

Overloads:

  • #eofBoolean

    Returns:

    • (Boolean)
  • #eof?Boolean

    Returns:

    • (Boolean)

Returns:

  • (Boolean)

439
440
441
442
443
444
445
# File 'stringio.c', line 439

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

#external_encodingEncoding

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

Returns:

  • (Encoding)

1411
1412
1413
1414
1415
# File 'stringio.c', line 1411

static VALUE
strio_external_encoding(VALUE self)
{
    return rb_enc_from_encoding(rb_enc_get(StringIO(self)->string));
}

#fcntlObject

#filenoObject

#flushObject

#fsyncObject

#getbyteFixnum?

See IO#getbyte.

Returns:

  • (Fixnum, nil)

693
694
695
696
697
698
699
700
701
702
703
# File 'stringio.c', line 693

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

#getcString?

See IO#getc.

Returns:

  • (String, nil)

670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
# File 'stringio.c', line 670

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

#gets(sep = $/) ⇒ String? #gets(limit) ⇒ String? #gets(sep, limit) ⇒ String?

See IO#gets.

Overloads:

  • #gets(sep = $/) ⇒ String?

    Returns:

    • (String, nil)
  • #gets(limit) ⇒ String?

    Returns:

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

    Returns:

    • (String, nil)

1062
1063
1064
1065
1066
1067
1068
1069
# File 'stringio.c', line 1062

static VALUE
strio_gets(int argc, VALUE *argv, VALUE self)
{
    VALUE str = strio_getline(argc, argv, readable(self));

    rb_lastline_set(str);
    return str;
}

#initialize_copyObject

:nodoc:


448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
# File 'stringio.c', line 448

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;
    OBJ_INFECT(copy, orig);
    RBASIC(copy)->flags &= ~STRIO_READWRITE;
    RBASIC(copy)->flags |= RBASIC(orig)->flags & STRIO_READWRITE;
    ++ptr->count;
    return copy;
}

#internal_encodingEncoding

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

Returns:

  • (Encoding)

1425
1426
1427
1428
1429
# File 'stringio.c', line 1425

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

#isattyObject

#sizeInteger

Returns the size of the buffer string.

Returns:

  • (Integer)

1370
1371
1372
1373
1374
1375
1376
1377
1378
# File 'stringio.c', line 1370

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

#linenoInteger

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.

Returns:

  • (Integer)

477
478
479
480
481
# File 'stringio.c', line 477

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)

490
491
492
493
494
495
# File 'stringio.c', line 490

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

#linesObject

This is a deprecated alias for each_line.


1123
1124
1125
1126
1127
1128
1129
1130
# File 'stringio.c', line 1123

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

#pidObject

#posInteger #tellInteger

Returns the current offset (in bytes) of strio.

Overloads:

  • #posInteger

    Returns:

    • (Integer)
  • #tellInteger

    Returns:

    • (Integer)

535
536
537
538
539
# File 'stringio.c', line 535

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

#pos=(integer) ⇒ Integer

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

Returns:

  • (Integer)

547
548
549
550
551
552
553
554
555
556
557
# File 'stringio.c', line 547

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)

1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
# File 'stringio.c', line 1234

static VALUE
strio_putc(VALUE self, VALUE ch)
{
    struct StringIO *ptr = writable(self);
    int c = NUM2CHR(ch);
    long olen;

    check_modifiable(ptr);
    olen = RSTRING_LEN(ptr->string);
    if (ptr->flags & FMODE_APPEND) {
	ptr->pos = olen;
    }
    strio_extend(ptr, ptr->pos, 1);
    RSTRING_PTR(ptr->string)[ptr->pos++] = c;
    OBJ_INFECT(ptr->string, self);
    return ch;
}

#read([length [, outbuf]]) ⇒ String?

See IO#read.

Returns:

  • (String, nil)

1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
# File 'stringio.c', line 1266

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

#readlines(sep = $/) ⇒ Array #readlines(limit) ⇒ Array #readlines(sep, limit) ⇒ Array

See IO#readlines.

Overloads:

  • #readlines(sep = $/) ⇒ Array

    Returns:

    • (Array)
  • #readlines(limit) ⇒ Array

    Returns:

    • (Array)
  • #readlines(sep, limit) ⇒ Array

    Returns:

    • (Array)

1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
# File 'stringio.c', line 1140

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

#reopen(other_StrIO) ⇒ Object #reopen(string, mode) ⇒ Object

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


517
518
519
520
521
522
523
524
525
526
# File 'stringio.c', line 517

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

#rewind0

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

Returns:

  • (0)

566
567
568
569
570
571
572
573
# File 'stringio.c', line 566

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)

582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
# File 'stringio.c', line 582

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

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


1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
# File 'stringio.c', line 1441

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

#sizeInteger

Returns the size of the buffer string.

Returns:

  • (Integer)

1370
1371
1372
1373
1374
1375
1376
1377
1378
# File 'stringio.c', line 1370

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

#stringString

Returns underlying String object, the subject of IO.

Returns:

  • (String)

309
310
311
312
313
# File 'stringio.c', line 309

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

#string=(string) ⇒ String

Changes underlying String object, the subject of IO.

Returns:

  • (String)

321
322
323
324
325
326
327
328
329
330
331
332
333
# File 'stringio.c', line 321

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

#synctrue

Returns true always.

Returns:

  • (true)

619
620
621
622
623
624
# File 'stringio.c', line 619

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

#sync=Object

#tellObject

#truncate(integer) ⇒ 0

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

Returns:

  • (0)

1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
# File 'stringio.c', line 1387

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)

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
816
817
818
819
820
821
822
# File 'stringio.c', line 787

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

#ungetc(string) ⇒ nil

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.

Returns:

  • (nil)

731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
# File 'stringio.c', line 731

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

#write(string) ⇒ Integer #syswrite(string) ⇒ Integer

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

Overloads:

  • #write(string) ⇒ Integer

    Returns:

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

    Returns:

    • (Integer)

1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
# File 'stringio.c', line 1168

static VALUE
strio_write(VALUE self, VALUE str)
{
    struct StringIO *ptr = writable(self);
    long len, olen;
    rb_encoding *enc, *enc2;

    RB_GC_GUARD(str);
    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 != rb_ascii8bit_encoding()) {
	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) {
	rb_str_cat(ptr->string, RSTRING_PTR(str), len);
    }
    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);
    ptr->pos += len;
    return LONG2NUM(len);
}