phronomy 0.2.1 → 0.2.2

data/vendor/bundle/ruby/3.2.0/gems/stringio-3.2.0/ext/stringio/stringio.c

@@ -1,2110 +0,0 @@
-/* -*- mode: c; indent-tabs-mode: t -*- */
-/**********************************************************************
-
-  stringio.c -
-
-  $Author$
-  $RoughId: stringio.c,v 1.13 2002/03/14 03:24:18 nobu Exp $
-  created at: Tue Feb 19 04:10:38 JST 2002
-
-  All the files in this distribution are covered under the Ruby's
-  license (see the file COPYING).
-
-**********************************************************************/
-
-static const char *const
-STRINGIO_VERSION = "3.2.0";
-
-#include <stdbool.h>
-
-#include "ruby.h"
-#include "ruby/io.h"
-#include "ruby/encoding.h"
-#include "ruby/version.h"
-#if defined(HAVE_FCNTL_H) || defined(_WIN32)
-#include <fcntl.h>
-#elif defined(HAVE_SYS_FCNTL_H)
-#include <sys/fcntl.h>
-#endif
-
-#ifndef RB_INTEGER_TYPE_P
-# define RB_INTEGER_TYPE_P(c) (FIXNUM_P(c) || RB_TYPE_P(c, T_BIGNUM))
-#endif
-
-#ifndef RB_PASS_CALLED_KEYWORDS
-# define rb_funcallv_kw(recv, mid, arg, argv, kw_splat) rb_funcallv(recv, mid, arg, argv)
-# define rb_class_new_instance_kw(argc, argv, klass, kw_splat) rb_class_new_instance(argc, argv, klass)
-#endif
-
-static inline bool
-str_chilled_p(VALUE str)
-{
-#if (RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR >= 4) || RUBY_API_VERSION_MAJOR >= 4
-    // Do not attempt to modify chilled strings on Ruby 3.4+
-    // RUBY_FL_USER2 == STR_CHILLED_LITERAL
-    // RUBY_FL_USER3 == STR_CHILLED_SYMBOL_TO_S
-    return FL_TEST_RAW(str, RUBY_FL_USER2 | RUBY_FL_USER3);
-#else
-    return false;
-#endif
-}
-
-#ifndef HAVE_TYPE_RB_IO_MODE_T
-typedef int rb_io_mode_t;
-#endif
-
-struct StringIO {
-    VALUE string;
-    rb_encoding *enc;
-    long pos;
-    long lineno;
-    rb_io_mode_t flags;
-    int count;
-};
-
-static VALUE strio_init(int, VALUE *, struct StringIO *, VALUE);
-static VALUE strio_unget_bytes(struct StringIO *, const char *, long);
-static long strio_write(VALUE self, VALUE str);
-
-#define IS_STRIO(obj) (rb_typeddata_is_kind_of((obj), &strio_data_type))
-#define error_inval(msg) (rb_syserr_fail(EINVAL, msg))
-#define get_enc(ptr) ((ptr)->enc ? (ptr)->enc : !NIL_P((ptr)->string) ? rb_enc_get((ptr)->string) : NULL)
-
-static bool
-readonly_string_p(VALUE string)
-{
-    return OBJ_FROZEN_RAW(string);
-}
-
-static struct StringIO *
-strio_alloc(void)
-{
-    struct StringIO *ptr = ALLOC(struct StringIO);
-    ptr->string = Qnil;
-    ptr->pos = 0;
-    ptr->lineno = 0;
-    ptr->flags = 0;
-    ptr->count = 1;
-    return ptr;
-}
-
-static void
-strio_mark(void *p)
-{
-    struct StringIO *ptr = p;
-
-    rb_gc_mark(ptr->string);
-}
-
-static void
-strio_free(void *p)
-{
-    struct StringIO *ptr = p;
-    if (--ptr->count <= 0) {
-	xfree(ptr);
-    }
-}
-
-static size_t
-strio_memsize(const void *p)
-{
-    return sizeof(struct StringIO);
-}
-
-static const rb_data_type_t strio_data_type = {
-    "strio",
-    {
-	strio_mark,
-	strio_free,
-	strio_memsize,
-    },
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
-};
-
-#define check_strio(self) ((struct StringIO*)rb_check_typeddata((self), &strio_data_type))
-
-static struct StringIO*
-get_strio(VALUE self)
-{
-    struct StringIO *ptr = check_strio(rb_io_taint_check(self));
-
-    if (!ptr) {
-	rb_raise(rb_eIOError, "uninitialized stream");
-    }
-    return ptr;
-}
-
-static VALUE
-enc_subseq(VALUE str, long pos, long len, rb_encoding *enc)
-{
-    str = rb_str_subseq(str, pos, len);
-    rb_enc_associate(str, enc);
-    return str;
-}
-
-static VALUE
-strio_substr(struct StringIO *ptr, long pos, long len, rb_encoding *enc)
-{
-    VALUE str = ptr->string;
-    long rlen = RSTRING_LEN(str) - pos;
-
-    if (len > rlen) len = rlen;
-    if (len < 0) len = 0;
-    if (len == 0) return rb_enc_str_new(0, 0, enc);
-    return enc_subseq(str, pos, len, enc);
-}
-
-#define StringIO(obj) get_strio(obj)
-
-#define STRIO_READABLE FL_USER4
-#define STRIO_WRITABLE FL_USER5
-#define STRIO_READWRITE (STRIO_READABLE|STRIO_WRITABLE)
-typedef char strio_flags_check[(STRIO_READABLE/FMODE_READABLE == STRIO_WRITABLE/FMODE_WRITABLE) * 2 - 1];
-#define STRIO_MODE_SET_P(strio, mode) \
-    ((RBASIC(strio)->flags & STRIO_##mode) && \
-     ((struct StringIO*)DATA_PTR(strio))->flags & FMODE_##mode)
-#define CLOSED(strio) (!STRIO_MODE_SET_P(strio, READWRITE))
-#define READABLE(strio) STRIO_MODE_SET_P(strio, READABLE)
-#define WRITABLE(strio) STRIO_MODE_SET_P(strio, WRITABLE)
-
-static VALUE sym_exception;
-
-static struct StringIO*
-readable(VALUE strio)
-{
-    struct StringIO *ptr = StringIO(strio);
-    if (!READABLE(strio)) {
-	rb_raise(rb_eIOError, "not opened for reading");
-    }
-    return ptr;
-}
-
-static struct StringIO*
-writable(VALUE strio)
-{
-    struct StringIO *ptr = StringIO(strio);
-    if (!WRITABLE(strio)) {
-	rb_raise(rb_eIOError, "not opened for writing");
-    }
-    return ptr;
-}
-
-static void
-check_modifiable(struct StringIO *ptr)
-{
-    if (NIL_P(ptr->string)) {
-	/* Null device StringIO */
-    }
-    else if (OBJ_FROZEN_RAW(ptr->string)) {
-	rb_raise(rb_eIOError, "not modifiable string");
-    }
-    else {
-	rb_str_modify(ptr->string);
-    }
-}
-
-static inline bool
-outside_p(struct StringIO *ptr, long pos)
-{
-    return NIL_P(ptr->string) || pos >= RSTRING_LEN(ptr->string);
-}
-
-static inline bool
-eos_p(struct StringIO *ptr)
-{
-    return outside_p(ptr, ptr->pos);
-}
-
-static VALUE
-strio_s_allocate(VALUE klass)
-{
-    return TypedData_Wrap_Struct(klass, &strio_data_type, 0);
-}
-
-/*
- * call-seq:
- *   StringIO.new(string = '', mode = 'r+') -> new_stringio
- *
- * Returns a new \StringIO instance formed from +string+ and +mode+;
- * the instance should be closed when no longer needed:
- *
- *   strio = StringIO.new
- *   strio.string        # => ""
- *   strio.closed_read?  # => false
- *   strio.closed_write? # => false
- *   strio.close
- *
- * If +string+ is frozen, the default +mode+ is <tt>'r'</tt>:
- *
- *   strio = StringIO.new('foo'.freeze)
- *   strio.string        # => "foo"
- *   strio.closed_read?  # => false
- *   strio.closed_write? # => true
- *   strio.close
- *
- * Argument +mode+ must be a valid
- * {Access Mode}[https://docs.ruby-lang.org/en/master/File.html#class-File-label-Access+Modes],
- * which may be a string or an integer constant:
- *
- *   StringIO.new('foo', 'w+')
- *   StringIO.new('foo', File::RDONLY)
- *
- * Related: StringIO.open
- * (passes the \StringIO object to the block; closes the object automatically on block exit).
- */
-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);
-}
-
-static int
-detect_bom(VALUE str, int *bomlen)
-{
-    const char *p;
-    long len;
-
-    RSTRING_GETMEM(str, p, len);
-    if (len < 1) return 0;
-    switch ((unsigned char)p[0]) {
-      case 0xEF:
-	if (len < 2) break;
-	if ((unsigned char)p[1] == 0xBB && len > 2) {
-	    if ((unsigned char)p[2] == 0xBF) {
-		*bomlen = 3;
-		return rb_utf8_encindex();
-	    }
-	}
-	break;
-
-      case 0xFE:
-	if (len < 2) break;
-	if ((unsigned char)p[1] == 0xFF) {
-	    *bomlen = 2;
-	    return rb_enc_find_index("UTF-16BE");
-	}
-	break;
-
-      case 0xFF:
-	if (len < 2) break;
-	if ((unsigned char)p[1] == 0xFE) {
-	    if (len >= 4 && (unsigned char)p[2] == 0 && (unsigned char)p[3] == 0) {
-		*bomlen = 4;
-		return rb_enc_find_index("UTF-32LE");
-	    }
-	    *bomlen = 2;
-	    return rb_enc_find_index("UTF-16LE");
-	}
-	break;
-
-      case 0:
-	if (len < 4) break;
-	if ((unsigned char)p[1] == 0 && (unsigned char)p[2] == 0xFE && (unsigned char)p[3] == 0xFF) {
-	    *bomlen = 4;
-	    return rb_enc_find_index("UTF-32BE");
-	}
-	break;
-    }
-    return 0;
-}
-
-static rb_encoding *
-set_encoding_by_bom(struct StringIO *ptr)
-{
-    int bomlen, idx = detect_bom(ptr->string, &bomlen);
-    rb_encoding *extenc = NULL;
-
-    if (idx) {
-	extenc = rb_enc_from_index(idx);
-	ptr->pos = bomlen;
-	if (ptr->flags & FMODE_WRITABLE) {
-	    rb_enc_associate_index(ptr->string, idx);
-	}
-    }
-    ptr->enc = extenc;
-    return extenc;
-}
-
-static VALUE
-strio_init(int argc, VALUE *argv, struct StringIO *ptr, VALUE self)
-{
-    VALUE string, vmode, opt;
-    int oflags;
-    rb_io_enc_t convconfig;
-
-    argc = rb_scan_args(argc, argv, "02:", &string, &vmode, &opt);
-    rb_io_extract_modeenc(&vmode, 0, opt, &oflags, &ptr->flags, &convconfig);
-    if (!NIL_P(string)) {
-	StringValue(string);
-    }
-    else if (!argc) {
-	string = rb_enc_str_new("", 0, rb_default_external_encoding());
-    }
-
-    if (!NIL_P(string) && readonly_string_p(string)) {
-	if (ptr->flags & FMODE_WRITABLE) {
-	    rb_syserr_fail(EACCES, 0);
-	}
-    }
-    else {
-	if (NIL_P(vmode)) {
-	    ptr->flags |= FMODE_WRITABLE;
-	}
-    }
-    if (!NIL_P(string) && (ptr->flags & FMODE_TRUNC)) {
-	rb_str_resize(string, 0);
-    }
-    RB_OBJ_WRITE(self, &ptr->string, string);
-    if (argc == 1 && !NIL_P(string)) {
-	ptr->enc = rb_enc_get(string);
-    }
-    else {
-	ptr->enc = convconfig.enc;
-    }
-    ptr->pos = 0;
-    ptr->lineno = 0;
-    if (ptr->flags & FMODE_SETENC_BY_BOM) set_encoding_by_bom(ptr);
-    RBASIC(self)->flags |= (ptr->flags & FMODE_READWRITE) * (STRIO_READABLE / FMODE_READABLE);
-    return self;
-}
-
-static VALUE
-strio_finalize(VALUE self)
-{
-    struct StringIO *ptr = StringIO(self);
-    RB_OBJ_WRITE(self, &ptr->string, Qnil);
-    ptr->flags &= ~FMODE_READWRITE;
-    return self;
-}
-
-/*
- * call-seq:
- *   StringIO.open(string = '', mode = 'r+') -> new_stringio
- *   StringIO.open(string = '', mode = 'r+') {|strio| ... } -> object
- *
- * Creates new \StringIO instance by calling <tt>StringIO.new(string, mode)</tt>.
- *
- * With no block given, returns the new instance:
- *
- *   strio = StringIO.open # => #<StringIO>
- *
- * With a block given, calls the block with the new instance
- * and returns the block's value;
- * closes the instance on block exit:
- *
- *   StringIO.open('foo') {|strio| strio.string.upcase } # => "FOO"
- *
- * Related: StringIO.new.
- */
-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);
-}
-
-/* :nodoc: */
-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);
-}
-
-/*
- * Returns +false+; for compatibility with IO.
- */
-static VALUE
-strio_false(VALUE self)
-{
-    StringIO(self);
-    return Qfalse;
-}
-
-/*
- * Returns +nil+; for compatibility with IO.
- */
-static VALUE
-strio_nil(VALUE self)
-{
-    StringIO(self);
-    return Qnil;
-}
-
-/*
- * Returns +self+; for compatibility with IO.
- */
-static VALUE
-strio_self(VALUE self)
-{
-    StringIO(self);
-    return self;
-}
-
-/*
- * Returns 0; for compatibility with IO.
- */
-static VALUE
-strio_0(VALUE self)
-{
-    StringIO(self);
-    return INT2FIX(0);
-}
-
-/*
- * Returns the argument unchanged.  Just for compatibility to IO.
- */
-static VALUE
-strio_first(VALUE self, VALUE arg)
-{
-    StringIO(self);
-    return arg;
-}
-
-/*
- * Raises NotImplementedError.
- */
-static VALUE
-strio_unimpl(int argc, VALUE *argv, VALUE self)
-{
-    StringIO(self);
-    rb_notimplement();
-
-    UNREACHABLE;
-}
-
-/*
- * call-seq:
- *   string -> string
- *
- * Returns underlying string:
- *
- *   StringIO.open('foo') do |strio|
- *     p strio.string
- *     strio.string = 'bar'
- *     p strio.string
- *   end
- *
- * Output:
- *
- *   "foo"
- *   "bar"
- *
- * Related: StringIO#string= (assigns the underlying string).
- */
-static VALUE
-strio_get_string(VALUE self)
-{
-    return StringIO(self)->string;
-}
-
-/*
- * call-seq:
- *   string = other_string -> other_string
- *
- * Replaces the stored string with +other_string+, and sets the position to zero;
- * returns +other_string+:
- *
- *   StringIO.open('foo') do |strio|
- *     p strio.string
- *     strio.string = 'bar'
- *     p strio.string
- *   end
- *
- * Output:
- *
- *   "foo"
- *   "bar"
- *
- * Related: StringIO#string (returns the stored string).
- */
-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 = readonly_string_p(string) ? FMODE_READABLE : FMODE_READWRITE;
-    ptr->pos = 0;
-    ptr->lineno = 0;
-    RB_OBJ_WRITE(self, &ptr->string, string);
-    return string;
-}
-
-/*
- * call-seq:
- *   close -> nil
- *
- * Closes +self+ for both reading and writing; returns +nil+:
- *
- *   strio = StringIO.new
- *   strio.closed? # => false
- *   strio.close   # => nil
- *   strio.closed? # => true
- *   strio.read    # Raises IOError: not opened for reading
- *   strio.write   # Raises IOError: not opened for writing
- *
- * Related: StringIO#close_read, StringIO#close_write, StringIO.closed?.
- */
-static VALUE
-strio_close(VALUE self)
-{
-    StringIO(self);
-    RBASIC(self)->flags &= ~STRIO_READWRITE;
-    return Qnil;
-}
-
-/*
- * call-seq:
- *   close_read -> nil
- *
- * Closes +self+ for reading;
- * closed-write setting remains unchanged;
- * returns +nil+:
- *
- *   strio = StringIO.new
- *   strio.closed_read?  # => false
- *   strio.close_read    # => nil
- *   strio.closed_read?  # => true
- *   strio.closed_write? # => false
- *   strio.read          # Raises IOError: not opened for reading
- *
- * Related: StringIO#close, StringIO#close_write.
- */
-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;
-}
-
-/*
- * call-seq:
- *   close_write -> nil
- *
- * Closes +self+ for writing; closed-read setting remains unchanged; returns +nil+:
- *
- *   strio = StringIO.new
- *   strio.closed_write? # => false
- *   strio.close_write   # => nil
- *   strio.closed_write? # => true
- *   strio.closed_read?  # => false
- *   strio.write('foo')  # Raises IOError: not opened for writing
- *
- * Related: StringIO#close, StringIO#close_read, StringIO#closed_write?.
- */
-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;
-}
-
-/*
- * call-seq:
- *   closed? -> true or false
- *
- * Returns whether +self+ is closed for both reading and writing:
- *
- *   strio = StringIO.new
- *   strio.closed?     # => false  # Open for reading and writing.
- *   strio.close_read
- *   strio.closed?     # => false  # Still open for writing.
- *   strio.close_write
- *   strio.closed?     # => true   # Now closed for both.
- *
- * Related: StringIO.closed_read?, StringIO.closed_write?.
- */
-static VALUE
-strio_closed(VALUE self)
-{
-    StringIO(self);
-    if (!CLOSED(self)) return Qfalse;
-    return Qtrue;
-}
-
-/*
- * call-seq:
- *   closed_read? -> true or false
- *
- * Returns whether +self+ is closed for reading:
- *
- *   strio = StringIO.new
- *   strio.closed_read?   # => false
- *   strio.close_read
- *   strio.closed_read?   # => true
- *
- * Related: StringIO#closed?, StringIO#closed_write?, StringIO#close_read.
- */
-static VALUE
-strio_closed_read(VALUE self)
-{
-    StringIO(self);
-    if (READABLE(self)) return Qfalse;
-    return Qtrue;
-}
-
-/*
- * call-seq:
- *   closed_write? -> true or false
- *
- * Returns whether +self+ is closed for writing:
- *
- *   strio = StringIO.new
- *   strio.closed_write? # => false
- *   strio.close_write
- *   strio.closed_write? # => true
- *
- * Related: StringIO#close_write, StringIO#closed?, StringIO#closed_read?.
- */
-static VALUE
-strio_closed_write(VALUE self)
-{
-    StringIO(self);
-    if (WRITABLE(self)) return Qfalse;
-    return Qtrue;
-}
-
-static struct StringIO *
-strio_to_read(VALUE self)
-{
-    struct StringIO *ptr = readable(self);
-    if (eos_p(ptr)) return NULL;
-    return ptr;
-}
-
-/*
- * call-seq:
- *   eof? -> true or false
- *
- * Returns whether +self+ is positioned at end-of-stream:
- *
- *   strio = StringIO.new('foo')
- *   strio.pos  # => 0
- *   strio.eof? # => false
- *   strio.read # => "foo"
- *   strio.pos  # => 3
- *   strio.eof? # => true
- *   strio.close_read
- *   strio.eof? # Raises IOError: not opened for reading
- *
- * Related: StringIO#pos.
- */
-static VALUE
-strio_eof(VALUE self)
-{
-    if (strio_to_read(self)) return Qfalse;
-    return Qtrue;
-}
-
-/* :nodoc: */
-static VALUE
-strio_copy(VALUE copy, VALUE orig)
-{
-    struct StringIO *ptr, *old_ptr;
-    VALUE old_string = Qundef;
-
-    orig = rb_convert_type(orig, T_DATA, "StringIO", "to_strio");
-    if (copy == orig) return copy;
-    ptr = StringIO(orig);
-    old_ptr = check_strio(copy);
-    if (old_ptr) {
-	old_string = old_ptr->string;
-	strio_free(old_ptr);
-    }
-    DATA_PTR(copy) = ptr;
-    RB_OBJ_WRITTEN(copy, old_string, ptr->string);
-    RBASIC(copy)->flags &= ~STRIO_READWRITE;
-    RBASIC(copy)->flags |= RBASIC(orig)->flags & STRIO_READWRITE;
-    ++ptr->count;
-    return copy;
-}
-
-/*
- * call-seq:
- *   lineno -> current_line_number
- *
- * Returns the current line number in +self+;
- * see {Line Number}[rdoc-ref:StringIO@Line+Number].
- */
-static VALUE
-strio_get_lineno(VALUE self)
-{
-    return LONG2NUM(StringIO(self)->lineno);
-}
-
-/*
- * call-seq:
- *   lineno = new_line_number -> new_line_number
- *
- * Sets the current line number in +self+ to the given +new_line_number+;
- * see {Line Number}[rdoc-ref:StringIO@Line+Number].
- */
-static VALUE
-strio_set_lineno(VALUE self, VALUE lineno)
-{
-    StringIO(self)->lineno = NUM2LONG(lineno);
-    return lineno;
-}
-
-/*
- * call-seq:
- *   binmode -> self
- *
- * Sets the data mode in +self+ to binary mode;
- * see {Data Mode}[rdoc-ref:StringIO@Data+Mode].
- *
- */
-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;
-}
-
-#define strio_fcntl strio_unimpl
-
-#define strio_flush strio_self
-
-#define strio_fsync strio_0
-
-/*
- * call-seq:
- *   reopen(other, mode = 'r+') -> self
- *
- * Reinitializes the stream with the given +other+ (string or StringIO) and +mode+;
- * see IO.new:
- *
- *   StringIO.open('foo') do |strio|
- *     p strio.string
- *     strio.reopen('bar')
- *     p strio.string
- *     other_strio = StringIO.new('baz')
- *     strio.reopen(other_strio)
- *     p strio.string
- *     other_strio.close
- *   end
- *
- * Output:
- *
- *   "foo"
- *   "bar"
- *   "baz"
- *
- */
-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);
-}
-
-/*
- * call-seq:
- *   pos -> stream_position
- *
- * Returns the current position (in bytes);
- * see {Position}[rdoc-ref:StringIO@Position].
- */
-static VALUE
-strio_get_pos(VALUE self)
-{
-    return LONG2NUM(StringIO(self)->pos);
-}
-
-/*
- * call-seq:
- *   pos = new_position -> new_position
- *
- * Sets the current position (in bytes);
- * see {Position}[rdoc-ref:StringIO@Position].
- */
-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;
-}
-
-/*
- * call-seq:
- *   rewind -> 0
- *
- * Sets the current position and line number to zero;
- * see {Position}[rdoc-ref:IO@Position]
- * and {Line Number}[rdoc-ref:IO@Line+Number].
- */
-static VALUE
-strio_rewind(VALUE self)
-{
-    struct StringIO *ptr = StringIO(self);
-    ptr->pos = 0;
-    ptr->lineno = 0;
-    return INT2FIX(0);
-}
-
-/*
- * call-seq:
- *   seek(offset, whence = SEEK_SET) -> 0
- *
- * Sets the position to the given integer +offset+ (in bytes),
- * with respect to a given constant +whence+;
- * see {IO#seek}[https://docs.ruby-lang.org/en/master/IO.html#method-i-seek].
- */
-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:
-	if (NIL_P(ptr->string)) {
-	    offset = 0;
-	} else {
-	    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);
-}
-
-/*
- * call-seq:
- *   sync -> true
- *
- * Returns +true+; implemented only for compatibility with other stream classes.
- */
-static VALUE
-strio_get_sync(VALUE self)
-{
-    StringIO(self);
-    return Qtrue;
-}
-
-#define strio_set_sync strio_first
-
-#define strio_tell strio_get_pos
-
-/*
- * call-seq:
- *   each_byte {|byte| ... } -> self
- *
- * :include: stringio/each_byte.rdoc
- *
- * Related: StringIO#each_char, StringIO#each_codepoint, StringIO#each_line.
- */
-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;
-}
-
-/*
- * call-seq:
- *   getc -> character, byte, or nil
- *
- * :include: stringio/getc.rdoc
- *
- */
-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 (eos_p(ptr)) {
-	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);
-}
-
-/*
- * call-seq:
- *   getbyte -> integer or nil
- *
- * :include: stringio/getbyte.rdoc
- *
- */
-static VALUE
-strio_getbyte(VALUE self)
-{
-    struct StringIO *ptr = readable(self);
-    int c;
-    if (eos_p(ptr)) {
-	return Qnil;
-    }
-    c = RSTRING_PTR(ptr->string)[ptr->pos++];
-    return CHR2FIX(c);
-}
-
-static void
-strio_extend(struct StringIO *ptr, long pos, long len)
-{
-    long olen;
-
-    if (len > LONG_MAX - pos)
-	rb_raise(rb_eArgError, "string size too big");
-
-    check_modifiable(ptr);
-    olen = RSTRING_LEN(ptr->string);
-    if (pos + len > olen) {
-	rb_str_resize(ptr->string, pos + len);
-	if (pos > olen)
-	    MEMZERO(RSTRING_PTR(ptr->string) + olen, char, pos - olen);
-    }
-}
-
-static void
-strio_unget_string(struct StringIO *ptr, VALUE c)
-{
-    const char *cp = NULL;
-    long cl = RSTRING_LEN(c);
-    if (cl > 0) {
-	if (c != ptr->string) cp = RSTRING_PTR(c);
-	strio_unget_bytes(ptr, cp, cl);
-	RB_GC_GUARD(c);
-    }
-}
-
-/*
- * call-seq:
- *   ungetc(character) -> nil
- *
- * Pushes back ("unshifts") a character or integer onto the stream;
- * see {Character IO}[rdoc-ref:IO@Character+IO].
- */
-static VALUE
-strio_ungetc(VALUE self, VALUE c)
-{
-    struct StringIO *ptr = readable(self);
-    rb_encoding *enc, *enc2;
-
-    check_modifiable(ptr);
-    if (NIL_P(ptr->string)) return Qnil;
-    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); /* to raise an exception */
-	    UNREACHABLE;
-	}
-	rb_enc_mbcput(cc, buf, enc);
-	return strio_unget_bytes(ptr, buf, len);
-    }
-    else {
-	StringValue(c);
-	if (RSTRING_LEN(c) == 0) return Qnil;
-	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_string(ptr, c);
-	return Qnil;
-    }
-}
-
-/*
- * call-seq:
- *   ungetbyte(byte) -> nil
- *
- * Pushes back ("unshifts") an 8-bit byte onto the stream;
- * see {Byte IO}[rdoc-ref:IO@Byte+IO].
- */
-static VALUE
-strio_ungetbyte(VALUE self, VALUE c)
-{
-    struct StringIO *ptr = readable(self);
-
-    check_modifiable(ptr);
-    if (NIL_P(ptr->string)) return Qnil;
-    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 {
-	StringValue(c);
-	strio_unget_string(ptr, c);
-    }
-    return Qnil;
-}
-
-static VALUE
-strio_unget_bytes(struct StringIO *ptr, const char *cp, long cl)
-{
-    long pos = ptr->pos, len, rest;
-    VALUE str = ptr->string;
-    char *s;
-
-    len = RSTRING_LEN(str);
-    rest = pos - len;
-    if (cl > pos) {
-	long ex = cl - (rest < 0 ? pos : len);
-	rb_str_modify_expand(str, ex);
-	rb_str_set_len(str, len + ex);
-	s = RSTRING_PTR(str);
-	if (rest < 0) memmove(s + cl, s + pos, -rest);
-	pos = 0;
-    }
-    else {
-	if (rest > 0) {
-	    rb_str_modify_expand(str, rest);
-	    rb_str_set_len(str, len + rest);
-	}
-	s = RSTRING_PTR(str);
-	if (rest > cl) memset(s + len, 0, rest - cl);
-	pos -= cl;
-    }
-    memcpy(s + pos, (cp ? cp : s), cl);
-    ptr->pos = pos;
-    return Qnil;
-}
-
-/*
- * call-seq:
- *   readchar -> string
- *
- * Like +getc+, but raises an exception if already at end-of-stream;
- * see {Character IO}[rdoc-ref:IO@Character+IO].
- */
-static VALUE
-strio_readchar(VALUE self)
-{
-    VALUE c = rb_funcallv(self, rb_intern("getc"), 0, 0);
-    if (NIL_P(c)) rb_eof_error();
-    return c;
-}
-
-/*
- * call-seq:
- *   readbyte -> byte
- *
- * Like +getbyte+, but raises an exception if already at end-of-stream;
- * see {Byte IO}[rdoc-ref:IO@Byte+IO].
- */
-static VALUE
-strio_readbyte(VALUE self)
-{
-    VALUE c = rb_funcallv(self, rb_intern("getbyte"), 0, 0);
-    if (NIL_P(c)) rb_eof_error();
-    return c;
-}
-
-/*
- * call-seq:
- *   each_char {|char| ... } -> self
- *
- * :include: stringio/each_char.rdoc
- *
- * Related: StringIO#each_byte, StringIO#each_codepoint, StringIO#each_line.
- */
-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;
-}
-
-/*
- * call-seq:
- *   each_codepoint {|codepoint| ... } -> self
- *
- * :include: stringio/each_codepoint.rdoc
- *
- * Related: StringIO#each_byte, StringIO#each_char, StringIO#each_line.
- */
-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;
-}
-
-/* Boyer-Moore search: copied from regex.c */
-static void
-bm_init_skip(long *skip, const char *pat, long m)
-{
-    int c;
-
-    for (c = 0; c < (1 << CHAR_BIT); c++) {
-	skip[c] = m;
-    }
-    while (--m) {
-	skip[(unsigned char)*pat++] = m;
-    }
-}
-
-static long
-bm_search(const char *little, long llen, const char *big, long blen, const long *skip)
-{
-    long i, j, k;
-
-    i = llen - 1;
-    while (i < blen) {
-	k = i;
-	j = llen - 1;
-	while (j >= 0 && big[k] == little[j]) {
-	    k--;
-	    j--;
-	}
-	if (j < 0) return k + 1;
-	i += skip[(unsigned char)big[i]];
-    }
-    return -1;
-}
-
-struct getline_arg {
-    VALUE rs;
-    long limit;
-    unsigned int chomp: 1;
-};
-
-static struct getline_arg *
-prepare_getline_args(struct StringIO *ptr, struct getline_arg *arg, int argc, VALUE *argv)
-{
-    VALUE rs, lim, opts;
-    long limit = -1;
-    int respect_chomp;
-
-    argc = rb_scan_args(argc, argv, "02:", &rs, &lim, &opts);
-    respect_chomp = argc == 0 || !NIL_P(rs);
-    switch (argc) {
-      case 0:
-	rs = rb_rs;
-	break;
-
-      case 1:
-	if (!NIL_P(rs) && !RB_TYPE_P(rs, T_STRING)) {
-	    VALUE tmp = rb_check_string_type(rs);
-	    if (NIL_P(tmp)) {
-		limit = NUM2LONG(rs);
-		rs = rb_rs;
-	    }
-	    else {
-		rs = tmp;
-	    }
-	}
-	break;
-
-      case 2:
-	if (!NIL_P(rs)) StringValue(rs);
-	if (!NIL_P(lim)) limit = NUM2LONG(lim);
-	break;
-    }
-    if (!NIL_P(ptr->string) && !NIL_P(rs)) {
-	rb_encoding *enc_rs, *enc_io;
-	enc_rs = rb_enc_get(rs);
-	enc_io = get_enc(ptr);
-	if (enc_rs != enc_io &&
-	    (rb_enc_str_coderange(rs) != ENC_CODERANGE_7BIT ||
-	     (RSTRING_LEN(rs) > 0 && !rb_enc_asciicompat(enc_io)))) {
-	    if (rs == rb_rs) {
-		rs = rb_enc_str_new(0, 0, enc_io);
-		rb_str_buf_cat_ascii(rs, "\n");
-		rs = rs;
-	    }
-	    else {
-		rb_raise(rb_eArgError, "encoding mismatch: %s IO with %s RS",
-			 rb_enc_name(enc_io),
-			 rb_enc_name(enc_rs));
-	    }
-	}
-    }
-    arg->rs = rs;
-    arg->limit = limit;
-    arg->chomp = 0;
-    if (!NIL_P(opts)) {
-	static ID keywords[1];
-	VALUE vchomp;
-	if (!keywords[0]) {
-	    keywords[0] = rb_intern_const("chomp");
-	}
-	rb_get_kwargs(opts, keywords, 0, 1, &vchomp);
-	if (respect_chomp) {
-	    arg->chomp = (vchomp != Qundef) && RTEST(vchomp);
-	}
-    }
-    return arg;
-}
-
-static inline int
-chomp_newline_width(const char *s, const char *e)
-{
-    if (e > s && *--e == '\n') {
-	if (e > s && *--e == '\r') return 2;
-	return 1;
-    }
-    return 0;
-}
-
-static VALUE
-strio_getline(struct getline_arg *arg, struct StringIO *ptr)
-{
-    const char *s, *e, *p;
-    long n, limit = arg->limit;
-    VALUE str = arg->rs;
-    long w = 0;
-    rb_encoding *enc = get_enc(ptr);
-
-    if (NIL_P(ptr->string) || ptr->pos >= (n = RSTRING_LEN(ptr->string))) {
-	return Qnil;
-    }
-    s = RSTRING_PTR(ptr->string);
-    e = s + RSTRING_LEN(ptr->string);
-    s += ptr->pos;
-    if (limit > 0 && (size_t)limit < (size_t)(e - s)) {
-	e = rb_enc_right_char_head(s, s + limit, e, get_enc(ptr));
-    }
-    if (NIL_P(str)) {
-	if (arg->chomp) {
-	    w = chomp_newline_width(s, e);
-	}
-	str = strio_substr(ptr, ptr->pos, e - s - w, enc);
-    }
-    else if ((n = RSTRING_LEN(str)) == 0) {
-	const char *paragraph_end = NULL;
-	p = s;
-	while (p[(p + 1 < e) && (*p == '\r') && 0] == '\n') {
-	    p += *p == '\r';
-	    if (++p == e) {
-		return Qnil;
-	    }
-	}
-	s = p;
-	while ((p = memchr(p, '\n', e - p)) && (p != e)) {
-	    p++;
-	    if (!((p < e && *p == '\n') ||
-		  (p + 1 < e && *p == '\r' && *(p+1) == '\n'))) {
-		continue;
-	    }
-	    paragraph_end = p - ((*(p-2) == '\r') ? 2 : 1);
-	    while ((p < e && *p == '\n') ||
-		   (p + 1 < e && *p == '\r' && *(p+1) == '\n')) {
-		p += (*p == '\r') ? 2 : 1;
-	    }
-	    e = p;
-	    break;
-	}
-	if (arg->chomp && paragraph_end) {
-	    w = e - paragraph_end;
-	}
-	str = strio_substr(ptr, s - RSTRING_PTR(ptr->string), e - s - w, enc);
-    }
-    else if (n == 1) {
-	if ((p = memchr(s, RSTRING_PTR(str)[0], e - s)) != 0) {
-	    e = p + 1;
-	    w = (arg->chomp ? (p > s && *(p-1) == '\r') + 1 : 0);
-	}
-	str = strio_substr(ptr, ptr->pos, e - s - w, enc);
-    }
-    else {
-	if (n < e - s + arg->chomp) {
-	    /* unless chomping, RS at the end does not matter */
-	    if (e - s < 1024 || n == e - s) {
-		for (p = s; p + n <= e; ++p) {
-		    if (MEMCMP(p, RSTRING_PTR(str), char, n) == 0) {
-			e = p + n;
-			w = (arg->chomp ? n : 0);
-			break;
-		    }
-		}
-	    }
-	    else {
-		long skip[1 << CHAR_BIT], pos;
-		p = RSTRING_PTR(str);
-		bm_init_skip(skip, p, n);
-		if ((pos = bm_search(p, n, s, e - s, skip)) >= 0) {
-		    e = s + pos + (arg->chomp ? 0 : n);
-		}
-	    }
-	}
-	str = strio_substr(ptr, ptr->pos, e - s - w, enc);
-    }
-    ptr->pos = e - RSTRING_PTR(ptr->string);
-    ptr->lineno++;
-    return str;
-}
-
-/*
- * call-seq:
- *   gets(sep = $/, chomp: false) -> string or nil
- *   gets(limit, chomp: false) -> string or nil
- *   gets(sep, limit, chomp: false) -> string or nil
- *
- * :include: stringio/gets.rdoc
- *
- */
-static VALUE
-strio_gets(int argc, VALUE *argv, VALUE self)
-{
-    struct StringIO *ptr = readable(self);
-    struct getline_arg arg;
-    VALUE str;
-
-    if (prepare_getline_args(ptr, &arg, argc, argv)->limit == 0) {
-	if (NIL_P(ptr->string)) return Qnil;
-	return rb_enc_str_new(0, 0, get_enc(ptr));
-    }
-
-    str = strio_getline(&arg, ptr);
-    rb_lastline_set(str);
-    return str;
-}
-
-/*
- * call-seq:
- *   readline(sep = $/, chomp: false) -> string
- *   readline(limit, chomp: false) -> string
- *   readline(sep, limit, chomp: false) -> string
- *
- * Reads a line as with IO#gets, but raises EOFError if already at end-of-file;
- * see {Line IO}[rdoc-ref:IO@Line+IO].
- */
-static VALUE
-strio_readline(int argc, VALUE *argv, VALUE self)
-{
-    VALUE line = rb_funcallv_kw(self, rb_intern("gets"), argc, argv, RB_PASS_CALLED_KEYWORDS);
-    if (NIL_P(line)) rb_eof_error();
-    return line;
-}
-
-/*
- * :markup: markdown
- *
- * call-seq:
- *   each_line(sep = $/, chomp: false) {|line| ... }   -> self
- *   each_line(limit, chomp: false) {|line| ... }      -> self
- *   each_line(sep, limit, chomp: false) {|line| ... } -> self
- *
- * :include: stringio/each_line.md
- *
- */
-static VALUE
-strio_each(int argc, VALUE *argv, VALUE self)
-{
-    VALUE line;
-    struct StringIO *ptr = readable(self);
-    struct getline_arg arg;
-
-    RETURN_ENUMERATOR(self, argc, argv);
-
-    if (prepare_getline_args(ptr, &arg, argc, argv)->limit == 0) {
-	rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
-    }
-
-    while (!NIL_P(line = strio_getline(&arg, ptr))) {
-	rb_yield(line);
-    }
-    return self;
-}
-
-/*
- * call-seq:
- *   strio.readlines(sep=$/, chomp: false)     ->   array
- *   strio.readlines(limit, chomp: false)      ->   array
- *   strio.readlines(sep, limit, chomp: false) ->   array
- *
- * See IO#readlines.
- */
-static VALUE
-strio_readlines(int argc, VALUE *argv, VALUE self)
-{
-    VALUE ary, line;
-    struct StringIO *ptr = readable(self);
-    struct getline_arg arg;
-
-    if (prepare_getline_args(ptr, &arg, argc, argv)->limit == 0) {
-	rb_raise(rb_eArgError, "invalid limit: 0 for readlines");
-    }
-
-    ary = rb_ary_new();
-    while (!NIL_P(line = strio_getline(&arg, ptr))) {
-	rb_ary_push(ary, line);
-    }
-    return ary;
-}
-
-/*
- * call-seq:
- *   strio.write(string, ...) -> integer
- *   strio.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 <code>to_s</code>.
- * Returns the number of bytes written.  See IO#write.
- */
-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);
-}
-
-static long
-strio_write(VALUE self, VALUE str)
-{
-    struct StringIO *ptr = writable(self);
-    long len, olen;
-    rb_encoding *enc, *enc2;
-    rb_encoding *const ascii8bit = rb_ascii8bit_encoding();
-    rb_encoding *usascii = 0;
-
-    if (!RB_TYPE_P(str, T_STRING))
-	str = rb_obj_as_string(str);
-    enc = get_enc(ptr);
-    if (!enc) return 0;
-    enc2 = rb_enc_get(str);
-    if (enc != enc2 && enc != ascii8bit && enc != (usascii = rb_usascii_encoding())) {
-	VALUE converted = rb_str_conv_enc(str, enc2, enc);
-	if (converted == str && enc2 != ascii8bit && enc2 != usascii) { /* conversion failed */
-	    rb_enc_check(rb_enc_from_encoding(enc), str);
-	}
-	str = converted;
-    }
-    len = RSTRING_LEN(str);
-    if (len == 0) return 0;
-    check_modifiable(ptr);
-    olen = RSTRING_LEN(ptr->string);
-    if (ptr->flags & FMODE_APPEND) {
-	ptr->pos = olen;
-    }
-    if (ptr->pos == olen) {
-	if (enc == ascii8bit || enc2 == ascii8bit) {
-	    rb_enc_str_buf_cat(ptr->string, RSTRING_PTR(str), len, enc);
-	}
-	else {
-	    rb_str_buf_append(ptr->string, str);
-	}
-    }
-    else {
-	strio_extend(ptr, ptr->pos, len);
-	rb_str_modify(ptr->string);
-	memmove(RSTRING_PTR(ptr->string)+ptr->pos, RSTRING_PTR(str), len);
-    }
-    RB_GC_GUARD(str);
-    ptr->pos += len;
-    return len;
-}
-
-/*
- * call-seq:
- *   strio << obj     -> strio
- *
- * See IO#<<.
- */
-#define strio_addstr rb_io_addstr
-
-/*
- * call-seq:
- *   strio.print()             -> nil
- *   strio.print(obj, ...)     -> nil
- *
- * See IO#print.
- */
-#define strio_print rb_io_print
-
-/*
- * call-seq:
- *   strio.printf(format_string [, obj, ...] )   -> nil
- *
- * See IO#printf.
- */
-#define strio_printf rb_io_printf
-
-/*
- * call-seq:
- *   strio.putc(obj)    -> obj
- *
- * See IO#putc.
- */
-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)) {
-	if (NIL_P(ptr->string)) return ch;
-	str = rb_str_substr(ch, 0, 1);
-    }
-    else {
-	char c = NUM2CHR(ch);
-	if (NIL_P(ptr->string)) return ch;
-	str = rb_str_new(&c, 1);
-    }
-    strio_write(self, str);
-    return ch;
-}
-
-/*
- * call-seq:
- *   strio.puts(obj, ...)    -> nil
- *
- * See IO#puts.
- */
-#define strio_puts rb_io_puts
-
-/*
- * call-seq:
- *   strio.read([length [, outbuf]])    -> string, outbuf, or nil
- *
- * See IO#read.
- */
-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 (eos_p(ptr)) {
-		if (!NIL_P(str)) rb_str_resize(str, 0);
-		return len > 0 ? Qnil : rb_str_new(0, 0);
-	    }
-	    binary = 1;
-	    break;
-	}
-	/* fall through */
-      case 0:
-	if (NIL_P(ptr->string)) return Qnil;
-	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_copy(str, ptr->string);
-	}
-    }
-    ptr->pos += RSTRING_LEN(str);
-    return str;
-}
-
-/*
- *  call-seq:
- *    pread(maxlen, offset)             -> string
- *    pread(maxlen, offset, out_string) -> string
- *
- *  See IO#pread.
- */
-static VALUE
-strio_pread(int argc, VALUE *argv, VALUE self)
-{
-    VALUE rb_len, rb_offset, rb_buf;
-    rb_scan_args(argc, argv, "21", &rb_len, &rb_offset, &rb_buf);
-    long len = NUM2LONG(rb_len);
-    long offset = NUM2LONG(rb_offset);
-
-    if (len < 0) {
-	rb_raise(rb_eArgError, "negative string size (or size too big): %" PRIsVALUE, rb_len);
-    }
-
-    if (len == 0) {
-	if (NIL_P(rb_buf)) {
-	    return rb_str_new("", 0);
-	}
-	return rb_buf;
-    }
-
-    if (offset < 0) {
-	rb_syserr_fail_str(EINVAL, rb_sprintf("pread: Invalid offset argument: %" PRIsVALUE, rb_offset));
-    }
-
-    struct StringIO *ptr = readable(self);
-
-    if (outside_p(ptr, offset)) {
-	rb_eof_error();
-    }
-
-    if (NIL_P(rb_buf)) {
-	return strio_substr(ptr, offset, len, rb_ascii8bit_encoding());
-    }
-
-    long rest = RSTRING_LEN(ptr->string) - offset;
-    if (len > rest) len = rest;
-    rb_str_resize(rb_buf, len);
-    rb_enc_associate(rb_buf, rb_ascii8bit_encoding());
-    MEMCPY(RSTRING_PTR(rb_buf), RSTRING_PTR(ptr->string) + offset, char, len);
-    return rb_buf;
-}
-
-
-/*
- * call-seq:
- *   strio.sysread(integer[, outbuf])    -> string
- *   strio.readpartial(integer[, outbuf])    -> string
- *
- * Similar to #read, but raises +EOFError+ at end of string instead of
- * returning +nil+, as well as IO#sysread does.
- */
-static VALUE
-strio_sysread(int argc, VALUE *argv, VALUE self)
-{
-    VALUE val = rb_funcallv_kw(self, rb_intern("read"), argc, argv, RB_PASS_CALLED_KEYWORDS);
-    if (NIL_P(val)) {
-	rb_eof_error();
-    }
-    return val;
-}
-
-/*
- * call-seq:
- *   strio.read_nonblock(integer[, outbuf [, opts]])    -> string
- *
- * Similar to #read, but raises +EOFError+ at end of string unless the
- * +exception: false+ option is passed in.
- */
-static VALUE
-strio_read_nonblock(int argc, VALUE *argv, VALUE self)
-{
-    VALUE opts = Qnil, val;
-
-    rb_scan_args(argc, argv, "11:", NULL, NULL, &opts);
-
-    if (!NIL_P(opts)) {
-	argc--;
-    }
-
-    val = strio_read(argc, argv, self);
-    if (NIL_P(val)) {
-	if (!NIL_P(opts) &&
-	      rb_hash_lookup2(opts, sym_exception, Qundef) == Qfalse)
-	    return Qnil;
-	else
-	    rb_eof_error();
-    }
-
-    return val;
-}
-
-/*
- * See IO#write
- */
-#define strio_syswrite rb_io_write
-
-/*
- * See IO#write_nonblock
- */
-static VALUE
-strio_syswrite_nonblock(int argc, VALUE *argv, VALUE self)
-{
-    VALUE str;
-
-    rb_scan_args(argc, argv, "10:", &str, NULL);
-    return strio_syswrite(self, str);
-}
-
-#define strio_isatty strio_false
-
-#define strio_pid strio_nil
-
-#define strio_fileno strio_nil
-
-/*
- * call-seq:
- *   size -> integer
- *
- * :include: stringio/size.rdoc
- *
- */
-static VALUE
-strio_size(VALUE self)
-{
-    VALUE string = StringIO(self)->string;
-    if (NIL_P(string)) {
-	return INT2FIX(0);
-    }
-    return ULONG2NUM(RSTRING_LEN(string));
-}
-
-/*
- * call-seq:
- *   strio.truncate(integer)    -> 0
- *
- * Truncates the buffer string to at most _integer_ bytes. The stream
- * must be opened for writing.
- */
-static VALUE
-strio_truncate(VALUE self, VALUE len)
-{
-    VALUE string = writable(self)->string;
-    long l = NUM2LONG(len);
-    long plen;
-    if (l < 0) {
-	error_inval("negative length");
-    }
-    if (NIL_P(string)) return 0;
-    plen = RSTRING_LEN(string);
-    rb_str_resize(string, l);
-    if (plen < l) {
-	MEMZERO(RSTRING_PTR(string) + plen, char, l - plen);
-    }
-    return INT2FIX(0);
-}
-
-/*
- * call-seq:
- *   external_encoding -> encoding or nil
- *
- * Returns an Encoding object that represents the encoding of the string;
- * see {Encodings}[rdoc-ref:StringIO@Encodings]:
- *
- *   strio = StringIO.new('foo')
- *   strio.external_encoding # => #<Encoding:UTF-8>
- *
- * Returns +nil+ if +self+ has no string and is in write mode:
- *
- *   strio = StringIO.new(nil, 'w+')
- *   strio.external_encoding # => nil
- *
- */
-
-static VALUE
-strio_external_encoding(VALUE self)
-{
-    struct StringIO *ptr = StringIO(self);
-    return rb_enc_from_encoding(get_enc(ptr));
-}
-
-/*
- *  call-seq:
- *     internal_encoding -> nil
- *
- *  Returns +nil+; for compatibility with IO.
- */
-
-static VALUE
-strio_internal_encoding(VALUE self)
-{
-    return Qnil;
-}
-
-/*
- *  call-seq:
- *     strio.set_encoding(ext_enc, [int_enc[, opt]])  => strio
- *
- *  Specify the encoding of the StringIO as <i>ext_enc</i>.
- *  Use the default external encoding if <i>ext_enc</i> is nil.
- *  2nd argument <i>int_enc</i> and optional hash <i>opt</i> argument
- *  are ignored; they are for API compatibility to IO.
- */
-
-static VALUE
-strio_set_encoding(int argc, VALUE *argv, VALUE self)
-{
-    rb_encoding* enc;
-    struct StringIO *ptr = StringIO(self);
-    VALUE ext_enc, int_enc, opt;
-
-    argc = rb_scan_args(argc, argv, "11:", &ext_enc, &int_enc, &opt);
-
-    if (NIL_P(ext_enc)) {
-	enc = rb_default_external_encoding();
-    }
-    else {
-	enc = rb_find_encoding(ext_enc);
-	if (!enc) {
-	    rb_io_enc_t convconfig;
-	    int oflags;
-	    rb_io_mode_t fmode;
-	    VALUE vmode = rb_str_append(rb_str_new_cstr("r:"), ext_enc);
-	    rb_io_extract_modeenc(&vmode, 0, Qnil, &oflags, &fmode, &convconfig);
-	    enc = convconfig.enc2;
-	}
-    }
-    ptr->enc = enc;
-    if (!NIL_P(ptr->string) && WRITABLE(self) && !str_chilled_p(ptr->string)) {
-	rb_enc_associate(ptr->string, enc);
-    }
-
-    return self;
-}
-
-/*
- *  call-seq:
- *     strio.set_encoding_by_bom  => strio or nil
- *
- *  Sets the encoding according to the BOM (Byte Order Mark) in the
- *  string.
- *
- *  Returns +self+ if the BOM is found, otherwise +nil.
- */
-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);
-}
-
-/*
- * :markup: markdown
- *
- * :include: stringio/stringio.md
- */
-void
-Init_stringio(void)
-{
-#undef rb_intern
-
-#ifdef HAVE_RB_EXT_RACTOR_SAFE
-    rb_ext_ractor_safe(true);
-#endif
-
-    VALUE StringIO = rb_define_class("StringIO", rb_cObject);
-
-    /* The version string */
-    rb_define_const(StringIO, "VERSION", rb_str_new_cstr(STRINGIO_VERSION));
-
-    rb_include_module(StringIO, rb_mEnumerable);
-    rb_define_alloc_func(StringIO, strio_s_allocate);
-
-    /* Maximum length that a StringIO instance can hold */
-    rb_define_const(StringIO, "MAX_LENGTH", LONG2NUM(LONG_MAX));
-
-    rb_define_singleton_method(StringIO, "new", strio_s_new, -1);
-    rb_define_singleton_method(StringIO, "open", strio_s_open, -1);
-    rb_define_method(StringIO, "initialize", strio_initialize, -1);
-    rb_define_method(StringIO, "initialize_copy", strio_copy, 1);
-    rb_define_method(StringIO, "reopen", strio_reopen, -1);
-
-    rb_define_method(StringIO, "string", strio_get_string, 0);
-    rb_define_method(StringIO, "string=", strio_set_string, 1);
-    rb_define_method(StringIO, "lineno", strio_get_lineno, 0);
-    rb_define_method(StringIO, "lineno=", strio_set_lineno, 1);
-
-
-    /* call-seq: strio.binmode -> true */
-    rb_define_method(StringIO, "binmode", strio_binmode, 0);
-    rb_define_method(StringIO, "close", strio_close, 0);
-    rb_define_method(StringIO, "close_read", strio_close_read, 0);
-    rb_define_method(StringIO, "close_write", strio_close_write, 0);
-    rb_define_method(StringIO, "closed?", strio_closed, 0);
-    rb_define_method(StringIO, "closed_read?", strio_closed_read, 0);
-    rb_define_method(StringIO, "closed_write?", strio_closed_write, 0);
-    rb_define_method(StringIO, "eof", strio_eof, 0);
-    rb_define_method(StringIO, "eof?", strio_eof, 0);
-    /* call-seq: strio.fcntl */
-    rb_define_method(StringIO, "fcntl", strio_fcntl, -1);
-    /* call-seq: strio.flush -> strio */
-    rb_define_method(StringIO, "flush", strio_flush, 0);
-    /* call-seq: strio.fsync -> 0 */
-    rb_define_method(StringIO, "fsync", strio_fsync, 0);
-    rb_define_method(StringIO, "pos", strio_get_pos, 0);
-    rb_define_method(StringIO, "pos=", strio_set_pos, 1);
-    rb_define_method(StringIO, "rewind", strio_rewind, 0);
-    rb_define_method(StringIO, "seek", strio_seek, -1);
-    rb_define_method(StringIO, "sync", strio_get_sync, 0);
-    /* call-seq: strio.sync = boolean -> boolean */
-    rb_define_method(StringIO, "sync=", strio_set_sync, 1);
-    rb_define_method(StringIO, "tell", strio_tell, 0);
-
-    rb_define_method(StringIO, "each", strio_each, -1);
-    rb_define_method(StringIO, "each_line", strio_each, -1);
-    rb_define_method(StringIO, "each_byte", strio_each_byte, 0);
-    rb_define_method(StringIO, "each_char", strio_each_char, 0);
-    rb_define_method(StringIO, "each_codepoint", strio_each_codepoint, 0);
-    rb_define_method(StringIO, "getc", strio_getc, 0);
-    rb_define_method(StringIO, "ungetc", strio_ungetc, 1);
-    rb_define_method(StringIO, "ungetbyte", strio_ungetbyte, 1);
-    rb_define_method(StringIO, "getbyte", strio_getbyte, 0);
-    rb_define_method(StringIO, "gets", strio_gets, -1);
-    rb_define_method(StringIO, "readlines", strio_readlines, -1);
-    rb_define_method(StringIO, "read", strio_read, -1);
-    rb_define_method(StringIO, "pread", strio_pread, -1);
-
-    rb_define_method(StringIO, "write", strio_write_m, -1);
-    rb_define_method(StringIO, "putc", strio_putc, 1);
-
-    /*
-     * call-seq:
-     *   strio.isatty -> nil
-     *   strio.tty? -> nil
-     *
-     */
-    rb_define_method(StringIO, "isatty", strio_isatty, 0);
-    rb_define_method(StringIO, "tty?", strio_isatty, 0);
-
-    /* call-seq: strio.pid -> nil */
-    rb_define_method(StringIO, "pid", strio_pid, 0);
-
-    /* call-seq: strio.fileno -> nil */
-    rb_define_method(StringIO, "fileno", strio_fileno, 0);
-    rb_define_method(StringIO, "size", strio_size, 0);
-    rb_define_method(StringIO, "length", strio_size, 0);
-    rb_define_method(StringIO, "truncate", strio_truncate, 1);
-
-    rb_define_method(StringIO, "external_encoding", strio_external_encoding, 0);
-    rb_define_method(StringIO, "internal_encoding", strio_internal_encoding, 0);
-    rb_define_method(StringIO, "set_encoding", strio_set_encoding, -1);
-    rb_define_method(StringIO, "set_encoding_by_bom", strio_set_encoding_by_bom, 0);
-
-    {
-	/* :stopdoc: */
-	VALUE mReadable = rb_define_module_under(rb_cIO, "generic_readable");
-	/* :startdoc: */
-	rb_define_method(mReadable, "readchar", strio_readchar, 0);
-	rb_define_method(mReadable, "readbyte", strio_readbyte, 0);
-	rb_define_method(mReadable, "readline", strio_readline, -1);
-	rb_define_method(mReadable, "sysread", strio_sysread, -1);
-	rb_define_method(mReadable, "readpartial", strio_sysread, -1);
-	rb_define_method(mReadable, "read_nonblock", strio_read_nonblock, -1);
-	rb_include_module(StringIO, mReadable);
-    }
-    {
-	/* :stopdoc: */
-	VALUE mWritable = rb_define_module_under(rb_cIO, "generic_writable");
-	/* :startdoc: */
-	rb_define_method(mWritable, "<<", strio_addstr, 1);
-	rb_define_method(mWritable, "print", strio_print, -1);
-	rb_define_method(mWritable, "printf", strio_printf, -1);
-	rb_define_method(mWritable, "puts", strio_puts, -1);
-	rb_define_method(mWritable, "syswrite", strio_syswrite, 1);
-	rb_define_method(mWritable, "write_nonblock", strio_syswrite_nonblock, -1);
-	rb_include_module(StringIO, mWritable);
-    }
-
-    sym_exception = ID2SYM(rb_intern("exception"));
-}