From 7435953055479a7733b1435f7e58454476702126 Mon Sep 17 00:00:00 2001 From: nobu Date: Mon, 11 Mar 2002 11:58:07 +0000 Subject: Initial revision git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2173 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- ext/stringio/MANIFEST | 3 + ext/stringio/stringio.c | 887 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 890 insertions(+) create mode 100644 ext/stringio/MANIFEST create mode 100644 ext/stringio/stringio.c (limited to 'ext') diff --git a/ext/stringio/MANIFEST b/ext/stringio/MANIFEST new file mode 100644 index 0000000000..2c42c84753 --- /dev/null +++ b/ext/stringio/MANIFEST @@ -0,0 +1,3 @@ +MANIFEST +README +stringio.c diff --git a/ext/stringio/stringio.c b/ext/stringio/stringio.c new file mode 100644 index 0000000000..c3bf916657 --- /dev/null +++ b/ext/stringio/stringio.c @@ -0,0 +1,887 @@ +/********************************************************************** + + stringio.c - + + $Author$ + $Date$ + 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 "rubyio.h" + +#define STRIO_APPEND 4 + +struct StringIO { + VALUE string; + 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 *)); + +#define IS_STRIO(obj) (RDATA(obj)->dmark == (RUBY_DATA_FUNC)strio_mark) +#define error_inval(msg) (errno = EINVAL, rb_sys_fail(msg)) + +static struct StringIO * +strio_alloc() +{ + 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(ptr) + struct StringIO *ptr; +{ + rb_gc_mark(ptr->string); +} + +static void +strio_free(ptr) + struct StringIO *ptr; +{ + if (--ptr->count <= 0) { + xfree(ptr); + } +} + +static struct StringIO* +check_strio(self) + VALUE self; +{ + Check_Type(self, T_DATA); + if (!IS_STRIO(self)) { + rb_raise(rb_eTypeError, "wrong argument type %s (expected String::IO)", + rb_class2name(CLASS_OF(self))); + } + return DATA_PTR(self); +} + +static struct StringIO* +get_strio(self) + VALUE self; +{ + struct StringIO *ptr = check_strio(self); + + if (!ptr) { + rb_raise(rb_eIOError, "uninitialized stream"); + } + return ptr; +} + +#define StringIO(obj) get_strio(obj) + +static struct StringIO* +readable(ptr) + struct StringIO *ptr; +{ + if (NIL_P(ptr->string) || !(ptr->flags & FMODE_READABLE)) { + rb_raise(rb_eIOError, "not opened for reading"); + } + return ptr; +} + +static struct StringIO* +writable(ptr) + struct StringIO *ptr; +{ + if (NIL_P(ptr->string) || !(ptr->flags & FMODE_WRITABLE)) { + rb_raise(rb_eIOError, "not opened for writing"); + } + if (!OBJ_TAINTED(ptr->string)) { + rb_secure(4); + } + return ptr; +} + +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_clone _((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_set_sync _((VALUE, 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_gets_internal _((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_print _((int, VALUE *, VALUE)); +static VALUE strio_printf _((int, 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; +{ + struct StringIO *ptr; + return Data_Wrap_Struct(klass, strio_mark, strio_free, 0); +} + +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); +} + +static VALUE +strio_initialize(argc, argv, self) + int argc; + VALUE *argv; + VALUE self; +{ + struct StringIO *ptr = check_strio(self); + VALUE string, mode; + + if (!ptr) { + DATA_PTR(self) = ptr = strio_alloc(); + } + rb_call_super(0, 0); + switch (rb_scan_args(argc, argv, "02", &string, &mode)) { + case 2: + StringValue(mode); + StringValue(string); + ptr->flags = rb_io_mode_flags(RSTRING(mode)->ptr); + switch (*RSTRING(mode)->ptr) { + case 'a': + ptr->flags |= STRIO_APPEND; + break; + case 'w': + rb_str_resize(string, 0); + break; + } + break; + case 1: + StringValue(string); + ptr->flags = FMODE_READWRITE; + break; + case 0: + string = rb_str_new("", 0); + ptr->flags = FMODE_READWRITE; + break; + } + ptr->string = string; + return self; +} + +static VALUE +strio_finalize(self) + VALUE self; +{ + struct StringIO *ptr = StringIO(self); + ptr->string = Qnil; + ptr->flags &= ~FMODE_READWRITE; + return self; +} + +static VALUE +strio_false(self) + VALUE self; +{ + StringIO(self); + return Qfalse; +} + +static VALUE +strio_nil(self) + VALUE self; +{ + StringIO(self); + return Qnil; +} + +static VALUE +strio_self(self) + VALUE self; +{ + StringIO(self); + return self; +} + +static VALUE +strio_0(self) + VALUE self; +{ + StringIO(self); + return INT2FIX(0); +} + +static VALUE +strio_first(self, arg) + VALUE self, arg; +{ + StringIO(self); + return arg; +} + +static VALUE +strio_unimpl(argc, argv, self) + int argc; + VALUE *argv; + VALUE self; +{ + StringIO(self); + rb_notimplement(); + return Qnil; /* not reached */ +} + +static VALUE +strio_get_string(self) + VALUE self; +{ + return StringIO(self)->string; +} + +static VALUE +strio_set_string(self, string) + VALUE self, string; +{ + struct StringIO *ptr = StringIO(self); + + if (NIL_P(string)) { + ptr->flags &= ~FMODE_READWRITE; + } + else { + StringValue(string); + ptr->flags |= FMODE_READWRITE; + } + return ptr->string = string; +} + +static VALUE +strio_close(self) + VALUE self; +{ + struct StringIO *ptr = StringIO(self); + if (NIL_P(ptr->string)) { + rb_raise(rb_eIOError, "closed stream"); + } + ptr->string = Qnil; + ptr->flags &= ~FMODE_READWRITE; + return self; +} + +static VALUE +strio_close_read(self) + VALUE self; +{ + struct StringIO *ptr = readable(StringIO(self)); + if (!((ptr->flags &= ~FMODE_READABLE) & FMODE_READWRITE)) { + ptr->string = Qnil; + } + return self; +} + +static VALUE +strio_close_write(self) + VALUE self; +{ + struct StringIO *ptr = writable(StringIO(self)); + if (!((ptr->flags &= ~FMODE_WRITABLE) & FMODE_READWRITE)) { + ptr->string = Qnil; + } + return self; +} + +static VALUE +strio_closed(self) + VALUE self; +{ + struct StringIO *ptr = StringIO(self); + if (!NIL_P(ptr->string)) return Qfalse; + return Qtrue; +} + +static VALUE +strio_closed_read(self) + VALUE self; +{ + struct StringIO *ptr = StringIO(self); + if (ptr->flags & FMODE_READABLE) return Qfalse; + return Qtrue; +} + +static VALUE +strio_closed_write(self) + VALUE self; +{ + struct StringIO *ptr = StringIO(self); + if (ptr->flags & FMODE_WRITABLE) return Qfalse; + return Qtrue; +} + +static VALUE +strio_eof(self) + VALUE self; +{ + struct StringIO *ptr = StringIO(self); + if (!(ptr->flags & FMODE_READABLE)) return Qtrue; + if (NIL_P(ptr->string)) return Qtrue; + if (ptr->pos < RSTRING(ptr->string)->len) return Qfalse; + return Qtrue; +} + +static VALUE +strio_clone(self) + VALUE self; +{ + struct StringIO *ptr = StringIO(self); + VALUE clone = rb_call_super(0, 0); + DATA_PTR(clone) = ptr; + ++ptr->count; + return self; +} + +static VALUE +strio_get_lineno(self) + VALUE self; +{ + return LONG2NUM(StringIO(self)->lineno); +} + +static VALUE +strio_set_lineno(self, lineno) + VALUE self, lineno; +{ + StringIO(self)->lineno = NUM2LONG(lineno); + return lineno; +} + +#define strio_binmode strio_self + +#define strio_reopen strio_unimpl + +#define strio_fcntl strio_unimpl + +#define strio_flush strio_self + +#define strio_fsync strio_0 + +static VALUE +strio_get_pos(self) + VALUE self; +{ + return LONG2NUM(StringIO(self)->pos); +} + +static VALUE +strio_set_pos(self, 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; +} + +static VALUE +strio_rewind(self) + VALUE self; +{ + struct StringIO *ptr = StringIO(self); + ptr->pos = 0; + ptr->lineno = 0; + return INT2FIX(0); +} + +static VALUE +strio_seek(argc, argv, self) + 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]); + switch (NIL_P(whence) ? 0 : NUM2LONG(whence)) { + case 0: + break; + case 1: + offset += ptr->pos; + break; + case 2: + offset += RSTRING(ptr->string)->len; + break; + default: + rb_raise(rb_eArgError, "invalid whence %ld", NUM2LONG(whence)); + } + if (offset < 0) { + error_inval(0); + } + ptr->pos = offset; + return INT2FIX(0); +} + +static VALUE +strio_get_sync(self) + VALUE self; +{ + StringIO(self); + return Qtrue; +} + +#define strio_set_sync strio_first + +#define strio_tell strio_get_pos + +static VALUE +strio_each_byte(self) + VALUE self; +{ + struct StringIO *ptr = readable(StringIO(self)); + while (ptr->pos < RSTRING(ptr->string)->len) { + char c = RSTRING(ptr->string)->ptr[ptr->pos++]; + rb_yield(CHR2FIX(c)); + } + return Qnil; +} + +static VALUE +strio_getc(self) + VALUE self; +{ + struct StringIO *ptr = readable(StringIO(self)); + int c; + if (ptr->pos >= RSTRING(ptr->string)->len) { + return Qnil; + } + c = RSTRING(ptr->string)->ptr[ptr->pos++]; + return CHR2FIX(c); +} + +static VALUE +strio_ungetc(self, ch) + VALUE self, ch; +{ + struct StringIO *ptr = readable(StringIO(self)); + int cc = NUM2INT(ch); + + if (cc != EOF && ptr->pos > 0) { + rb_str_modify(ptr->string); + RSTRING(ptr->string)->ptr[--ptr->pos] = cc; + } + return Qnil; +} + +static VALUE +strio_readchar(self) + VALUE self; +{ + VALUE c = strio_getc(self); + if (NIL_P(c)) rb_eof_error(); + return c; +} + +static void +bm_init_skip(skip, pat, m) + 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(little, llen, big, blen, skip) + 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_gets_internal(argc, argv, ptr) + int argc; + VALUE *argv; + struct StringIO *ptr; +{ + const char *s, *e, *p; + long n; + VALUE str; + + if (argc == 0) { + str = rb_rs; + } + else { + rb_scan_args(argc, argv, "1", &str); + if (!NIL_P(str)) StringValue(str); + } + + if (ptr->pos >= (n = RSTRING(ptr->string)->len)) return Qnil; + s = RSTRING(ptr->string)->ptr; + e = s + RSTRING(ptr->string)->len; + s += ptr->pos; + if (NIL_P(str)) { + str = rb_str_substr(ptr->string, ptr->pos, e - s); + } + else if ((n = RSTRING(str)->len) == 0) { + p = s; + while (*p == '\n') { + if (++p == e) return Qnil; + } + s = p; + while (p = memchr(p, '\n', e - p)) { + if (p == e) break; + if (*++p == '\n') { + e = p; + break; + } + } + str = rb_str_substr(ptr->string, s - RSTRING(ptr->string)->ptr, e - s); + } + else if (n == 1) { + if (p = memchr(s, RSTRING(str)->ptr[0], e - s)) { + e = p + 1; + } + str = rb_str_substr(ptr->string, ptr->pos, e - s); + } + else { + if (n < s - e) { + if (s - e < 1024) { + for (p = s; p + n <= e; ++p) { + if (MEMCMP(p, RSTRING(str)->ptr, char, n) == 0) { + e = p + n; + break; + } + } + } + else { + long skip[1 << CHAR_BIT], pos; + p = RSTRING(str)->ptr; + bm_init_skip(skip, p, n); + if ((pos = bm_search(p, n, s, e - s, skip)) >= 0) { + e = s + pos + n; + } + } + } + str = rb_str_substr(ptr->string, ptr->pos, e - s); + } + ptr->pos = e - RSTRING(ptr->string)->ptr; + ptr->lineno++; + rb_lastline_set(str); + return str; +} + +static VALUE +strio_gets(argc, argv, self) + int argc; + VALUE *argv; + VALUE self; +{ + return strio_gets_internal(argc, argv, readable(StringIO(self))); +} + +static VALUE +strio_readline(argc, argv, self) + int argc; + VALUE *argv; + VALUE self; +{ + VALUE line = strio_gets_internal(argc, argv, readable(StringIO(self))); + if (NIL_P(line)) rb_eof_error(); + return line; +} + +static VALUE +strio_each(argc, argv, self) + int argc; + VALUE *argv; + VALUE self; +{ + struct StringIO *ptr = StringIO(self); + VALUE line; + + while (!NIL_P(line = strio_gets_internal(argc, argv, readable(ptr)))) { + rb_yield(line); + } + return self; +} + +static VALUE +strio_readlines(argc, argv, self) + int argc; + VALUE *argv; + VALUE self; +{ + struct StringIO *ptr = StringIO(self); + VALUE ary = rb_ary_new(), line; + while (!NIL_P(line = strio_gets_internal(argc, argv, readable(ptr)))) { + rb_ary_push(ary, line); + } + return ary; +} + +static VALUE +strio_write(self, str) + VALUE self, str; +{ + struct StringIO *ptr = writable(StringIO(self)); + long len; + + if (TYPE(str) != T_STRING) + str = rb_obj_as_string(str); + len = RSTRING(str)->len; + if (ptr->flags & STRIO_APPEND) { + ptr->pos = RSTRING(ptr->string)->len; + } + if (ptr->pos + len > RSTRING(ptr->string)->len) { + rb_str_resize(ptr->string, ptr->pos + len); + } + rb_str_update(ptr->string, ptr->pos, len, str); + ptr->pos += len; + return LONG2NUM(len); +} + +#define strio_addstr rb_io_addstr + +#define strio_print rb_io_print + +#define strio_printf rb_io_printf + +static VALUE +strio_putc(self, ch) + VALUE self, ch; +{ + struct StringIO *ptr = writable(StringIO(self)); + int c = NUM2CHR(ch); + + if (ptr->pos >= RSTRING(ptr->string)->len) { + rb_str_resize(ptr->string, ptr->pos + 1); + } + RSTRING(ptr->string)->ptr[ptr->pos++] = c; + return ch; +} + +#define strio_puts rb_io_puts + +static VALUE +strio_read(argc, argv, self) + int argc; + VALUE *argv; + VALUE self; +{ + struct StringIO *ptr = readable(StringIO(self)); + VALUE str; + long len; + + if (ptr->pos >= RSTRING(ptr->string)->len) { + return Qnil; + } + switch (argc) { + case 1: + if (!NIL_P(argv[0])) { + len = NUM2LONG(argv[0]); + break; + } + /* fall through */ + case 0: + len = RSTRING(ptr->string)->len - ptr->pos; + break; + default: + rb_raise(rb_eArgError, "wrong number arguments (%d for 0)", argc); + } + str = rb_str_substr(ptr->string, ptr->pos, len); + ptr->pos += len; + return str; +} + +static VALUE +strio_sysread(argc, argv, self) + int argc; + VALUE *argv; + VALUE self; +{ + VALUE val = strio_read(argc, argv, self); + if (NIL_P(val)) { + rb_eof_error(); + } + return val; +} + +#define strio_syswrite strio_write + +#define strio_path rb_inspect + +#define strio_isatty strio_false + +#define strio_pid strio_nil + +#define strio_fileno strio_nil + +static VALUE +strio_size(self) + VALUE self; +{ + VALUE string = StringIO(self)->string; + if (NIL_P(string)) { + rb_raise(rb_eIOError, "not opened"); + } + return ULONG2NUM(RSTRING(string)->len); +} + +static VALUE +strio_truncate(self, len) + VALUE self, len; +{ + VALUE string = writable(StringIO(self))->string; + long l = NUM2LONG(len); + if (l < 0) { + error_inval("negative legnth"); + } + rb_str_resize(string, l); + return len; +} + +void +Init_stringio() +{ + VALUE StringIO = rb_define_class("StringIO", rb_cData); + rb_define_singleton_method(StringIO, "allocate", strio_s_allocate, 0); + rb_define_singleton_method(StringIO, "open", strio_s_open, -1); + rb_define_method(StringIO, "initialize", strio_initialize, -1); + rb_enable_super(StringIO, "initialize"); + rb_define_method(StringIO, "clone", strio_clone, 0); + rb_enable_super(StringIO, "clone"); + 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); + + 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); + rb_define_method(StringIO, "fcntl", strio_fcntl, -1); + rb_define_method(StringIO, "flush", strio_flush, 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); + 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, "getc", strio_getc, 0); + rb_define_method(StringIO, "ungetc", strio_ungetc, 1); + rb_define_method(StringIO, "readchar", strio_readchar, 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, "putc", strio_putc, 1); + rb_define_method(StringIO, "puts", strio_puts, -1); + rb_define_method(StringIO, "syswrite", strio_syswrite, 1); + + rb_define_method(StringIO, "isatty", strio_isatty, 0); + rb_define_method(StringIO, "tty?", strio_isatty, 0); + rb_define_method(StringIO, "pid", strio_pid, 0); + 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); +} -- cgit v1.2.3