Class: StringIO
- Inherits:
-
Data
- Object
- Data
- StringIO
- Includes:
- Enumerable, IO::readable, IO::writable
- Defined in:
- stringio.c
Class Method Summary collapse
-
.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
-
#bytes ⇒ Object
strio.each_byte {|byte| block } -> strio strio.each_byte -> anEnumerator.
-
#chars ⇒ Object
strio.each_char {|char| block } -> strio strio.each_char -> anEnumerator.
-
#close ⇒ nil
Closes strio.
-
#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 strio is completely closed,false
otherwise. -
#closed_read? ⇒ Boolean
Returns
true
if strio is not readable,false
otherwise. -
#closed_write? ⇒ Boolean
Returns
true
if strio is not writable,false
otherwise. -
#codepoints ⇒ Object
strio.each_codepoint {|c| block } -> strio strio.each_codepoint -> anEnumerator.
-
#each ⇒ Object
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.
-
#each_byte ⇒ Object
strio.each_byte {|byte| block } -> strio strio.each_byte -> anEnumerator.
-
#each_char ⇒ Object
strio.each_char {|char| block } -> strio strio.each_char -> anEnumerator.
-
#each_codepoint ⇒ Object
strio.each_codepoint {|c| block } -> strio strio.each_codepoint -> anEnumerator.
-
#each_line ⇒ Object
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.
-
#eof ⇒ Object
Returns true if strio is at end of file.
-
#eof? ⇒ Boolean
Returns true if strio is at end of file.
-
#external_encoding ⇒ Encoding
Returns the Encoding object that represents the encoding of the file.
- #fcntl ⇒ Object
- #fileno ⇒ Object
- #flush ⇒ Object
- #fsync ⇒ Object
-
#getbyte ⇒ Fixnum?
See IO#getbyte.
-
#getc ⇒ String?
See IO#getc.
-
#gets ⇒ Object
See IO#gets.
-
#new(string = ""[, mode]) ⇒ Object
constructor
Creates new StringIO instance from with string and mode.
-
#initialize_copy ⇒ Object
:nodoc:.
-
#internal_encoding ⇒ Encoding
Returns the Encoding of the internal string if conversion is specified.
- #isatty ⇒ Object
-
#size ⇒ Integer
Returns the size of the buffer string.
-
#lineno ⇒ Integer
Returns the current line number in strio.
-
#lineno=(integer) ⇒ Integer
Manually sets the current line number to the given value.
-
#lines ⇒ Object
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.
- #pid ⇒ Object
-
#pos ⇒ Object
Returns the current offset (in bytes) of strio.
-
#pos=(integer) ⇒ Integer
Seeks to the given position (in bytes) in strio.
-
#putc(obj) ⇒ Object
See IO#putc.
-
#read([length [, buffer]]) ⇒ String?
See IO#read.
-
#readlines ⇒ Object
See IO#readlines.
-
#reopen ⇒ Object
Reinitializes strio with the given other_StrIO or string and mode (see StringIO#new).
-
#rewind ⇒ 0
Positions strio 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.
-
#size ⇒ Integer
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= ⇒ Object
- #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) onto strio such that a subsequent buffered read will return it.
-
#write ⇒ Object
Appends the given string to the underlying buffer string of strio.
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.
154 155 156 157 158 159 160 161 162 163 164 165 |
# File 'stringio.c', line 154
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);
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.
224 225 226 227 228 229 230 |
# File 'stringio.c', line 224
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
#binmode ⇒ Object
#bytes {|byte| ... } ⇒ Object #bytes ⇒ Enumerator
strio.each_byte {|byte| block } -> strio
strio.each_byte -> anEnumerator
See IO#each_byte.
628 629 630 631 632 633 634 635 636 637 638 639 640 |
# File 'stringio.c', line 628
static VALUE
strio_each_byte(VALUE self)
{
struct StringIO *ptr = readable(StringIO(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;
}
|
#chars {|char| ... } ⇒ Object #chars ⇒ Enumerator
strio.each_char {|char| block } -> strio
strio.each_char -> anEnumerator
See IO#each_char.
838 839 840 841 842 843 844 845 846 847 848 849 |
# File 'stringio.c', line 838
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;
}
|
#close ⇒ nil
Closes strio. The strio is unavailable for any further data operations; an IOError
is raised if such an attempt is made.
331 332 333 334 335 336 337 338 339 340 |
# File 'stringio.c', line 331
static VALUE
strio_close(VALUE self)
{
struct StringIO *ptr = StringIO(self);
if (CLOSED(ptr)) {
rb_raise(rb_eIOError, "closed stream");
}
ptr->flags &= ~FMODE_READWRITE;
return Qnil;
}
|
#close_read ⇒ nil
Closes the read end of a StringIO. Will raise an IOError
if the strio is not readable.
349 350 351 352 353 354 355 356 357 358 |
# File 'stringio.c', line 349
static VALUE
strio_close_read(VALUE self)
{
struct StringIO *ptr = StringIO(self);
if (!READABLE(ptr)) {
rb_raise(rb_eIOError, "closing non-duplex IO for reading");
}
ptr->flags &= ~FMODE_READABLE;
return Qnil;
}
|
#close_write ⇒ nil
Closes the write end of a StringIO. Will raise an IOError
if the strio is not writeable.
367 368 369 370 371 372 373 374 375 376 |
# File 'stringio.c', line 367
static VALUE
strio_close_write(VALUE self)
{
struct StringIO *ptr = StringIO(self);
if (!WRITABLE(ptr)) {
rb_raise(rb_eIOError, "closing non-duplex IO for writing");
}
ptr->flags &= ~FMODE_WRITABLE;
return Qnil;
}
|
#closed? ⇒ Boolean
Returns true
if strio is completely closed, false
otherwise.
384 385 386 387 388 389 390 |
# File 'stringio.c', line 384
static VALUE
strio_closed(VALUE self)
{
struct StringIO *ptr = StringIO(self);
if (!CLOSED(ptr)) return Qfalse;
return Qtrue;
}
|
#closed_read? ⇒ Boolean
Returns true
if strio is not readable, false
otherwise.
398 399 400 401 402 403 404 |
# File 'stringio.c', line 398
static VALUE
strio_closed_read(VALUE self)
{
struct StringIO *ptr = StringIO(self);
if (READABLE(ptr)) return Qfalse;
return Qtrue;
}
|
#closed_write? ⇒ Boolean
Returns true
if strio is not writable, false
otherwise.
412 413 414 415 416 417 418 |
# File 'stringio.c', line 412
static VALUE
strio_closed_write(VALUE self)
{
struct StringIO *ptr = StringIO(self);
if (WRITABLE(ptr)) return Qfalse;
return Qtrue;
}
|
#codepoints {|c| ... } ⇒ Object #codepoints ⇒ Enumerator
strio.each_codepoint {|c| block } -> strio
strio.each_codepoint -> anEnumerator
See IO#each_codepoint.
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 |
# File 'stringio.c', line 861
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(StringIO(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
strio.lines(sep=$/) {|line| block } -> strio
strio.lines(limit) {|line| block } -> strio
strio.lines(sep,limit) {|line| block } -> strio
strio.lines(...) -> anEnumerator
See IO#each.
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 |
# File 'stringio.c', line 1064
static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
struct StringIO *ptr = StringIO(self);
VALUE line;
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(ptr)))) {
rb_yield(line);
}
return self;
}
|
#bytes {|byte| ... } ⇒ Object #bytes ⇒ Enumerator
strio.each_byte {|byte| block } -> strio
strio.each_byte -> anEnumerator
See IO#each_byte.
628 629 630 631 632 633 634 635 636 637 638 639 640 |
# File 'stringio.c', line 628
static VALUE
strio_each_byte(VALUE self)
{
struct StringIO *ptr = readable(StringIO(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;
}
|
#chars {|char| ... } ⇒ Object #chars ⇒ Enumerator
strio.each_char {|char| block } -> strio
strio.each_char -> anEnumerator
See IO#each_char.
838 839 840 841 842 843 844 845 846 847 848 849 |
# File 'stringio.c', line 838
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;
}
|
#codepoints {|c| ... } ⇒ Object #codepoints ⇒ Enumerator
strio.each_codepoint {|c| block } -> strio
strio.each_codepoint -> anEnumerator
See IO#each_codepoint.
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 |
# File 'stringio.c', line 861
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(StringIO(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
strio.lines(sep=$/) {|line| block } -> strio
strio.lines(limit) {|line| block } -> strio
strio.lines(sep,limit) {|line| block } -> strio
strio.lines(...) -> anEnumerator
See IO#each.
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 |
# File 'stringio.c', line 1064
static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
struct StringIO *ptr = StringIO(self);
VALUE line;
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(ptr)))) {
rb_yield(line);
}
return self;
}
|
#eof ⇒ Boolean #eof? ⇒ Boolean
Returns true if strio is at end of file. The stringio must be opened for reading or an IOError
will be raised.
428 429 430 431 432 433 434 |
# File 'stringio.c', line 428
static VALUE
strio_eof(VALUE self)
{
struct StringIO *ptr = readable(StringIO(self));
if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
return Qtrue;
}
|
#eof ⇒ Boolean #eof? ⇒ Boolean
Returns true if strio is at end of file. The stringio must be opened for reading or an IOError
will be raised.
428 429 430 431 432 433 434 |
# File 'stringio.c', line 428
static VALUE
strio_eof(VALUE self)
{
struct StringIO *ptr = readable(StringIO(self));
if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
return Qtrue;
}
|
#external_encoding ⇒ Encoding
Returns the Encoding object that represents the encoding of the file. If strio is write mode and no encoding is specified, returns nil
.
1361 1362 1363 1364 1365 |
# File 'stringio.c', line 1361
static VALUE
strio_external_encoding(VALUE self)
{
return rb_enc_from_encoding(rb_enc_get(StringIO(self)->string));
}
|
#fcntl ⇒ Object
#fileno ⇒ Object
#flush ⇒ Object
#fsync ⇒ Object
#getbyte ⇒ Fixnum?
See IO#getbyte.
671 672 673 674 675 676 677 678 679 680 681 |
# File 'stringio.c', line 671
static VALUE
strio_getbyte(VALUE self)
{
struct StringIO *ptr = readable(StringIO(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.
648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 |
# File 'stringio.c', line 648
static VALUE
strio_getc(VALUE self)
{
struct StringIO *ptr = readable(StringIO(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.
1020 1021 1022 1023 1024 1025 1026 1027 |
# File 'stringio.c', line 1020
static VALUE
strio_gets(int argc, VALUE *argv, VALUE self)
{
VALUE str = strio_getline(argc, argv, readable(StringIO(self)));
rb_lastline_set(str);
return str;
}
|
#initialize_copy ⇒ Object
:nodoc:
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 |
# File 'stringio.c', line 437
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);
++ptr->count;
return copy;
}
|
#internal_encoding ⇒ Encoding
Returns the Encoding of the internal string if conversion is specified. Otherwise returns nil.
1375 1376 1377 1378 1379 |
# File 'stringio.c', line 1375
static VALUE
strio_internal_encoding(VALUE self)
{
return Qnil;
}
|
#isatty ⇒ Object
#size ⇒ Integer
Returns the size of the buffer string.
1320 1321 1322 1323 1324 1325 1326 1327 1328 |
# File 'stringio.c', line 1320
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 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.
464 465 466 467 468 |
# File 'stringio.c', line 464
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.
477 478 479 480 481 482 |
# File 'stringio.c', line 477
static VALUE
strio_set_lineno(VALUE self, VALUE lineno)
{
StringIO(self)->lineno = NUM2LONG(lineno);
return lineno;
}
|
#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
strio.lines(sep=$/) {|line| block } -> strio
strio.lines(limit) {|line| block } -> strio
strio.lines(sep,limit) {|line| block } -> strio
strio.lines(...) -> anEnumerator
See IO#each.
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 |
# File 'stringio.c', line 1064
static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
struct StringIO *ptr = StringIO(self);
VALUE line;
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(ptr)))) {
rb_yield(line);
}
return self;
}
|
#pid ⇒ Object
#pos ⇒ Integer #tell ⇒ Integer
Returns the current offset (in bytes) of strio.
522 523 524 525 526 |
# File 'stringio.c', line 522
static VALUE
strio_get_pos(VALUE self)
{
return LONG2NUM(StringIO(self)->pos);
}
|
#pos=(integer) ⇒ Integer
Seeks to the given position (in bytes) in strio.
534 535 536 537 538 539 540 541 542 543 544 |
# File 'stringio.c', line 534
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.
1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 |
# File 'stringio.c', line 1184
static VALUE
strio_putc(VALUE self, VALUE ch)
{
struct StringIO *ptr = writable(StringIO(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 [, buffer]]) ⇒ String?
See IO#read.
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 |
# File 'stringio.c', line 1216
static VALUE
strio_read(int argc, VALUE *argv, VALUE self)
{
struct StringIO *ptr = readable(StringIO(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.
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 |
# File 'stringio.c', line 1091
static VALUE
strio_readlines(int argc, VALUE *argv, VALUE self)
{
struct StringIO *ptr = StringIO(self);
VALUE ary = rb_ary_new(), line;
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(ptr)))) {
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).
504 505 506 507 508 509 510 511 512 513 |
# File 'stringio.c', line 504
static VALUE
strio_reopen(int argc, VALUE *argv, VALUE self)
{
rb_io_taint_check(self);
if (argc == 1 && TYPE(*argv) != T_STRING) {
return strio_copy(self, *argv);
}
strio_init(argc, argv, StringIO(self));
return self;
}
|
#rewind ⇒ 0
Positions strio to the beginning of input, resetting lineno
to zero.
553 554 555 556 557 558 559 560 |
# File 'stringio.c', line 553
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).
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 |
# File 'stringio.c', line 569
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(ptr)) {
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.
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 |
# File 'stringio.c', line 1391
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;
}
|
#size ⇒ Integer
Returns the size of the buffer string.
1320 1321 1322 1323 1324 1325 1326 1327 1328 |
# File 'stringio.c', line 1320
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.
298 299 300 301 302 |
# File 'stringio.c', line 298
static VALUE
strio_get_string(VALUE self)
{
return StringIO(self)->string;
}
|
#string=(string) ⇒ String
Changes underlying String object, the subject of IO.
310 311 312 313 314 315 316 317 318 319 320 321 322 |
# File 'stringio.c', line 310
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.
606 607 608 609 610 611 |
# File 'stringio.c', line 606
static VALUE
strio_get_sync(VALUE self)
{
StringIO(self);
return Qtrue;
}
|
#sync= ⇒ Object
#tell ⇒ Object
#truncate(integer) ⇒ 0
Truncates the buffer string to at most integer bytes. The strio must be opened for writing.
1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 |
# File 'stringio.c', line 1337
static VALUE
strio_truncate(VALUE self, VALUE len)
{
VALUE string = writable(StringIO(self))->string;
long l = NUM2LONG(len);
long plen = RSTRING_LEN(string);
if (l < 0) {
error_inval("negative legnth");
}
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
764 765 766 767 768 769 770 771 772 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 |
# File 'stringio.c', line 764
static VALUE
strio_ungetbyte(VALUE self, VALUE c)
{
struct StringIO *ptr = readable(StringIO(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;
}
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.
709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 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 |
# File 'stringio.c', line 709
static VALUE
strio_ungetc(VALUE self, VALUE c)
{
struct StringIO *ptr = readable(StringIO(self));
long lpos, clen;
char *p, *pend;
rb_encoding *enc, *enc2;
if (NIL_P(c)) return Qnil;
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.
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 |
# File 'stringio.c', line 1118
static VALUE
strio_write(VALUE self, VALUE str)
{
struct StringIO *ptr = writable(StringIO(self));
long len, olen;
rb_encoding *enc, *enc2;
RB_GC_GUARD(str);
if (TYPE(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);
}
|