diff options
Diffstat (limited to 'ext/stringio')
| -rw-r--r-- | ext/stringio/.cvsignore | 3 | ||||
| -rw-r--r-- | ext/stringio/README | 19 | ||||
| -rw-r--r-- | ext/stringio/README.md | 10 | ||||
| -rw-r--r-- | ext/stringio/depend | 176 | ||||
| -rw-r--r-- | ext/stringio/extconf.rb | 2 | ||||
| -rw-r--r-- | ext/stringio/stringio.c | 1483 | ||||
| -rw-r--r-- | ext/stringio/stringio.gemspec | 31 |
7 files changed, 1238 insertions, 486 deletions
diff --git a/ext/stringio/.cvsignore b/ext/stringio/.cvsignore deleted file mode 100644 index 4088712231..0000000000 --- a/ext/stringio/.cvsignore +++ /dev/null @@ -1,3 +0,0 @@ -Makefile -mkmf.log -*.def diff --git a/ext/stringio/README b/ext/stringio/README deleted file mode 100644 index c4031f7e97..0000000000 --- a/ext/stringio/README +++ /dev/null @@ -1,19 +0,0 @@ --*- rd -*- -$Author$ -$Date$ - -=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/ext/stringio/README.md b/ext/stringio/README.md new file mode 100644 index 0000000000..94532ed688 --- /dev/null +++ b/ext/stringio/README.md @@ -0,0 +1,10 @@ +# StringIO + +Pseudo `IO` class from/to `String`. + +This library is based on MoonWolf version written in Ruby. Thanks a lot. + +## Differences to `IO` + +* `fileno` raises `NotImplementedError`. +* encoding conversion is not implemented, and ignored silently. diff --git a/ext/stringio/depend b/ext/stringio/depend index cc9eae3f55..7b70a77d20 100644 --- a/ext/stringio/depend +++ b/ext/stringio/depend @@ -1,2 +1,174 @@ -stringio.o: stringio.c $(hdrdir)/ruby.h $(topdir)/config.h \ - $(hdrdir)/defines.h $(hdrdir)/intern.h $(hdrdir)/rubyio.h +# AUTOGENERATED DEPENDENCIES START +stringio.o: $(RUBY_EXTCONF_H) +stringio.o: $(arch_hdrdir)/ruby/config.h +stringio.o: $(hdrdir)/ruby.h +stringio.o: $(hdrdir)/ruby/assert.h +stringio.o: $(hdrdir)/ruby/backward.h +stringio.o: $(hdrdir)/ruby/backward/2/assume.h +stringio.o: $(hdrdir)/ruby/backward/2/attributes.h +stringio.o: $(hdrdir)/ruby/backward/2/bool.h +stringio.o: $(hdrdir)/ruby/backward/2/inttypes.h +stringio.o: $(hdrdir)/ruby/backward/2/limits.h +stringio.o: $(hdrdir)/ruby/backward/2/long_long.h +stringio.o: $(hdrdir)/ruby/backward/2/stdalign.h +stringio.o: $(hdrdir)/ruby/backward/2/stdarg.h +stringio.o: $(hdrdir)/ruby/defines.h +stringio.o: $(hdrdir)/ruby/encoding.h +stringio.o: $(hdrdir)/ruby/intern.h +stringio.o: $(hdrdir)/ruby/internal/anyargs.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/char.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/double.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/fixnum.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/gid_t.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/int.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/intptr_t.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/long.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/long_long.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/mode_t.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/off_t.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/pid_t.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/short.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/size_t.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/st_data_t.h +stringio.o: $(hdrdir)/ruby/internal/arithmetic/uid_t.h +stringio.o: $(hdrdir)/ruby/internal/assume.h +stringio.o: $(hdrdir)/ruby/internal/attr/alloc_size.h +stringio.o: $(hdrdir)/ruby/internal/attr/artificial.h +stringio.o: $(hdrdir)/ruby/internal/attr/cold.h +stringio.o: $(hdrdir)/ruby/internal/attr/const.h +stringio.o: $(hdrdir)/ruby/internal/attr/constexpr.h +stringio.o: $(hdrdir)/ruby/internal/attr/deprecated.h +stringio.o: $(hdrdir)/ruby/internal/attr/diagnose_if.h +stringio.o: $(hdrdir)/ruby/internal/attr/enum_extensibility.h +stringio.o: $(hdrdir)/ruby/internal/attr/error.h +stringio.o: $(hdrdir)/ruby/internal/attr/flag_enum.h +stringio.o: $(hdrdir)/ruby/internal/attr/forceinline.h +stringio.o: $(hdrdir)/ruby/internal/attr/format.h +stringio.o: $(hdrdir)/ruby/internal/attr/maybe_unused.h +stringio.o: $(hdrdir)/ruby/internal/attr/noalias.h +stringio.o: $(hdrdir)/ruby/internal/attr/nodiscard.h +stringio.o: $(hdrdir)/ruby/internal/attr/noexcept.h +stringio.o: $(hdrdir)/ruby/internal/attr/noinline.h +stringio.o: $(hdrdir)/ruby/internal/attr/nonnull.h +stringio.o: $(hdrdir)/ruby/internal/attr/noreturn.h +stringio.o: $(hdrdir)/ruby/internal/attr/pure.h +stringio.o: $(hdrdir)/ruby/internal/attr/restrict.h +stringio.o: $(hdrdir)/ruby/internal/attr/returns_nonnull.h +stringio.o: $(hdrdir)/ruby/internal/attr/warning.h +stringio.o: $(hdrdir)/ruby/internal/attr/weakref.h +stringio.o: $(hdrdir)/ruby/internal/cast.h +stringio.o: $(hdrdir)/ruby/internal/compiler_is.h +stringio.o: $(hdrdir)/ruby/internal/compiler_is/apple.h +stringio.o: $(hdrdir)/ruby/internal/compiler_is/clang.h +stringio.o: $(hdrdir)/ruby/internal/compiler_is/gcc.h +stringio.o: $(hdrdir)/ruby/internal/compiler_is/intel.h +stringio.o: $(hdrdir)/ruby/internal/compiler_is/msvc.h +stringio.o: $(hdrdir)/ruby/internal/compiler_is/sunpro.h +stringio.o: $(hdrdir)/ruby/internal/compiler_since.h +stringio.o: $(hdrdir)/ruby/internal/config.h +stringio.o: $(hdrdir)/ruby/internal/constant_p.h +stringio.o: $(hdrdir)/ruby/internal/core.h +stringio.o: $(hdrdir)/ruby/internal/core/rarray.h +stringio.o: $(hdrdir)/ruby/internal/core/rbasic.h +stringio.o: $(hdrdir)/ruby/internal/core/rbignum.h +stringio.o: $(hdrdir)/ruby/internal/core/rclass.h +stringio.o: $(hdrdir)/ruby/internal/core/rdata.h +stringio.o: $(hdrdir)/ruby/internal/core/rfile.h +stringio.o: $(hdrdir)/ruby/internal/core/rhash.h +stringio.o: $(hdrdir)/ruby/internal/core/robject.h +stringio.o: $(hdrdir)/ruby/internal/core/rregexp.h +stringio.o: $(hdrdir)/ruby/internal/core/rstring.h +stringio.o: $(hdrdir)/ruby/internal/core/rstruct.h +stringio.o: $(hdrdir)/ruby/internal/core/rtypeddata.h +stringio.o: $(hdrdir)/ruby/internal/ctype.h +stringio.o: $(hdrdir)/ruby/internal/dllexport.h +stringio.o: $(hdrdir)/ruby/internal/dosish.h +stringio.o: $(hdrdir)/ruby/internal/encoding/coderange.h +stringio.o: $(hdrdir)/ruby/internal/encoding/ctype.h +stringio.o: $(hdrdir)/ruby/internal/encoding/encoding.h +stringio.o: $(hdrdir)/ruby/internal/encoding/pathname.h +stringio.o: $(hdrdir)/ruby/internal/encoding/re.h +stringio.o: $(hdrdir)/ruby/internal/encoding/sprintf.h +stringio.o: $(hdrdir)/ruby/internal/encoding/string.h +stringio.o: $(hdrdir)/ruby/internal/encoding/symbol.h +stringio.o: $(hdrdir)/ruby/internal/encoding/transcode.h +stringio.o: $(hdrdir)/ruby/internal/error.h +stringio.o: $(hdrdir)/ruby/internal/eval.h +stringio.o: $(hdrdir)/ruby/internal/event.h +stringio.o: $(hdrdir)/ruby/internal/fl_type.h +stringio.o: $(hdrdir)/ruby/internal/gc.h +stringio.o: $(hdrdir)/ruby/internal/glob.h +stringio.o: $(hdrdir)/ruby/internal/globals.h +stringio.o: $(hdrdir)/ruby/internal/has/attribute.h +stringio.o: $(hdrdir)/ruby/internal/has/builtin.h +stringio.o: $(hdrdir)/ruby/internal/has/c_attribute.h +stringio.o: $(hdrdir)/ruby/internal/has/cpp_attribute.h +stringio.o: $(hdrdir)/ruby/internal/has/declspec_attribute.h +stringio.o: $(hdrdir)/ruby/internal/has/extension.h +stringio.o: $(hdrdir)/ruby/internal/has/feature.h +stringio.o: $(hdrdir)/ruby/internal/has/warning.h +stringio.o: $(hdrdir)/ruby/internal/intern/array.h +stringio.o: $(hdrdir)/ruby/internal/intern/bignum.h +stringio.o: $(hdrdir)/ruby/internal/intern/class.h +stringio.o: $(hdrdir)/ruby/internal/intern/compar.h +stringio.o: $(hdrdir)/ruby/internal/intern/complex.h +stringio.o: $(hdrdir)/ruby/internal/intern/cont.h +stringio.o: $(hdrdir)/ruby/internal/intern/dir.h +stringio.o: $(hdrdir)/ruby/internal/intern/enum.h +stringio.o: $(hdrdir)/ruby/internal/intern/enumerator.h +stringio.o: $(hdrdir)/ruby/internal/intern/error.h +stringio.o: $(hdrdir)/ruby/internal/intern/eval.h +stringio.o: $(hdrdir)/ruby/internal/intern/file.h +stringio.o: $(hdrdir)/ruby/internal/intern/gc.h +stringio.o: $(hdrdir)/ruby/internal/intern/hash.h +stringio.o: $(hdrdir)/ruby/internal/intern/io.h +stringio.o: $(hdrdir)/ruby/internal/intern/load.h +stringio.o: $(hdrdir)/ruby/internal/intern/marshal.h +stringio.o: $(hdrdir)/ruby/internal/intern/numeric.h +stringio.o: $(hdrdir)/ruby/internal/intern/object.h +stringio.o: $(hdrdir)/ruby/internal/intern/parse.h +stringio.o: $(hdrdir)/ruby/internal/intern/proc.h +stringio.o: $(hdrdir)/ruby/internal/intern/process.h +stringio.o: $(hdrdir)/ruby/internal/intern/random.h +stringio.o: $(hdrdir)/ruby/internal/intern/range.h +stringio.o: $(hdrdir)/ruby/internal/intern/rational.h +stringio.o: $(hdrdir)/ruby/internal/intern/re.h +stringio.o: $(hdrdir)/ruby/internal/intern/ruby.h +stringio.o: $(hdrdir)/ruby/internal/intern/select.h +stringio.o: $(hdrdir)/ruby/internal/intern/select/largesize.h +stringio.o: $(hdrdir)/ruby/internal/intern/signal.h +stringio.o: $(hdrdir)/ruby/internal/intern/sprintf.h +stringio.o: $(hdrdir)/ruby/internal/intern/string.h +stringio.o: $(hdrdir)/ruby/internal/intern/struct.h +stringio.o: $(hdrdir)/ruby/internal/intern/thread.h +stringio.o: $(hdrdir)/ruby/internal/intern/time.h +stringio.o: $(hdrdir)/ruby/internal/intern/variable.h +stringio.o: $(hdrdir)/ruby/internal/intern/vm.h +stringio.o: $(hdrdir)/ruby/internal/interpreter.h +stringio.o: $(hdrdir)/ruby/internal/iterator.h +stringio.o: $(hdrdir)/ruby/internal/memory.h +stringio.o: $(hdrdir)/ruby/internal/method.h +stringio.o: $(hdrdir)/ruby/internal/module.h +stringio.o: $(hdrdir)/ruby/internal/newobj.h +stringio.o: $(hdrdir)/ruby/internal/rgengc.h +stringio.o: $(hdrdir)/ruby/internal/scan_args.h +stringio.o: $(hdrdir)/ruby/internal/special_consts.h +stringio.o: $(hdrdir)/ruby/internal/static_assert.h +stringio.o: $(hdrdir)/ruby/internal/stdalign.h +stringio.o: $(hdrdir)/ruby/internal/stdbool.h +stringio.o: $(hdrdir)/ruby/internal/symbol.h +stringio.o: $(hdrdir)/ruby/internal/value.h +stringio.o: $(hdrdir)/ruby/internal/value_type.h +stringio.o: $(hdrdir)/ruby/internal/variable.h +stringio.o: $(hdrdir)/ruby/internal/warning_push.h +stringio.o: $(hdrdir)/ruby/internal/xmalloc.h +stringio.o: $(hdrdir)/ruby/io.h +stringio.o: $(hdrdir)/ruby/missing.h +stringio.o: $(hdrdir)/ruby/onigmo.h +stringio.o: $(hdrdir)/ruby/oniguruma.h +stringio.o: $(hdrdir)/ruby/ruby.h +stringio.o: $(hdrdir)/ruby/st.h +stringio.o: $(hdrdir)/ruby/subst.h +stringio.o: stringio.c +# AUTOGENERATED DEPENDENCIES END diff --git a/ext/stringio/extconf.rb b/ext/stringio/extconf.rb index 8fc84b3735..a933159766 100644 --- a/ext/stringio/extconf.rb +++ b/ext/stringio/extconf.rb @@ -1,2 +1,4 @@ +# frozen_string_literal: false require 'mkmf' +have_func("rb_io_extract_modeenc", "ruby/io.h") create_makefile('stringio') diff --git a/ext/stringio/stringio.c b/ext/stringio/stringio.c index a64aaf837c..a2aef6b11c 100644 --- a/ext/stringio/stringio.c +++ b/ext/stringio/stringio.c @@ -1,9 +1,9 @@ +/* -*- mode: c; indent-tabs-mode: t -*- */ /********************************************************************** stringio.c - $Author$ - $Date$ $RoughId: stringio.c,v 1.13 2002/03/14 03:24:18 nobu Exp $ created at: Tue Feb 19 04:10:38 JST 2002 @@ -12,38 +12,120 @@ **********************************************************************/ +#define STRINGIO_VERSION "3.0.1.2" + #include "ruby.h" -#include "rubyio.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 -#define STRIO_EOF FMODE_SYNC +#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 + +#ifndef HAVE_RB_IO_EXTRACT_MODEENC +#define rb_io_extract_modeenc strio_extract_modeenc +static void +strio_extract_modeenc(VALUE *vmode_p, VALUE *vperm_p, VALUE opthash, + int *oflags_p, int *fmode_p, struct rb_io_enc_t *convconfig_p) +{ + VALUE mode = *vmode_p; + VALUE intmode; + int fmode; + int has_enc = 0, has_vmode = 0; + + convconfig_p->enc = convconfig_p->enc2 = 0; + + vmode_handle: + if (NIL_P(mode)) { + fmode = FMODE_READABLE; + } + else if (!NIL_P(intmode = rb_check_to_integer(mode, "to_int"))) { + int flags = NUM2INT(intmode); + fmode = rb_io_oflags_fmode(flags); + } + else { + const char *m = StringValueCStr(mode), *n, *e; + fmode = rb_io_modestr_fmode(m); + n = strchr(m, ':'); + if (n) { + long len; + char encname[ENCODING_MAXNAMELEN+1]; + has_enc = 1; + if (fmode & FMODE_SETENC_BY_BOM) { + n = strchr(n, '|'); + } + e = strchr(++n, ':'); + len = e ? e - n : (long)strlen(n); + if (len > 0 && len <= ENCODING_MAXNAMELEN) { + if (e) { + memcpy(encname, n, len); + encname[len] = '\0'; + n = encname; + } + convconfig_p->enc = rb_enc_find(n); + } + if (e && (len = strlen(++e)) > 0 && len <= ENCODING_MAXNAMELEN) { + convconfig_p->enc2 = rb_enc_find(e); + } + } + } + + if (!NIL_P(opthash)) { + rb_encoding *extenc = 0, *intenc = 0; + VALUE v; + if (!has_vmode) { + ID id_mode; + CONST_ID(id_mode, "mode"); + v = rb_hash_aref(opthash, ID2SYM(id_mode)); + if (!NIL_P(v)) { + if (!NIL_P(mode)) { + rb_raise(rb_eArgError, "mode specified twice"); + } + has_vmode = 1; + mode = v; + goto vmode_handle; + } + } + + if (rb_io_extract_encoding_option(opthash, &extenc, &intenc, &fmode)) { + if (has_enc) { + rb_raise(rb_eArgError, "encoding specified twice"); + } + } + } + *fmode_p = fmode; +} +#endif struct StringIO { VALUE string; + rb_encoding *enc; long pos; long lineno; int flags; int count; }; -static struct StringIO* strio_alloc _((void)); -static void strio_mark _((struct StringIO *)); -static void strio_free _((struct StringIO *)); -static struct StringIO* check_strio _((VALUE)); -static struct StringIO* get_strio _((VALUE)); -static struct StringIO* readable _((struct StringIO *)); -static struct StringIO* writable _((struct StringIO *)); -static void check_modifiable _((struct StringIO *)); +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) (RDATA(obj)->dmark == (RUBY_DATA_FUNC)strio_mark) -#define error_inval(msg) (errno = EINVAL, rb_sys_fail(msg)) +#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 : rb_enc_get((ptr)->string)) static struct StringIO * -strio_alloc() +strio_alloc(void) { struct StringIO *ptr = ALLOC(struct StringIO); ptr->string = Qnil; @@ -55,40 +137,44 @@ strio_alloc() } static void -strio_mark(ptr) - struct StringIO *ptr; +strio_mark(void *p) { - if (ptr) { - rb_gc_mark(ptr->string); - } + struct StringIO *ptr = p; + + rb_gc_mark(ptr->string); } static void -strio_free(ptr) - struct StringIO *ptr; +strio_free(void *p) { + struct StringIO *ptr = p; if (--ptr->count <= 0) { xfree(ptr); } } -static struct StringIO* -check_strio(self) - VALUE self; +static size_t +strio_memsize(const void *p) { - Check_Type(self, T_DATA); - if (!IS_STRIO(self)) { - rb_raise(rb_eTypeError, "wrong argument type %s (expected StringIO)", - rb_class2name(CLASS_OF(self))); - } - return DATA_PTR(self); + 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(self) - VALUE self; +get_strio(VALUE self) { - struct StringIO *ptr = check_strio(self); + struct StringIO *ptr = check_strio(rb_io_taint_check(self)); if (!ptr) { rb_raise(rb_eIOError, "uninitialized stream"); @@ -96,113 +182,73 @@ get_strio(self) 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 CLOSED(ptr) (!((ptr)->flags & FMODE_READWRITE)) -#define READABLE(ptr) ((ptr)->flags & FMODE_READABLE) -#define WRITABLE(ptr) ((ptr)->flags & FMODE_WRITABLE) +#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(ptr) - struct StringIO *ptr; +readable(VALUE strio) { - if (!READABLE(ptr)) { + struct StringIO *ptr = StringIO(strio); + if (!READABLE(strio)) { rb_raise(rb_eIOError, "not opened for reading"); } return ptr; } static struct StringIO* -writable(ptr) - struct StringIO *ptr; +writable(VALUE strio) { - if (!WRITABLE(ptr)) { + struct StringIO *ptr = StringIO(strio); + if (!WRITABLE(strio)) { rb_raise(rb_eIOError, "not opened for writing"); } - if (!OBJ_TAINTED(ptr->string)) { - rb_secure(4); - } return ptr; } static void -check_modifiable(ptr) - struct StringIO *ptr; +check_modifiable(struct StringIO *ptr) { if (OBJ_FROZEN(ptr->string)) { rb_raise(rb_eIOError, "not modifiable string"); } } -static VALUE strio_s_allocate _((VALUE)); -static VALUE strio_s_open _((int, VALUE *, VALUE)); -static VALUE strio_initialize _((int, VALUE *, VALUE)); -static VALUE strio_finalize _((VALUE)); -static VALUE strio_self _((VALUE)); -static VALUE strio_false _((VALUE)); -static VALUE strio_nil _((VALUE)); -static VALUE strio_0 _((VALUE)); -static VALUE strio_first _((VALUE, VALUE)); -static VALUE strio_unimpl _((int, VALUE *, VALUE)); -static VALUE strio_get_string _((VALUE)); -static VALUE strio_set_string _((VALUE, VALUE)); -static VALUE strio_close _((VALUE)); -static VALUE strio_close_read _((VALUE)); -static VALUE strio_close_write _((VALUE)); -static VALUE strio_closed _((VALUE)); -static VALUE strio_closed_read _((VALUE)); -static VALUE strio_closed_write _((VALUE)); -static VALUE strio_eof _((VALUE)); -static VALUE strio_get_lineno _((VALUE)); -static VALUE strio_set_lineno _((VALUE, VALUE)); -static VALUE strio_get_pos _((VALUE)); -static VALUE strio_set_pos _((VALUE, VALUE)); -static VALUE strio_rewind _((VALUE)); -static VALUE strio_seek _((int, VALUE *, VALUE)); -static VALUE strio_get_sync _((VALUE)); -static VALUE strio_each_byte _((VALUE)); -static VALUE strio_getc _((VALUE)); -static VALUE strio_ungetc _((VALUE, VALUE)); -static VALUE strio_readchar _((VALUE)); -static VALUE strio_getline _((int, VALUE *, struct StringIO *)); -static VALUE strio_gets _((int, VALUE *, VALUE)); -static VALUE strio_readline _((int, VALUE *, VALUE)); -static VALUE strio_each _((int, VALUE *, VALUE)); -static VALUE strio_readlines _((int, VALUE *, VALUE)); -static VALUE strio_write _((VALUE, VALUE)); -static VALUE strio_putc _((VALUE, VALUE)); -static VALUE strio_read _((int, VALUE *, VALUE)); -static VALUE strio_size _((VALUE)); -static VALUE strio_truncate _((VALUE, VALUE)); -void Init_stringio _((void)); - -/* Boyer-Moore search: copied from regex.c */ -static void bm_init_skip _((long *, const char *, long)); -static long bm_search _((const char *, long, const char *, long, const long *)); - static VALUE -strio_s_allocate(klass) - VALUE klass; +strio_s_allocate(VALUE klass) { - return Data_Wrap_Struct(klass, strio_mark, strio_free, 0); -} - -/* - * 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(argc, argv, klass) - 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); + return TypedData_Wrap_Struct(klass, &strio_data_type, 0); } /* @@ -211,56 +257,128 @@ strio_s_open(argc, argv, klass) * Creates new StringIO instance from with _string_ and _mode_. */ static VALUE -strio_initialize(argc, argv, self) - int argc; - VALUE *argv; - VALUE self; +strio_initialize(int argc, VALUE *argv, VALUE self) { struct StringIO *ptr = check_strio(self); - VALUE string, mode; - int trunc = Qfalse; if (!ptr) { DATA_PTR(self) = ptr = strio_alloc(); } rb_call_super(0, 0); - switch (rb_scan_args(argc, argv, "02", &string, &mode)) { - case 2: - if (FIXNUM_P(mode)) { - int flags = FIX2INT(mode); - ptr->flags = rb_io_modenum_flags(flags); - trunc = flags & O_TRUNC; - } - else { - const char *m = StringValueCStr(mode); - ptr->flags = rb_io_mode_flags(m); - trunc = *m == 'w'; - } - StringValue(string); - if ((ptr->flags & FMODE_WRITABLE) && OBJ_FROZEN(string)) { - errno = EACCES; - rb_sys_fail(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(); + } } - if (trunc) { - rb_str_resize(string, 0); + break; + + case 0xFE: + if (len < 2) break; + if ((unsigned char)p[1] == 0xFF) { + *bomlen = 2; + return rb_enc_find_index("UTF-16BE"); } break; - case 1: - StringValue(string); - ptr->flags = OBJ_FROZEN(string) ? FMODE_READABLE : FMODE_READWRITE; + + 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: - string = rb_str_new("", 0); - ptr->flags = FMODE_READWRITE; + 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; + struct 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 (argc) { + StringValue(string); + } + else { + string = rb_enc_str_new("", 0, rb_default_external_encoding()); + } + if (OBJ_FROZEN_RAW(string)) { + if (ptr->flags & FMODE_WRITABLE) { + rb_syserr_fail(EACCES, 0); + } + } + else { + if (NIL_P(vmode)) { + ptr->flags |= FMODE_WRITABLE; + } + } + if (ptr->flags & FMODE_TRUNC) { + rb_str_resize(string, 0); + } ptr->string = string; + if (argc == 1) { + 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(self) - VALUE self; +strio_finalize(VALUE self) { struct StringIO *ptr = StringIO(self); ptr->string = Qnil; @@ -269,11 +387,38 @@ strio_finalize(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_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+. Just for compatibility to IO. */ static VALUE -strio_false(self) - VALUE self; +strio_false(VALUE self) { StringIO(self); return Qfalse; @@ -283,19 +428,17 @@ strio_false(self) * Returns +nil+. Just for compatibility to IO. */ static VALUE -strio_nil(self) - VALUE self; +strio_nil(VALUE self) { StringIO(self); return Qnil; } /* - * Returns *strio* itself. Just for compatibility to IO. + * Returns an object itself. Just for compatibility to IO. */ static VALUE -strio_self(self) - VALUE self; +strio_self(VALUE self) { StringIO(self); return self; @@ -305,8 +448,7 @@ strio_self(self) * Returns 0. Just for compatibility to IO. */ static VALUE -strio_0(self) - VALUE self; +strio_0(VALUE self) { StringIO(self); return INT2FIX(0); @@ -316,8 +458,7 @@ strio_0(self) * Returns the argument unchanged. Just for compatibility to IO. */ static VALUE -strio_first(self, arg) - VALUE self, arg; +strio_first(VALUE self, VALUE arg) { StringIO(self); return arg; @@ -327,14 +468,12 @@ strio_first(self, arg) * Raises NotImplementedError. */ static VALUE -strio_unimpl(argc, argv, self) - int argc; - VALUE *argv; - VALUE self; +strio_unimpl(int argc, VALUE *argv, VALUE self) { StringIO(self); rb_notimplement(); - return Qnil; /* not reached */ + + UNREACHABLE; } /* @@ -343,8 +482,7 @@ strio_unimpl(argc, argv, self) * Returns underlying String object, the subject of IO. */ static VALUE -strio_get_string(self) - VALUE self; +strio_get_string(VALUE self) { return StringIO(self)->string; } @@ -356,12 +494,11 @@ strio_get_string(self) * Changes underlying String object, the subject of IO. */ static VALUE -strio_set_string(self, string) - VALUE self, string; +strio_set_string(VALUE self, VALUE string) { struct StringIO *ptr = StringIO(self); - if (!OBJ_TAINTED(self)) rb_secure(4); + rb_io_taint_check(self); ptr->flags &= ~FMODE_READWRITE; StringValue(string); ptr->flags = OBJ_FROZEN(string) ? FMODE_READABLE : FMODE_READWRITE; @@ -374,18 +511,14 @@ strio_set_string(self, string) * call-seq: * strio.close -> nil * - * Closes strio. The *strio* is unavailable for any further data + * Closes a StringIO. The stream is unavailable for any further data * operations; an +IOError+ is raised if such an attempt is made. */ static VALUE -strio_close(self) - VALUE self; +strio_close(VALUE self) { - struct StringIO *ptr = StringIO(self); - if (CLOSED(ptr)) { - rb_raise(rb_eIOError, "closed stream"); - } - ptr->flags &= ~FMODE_READWRITE; + StringIO(self); + RBASIC(self)->flags &= ~STRIO_READWRITE; return Qnil; } @@ -394,17 +527,16 @@ strio_close(self) * strio.close_read -> nil * * Closes the read end of a StringIO. Will raise an +IOError+ if the - * *strio* is not readable. + * receiver is not readable. */ static VALUE -strio_close_read(self) - VALUE self; +strio_close_read(VALUE self) { struct StringIO *ptr = StringIO(self); - if (!READABLE(ptr)) { + if (!(ptr->flags & FMODE_READABLE)) { rb_raise(rb_eIOError, "closing non-duplex IO for reading"); } - ptr->flags &= ~FMODE_READABLE; + RBASIC(self)->flags &= ~STRIO_READABLE; return Qnil; } @@ -413,17 +545,16 @@ strio_close_read(self) * strio.close_write -> nil * * Closes the write end of a StringIO. Will raise an +IOError+ if the - * *strio* is not writeable. + * receiver is not writeable. */ static VALUE -strio_close_write(self) - VALUE self; +strio_close_write(VALUE self) { struct StringIO *ptr = StringIO(self); - if (!WRITABLE(ptr)) { + if (!(ptr->flags & FMODE_WRITABLE)) { rb_raise(rb_eIOError, "closing non-duplex IO for writing"); } - ptr->flags &= ~FMODE_WRITABLE; + RBASIC(self)->flags &= ~STRIO_WRITABLE; return Qnil; } @@ -431,14 +562,13 @@ strio_close_write(self) * call-seq: * strio.closed? -> true or false * - * Returns +true+ if *strio* is completely closed, +false+ otherwise. + * Returns +true+ if the stream is completely closed, +false+ otherwise. */ static VALUE -strio_closed(self) - VALUE self; +strio_closed(VALUE self) { - struct StringIO *ptr = StringIO(self); - if (!CLOSED(ptr)) return Qfalse; + StringIO(self); + if (!CLOSED(self)) return Qfalse; return Qtrue; } @@ -446,14 +576,13 @@ strio_closed(self) * call-seq: * strio.closed_read? -> true or false * - * Returns +true+ if *strio* is not readable, +false+ otherwise. + * Returns +true+ if the stream is not readable, +false+ otherwise. */ static VALUE -strio_closed_read(self) - VALUE self; +strio_closed_read(VALUE self) { - struct StringIO *ptr = StringIO(self); - if (READABLE(ptr)) return Qfalse; + StringIO(self); + if (READABLE(self)) return Qfalse; return Qtrue; } @@ -461,38 +590,42 @@ strio_closed_read(self) * call-seq: * strio.closed_write? -> true or false * - * Returns +true+ if *strio* is not writable, +false+ otherwise. + * Returns +true+ if the stream is not writable, +false+ otherwise. */ static VALUE -strio_closed_write(self) - VALUE self; +strio_closed_write(VALUE self) { - struct StringIO *ptr = StringIO(self); - if (WRITABLE(ptr)) return Qfalse; + StringIO(self); + if (WRITABLE(self)) return Qfalse; return Qtrue; } +static struct StringIO * +strio_to_read(VALUE self) +{ + struct StringIO *ptr = readable(self); + if (ptr->pos < RSTRING_LEN(ptr->string)) return ptr; + return NULL; +} + /* * 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. + * Returns true if the stream is at the end of the data (underlying string). + * The stream must be opened for reading or an +IOError+ will be raised. */ static VALUE -strio_eof(self) - VALUE self; +strio_eof(VALUE self) { - struct StringIO *ptr = readable(StringIO(self)); - if (ptr->pos < RSTRING(ptr->string)->len) return Qfalse; + if (strio_to_read(self)) return Qfalse; return Qtrue; } /* :nodoc: */ static VALUE -strio_copy(copy, orig) - VALUE copy, orig; +strio_copy(VALUE copy, VALUE orig) { struct StringIO *ptr; @@ -503,7 +636,8 @@ strio_copy(copy, orig) 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; } @@ -512,15 +646,14 @@ strio_copy(copy, orig) * call-seq: * strio.lineno -> integer * - * Returns the current line number in *strio*. The stringio must be + * Returns the current line number. The stream must be * opened for reading. +lineno+ counts the number of times +gets+ is * called, rather than the number of newlines encountered. The two * values will differ if +gets+ is called with a separator other than * newline. See also the <code>$.</code> variable. */ static VALUE -strio_get_lineno(self) - VALUE self; +strio_get_lineno(VALUE self) { return LONG2NUM(StringIO(self)->lineno); } @@ -533,23 +666,36 @@ strio_get_lineno(self) * <code>$.</code> is updated only on the next read. */ static VALUE -strio_set_lineno(self, lineno) - VALUE self, lineno; +strio_set_lineno(VALUE self, VALUE lineno) { StringIO(self)->lineno = NUM2LONG(lineno); return lineno; } -/* call-seq: strio.binmode -> true */ -#define strio_binmode strio_self +/* + * call-seq: + * strio.binmode -> stringio + * + * Puts stream into binary mode. See IO#binmode. + * + */ +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; +} -/* call-seq: strio.fcntl */ #define strio_fcntl strio_unimpl -/* call-seq: strio.flush -> strio */ #define strio_flush strio_self -/* call-seq: strio.fsync -> 0 */ #define strio_fsync strio_0 /* @@ -557,20 +703,17 @@ strio_set_lineno(self, lineno) * strio.reopen(other_StrIO) -> strio * strio.reopen(string, mode) -> strio * - * Reinitializes *strio* with the given <i>other_StrIO</i> or _string_ + * Reinitializes the stream with the given <i>other_StrIO</i> or _string_ * and _mode_ (see StringIO#new). */ static VALUE -strio_reopen(argc, argv, self) - int argc; - VALUE *argv; - VALUE self; +strio_reopen(int argc, VALUE *argv, VALUE self) { - if (!OBJ_TAINTED(self)) rb_secure(4); - if (argc == 1 && TYPE(*argv) != T_STRING) { + rb_io_taint_check(self); + if (argc == 1 && !RB_TYPE_P(*argv, T_STRING)) { return strio_copy(self, *argv); } - return strio_initialize(argc, argv, self); + return strio_init(argc, argv, StringIO(self), self); } /* @@ -578,11 +721,10 @@ strio_reopen(argc, argv, self) * strio.pos -> integer * strio.tell -> integer * - * Returns the current offset (in bytes) of *strio*. + * Returns the current offset (in bytes). */ static VALUE -strio_get_pos(self) - VALUE self; +strio_get_pos(VALUE self) { return LONG2NUM(StringIO(self)->pos); } @@ -591,12 +733,10 @@ strio_get_pos(self) * call-seq: * strio.pos = integer -> integer * - * Seeks to the given position (in bytes) in *strio*. + * Seeks to the given position (in bytes). */ static VALUE -strio_set_pos(self, pos) - VALUE self; - VALUE pos; +strio_set_pos(VALUE self, VALUE pos) { struct StringIO *ptr = StringIO(self); long p = NUM2LONG(pos); @@ -604,7 +744,6 @@ strio_set_pos(self, pos) error_inval(0); } ptr->pos = p; - ptr->flags &= ~STRIO_EOF; return pos; } @@ -612,17 +751,15 @@ strio_set_pos(self, pos) * call-seq: * strio.rewind -> 0 * - * Positions *strio* to the beginning of input, resetting + * Positions the stream to the beginning of input, resetting * +lineno+ to zero. */ static VALUE -strio_rewind(self) - VALUE self; +strio_rewind(VALUE self) { struct StringIO *ptr = StringIO(self); ptr->pos = 0; ptr->lineno = 0; - ptr->flags &= ~STRIO_EOF; return INT2FIX(0); } @@ -634,34 +771,34 @@ strio_rewind(self) * the value of _whence_ (see IO#seek). */ static VALUE -strio_seek(argc, argv, self) - int argc; - VALUE *argv; - VALUE self; +strio_seek(int argc, VALUE *argv, VALUE self) { VALUE whence; struct StringIO *ptr = StringIO(self); - long offset; + long amount, offset; rb_scan_args(argc, argv, "11", NULL, &whence); - offset = NUM2LONG(argv[0]); + 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; + offset = ptr->pos; break; case 2: - offset += RSTRING(ptr->string)->len; + offset = RSTRING_LEN(ptr->string); break; default: - rb_raise(rb_eArgError, "invalid whence %ld", NUM2LONG(whence)); + error_inval("invalid whence"); } - if (offset < 0) { + if (amount > LONG_MAX - offset || amount + offset < 0) { error_inval(0); } - ptr->pos = offset; - ptr->flags &= ~STRIO_EOF; + ptr->pos = amount + offset; return INT2FIX(0); } @@ -672,14 +809,12 @@ strio_seek(argc, argv, self) * Returns +true+ always. */ static VALUE -strio_get_sync(self) - VALUE self; +strio_get_sync(VALUE self) { StringIO(self); return Qtrue; } -/* call-seq: strio.sync = boolean -> boolean */ #define strio_set_sync strio_first #define strio_tell strio_get_pos @@ -687,54 +822,81 @@ strio_get_sync(self) /* * call-seq: * strio.each_byte {|byte| block } -> strio + * strio.each_byte -> anEnumerator * * See IO#each_byte. */ static VALUE -strio_each_byte(self) - VALUE self; +strio_each_byte(VALUE self) { - struct StringIO *ptr = readable(StringIO(self)); - while (ptr->pos < RSTRING(ptr->string)->len) { - char c = RSTRING(ptr->string)->ptr[ptr->pos++]; + 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 Qnil; + return self; } /* * call-seq: - * strio.getc -> fixnum or nil + * strio.getc -> string or nil * * See IO#getc. */ static VALUE -strio_getc(self) - VALUE self; +strio_getc(VALUE self) +{ + struct StringIO *ptr = readable(self); + rb_encoding *enc = get_enc(ptr); + VALUE str = ptr->string; + long pos = ptr->pos; + int len; + char *p; + + if (pos >= RSTRING_LEN(str)) { + return Qnil; + } + p = RSTRING_PTR(str)+pos; + len = rb_enc_mbclen(p, RSTRING_END(str), enc); + ptr->pos += len; + return enc_subseq(str, pos, len, enc); +} + +/* + * call-seq: + * strio.getbyte -> fixnum or nil + * + * See IO#getbyte. + */ +static VALUE +strio_getbyte(VALUE self) { - struct StringIO *ptr = readable(StringIO(self)); + struct StringIO *ptr = readable(self); int c; - if (ptr->pos >= RSTRING(ptr->string)->len) { - ptr->flags |= STRIO_EOF; + if (ptr->pos >= RSTRING_LEN(ptr->string)) { return Qnil; } - c = RSTRING(ptr->string)->ptr[ptr->pos++]; + c = RSTRING_PTR(ptr->string)[ptr->pos++]; return CHR2FIX(c); } static void -strio_extend(ptr, pos, len) - struct StringIO *ptr; - long pos, len; +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(ptr->string)->len; + olen = RSTRING_LEN(ptr->string); if (pos + len > olen) { rb_str_resize(ptr->string, pos + len); if (pos > olen) - MEMZERO(RSTRING(ptr->string)->ptr + olen, char, pos - olen); + MEMZERO(RSTRING_PTR(ptr->string) + olen, char, pos - olen); } else { rb_str_modify(ptr->string); @@ -743,56 +905,185 @@ strio_extend(ptr, pos, len) /* * call-seq: - * strio.ungetc(integer) -> nil + * strio.ungetc(string) -> nil * - * Pushes back one character (passed as a parameter) onto *strio* - * such that a subsequent buffered read will return it. Pushing back - * behind the beginning of the buffer string is not possible. Nothing - * will be done if such an attempt is made. - * In other case, there is no limitation for multiple pushbacks. + * Pushes back one character (passed as a parameter) + * such that a subsequent buffered read will return it. There is no + * limitation for multiple pushbacks including pushing back behind the + * beginning of the buffer string. */ static VALUE -strio_ungetc(self, ch) - VALUE self, ch; -{ - struct StringIO *ptr = readable(StringIO(self)); - int cc = NUM2INT(ch); - long len, pos = ptr->pos; - - if (cc != EOF && pos > 0) { - if ((len = RSTRING(ptr->string)->len) < pos-- || - (unsigned char)RSTRING(ptr->string)->ptr[pos] != - (unsigned char)cc) { - strio_extend(ptr, pos, 1); - RSTRING(ptr->string)->ptr[pos] = cc; - OBJ_INFECT(ptr->string, self); +strio_ungetc(VALUE self, VALUE c) +{ + struct StringIO *ptr = readable(self); + rb_encoding *enc, *enc2; + + check_modifiable(ptr); + if (NIL_P(c)) return Qnil; + if (RB_INTEGER_TYPE_P(c)) { + int len, cc = NUM2INT(c); + char buf[16]; + + enc = rb_enc_get(ptr->string); + len = rb_enc_codelen(cc, enc); + if (len <= 0) rb_enc_uint_chr(cc, enc); + rb_enc_mbcput(cc, buf, enc); + return strio_unget_bytes(ptr, buf, len); + } + else { + SafeStringValue(c); + enc = rb_enc_get(ptr->string); + enc2 = rb_enc_get(c); + if (enc != enc2 && enc != rb_ascii8bit_encoding()) { + c = rb_str_conv_enc(c, enc2, enc); + } + strio_unget_bytes(ptr, RSTRING_PTR(c), RSTRING_LEN(c)); + RB_GC_GUARD(c); + return Qnil; + } +} + +/* + * call-seq: + * strio.ungetbyte(fixnum) -> nil + * + * See IO#ungetbyte + */ +static VALUE +strio_ungetbyte(VALUE self, VALUE c) +{ + struct StringIO *ptr = readable(self); + + check_modifiable(ptr); + if (NIL_P(c)) return Qnil; + if (RB_INTEGER_TYPE_P(c)) { + /* rb_int_and() not visible from exts */ + VALUE v = rb_funcall(c, '&', 1, INT2FIX(0xff)); + const char cc = NUM2INT(v) & 0xFF; + strio_unget_bytes(ptr, &cc, 1); + } + else { + long cl; + SafeStringValue(c); + cl = RSTRING_LEN(c); + if (cl > 0) { + strio_unget_bytes(ptr, RSTRING_PTR(c), cl); + RB_GC_GUARD(c); } - --ptr->pos; - ptr->flags &= ~STRIO_EOF; } 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, cl); + ptr->pos = pos; + return Qnil; +} + /* * call-seq: - * strio.readchar -> fixnum + * strio.readchar -> string * * See IO#readchar. */ static VALUE -strio_readchar(self) - VALUE self; +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: + * strio.readbyte -> fixnum + * + * See IO#readbyte. + */ +static VALUE +strio_readbyte(VALUE self) { - VALUE c = strio_getc(self); + VALUE c = rb_funcallv(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; +} + +/* + * 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 = 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(skip, pat, m) - long *skip; - const char *pat; - long m; +bm_init_skip(long *skip, const char *pat, long m) { int c; @@ -805,12 +1096,7 @@ bm_init_skip(skip, pat, m) } static long -bm_search(little, llen, big, blen, skip) - const char *little; - long llen; - const char *big; - long blen; - const long *skip; +bm_search(const char *little, long llen, const char *big, long blen, const long *skip) { long i, j, k; @@ -828,135 +1114,219 @@ bm_search(little, llen, big, blen, skip) return -1; } -static VALUE -strio_getline(argc, argv, ptr) - int argc; - VALUE *argv; - struct StringIO *ptr; +struct getline_arg { + VALUE rs; + long limit; + unsigned int chomp: 1; +}; + +static struct getline_arg * +prepare_getline_args(struct getline_arg *arg, int argc, VALUE *argv) { - const char *s, *e, *p; - long n; - VALUE str; + VALUE str, lim, opts; + long limit = -1; - if (argc == 0) { + argc = rb_scan_args(argc, argv, "02:", &str, &lim, &opts); + switch (argc) { + case 0: str = rb_rs; - } - else { - rb_scan_args(argc, argv, "1", &str); + 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); + str = rb_rs; + } + else { + str = tmp; + } + } + break; + + case 2: if (!NIL_P(str)) StringValue(str); + if (!NIL_P(lim)) limit = NUM2LONG(lim); + break; + } + arg->rs = str; + 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); + 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; +} - if (ptr->pos >= (n = RSTRING(ptr->string)->len)) { - ptr->flags |= STRIO_EOF; +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; + int w = 0; + rb_encoding *enc = get_enc(ptr); + + if (ptr->pos >= (n = RSTRING_LEN(ptr->string))) { return Qnil; } - s = RSTRING(ptr->string)->ptr; - e = s + RSTRING(ptr->string)->len; + 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)) { - str = rb_str_substr(ptr->string, ptr->pos, e - s); + if (arg->chomp) { + w = chomp_newline_width(s, e); + } + str = strio_substr(ptr, ptr->pos, e - s - w, enc); } - else if ((n = RSTRING(str)->len) == 0) { + else if ((n = RSTRING_LEN(str)) == 0) { p = s; - while (*p == '\n') { + while (p[(p + 1 < e) && (*p == '\r') && 0] == '\n') { + p += *p == '\r'; if (++p == e) { - ptr->flags |= STRIO_EOF; return Qnil; } } s = p; while ((p = memchr(p, '\n', e - p)) && (p != e)) { if (*++p == '\n') { - e = p; + e = p + 1; + w = (arg->chomp ? 1 : 0); + break; + } + else if (*p == '\r' && p < e && p[1] == '\n') { + e = p + 2; + w = (arg->chomp ? 2 : 0); break; } } - str = rb_str_substr(ptr->string, s - RSTRING(ptr->string)->ptr, e - s); + if (!w && arg->chomp) { + w = chomp_newline_width(s, e); + } + str = strio_substr(ptr, s - RSTRING_PTR(ptr->string), e - s - w, enc); } else if (n == 1) { - if ((p = memchr(s, RSTRING(str)->ptr[0], e - s)) != 0) { + 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 = rb_str_substr(ptr->string, ptr->pos, e - s); + str = strio_substr(ptr, ptr->pos, e - s - w, enc); } else { - if (n < e - s) { - if (e - s < 1024) { + 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(str)->ptr, char, n) == 0) { - e = p + n; + if (MEMCMP(p, RSTRING_PTR(str), char, n) == 0) { + e = p + (arg->chomp ? 0 : n); break; } } } else { long skip[1 << CHAR_BIT], pos; - p = RSTRING(str)->ptr; + 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; + e = s + pos + (arg->chomp ? 0 : n); } } } - str = rb_str_substr(ptr->string, ptr->pos, e - s); + str = strio_substr(ptr, ptr->pos, e - s - w, enc); } - ptr->pos = e - RSTRING(ptr->string)->ptr; + ptr->pos = e - RSTRING_PTR(ptr->string); ptr->lineno++; return str; } /* * call-seq: - * strio.gets(sep_string=$/) -> string or nil + * strio.gets(sep=$/, chomp: false) -> string or nil + * strio.gets(limit, chomp: false) -> string or nil + * strio.gets(sep, limit, chomp: false) -> string or nil * * See IO#gets. */ static VALUE -strio_gets(argc, argv, self) - int argc; - VALUE *argv; - VALUE self; +strio_gets(int argc, VALUE *argv, VALUE self) { - VALUE str = strio_getline(argc, argv, readable(StringIO(self))); + struct getline_arg arg; + VALUE str; + if (prepare_getline_args(&arg, argc, argv)->limit == 0) { + struct StringIO *ptr = readable(self); + return rb_enc_str_new(0, 0, get_enc(ptr)); + } + + str = strio_getline(&arg, readable(self)); rb_lastline_set(str); return str; } /* * call-seq: - * strio.readline(sep_string=$/) -> string + * strio.readline(sep=$/, chomp: false) -> string + * strio.readline(limit, chomp: false) -> string or nil + * strio.readline(sep, limit, chomp: false) -> string or nil * * See IO#readline. */ static VALUE -strio_readline(argc, argv, self) - int argc; - VALUE *argv; - VALUE self; +strio_readline(int argc, VALUE *argv, VALUE self) { - VALUE line = strio_getline(argc, argv, readable(StringIO(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; } /* * call-seq: - * strio.each(sep_string=$/) {|line| block } -> strio - * strio.each_line(sep_string=$/) {|line| block } -> strio + * strio.each(sep=$/, chomp: false) {|line| block } -> strio + * strio.each(limit, chomp: false) {|line| block } -> strio + * strio.each(sep, limit, chomp: false) {|line| block } -> strio + * strio.each(...) -> anEnumerator + * + * strio.each_line(sep=$/, chomp: false) {|line| block } -> strio + * strio.each_line(limit, chomp: false) {|line| block } -> strio + * strio.each_line(sep, limit, chomp: false) {|line| block } -> strio + * strio.each_line(...) -> anEnumerator * * See IO#each. */ static VALUE -strio_each(argc, argv, self) - int argc; - VALUE *argv; - VALUE self; +strio_each(int argc, VALUE *argv, VALUE self) { - struct StringIO *ptr = StringIO(self); VALUE line; + struct getline_arg arg; + + StringIO(self); + RETURN_ENUMERATOR(self, argc, argv); - while (!NIL_P(line = strio_getline(argc, argv, readable(ptr)))) { + if (prepare_getline_args(&arg, argc, argv)->limit == 0) { + rb_raise(rb_eArgError, "invalid limit: 0 for each_line"); + } + + while (!NIL_P(line = strio_getline(&arg, readable(self)))) { rb_yield(line); } return self; @@ -964,19 +1334,25 @@ strio_each(argc, argv, self) /* * call-seq: - * strio.readlines(sep_string=$/) -> array + * 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(argc, argv, self) - int argc; - VALUE *argv; - VALUE self; +strio_readlines(int argc, VALUE *argv, VALUE self) { - struct StringIO *ptr = StringIO(self); - VALUE ary = rb_ary_new(), line; - while (!NIL_P(line = strio_getline(argc, argv, readable(ptr)))) { + VALUE ary, line; + struct getline_arg arg; + + StringIO(self); + ary = rb_ary_new(); + if (prepare_getline_args(&arg, argc, argv)->limit == 0) { + rb_raise(rb_eArgError, "invalid limit: 0 for readlines"); + } + + while (!NIL_P(line = strio_getline(&arg, readable(self)))) { rb_ary_push(ary, line); } return ary; @@ -984,40 +1360,67 @@ strio_readlines(argc, argv, self) /* * call-seq: - * strio.write(string) -> integer - * strio.syswrite(string) -> integer + * strio.write(string, ...) -> integer + * strio.syswrite(string) -> integer * - * Appends the given string to the underlying buffer string of *strio*. + * 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(self, str) - VALUE self, str; +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(StringIO(self)); + struct StringIO *ptr = writable(self); long len, olen; + rb_encoding *enc, *enc2; + rb_encoding *const ascii8bit = rb_ascii8bit_encoding(); + rb_encoding *usascii = 0; - if (TYPE(str) != T_STRING) + if (!RB_TYPE_P(str, T_STRING)) str = rb_obj_as_string(str); - len = RSTRING(str)->len; - if (!len) return INT2FIX(0); + enc = get_enc(ptr); + 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(ptr->string)->len; + olen = RSTRING_LEN(ptr->string); if (ptr->flags & FMODE_APPEND) { ptr->pos = olen; } if (ptr->pos == olen) { - rb_str_cat(ptr->string, RSTRING(str)->ptr, len); + 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_update(ptr->string, ptr->pos, len, str); + memmove(RSTRING_PTR(ptr->string)+ptr->pos, RSTRING_PTR(str), len); } - OBJ_INFECT(ptr->string, self); + RB_GC_GUARD(str); ptr->pos += len; - return LONG2NUM(len); + return len; } /* @@ -1052,21 +1455,20 @@ strio_write(self, str) * See IO#putc. */ static VALUE -strio_putc(self, ch) - VALUE self, ch; +strio_putc(VALUE self, VALUE ch) { - struct StringIO *ptr = writable(StringIO(self)); - int c = NUM2CHR(ch); - long olen; + struct StringIO *ptr = writable(self); + VALUE str; check_modifiable(ptr); - olen = RSTRING(ptr->string)->len; - if (ptr->flags & FMODE_APPEND) { - ptr->pos = olen; + 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_extend(ptr, ptr->pos, 1); - RSTRING(ptr->string)->ptr[ptr->pos++] = c; - OBJ_INFECT(ptr->string, self); + strio_write(self, str); return ch; } @@ -1080,54 +1482,51 @@ strio_putc(self, ch) /* * call-seq: - * strio.read([length [, buffer]]) -> string, buffer, or nil + * strio.read([length [, outbuf]]) -> string, outbuf, or nil * * See IO#read. */ static VALUE -strio_read(argc, argv, self) - int argc; - VALUE *argv; - VALUE self; +strio_read(int argc, VALUE *argv, VALUE self) { - struct StringIO *ptr = readable(StringIO(self)); + struct StringIO *ptr = readable(self); VALUE str = Qnil; - long len, olen; + long len; + int binary = 0; switch (argc) { case 2: str = argv[1]; - StringValue(str); - rb_str_modify(str); + if (!NIL_P(str)) { + StringValue(str); + rb_str_modify(str); + } + /* fall through */ case 1: if (!NIL_P(argv[0])) { - len = olen = NUM2LONG(argv[0]); + len = NUM2LONG(argv[0]); if (len < 0) { rb_raise(rb_eArgError, "negative length %ld given", len); } - if (len > 0 && ptr->pos >= RSTRING(ptr->string)->len) { - ptr->flags |= STRIO_EOF; - if (!NIL_P(str)) rb_str_resize(str, 0); - return Qnil; - } - else if (ptr->flags & STRIO_EOF) { + 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: - olen = -1; - len = RSTRING(ptr->string)->len; + len = RSTRING_LEN(ptr->string); if (len <= ptr->pos) { - ptr->flags |= STRIO_EOF; + 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 { @@ -1135,118 +1534,239 @@ strio_read(argc, argv, self) } break; default: - rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc); + rb_error_arity(argc, 0, 2); } if (NIL_P(str)) { - str = rb_str_substr(ptr->string, ptr->pos, len); + rb_encoding *enc = binary ? rb_ascii8bit_encoding() : get_enc(ptr); + str = strio_substr(ptr, ptr->pos, len, enc); } else { - long rest = RSTRING(ptr->string)->len - ptr->pos; + long rest = RSTRING_LEN(ptr->string) - ptr->pos; if (len > rest) len = rest; rb_str_resize(str, len); - MEMCPY(RSTRING(str)->ptr, RSTRING(ptr->string)->ptr + ptr->pos, char, len); - } - if (NIL_P(str)) { - if (!(ptr->flags & STRIO_EOF)) str = rb_str_new(0, 0); - len = 0; + 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); } - else { - ptr->pos += len = RSTRING(str)->len; - } - if (olen < 0 || olen > len) ptr->flags |= STRIO_EOF; + 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(argc, argv, self) - int argc; - VALUE *argv; - VALUE self; +strio_sysread(int argc, VALUE *argv, VALUE self) { - VALUE val = strio_read(argc, argv, self); - if (NIL_P(val) || RSTRING(val)->len == 0) { + VALUE val = rb_funcallv_kw(self, rb_intern("read"), argc, argv, RB_PASS_CALLED_KEYWORDS); + if (NIL_P(val)) { rb_eof_error(); } return val; } -#define strio_syswrite strio_write - -/* call-seq: strio.path -> nil */ -#define strio_path strio_nil - /* * call-seq: - * strio.isatty -> nil - * strio.tty? -> nil + * 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; +} + +#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 -/* call-seq: strio.pid -> nil */ #define strio_pid strio_nil -/* call-seq: strio.fileno -> 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(self) - VALUE self; +strio_size(VALUE self) { VALUE string = StringIO(self)->string; if (NIL_P(string)) { rb_raise(rb_eIOError, "not opened"); } - return ULONG2NUM(RSTRING(string)->len); + return ULONG2NUM(RSTRING_LEN(string)); } /* * call-seq: * strio.truncate(integer) -> 0 * - * Truncates the buffer string to at most _integer_ bytes. The *strio* + * Truncates the buffer string to at most _integer_ bytes. The stream * must be opened for writing. */ static VALUE -strio_truncate(self, len) - VALUE self, len; +strio_truncate(VALUE self, VALUE len) { - VALUE string = writable(StringIO(self))->string; + VALUE string = writable(self)->string; long l = NUM2LONG(len); - long plen = RSTRING(string)->len; + long plen = RSTRING_LEN(string); if (l < 0) { - error_inval("negative legnth"); + error_inval("negative length"); } rb_str_resize(string, l); if (plen < l) { - MEMZERO(RSTRING(string)->ptr + plen, char, l - plen); + MEMZERO(RSTRING_PTR(string) + plen, char, l - plen); } return len; } /* - * Pseudo I/O on String object. + * call-seq: + * strio.external_encoding => encoding + * + * Returns the Encoding object that represents the encoding of the file. + * If the stream is write mode and no encoding is specified, returns + * +nil+. + */ + +static VALUE +strio_external_encoding(VALUE self) +{ + struct StringIO *ptr = StringIO(self); + return rb_enc_from_encoding(get_enc(ptr)); +} + +/* + * 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; + struct StringIO *ptr = StringIO(self); + VALUE ext_enc, int_enc, opt; + + argc = rb_scan_args(argc, argv, "11:", &ext_enc, &int_enc, &opt); + + if (NIL_P(ext_enc)) { + enc = rb_default_external_encoding(); + } + else { + enc = rb_to_encoding(ext_enc); + } + ptr->enc = enc; + if (WRITABLE(self)) { + rb_enc_associate(ptr->string, enc); + } + + return self; +} + +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); +} + +/* + * Pseudo I/O on String object, with interface corresponding to IO. + * + * Commonly used to simulate <code>$stdio</code> or <code>$stderr</code> + * + * === Examples + * + * require 'stringio' + * + * # Writing stream emulation + * io = StringIO.new + * io.puts "Hello World" + * io.string #=> "Hello World\n" + * + * # Reading stream emulation + * io = StringIO.new "first\nsecond\nlast\n" + * io.getc #=> "f" + * io.gets #=> "irst\n" + * io.read #=> "second\nlast\n" */ void -Init_stringio() +Init_stringio(void) { - VALUE StringIO = rb_define_class("StringIO", rb_cData); +#undef rb_intern + +#ifdef HAVE_RB_EXT_RACTOR_SAFE + rb_ext_ractor_safe(true); +#endif + + VALUE StringIO = rb_define_class("StringIO", rb_cObject); + + 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); + 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); @@ -1257,6 +1777,8 @@ Init_stringio() 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); @@ -1266,43 +1788,80 @@ Init_stringio() 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, "path", strio_path, 0); rb_define_method(StringIO, "each", strio_each, -1); - rb_define_method(StringIO, "each_byte", strio_each_byte, 0); 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, "readchar", strio_readchar, 0); + 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, "readline", strio_readline, -1); rb_define_method(StringIO, "readlines", strio_readlines, -1); rb_define_method(StringIO, "read", strio_read, -1); - rb_define_method(StringIO, "sysread", strio_sysread, -1); - rb_define_method(StringIO, "write", strio_write, 1); - rb_define_method(StringIO, "<<", strio_addstr, 1); - rb_define_method(StringIO, "print", strio_print, -1); - rb_define_method(StringIO, "printf", strio_printf, -1); + rb_define_method(StringIO, "write", strio_write_m, -1); rb_define_method(StringIO, "putc", strio_putc, 1); - rb_define_method(StringIO, "puts", strio_puts, -1); - rb_define_method(StringIO, "syswrite", strio_syswrite, 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); + + { + 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")); } diff --git a/ext/stringio/stringio.gemspec b/ext/stringio/stringio.gemspec new file mode 100644 index 0000000000..524d976cfb --- /dev/null +++ b/ext/stringio/stringio.gemspec @@ -0,0 +1,31 @@ +# -*- encoding: utf-8 -*- +# frozen_string_literal: true + +source_version = ["", "ext/stringio/"].find do |dir| + begin + break File.open(File.join(__dir__, "#{dir}stringio.c")) {|f| + f.gets("\n#define STRINGIO_VERSION ") + f.gets[/\s*"(.+)"/, 1] + } + rescue Errno::ENOENT + end +end +Gem::Specification.new do |s| + s.name = "stringio" + s.version = source_version + + s.required_rubygems_version = Gem::Requirement.new(">= 2.6") + s.require_paths = ["lib"] + s.authors = ["Nobu Nakada"] + s.description = "Pseudo `IO` class from/to `String`." + s.email = "nobu@ruby-lang.org" + s.extensions = ["ext/stringio/extconf.rb"] + s.files = ["README.md", "ext/stringio/extconf.rb", "ext/stringio/stringio.c"] + s.homepage = "https://github.com/ruby/stringio" + s.licenses = ["Ruby", "BSD-2-Clause"] + s.required_ruby_version = ">= 2.5" + s.summary = "Pseudo IO on String" + + # s.cert_chain = %w[certs/nobu.pem] + # s.signing_key = File.expand_path("~/.ssh/gem-private_key.pem") if $0 =~ /gem\z/ +end |