summaryrefslogtreecommitdiff
path: root/jni/ruby/ext/stringio
diff options
context:
space:
mode:
Diffstat (limited to 'jni/ruby/ext/stringio')
-rw-r--r--jni/ruby/ext/stringio/Makefile273
-rw-r--r--jni/ruby/ext/stringio/README18
-rw-r--r--jni/ruby/ext/stringio/depend4
-rw-r--r--jni/ruby/ext/stringio/extconf.h3
-rw-r--r--jni/ruby/ext/stringio/extconf.rb2
-rw-r--r--jni/ruby/ext/stringio/stringio.c1621
6 files changed, 1921 insertions, 0 deletions
diff --git a/jni/ruby/ext/stringio/Makefile b/jni/ruby/ext/stringio/Makefile
new file mode 100644
index 0000000..474d920
--- /dev/null
+++ b/jni/ruby/ext/stringio/Makefile
@@ -0,0 +1,273 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose. other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@:)
+ECHO = $(ECHO1:0=@echo)
+NULLCMD = :
+
+#### Start of system configuration section. ####
+top_srcdir = $(topdir)/.
+srcdir = $(top_srcdir)/ext/stringio
+topdir = ../..
+hdrdir = $(top_srcdir)/include
+arch_hdrdir = $(extout)/include/$(arch)
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+RUBYLIB =
+RUBYOPT = -
+prefix = $(DESTDIR)/usr/local
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+rubyarchprefix = $(rubylibprefix)/$(arch)
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitearchdir = $(sitelibdir)/$(sitearch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitedir = $(rubylibprefix)/site_ruby
+rubyarchdir = $(rubylibdir)/$(arch)
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+sitearchincludedir = $(includedir)/$(sitearch)
+archincludedir = $(includedir)/$(arch)
+sitearchlibdir = $(libdir)/$(sitearch)
+archlibdir = $(libdir)/$(arch)
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(DESTDIR)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+archdir = $(rubyarchdir)
+
+
+CC = gcc
+CXX = g++
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+
+RUBY_EXTCONF_H = extconf.h
+cflags = $(optflags) $(debugflags) $(warnflags)
+optflags = -O3 -fno-fast-math
+debugflags = -ggdb3
+warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wunused-variable -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wimplicit-function-declaration -Wdeprecated-declarations -Wno-packed-bitfield-compat
+CCDLFLAGS = -fPIC
+CFLAGS = $(CCDLFLAGS) $(cflags) -fPIC $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir) -I$(srcdir)
+DEFS =
+CPPFLAGS = -DRUBY_EXTCONF_H=\"$(RUBY_EXTCONF_H)\" $(DEFS) $(cppflags)
+CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG)
+ldflags = -L. -fstack-protector -rdynamic -Wl,-export-dynamic
+dldflags =
+ARCH_FLAG =
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -shared
+LDSHAREDXX = $(CXX) -shared
+AR = ar
+EXEEXT =
+
+RUBY_INSTALL_NAME = $(RUBY_BASE_NAME)
+RUBY_SO_NAME = ruby
+RUBYW_INSTALL_NAME =
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+RUBYW_BASE_NAME = rubyw
+RUBY_BASE_NAME = ruby
+
+arch = x86_64-linux
+sitearch = $(arch)
+ruby_version = 2.2.0
+ruby = $(topdir)/miniruby -I'$(topdir)' -I'$(top_srcdir)/lib' -I'$(extout)/$(arch)' -I'$(extout)/common'
+RUBY = $(ruby)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h $(RUBY_EXTCONF_H)
+
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir --ignore-fail-on-non-empty -p
+MAKEDIRS = /bin/mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload =
+
+libpath = . $(topdir)
+LIBPATH = -L. -L$(topdir)
+DEFFILE =
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES =
+DISTCLEANDIRS =
+
+extout = $(topdir)/.ext
+extout_prefix = $(extout)$(target_prefix)/
+target_prefix =
+LOCAL_LIBS =
+LIBS = $(LIBRUBYARG_SHARED) -lpthread -lgmp -ldl -lcrypt -lm -lc
+ORIG_SRCS = stringio.c
+SRCS = $(ORIG_SRCS)
+OBJS = stringio.o
+HDRS = $(srcdir)/extconf.h
+TARGET = stringio
+TARGET_NAME = stringio
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).so
+EXTSTATIC =
+STATIC_LIB = $(TARGET).a
+
+TIMESTAMP_DIR = $(extout)/.timestamp
+BINDIR = $(extout)/bin
+RUBYCOMMONDIR = $(extout)/common
+RUBYLIBDIR = $(RUBYCOMMONDIR)$(target_prefix)
+RUBYARCHDIR = $(extout)/$(arch)$(target_prefix)
+HDRDIR = $(extout)/include/ruby$(target_prefix)
+ARCHHDRDIR = $(extout)/include/$(arch)/ruby$(target_prefix)
+
+TARGET_SO = $(RUBYARCHDIR)/$(DLLIB)
+CLEANLIBS = $(RUBYARCHDIR)/$(TARGET).so
+CLEANOBJS = *.o *.bak
+
+all: install
+static: all
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+ -$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+ -$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+ -$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+ -$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+clean-so::
+ -$(Q)$(RM) $(RUBYARCHDIR)/$(DLLIB)
+ -$(Q)$(RMDIRS) $(RUBYARCHDIR) 2> /dev/null || true
+clean-static::
+ -$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+pre-install-rb-default:
+ @$(NULLCMD)
+$(TIMESTAMP_DIR)/.RUBYARCHDIR.time:
+ $(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+ $(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S
+
+.cc.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cc.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.mm.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.mm.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.cxx.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cxx.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.cpp.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cpp.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.c.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+.c.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $<
+
+.m.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+.m.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $<
+
+$(RUBYARCHDIR)/$(DLLIB): $(OBJS) Makefile $(TIMESTAMP_DIR)/.RUBYARCHDIR.time
+ $(ECHO) linking shared-object $(DLLIB)
+ -$(Q)$(RM) $(@)
+ $(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+$(STATIC_LIB): $(OBJS)
+ -$(Q)$(RM) $(@)
+ $(ECHO) linking static-library $(@)
+ $(Q) $(AR) cru $@ $(OBJS)
+ -$(Q)ranlib $(@) 2> /dev/null || true
+
+###
+$(OBJS): $(RUBY_EXTCONF_H)
+
+stringio.o: stringio.c $(HDRS) $(ruby_headers) \
+ $(hdrdir)/ruby/io.h \
+ $(hdrdir)/ruby/encoding.h \
+ $(hdrdir)/ruby/oniguruma.h
diff --git a/jni/ruby/ext/stringio/README b/jni/ruby/ext/stringio/README
new file mode 100644
index 0000000..fa3730d
--- /dev/null
+++ b/jni/ruby/ext/stringio/README
@@ -0,0 +1,18 @@
+-*- rd -*-
+$Author: nobu $
+
+=begin
+
+= StringIO
+Pseudo (({IO})) class from/to (({String})).
+
+This library is based on MoonWolf version written in Ruby. Thanks a lot.
+
+= Differences to (({IO}))
+
+* not implemented: (({fcntl})), (({reopen})).
+* (({fileno})) returns nil.
+* (({pos=})) returns new position, not 0.
+* (({ungetc})) does nothing at start of the string.
+
+=end
diff --git a/jni/ruby/ext/stringio/depend b/jni/ruby/ext/stringio/depend
new file mode 100644
index 0000000..db356dd
--- /dev/null
+++ b/jni/ruby/ext/stringio/depend
@@ -0,0 +1,4 @@
+stringio.o: stringio.c $(HDRS) $(ruby_headers) \
+ $(hdrdir)/ruby/io.h \
+ $(hdrdir)/ruby/encoding.h \
+ $(hdrdir)/ruby/oniguruma.h
diff --git a/jni/ruby/ext/stringio/extconf.h b/jni/ruby/ext/stringio/extconf.h
new file mode 100644
index 0000000..cda0cc8
--- /dev/null
+++ b/jni/ruby/ext/stringio/extconf.h
@@ -0,0 +1,3 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#endif
diff --git a/jni/ruby/ext/stringio/extconf.rb b/jni/ruby/ext/stringio/extconf.rb
new file mode 100644
index 0000000..8fc84b3
--- /dev/null
+++ b/jni/ruby/ext/stringio/extconf.rb
@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('stringio')
diff --git a/jni/ruby/ext/stringio/stringio.c b/jni/ruby/ext/stringio/stringio.c
new file mode 100644
index 0000000..e54f11a
--- /dev/null
+++ b/jni/ruby/ext/stringio/stringio.c
@@ -0,0 +1,1621 @@
+/**********************************************************************
+
+ stringio.c -
+
+ $Author: nobu $
+ $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).
+
+**********************************************************************/
+
+#include "ruby.h"
+#include "ruby/io.h"
+#include "ruby/encoding.h"
+#if defined(HAVE_FCNTL_H) || defined(_WIN32)
+#include <fcntl.h>
+#elif defined(HAVE_SYS_FCNTL_H)
+#include <sys/fcntl.h>
+#endif
+
+struct StringIO {
+ VALUE string;
+ long pos;
+ long lineno;
+ int flags;
+ int count;
+};
+
+static void strio_init(int, VALUE *, struct StringIO *, VALUE);
+
+#define IS_STRIO(obj) (rb_typeddata_is_kind_of((obj), &strio_data_type))
+#define error_inval(msg) (errno = EINVAL, rb_sys_fail(msg))
+
+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;
+ if (ptr) {
+ 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)
+{
+ const struct StringIO *ptr = p;
+ if (!ptr) return 0;
+ 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
+};
+
+#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
+strio_substr(struct StringIO *ptr, long pos, long len)
+{
+ VALUE str = ptr->string;
+ rb_encoding *enc = rb_enc_get(str);
+ long rlen = RSTRING_LEN(str) - pos;
+
+ if (len > rlen) len = rlen;
+ if (len < 0) len = 0;
+ if (len == 0) return rb_str_new(0,0);
+ return rb_enc_str_new(RSTRING_PTR(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");
+ }
+ if (!OBJ_TAINTED(ptr->string)) {
+ }
+ return ptr;
+}
+
+static void
+check_modifiable(struct StringIO *ptr)
+{
+ if (OBJ_FROZEN(ptr->string)) {
+ rb_raise(rb_eIOError, "not modifiable string");
+ }
+}
+
+static VALUE
+strio_s_allocate(VALUE klass)
+{
+ return TypedData_Wrap_Struct(klass, &strio_data_type, 0);
+}
+
+/*
+ * call-seq: StringIO.new(string=""[, mode])
+ *
+ * Creates new StringIO instance from with _string_ and _mode_.
+ */
+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;
+}
+
+static void
+strio_init(int argc, VALUE *argv, struct StringIO *ptr, VALUE self)
+{
+ VALUE string, mode;
+ int trunc = 0;
+
+ switch (rb_scan_args(argc, argv, "02", &string, &mode)) {
+ case 2:
+ if (FIXNUM_P(mode)) {
+ int flags = FIX2INT(mode);
+ ptr->flags = rb_io_oflags_fmode(flags);
+ trunc = flags & O_TRUNC;
+ }
+ else {
+ const char *m = StringValueCStr(mode);
+ ptr->flags = rb_io_modestr_fmode(m);
+ trunc = *m == 'w';
+ }
+ StringValue(string);
+ if ((ptr->flags & FMODE_WRITABLE) && OBJ_FROZEN(string)) {
+ errno = EACCES;
+ rb_sys_fail(0);
+ }
+ if (trunc) {
+ rb_str_resize(string, 0);
+ }
+ break;
+ case 1:
+ StringValue(string);
+ ptr->flags = OBJ_FROZEN(string) ? FMODE_READABLE : FMODE_READWRITE;
+ break;
+ case 0:
+ string = rb_enc_str_new("", 0, rb_default_external_encoding());
+ ptr->flags = FMODE_READWRITE;
+ break;
+ }
+ ptr->string = string;
+ ptr->pos = 0;
+ ptr->lineno = 0;
+ RBASIC(self)->flags |= (ptr->flags & FMODE_READWRITE) * (STRIO_READABLE / FMODE_READABLE);
+}
+
+static VALUE
+strio_finalize(VALUE self)
+{
+ struct StringIO *ptr = StringIO(self);
+ ptr->string = Qnil;
+ ptr->flags &= ~FMODE_READWRITE;
+ return self;
+}
+
+/*
+ * call-seq: StringIO.open(string=""[, mode]) {|strio| ...}
+ *
+ * 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.
+ */
+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);
+}
+
+/*
+ * Returns +false+. Just for compatibility to IO.
+ */
+static VALUE
+strio_false(VALUE self)
+{
+ StringIO(self);
+ return Qfalse;
+}
+
+/*
+ * Returns +nil+. Just for compatibility to IO.
+ */
+static VALUE
+strio_nil(VALUE self)
+{
+ StringIO(self);
+ return Qnil;
+}
+
+/*
+ * Returns *strio* itself. Just for compatibility to IO.
+ */
+static VALUE
+strio_self(VALUE self)
+{
+ StringIO(self);
+ return self;
+}
+
+/*
+ * Returns 0. Just for compatibility to 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: strio.string -> string
+ *
+ * Returns underlying String object, the subject of IO.
+ */
+static VALUE
+strio_get_string(VALUE self)
+{
+ return StringIO(self)->string;
+}
+
+/*
+ * call-seq:
+ * strio.string = string -> string
+ *
+ * Changes underlying String object, the subject of IO.
+ */
+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;
+}
+
+/*
+ * call-seq:
+ * strio.close -> nil
+ *
+ * Closes strio. The *strio* is unavailable for any further data
+ * operations; an +IOError+ is raised if such an attempt is made.
+ */
+static VALUE
+strio_close(VALUE self)
+{
+ StringIO(self);
+ if (CLOSED(self)) {
+ rb_raise(rb_eIOError, "closed stream");
+ }
+ RBASIC(self)->flags &= ~STRIO_READWRITE;
+ return Qnil;
+}
+
+/*
+ * call-seq:
+ * strio.close_read -> nil
+ *
+ * Closes the read end of a StringIO. Will raise an +IOError+ if the
+ * *strio* is not readable.
+ */
+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;
+}
+
+/*
+ * call-seq:
+ * strio.close_write -> nil
+ *
+ * Closes the write end of a StringIO. Will raise an +IOError+ if the
+ * *strio* is not writeable.
+ */
+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;
+}
+
+/*
+ * call-seq:
+ * strio.closed? -> true or false
+ *
+ * Returns +true+ if *strio* is completely closed, +false+ otherwise.
+ */
+static VALUE
+strio_closed(VALUE self)
+{
+ StringIO(self);
+ if (!CLOSED(self)) return Qfalse;
+ return Qtrue;
+}
+
+/*
+ * call-seq:
+ * strio.closed_read? -> true or false
+ *
+ * Returns +true+ if *strio* is not readable, +false+ otherwise.
+ */
+static VALUE
+strio_closed_read(VALUE self)
+{
+ StringIO(self);
+ if (READABLE(self)) return Qfalse;
+ return Qtrue;
+}
+
+/*
+ * call-seq:
+ * strio.closed_write? -> true or false
+ *
+ * Returns +true+ if *strio* is not writable, +false+ otherwise.
+ */
+static VALUE
+strio_closed_write(VALUE self)
+{
+ StringIO(self);
+ if (WRITABLE(self)) return Qfalse;
+ return Qtrue;
+}
+
+/*
+ * call-seq:
+ * strio.eof -> true or false
+ * strio.eof? -> true or false
+ *
+ * Returns true if *strio* is at end of file. The stringio must be
+ * opened for reading or an +IOError+ will be raised.
+ */
+static VALUE
+strio_eof(VALUE self)
+{
+ struct StringIO *ptr = readable(self);
+ if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
+ return Qtrue;
+}
+
+/* :nodoc: */
+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;
+}
+
+/*
+ * call-seq:
+ * strio.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 <code>$.</code> variable.
+ */
+static VALUE
+strio_get_lineno(VALUE self)
+{
+ return LONG2NUM(StringIO(self)->lineno);
+}
+
+/*
+ * call-seq:
+ * strio.lineno = integer -> integer
+ *
+ * Manually sets the current line number to the given value.
+ * <code>$.</code> is updated only on the next read.
+ */
+static VALUE
+strio_set_lineno(VALUE self, VALUE lineno)
+{
+ StringIO(self)->lineno = NUM2LONG(lineno);
+ return lineno;
+}
+
+#define strio_binmode strio_self
+
+#define strio_fcntl strio_unimpl
+
+#define strio_flush strio_self
+
+#define strio_fsync strio_0
+
+/*
+ * call-seq:
+ * strio.reopen(other_StrIO) -> strio
+ * strio.reopen(string, mode) -> strio
+ *
+ * Reinitializes *strio* with the given <i>other_StrIO</i> or _string_
+ * and _mode_ (see StringIO#new).
+ */
+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;
+}
+
+/*
+ * call-seq:
+ * strio.pos -> integer
+ * strio.tell -> integer
+ *
+ * Returns the current offset (in bytes) of *strio*.
+ */
+static VALUE
+strio_get_pos(VALUE self)
+{
+ return LONG2NUM(StringIO(self)->pos);
+}
+
+/*
+ * call-seq:
+ * strio.pos = integer -> integer
+ *
+ * Seeks to the given position (in bytes) in *strio*.
+ */
+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:
+ * strio.rewind -> 0
+ *
+ * Positions *strio* to the beginning of input, resetting
+ * +lineno+ to zero.
+ */
+static VALUE
+strio_rewind(VALUE self)
+{
+ struct StringIO *ptr = StringIO(self);
+ ptr->pos = 0;
+ ptr->lineno = 0;
+ return INT2FIX(0);
+}
+
+/*
+ * call-seq:
+ * strio.seek(amount, whence=SEEK_SET) -> 0
+ *
+ * Seeks to a given offset _amount_ in the stream according to
+ * the value of _whence_ (see IO#seek).
+ */
+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);
+}
+
+/*
+ * call-seq:
+ * strio.sync -> true
+ *
+ * Returns +true+ always.
+ */
+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:
+ * strio.each_byte {|byte| block } -> strio
+ * strio.each_byte -> anEnumerator
+ *
+ * See IO#each_byte.
+ */
+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;
+}
+
+/*
+ * This is a deprecated alias for #each_byte.
+ */
+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);
+}
+
+/*
+ * call-seq:
+ * strio.getc -> string or nil
+ *
+ * See IO#getc.
+ */
+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));
+}
+
+/*
+ * call-seq:
+ * strio.getbyte -> fixnum or nil
+ *
+ * See IO#getbyte.
+ */
+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);
+}
+
+static void
+strio_extend(struct StringIO *ptr, long pos, long len)
+{
+ long olen;
+
+ 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);
+ }
+ else {
+ rb_str_modify(ptr->string);
+ }
+}
+
+/*
+ * call-seq:
+ * strio.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.
+ */
+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;
+}
+
+/*
+ * call-seq:
+ * strio.ungetbyte(fixnum) -> nil
+ *
+ * See IO#ungetbyte
+ */
+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;
+}
+
+/*
+ * call-seq:
+ * strio.readchar -> string
+ *
+ * See IO#readchar.
+ */
+static VALUE
+strio_readchar(VALUE self)
+{
+ VALUE c = rb_funcall2(self, rb_intern("getc"), 0, 0);
+ if (NIL_P(c)) rb_eof_error();
+ return c;
+}
+
+/*
+ * call-seq:
+ * strio.readbyte -> fixnum
+ *
+ * See IO#readbyte.
+ */
+static VALUE
+strio_readbyte(VALUE self)
+{
+ VALUE c = rb_funcall2(self, rb_intern("getbyte"), 0, 0);
+ if (NIL_P(c)) rb_eof_error();
+ return c;
+}
+
+/*
+ * call-seq:
+ * strio.each_char {|char| block } -> strio
+ * strio.each_char -> anEnumerator
+ *
+ * See IO#each_char.
+ */
+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;
+}
+
+/*
+ * This is a deprecated alias for <code>each_char</code>.
+ */
+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);
+}
+
+/*
+ * call-seq:
+ * strio.each_codepoint {|c| block } -> strio
+ * strio.each_codepoint -> anEnumerator
+ *
+ * See IO#each_codepoint.
+ */
+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;
+}
+
+/*
+ * This is a deprecated alias for <code>each_codepoint</code>.
+ */
+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);
+}
+
+/* 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;
+}
+
+static VALUE
+strio_getline(int argc, VALUE *argv, struct StringIO *ptr)
+{
+ const char *s, *e, *p;
+ long n, limit = 0;
+ VALUE str, lim;
+
+ rb_scan_args(argc, argv, "02", &str, &lim);
+ switch (argc) {
+ case 0:
+ str = rb_rs;
+ break;
+
+ case 1:
+ if (!NIL_P(str) && !RB_TYPE_P(str, T_STRING)) {
+ VALUE tmp = rb_check_string_type(str);
+ if (NIL_P(tmp)) {
+ limit = NUM2LONG(str);
+ if (limit == 0) return rb_str_new(0,0);
+ str = rb_rs;
+ }
+ else {
+ str = tmp;
+ }
+ }
+ break;
+
+ case 2:
+ if (!NIL_P(str)) StringValue(str);
+ if (!NIL_P(lim)) limit = NUM2LONG(lim);
+ break;
+ }
+
+ if (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 && s + limit < e) {
+ e = rb_enc_right_char_head(s, s + limit, e, rb_enc_get(ptr->string));
+ }
+ if (NIL_P(str)) {
+ str = strio_substr(ptr, ptr->pos, e - s);
+ }
+ else if ((n = RSTRING_LEN(str)) == 0) {
+ p = s;
+ while (*p == '\n') {
+ if (++p == e) {
+ return Qnil;
+ }
+ }
+ s = p;
+ while ((p = memchr(p, '\n', e - p)) && (p != e)) {
+ if (*++p == '\n') {
+ e = p + 1;
+ break;
+ }
+ }
+ str = strio_substr(ptr, s - RSTRING_PTR(ptr->string), e - s);
+ }
+ else if (n == 1) {
+ if ((p = memchr(s, RSTRING_PTR(str)[0], e - s)) != 0) {
+ e = p + 1;
+ }
+ str = strio_substr(ptr, ptr->pos, e - s);
+ }
+ else {
+ if (n < e - s) {
+ if (e - s < 1024) {
+ for (p = s; p + n <= e; ++p) {
+ if (MEMCMP(p, RSTRING_PTR(str), char, n) == 0) {
+ e = p + n;
+ 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 + n;
+ }
+ }
+ }
+ str = strio_substr(ptr, ptr->pos, e - s);
+ }
+ ptr->pos = e - RSTRING_PTR(ptr->string);
+ ptr->lineno++;
+ return str;
+}
+
+/*
+ * call-seq:
+ * strio.gets(sep=$/) -> string or nil
+ * strio.gets(limit) -> string or nil
+ * strio.gets(sep, limit) -> string or nil
+ *
+ * See IO#gets.
+ */
+static VALUE
+strio_gets(int argc, VALUE *argv, VALUE self)
+{
+ VALUE str = strio_getline(argc, argv, readable(self));
+
+ rb_lastline_set(str);
+ return str;
+}
+
+/*
+ * call-seq:
+ * strio.readline(sep=$/) -> string
+ * strio.readline(limit) -> string or nil
+ * strio.readline(sep, limit) -> string or nil
+ *
+ * See IO#readline.
+ */
+static VALUE
+strio_readline(int argc, VALUE *argv, VALUE self)
+{
+ VALUE line = rb_funcall2(self, rb_intern("gets"), argc, argv);
+ if (NIL_P(line)) rb_eof_error();
+ return line;
+}
+
+/*
+ * call-seq:
+ * strio.each(sep=$/) {|line| block } -> strio
+ * strio.each(limit) {|line| block } -> strio
+ * strio.each(sep, limit) {|line| block } -> strio
+ * strio.each(...) -> anEnumerator
+ *
+ * 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.
+ */
+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;
+}
+
+/*
+ * This is a deprecated alias for <code>each_line</code>.
+ */
+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);
+}
+
+/*
+ * call-seq:
+ * strio.readlines(sep=$/) -> array
+ * strio.readlines(limit) -> array
+ * strio.readlines(sep,limit) -> array
+ *
+ * See IO#readlines.
+ */
+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;
+}
+
+/*
+ * call-seq:
+ * strio.write(string) -> integer
+ * strio.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 <code>to_s</code>.
+ * Returns the number of bytes written. See IO#write.
+ */
+static VALUE
+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();
+
+ 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 != ascii8bit) {
+ 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) {
+ if (enc == ascii8bit || enc2 == ascii8bit) {
+ rb_enc_str_buf_cat(ptr->string, RSTRING_PTR(str), len, enc);
+ OBJ_INFECT(ptr->string, str);
+ }
+ else {
+ rb_str_buf_append(ptr->string, str);
+ }
+ }
+ 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);
+ RB_GC_GUARD(str);
+ ptr->pos += len;
+ return LONG2NUM(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)) {
+ str = rb_str_substr(ch, 0, 1);
+ }
+ else {
+ char c = NUM2CHR(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);
+ }
+ 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;
+}
+
+/*
+ * 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_funcall2(self, rb_intern("read"), argc, argv);
+ 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;
+ int no_exception = 0;
+
+ rb_scan_args(argc, argv, "11:", NULL, NULL, &opts);
+
+ if (!NIL_P(opts)) {
+ argc--;
+
+ if (Qfalse == rb_hash_aref(opts, sym_exception))
+ no_exception = 1;
+ }
+
+ val = strio_read(argc, argv, self);
+ if (NIL_P(val)) {
+ if (no_exception)
+ return Qnil;
+ else
+ rb_eof_error();
+ }
+
+ return val;
+}
+
+#define strio_syswrite rb_io_write
+
+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:
+ * strio.length -> integer
+ * strio.size -> integer
+ *
+ * Returns the size of the buffer string.
+ */
+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));
+}
+
+/*
+ * call-seq:
+ * strio.truncate(integer) -> 0
+ *
+ * Truncates the buffer string to at most _integer_ bytes. The *strio*
+ * must be opened for writing.
+ */
+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;
+}
+
+/*
+ * call-seq:
+ * strio.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 <code>nil</code>.
+ */
+
+static VALUE
+strio_external_encoding(VALUE self)
+{
+ return rb_enc_from_encoding(rb_enc_get(StringIO(self)->string));
+}
+
+/*
+ * call-seq:
+ * strio.internal_encoding => encoding
+ *
+ * Returns the Encoding of the internal string if conversion is
+ * specified. Otherwise returns nil.
+ */
+
+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;
+ 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;
+}
+
+/*
+ * Pseudo I/O on String object.
+ *
+ * Commonly used to simulate `$stdio` or `$stderr`
+ *
+ * === Examples
+ *
+ * require 'stringio'
+ *
+ * io = StringIO.new
+ * io.puts "Hello World"
+ * io.string #=> "Hello World"
+ */
+void
+Init_stringio(void)
+{
+ VALUE StringIO = rb_define_class("StringIO", rb_cData);
+
+ rb_include_module(StringIO, rb_mEnumerable);
+ rb_define_alloc_func(StringIO, strio_s_allocate);
+ 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, "lines", strio_lines, -1);
+ rb_define_method(StringIO, "each_byte", strio_each_byte, 0);
+ rb_define_method(StringIO, "bytes", strio_bytes, 0);
+ rb_define_method(StringIO, "each_char", strio_each_char, 0);
+ rb_define_method(StringIO, "chars", strio_chars, 0);
+ rb_define_method(StringIO, "each_codepoint", strio_each_codepoint, 0);
+ rb_define_method(StringIO, "codepoints", strio_codepoints, 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, "write", strio_write, 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);
+
+ {
+ VALUE mReadable = rb_define_module_under(rb_cIO, "generic_readable");
+ 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);
+ }
+ {
+ VALUE mWritable = rb_define_module_under(rb_cIO, "generic_writable");
+ 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"));
+}
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-12-27 11:08:06 +0000