diff options
Diffstat (limited to 'trunk/io.c')
-rw-r--r-- | trunk/io.c | 8391 |
1 files changed, 8391 insertions, 0 deletions
diff --git a/trunk/io.c b/trunk/io.c new file mode 100644 index 0000000000..6ca2f71f59 --- /dev/null +++ b/trunk/io.c @@ -0,0 +1,8391 @@ +/********************************************************************** + + io.c - + + $Author$ + created at: Fri Oct 15 18:08:59 JST 1993 + + Copyright (C) 1993-2007 Yukihiro Matsumoto + Copyright (C) 2000 Network Applied Communication Laboratory, Inc. + Copyright (C) 2000 Information-technology Promotion Agency, Japan + +**********************************************************************/ + +#include "ruby/ruby.h" +#include "ruby/io.h" +#include "ruby/signal.h" +#include "vm_core.h" +#include <ctype.h> +#include <errno.h> + +#define free(x) xfree(x) + +#if defined(DOSISH) || defined(__CYGWIN__) +#include <io.h> +#endif + +#include <sys/types.h> +#if defined HAVE_NET_SOCKET_H +# include <net/socket.h> +#elif defined HAVE_SYS_SOCKET_H +# include <sys/socket.h> +#endif + +#if defined(MSDOS) || defined(__BOW__) || defined(__CYGWIN__) || defined(_WIN32) || defined(__human68k__) || defined(__EMX__) || defined(__BEOS__) +# define NO_SAFE_RENAME +#endif + +#if defined(MSDOS) || defined(__CYGWIN__) || defined(_WIN32) +# define NO_LONG_FNAME +#endif + +#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(sun) || defined(_nec_ews) +# define USE_SETVBUF +#endif + +#ifdef __QNXNTO__ +#include "unix.h" +#endif + +#include <sys/types.h> +#if defined(HAVE_SYS_IOCTL_H) && !defined(DJGPP) && !defined(_WIN32) && !defined(__human68k__) +#include <sys/ioctl.h> +#endif +#if defined(HAVE_FCNTL_H) || defined(_WIN32) +#include <fcntl.h> +#elif defined(HAVE_SYS_FCNTL_H) +#include <sys/fcntl.h> +#endif + +#if !HAVE_OFF_T && !defined(off_t) +# define off_t long +#endif + +#include <sys/stat.h> + +/* EMX has sys/param.h, but.. */ +#if defined(HAVE_SYS_PARAM_H) && !(defined(__EMX__) || defined(__HIUX_MPP__)) +# include <sys/param.h> +#endif + +#if !defined NOFILE +# define NOFILE 64 +#endif + +#ifdef HAVE_UNISTD_H +#include <unistd.h> +#endif + +#ifdef HAVE_SYSCALL_H +#include <syscall.h> +#elif defined HAVE_SYS_SYSCALL_H +#include <sys/syscall.h> +#endif + +extern void Init_File(void); + +#ifdef __BEOS__ +# ifndef NOFILE +# define NOFILE (OPEN_MAX) +# endif +#endif + +#include "ruby/util.h" + +#ifndef O_ACCMODE +#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR) +#endif + +#if SIZEOF_OFF_T > SIZEOF_LONG && !defined(HAVE_LONG_LONG) +# error off_t is bigger than long, but you have no long long... +#endif + +#ifndef PIPE_BUF +# ifdef _POSIX_PIPE_BUF +# define PIPE_BUF _POSIX_PIPE_BUF +# else +# define PIPE_BUF 512 /* is this ok? */ +# endif +#endif + +VALUE rb_cIO; +VALUE rb_eEOFError; +VALUE rb_eIOError; + +VALUE rb_stdin, rb_stdout, rb_stderr; +VALUE rb_deferr; /* rescue VIM plugin */ +static VALUE orig_stdout, orig_stderr; + +VALUE rb_output_fs; +VALUE rb_rs; +VALUE rb_output_rs; +VALUE rb_default_rs; + +static VALUE argf; + +static ID id_write, id_read, id_getc, id_flush, id_readpartial; +static VALUE sym_mode, sym_perm, sym_extenc, sym_intenc, sym_encoding, sym_open_args; +static VALUE sym_textmode, sym_binmode; + +struct timeval rb_time_interval(VALUE); + +struct argf { + VALUE filename, current_file; + int gets_lineno; + int init_p, next_p; + VALUE lineno; + VALUE argv; + char *inplace; + int binmode; + struct rb_io_enc_t encs; +}; + +static int max_file_descriptor = NOFILE; +#define UPDATE_MAXFD(fd) \ + do { \ + if (max_file_descriptor < (fd)) max_file_descriptor = (fd); \ + } while (0) + +#define argf_of(obj) (*(struct argf *)DATA_PTR(obj)) +#define ARGF argf_of(argf) + +#ifdef _STDIO_USES_IOSTREAM /* GNU libc */ +# ifdef _IO_fpos_t +# define STDIO_READ_DATA_PENDING(fp) ((fp)->_IO_read_ptr != (fp)->_IO_read_end) +# else +# define STDIO_READ_DATA_PENDING(fp) ((fp)->_gptr < (fp)->_egptr) +# endif +#elif defined(FILE_COUNT) +# define STDIO_READ_DATA_PENDING(fp) ((fp)->FILE_COUNT > 0) +#elif defined(FILE_READEND) +# define STDIO_READ_DATA_PENDING(fp) ((fp)->FILE_READPTR < (fp)->FILE_READEND) +#elif defined(__BEOS__) +# define STDIO_READ_DATA_PENDING(fp) (fp->_state._eof == 0) +#elif defined(__VMS) +# define STDIO_READ_DATA_PENDING(fp) (((unsigned int)(*(fp))->_cnt) > 0) +#else +# define STDIO_READ_DATA_PENDING(fp) (!feof(fp)) +#endif + +#if defined(__VMS) +#define open(file_spec, flags, mode) open(file_spec, flags, mode, "rfm=stmlf") +#endif + +#define GetWriteIO(io) rb_io_get_write_io(io) + +#define READ_DATA_PENDING(fptr) ((fptr)->rbuf_len) +#define READ_DATA_PENDING_COUNT(fptr) ((fptr)->rbuf_len) +#define READ_DATA_PENDING_PTR(fptr) ((fptr)->rbuf+(fptr)->rbuf_off) +#define READ_DATA_BUFFERED(fptr) READ_DATA_PENDING(fptr) + +#define READ_CHECK(fptr) do {\ + if (!READ_DATA_PENDING(fptr)) {\ + rb_thread_wait_fd((fptr)->fd);\ + rb_io_check_closed(fptr);\ + }\ +} while(0) + +#ifndef S_ISSOCK +# ifdef _S_ISSOCK +# define S_ISSOCK(m) _S_ISSOCK(m) +# else +# ifdef _S_IFSOCK +# define S_ISSOCK(m) ((m & S_IFMT) == _S_IFSOCK) +# else +# ifdef S_IFSOCK +# define S_ISSOCK(m) ((m & S_IFMT) == S_IFSOCK) +# endif +# endif +# endif +#endif + +#if !defined HAVE_SHUTDOWN && !defined shutdown +#define shutdown(a,b) 0 +#endif + +#define rb_sys_fail_path(path) rb_sys_fail(NIL_P(path) ? 0 : RSTRING_PTR(path)) + +#if defined(_WIN32) +#define is_socket(fd, path) rb_w32_is_socket(fd) +#elif !defined(S_ISSOCK) +#define is_socket(fd, path) 0 +#else +static int +is_socket(int fd, VALUE path) +{ + struct stat sbuf; + if (fstat(fd, &sbuf) < 0) + rb_sys_fail_path(path); + return S_ISSOCK(sbuf.st_mode); +} +#endif + +void +rb_eof_error(void) +{ + rb_raise(rb_eEOFError, "end of file reached"); +} + +VALUE +rb_io_taint_check(VALUE io) +{ + if (!OBJ_UNTRUSTED(io) && rb_safe_level() >= 4) + rb_raise(rb_eSecurityError, "Insecure: operation on trusted IO"); + rb_check_frozen(io); + return io; +} + +void +rb_io_check_initialized(rb_io_t *fptr) +{ + if (!fptr) { + rb_raise(rb_eIOError, "uninitialized stream"); + } +} + +void +rb_io_check_closed(rb_io_t *fptr) +{ + rb_io_check_initialized(fptr); + if (fptr->fd < 0) { + rb_raise(rb_eIOError, "closed stream"); + } +} + +static int io_fflush(rb_io_t *); + +VALUE +rb_io_get_io(VALUE io) +{ + return rb_convert_type(io, T_FILE, "IO", "to_io"); +} + +static VALUE +rb_io_check_io(VALUE io) +{ + return rb_check_convert_type(io, T_FILE, "IO", "to_io"); +} + +VALUE +rb_io_get_write_io(VALUE io) +{ + VALUE write_io; + rb_io_check_initialized(RFILE(io)->fptr); + write_io = RFILE(io)->fptr->tied_io_for_writing; + if (write_io) { + return write_io; + } + return io; +} + +/* + * call-seq: + * IO.try_convert(obj) -> io or nil + * + * Try to convert <i>obj</i> into an IO, using to_io method. + * Returns converted IO or nil if <i>obj</i> cannot be converted + * for any reason. + * + * IO.try_convert(STDOUT) # => STDOUT + * IO.try_convert("STDOUT") # => nil + */ +static VALUE +rb_io_s_try_convert(VALUE dummy, VALUE io) +{ + return rb_io_check_io(io); +} + +static void +io_unread(rb_io_t *fptr) +{ + off_t r; + rb_io_check_closed(fptr); + if (fptr->rbuf_len == 0 || fptr->mode & FMODE_DUPLEX) + return; + /* xxx: target position may be negative if buffer is filled by ungetc */ + r = lseek(fptr->fd, -fptr->rbuf_len, SEEK_CUR); + if (r < 0) { + if (errno == ESPIPE) + fptr->mode |= FMODE_DUPLEX; + return; + } + fptr->rbuf_off = 0; + fptr->rbuf_len = 0; + return; +} + +static rb_encoding *io_input_encoding(rb_io_t *fptr); + +static void +io_ungetbyte(VALUE str, rb_io_t *fptr) +{ + int len = RSTRING_LEN(str); + + if (fptr->rbuf == NULL) { + fptr->rbuf_off = 0; + fptr->rbuf_len = 0; + if (len > 8192) + fptr->rbuf_capa = len; + else + fptr->rbuf_capa = 8192; + fptr->rbuf = ALLOC_N(char, fptr->rbuf_capa); + } + if (fptr->rbuf_capa < len + fptr->rbuf_len) { + rb_raise(rb_eIOError, "ungetbyte failed"); + } + if (fptr->rbuf_off < len) { + MEMMOVE(fptr->rbuf+fptr->rbuf_capa-fptr->rbuf_len, + fptr->rbuf+fptr->rbuf_off, + char, fptr->rbuf_len); + fptr->rbuf_off = fptr->rbuf_capa-fptr->rbuf_len; + } + fptr->rbuf_off-=len; + fptr->rbuf_len+=len; + MEMMOVE(fptr->rbuf+fptr->rbuf_off, RSTRING_PTR(str), char, len); +} + +static rb_io_t * +flush_before_seek(rb_io_t *fptr) +{ + io_fflush(fptr); + io_unread(fptr); + errno = 0; + return fptr; +} + +#define io_seek(fptr, ofs, whence) lseek(flush_before_seek(fptr)->fd, ofs, whence) +#define io_tell(fptr) lseek(flush_before_seek(fptr)->fd, 0, SEEK_CUR) + +#ifndef SEEK_CUR +# define SEEK_SET 0 +# define SEEK_CUR 1 +# define SEEK_END 2 +#endif + +#define FMODE_SYNCWRITE (FMODE_SYNC|FMODE_WRITABLE) + +void +rb_io_check_readable(rb_io_t *fptr) +{ + rb_io_check_closed(fptr); + if (!(fptr->mode & FMODE_READABLE)) { + rb_raise(rb_eIOError, "not opened for reading"); + } + if (fptr->wbuf_len) { + io_fflush(fptr); + } + if (fptr->tied_io_for_writing) { + rb_io_t *wfptr; + GetOpenFile(fptr->tied_io_for_writing, wfptr); + io_fflush(wfptr); + } +} + +static rb_encoding* +io_read_encoding(rb_io_t *fptr) +{ + if (fptr->encs.enc) { + return fptr->encs.enc; + } + return rb_default_external_encoding(); +} + +static rb_encoding* +io_input_encoding(rb_io_t *fptr) +{ + if (fptr->encs.enc2) { + return fptr->encs.enc2; + } + return io_read_encoding(fptr); +} + +void +rb_io_check_writable(rb_io_t *fptr) +{ + rb_io_check_closed(fptr); + if (!(fptr->mode & FMODE_WRITABLE)) { + rb_raise(rb_eIOError, "not opened for writing"); + } + if (fptr->rbuf_len) { + io_unread(fptr); + } +} + +int +rb_read_pending(FILE *fp) +{ + return STDIO_READ_DATA_PENDING(fp); +} + +int +rb_io_read_pending(rb_io_t *fptr) +{ + return READ_DATA_PENDING(fptr); +} + +void +rb_read_check(FILE *fp) +{ + if (!STDIO_READ_DATA_PENDING(fp)) { + rb_thread_wait_fd(fileno(fp)); + } +} + +void +rb_io_read_check(rb_io_t *fptr) +{ + if (!READ_DATA_PENDING(fptr)) { + rb_thread_wait_fd(fptr->fd); + } + return; +} + +static int +ruby_dup(int orig) +{ + int fd; + + fd = dup(orig); + if (fd < 0) { + if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) { + rb_gc(); + fd = dup(orig); + } + if (fd < 0) { + rb_sys_fail(0); + } + } + return fd; +} + +static VALUE +io_alloc(VALUE klass) +{ + NEWOBJ(io, struct RFile); + OBJSETUP(io, klass, T_FILE); + + io->fptr = 0; + + return (VALUE)io; +} + +#ifndef S_ISREG +# define S_ISREG(m) ((m & S_IFMT) == S_IFREG) +#endif + +static int +wsplit_p(rb_io_t *fptr) +{ +#if defined(HAVE_FCNTL) && defined(F_GETFL) && defined(O_NONBLOCK) + int r; +#endif + + if (!(fptr->mode & FMODE_WSPLIT_INITIALIZED)) { + struct stat buf; + if (fstat(fptr->fd, &buf) == 0 && + !S_ISREG(buf.st_mode) +#if defined(HAVE_FCNTL) && defined(F_GETFL) && defined(O_NONBLOCK) + && (r = fcntl(fptr->fd, F_GETFL)) != -1 && + !(r & O_NONBLOCK) +#endif + ) { + fptr->mode |= FMODE_WSPLIT; + } + fptr->mode |= FMODE_WSPLIT_INITIALIZED; + } + return fptr->mode & FMODE_WSPLIT; +} + +struct io_internal_struct { + int fd; + void *buf; + size_t capa; +}; + +static VALUE +internal_read_func(void *ptr) +{ + struct io_internal_struct *iis = (struct io_internal_struct*)ptr; + return read(iis->fd, iis->buf, iis->capa); +} + +static VALUE +internal_write_func(void *ptr) +{ + struct io_internal_struct *iis = (struct io_internal_struct*)ptr; + return write(iis->fd, iis->buf, iis->capa); +} + +static int +rb_read_internal(int fd, void *buf, size_t count) +{ + struct io_internal_struct iis; + iis.fd = fd; + iis.buf = buf; + iis.capa = count; + + return rb_thread_blocking_region(internal_read_func, &iis, RB_UBF_DFL, 0); +} + +static int +rb_write_internal(int fd, void *buf, size_t count) +{ + struct io_internal_struct iis; + iis.fd = fd; + iis.buf = buf; + iis.capa = count; + + return rb_thread_blocking_region(internal_write_func, &iis, RB_UBF_DFL, 0); +} + +static int +io_fflush(rb_io_t *fptr) +{ + int r, l; + int wbuf_off, wbuf_len; + + rb_io_check_closed(fptr); + if (fptr->wbuf_len == 0) + return 0; + if (!rb_thread_fd_writable(fptr->fd)) { + rb_io_check_closed(fptr); + } + retry: + if (fptr->wbuf_len == 0) + return 0; + wbuf_off = fptr->wbuf_off; + wbuf_len = fptr->wbuf_len; + l = wbuf_len; + if (PIPE_BUF < l && + !rb_thread_critical && + !rb_thread_alone() && + wsplit_p(fptr)) { + l = PIPE_BUF; + } + r = rb_write_internal(fptr->fd, fptr->wbuf+wbuf_off, l); + /* xxx: Other threads may modify wbuf. + * A lock is required, definitely. */ + rb_io_check_closed(fptr); + if (fptr->wbuf_len <= r) { + fptr->wbuf_off = 0; + fptr->wbuf_len = 0; + return 0; + } + if (0 <= r) { + fptr->wbuf_off += r; + fptr->wbuf_len -= r; + errno = EAGAIN; + } + if (rb_io_wait_writable(fptr->fd)) { + rb_io_check_closed(fptr); + goto retry; + } + return -1; +} + +#ifdef HAVE_RB_FD_INIT +static VALUE +wait_readable(VALUE p) +{ + rb_fdset_t *rfds = (rb_fdset_t *)p; + + return rb_thread_select(rb_fd_max(rfds), rb_fd_ptr(rfds), NULL, NULL, NULL); +} +#endif + +int +rb_io_wait_readable(int f) +{ + rb_fdset_t rfds; + + if (f < 0) { + rb_raise(rb_eIOError, "closed stream"); + } + switch (errno) { + case EINTR: +#if defined(ERESTART) + case ERESTART: +#endif + rb_thread_wait_fd(f); + return Qtrue; + + case EAGAIN: +#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN + case EWOULDBLOCK: +#endif + rb_fd_init(&rfds); + rb_fd_set(f, &rfds); +#ifdef HAVE_RB_FD_INIT + rb_ensure(wait_readable, (VALUE)&rfds, + (VALUE (*)(VALUE))rb_fd_term, (VALUE)&rfds); +#else + rb_thread_select(f + 1, &rfds, NULL, NULL, NULL); +#endif + return Qtrue; + + default: + return Qfalse; + } +} + +#ifdef HAVE_RB_FD_INIT +static VALUE +wait_writable(VALUE p) +{ + rb_fdset_t *wfds = (rb_fdset_t *)p; + + return rb_thread_select(rb_fd_max(wfds), NULL, rb_fd_ptr(wfds), NULL, NULL); +} +#endif + +int +rb_io_wait_writable(int f) +{ + rb_fdset_t wfds; + + if (f < 0) { + rb_raise(rb_eIOError, "closed stream"); + } + switch (errno) { + case EINTR: +#if defined(ERESTART) + case ERESTART: +#endif + rb_thread_fd_writable(f); + return Qtrue; + + case EAGAIN: +#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN + case EWOULDBLOCK: +#endif + rb_fd_init(&wfds); + rb_fd_set(f, &wfds); +#ifdef HAVE_RB_FD_INIT + rb_ensure(wait_writable, (VALUE)&wfds, + (VALUE (*)(VALUE))rb_fd_term, (VALUE)&wfds); +#else + rb_thread_select(f + 1, NULL, &wfds, NULL, NULL); +#endif + return Qtrue; + + default: + return Qfalse; + } +} + +/* xxx: better way to determine the newline of the platform? */ +#if defined(O_BINARY) && O_BINARY != 0 +/* Windows */ +# define NEED_NEWLINE_DECODER(fptr) (!(fptr->mode & FMODE_BINMODE)) +# define NEED_NEWLINE_ENCODER(fptr) (!(fptr->mode & FMODE_BINMODE)) +# define TEXTMODE_NEWLINE_ENCODER ECONV_CRLF_NEWLINE_ENCODER +#else +/* Unix */ +# define NEED_NEWLINE_DECODER(fptr) (fptr->mode & FMODE_TEXTMODE) +# define NEED_NEWLINE_ENCODER(fptr) 0 +#endif +#define NEED_READCONV(fptr) (fptr->encs.enc2 != NULL || NEED_NEWLINE_DECODER(fptr)) +#define NEED_WRITECONV(fptr) (fptr->encs.enc != NULL || NEED_NEWLINE_ENCODER(fptr)) + +static void +make_writeconv(rb_io_t *fptr) +{ + if (!fptr->writeconv_initialized) { + const char *senc, *denc; + rb_encoding *enc; + rb_econv_option_t ecopts; + + fptr->writeconv_initialized = 1; + + ecopts = fptr->encs.opts; + +#ifdef TEXTMODE_NEWLINE_ENCODER + if (NEED_NEWLINE_ENCODER(fptr)) + ecopts.flags |= TEXTMODE_NEWLINE_ENCODER; + + if (!fptr->encs.enc) { + fptr->writeconv = rb_econv_open("", "", &ecopts); + if (!fptr->writeconv) + rb_exc_raise(rb_econv_open_exc("", "", &ecopts)); + fptr->writeconv_stateless = Qnil; + return; + } +#endif + + enc = fptr->encs.enc2 ? fptr->encs.enc2 : fptr->encs.enc; + senc = rb_econv_stateless_encoding(enc->name); + if (senc) { + denc = enc->name; + fptr->writeconv_stateless = rb_str_new2(senc); + } + else { + denc = NULL; + fptr->writeconv_stateless = Qnil; + } + if (senc) { + fptr->writeconv = rb_econv_open(senc, denc, &ecopts); + if (!fptr->writeconv) + rb_exc_raise(rb_econv_open_exc(senc, denc, &ecopts)); + } + else { + fptr->writeconv = NULL; + } + } +} + +/* writing functions */ +static long +io_fwrite(VALUE str, rb_io_t *fptr) +{ + long len, n, r, l, offset = 0; + + if (NEED_WRITECONV(fptr)) { + VALUE common_encoding = Qnil; + make_writeconv(fptr); + + if (fptr->writeconv) { + if (!NIL_P(fptr->writeconv_stateless)) + common_encoding = fptr->writeconv_stateless; + } + else { + if (fptr->encs.enc2) + common_encoding = rb_enc_from_encoding(fptr->encs.enc2); + else + common_encoding = rb_enc_from_encoding(fptr->encs.enc); + } + + if (!NIL_P(common_encoding)) { + str = rb_str_transcode(str, common_encoding, &fptr->encs.opts); + } + + if (fptr->writeconv) { + str = rb_econv_str_convert(fptr->writeconv, str, ECONV_PARTIAL_INPUT); + } + } + + len = RSTRING_LEN(str); + if ((n = len) <= 0) return n; + if (fptr->wbuf == NULL && !(fptr->mode & FMODE_SYNC)) { + fptr->wbuf_off = 0; + fptr->wbuf_len = 0; + fptr->wbuf_capa = 8192; + fptr->wbuf = ALLOC_N(char, fptr->wbuf_capa); + } + if ((fptr->mode & (FMODE_SYNC|FMODE_TTY)) || + (fptr->wbuf && fptr->wbuf_capa <= fptr->wbuf_len + len)) { + /* xxx: use writev to avoid double write if available */ + if (fptr->wbuf_len && fptr->wbuf_len+len <= fptr->wbuf_capa) { + if (fptr->wbuf_capa < fptr->wbuf_off+fptr->wbuf_len+len) { + MEMMOVE(fptr->wbuf, fptr->wbuf+fptr->wbuf_off, char, fptr->wbuf_len); + fptr->wbuf_off = 0; + } + MEMMOVE(fptr->wbuf+fptr->wbuf_off+fptr->wbuf_len, RSTRING_PTR(str)+offset, char, len); + fptr->wbuf_len += len; + n = 0; + } + if (io_fflush(fptr) < 0) + return -1L; + if (n == 0) + return len; + /* avoid context switch between "a" and "\n" in STDERR.puts "a". + [ruby-dev:25080] */ + if (fptr->stdio_file != stderr && !rb_thread_fd_writable(fptr->fd)) { + rb_io_check_closed(fptr); + } + retry: + l = n; + if (PIPE_BUF < l && + !rb_thread_critical && + !rb_thread_alone() && + wsplit_p(fptr)) { + l = PIPE_BUF; + } + r = rb_write_internal(fptr->fd, RSTRING_PTR(str)+offset, l); + /* xxx: other threads may modify given string. */ + if (r == n) return len; + if (0 <= r) { + offset += r; + n -= r; + errno = EAGAIN; + } + if (rb_io_wait_writable(fptr->fd)) { + rb_io_check_closed(fptr); + if (offset < RSTRING_LEN(str)) + goto retry; + } + return -1L; + } + + if (fptr->wbuf_off) { + if (fptr->wbuf_len) + MEMMOVE(fptr->wbuf, fptr->wbuf+fptr->wbuf_off, char, fptr->wbuf_len); + fptr->wbuf_off = 0; + } + MEMMOVE(fptr->wbuf+fptr->wbuf_off+fptr->wbuf_len, RSTRING_PTR(str)+offset, char, len); + fptr->wbuf_len += len; + return len; +} + +long +rb_io_fwrite(const char *ptr, long len, FILE *f) +{ + rb_io_t of; + + of.fd = fileno(f); + of.stdio_file = f; + of.mode = FMODE_WRITABLE; + of.pathv = Qnil; + return io_fwrite(rb_str_new(ptr, len), &of); +} + +/* + * call-seq: + * ios.write(string) => integer + * + * Writes the given string to <em>ios</em>. 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. + * + * count = $stdout.write( "This is a test\n" ) + * puts "That was #{count} bytes of data" + * + * <em>produces:</em> + * + * This is a test + * That was 15 bytes of data + */ + +static VALUE +io_write(VALUE io, VALUE str) +{ + rb_io_t *fptr; + long n; + VALUE tmp; + + rb_secure(4); + io = GetWriteIO(io); + str = rb_obj_as_string(str); + tmp = rb_io_check_io(io); + if (NIL_P(tmp)) { + /* port is not IO, call write method for it. */ + return rb_funcall(io, id_write, 1, str); + } + io = tmp; + if (RSTRING_LEN(str) == 0) return INT2FIX(0); + + GetOpenFile(io, fptr); + rb_io_check_writable(fptr); + + n = io_fwrite(str, fptr); + if (n == -1L) rb_sys_fail_path(fptr->pathv); + + return LONG2FIX(n); +} + +VALUE +rb_io_write(VALUE io, VALUE str) +{ + return rb_funcall(io, id_write, 1, str); +} + +/* + * call-seq: + * ios << obj => ios + * + * String Output---Writes <i>obj</i> to <em>ios</em>. + * <i>obj</i> will be converted to a string using + * <code>to_s</code>. + * + * $stdout << "Hello " << "world!\n" + * + * <em>produces:</em> + * + * Hello world! + */ + + +VALUE +rb_io_addstr(VALUE io, VALUE str) +{ + rb_io_write(io, str); + return io; +} + +/* + * call-seq: + * ios.flush => ios + * + * Flushes any buffered data within <em>ios</em> to the underlying + * operating system (note that this is Ruby internal buffering only; + * the OS may buffer the data as well). + * + * $stdout.print "no newline" + * $stdout.flush + * + * <em>produces:</em> + * + * no newline + */ + +VALUE +rb_io_flush(VALUE io) +{ + rb_io_t *fptr; + + if (TYPE(io) != T_FILE) { + return rb_funcall(io, id_flush, 0); + } + + io = GetWriteIO(io); + GetOpenFile(io, fptr); + + if (fptr->mode & FMODE_WRITABLE) { + io_fflush(fptr); + } + if (fptr->mode & FMODE_READABLE) { + io_unread(fptr); + } + + return io; +} + +/* + * call-seq: + * ios.pos => integer + * ios.tell => integer + * + * Returns the current offset (in bytes) of <em>ios</em>. + * + * f = File.new("testfile") + * f.pos #=> 0 + * f.gets #=> "This is line one\n" + * f.pos #=> 17 + */ + +static VALUE +rb_io_tell(VALUE io) +{ + rb_io_t *fptr; + off_t pos; + + GetOpenFile(io, fptr); + pos = io_tell(fptr); + if (pos < 0 && errno) rb_sys_fail_path(fptr->pathv); + return OFFT2NUM(pos); +} + +static VALUE +rb_io_seek(VALUE io, VALUE offset, int whence) +{ + rb_io_t *fptr; + off_t pos; + + pos = NUM2OFFT(offset); + GetOpenFile(io, fptr); + pos = io_seek(fptr, pos, whence); + if (pos < 0 && errno) rb_sys_fail_path(fptr->pathv); + + return INT2FIX(0); +} + +/* + * call-seq: + * ios.seek(amount, whence=SEEK_SET) -> 0 + * + * Seeks to a given offset <i>anInteger</i> in the stream according to + * the value of <i>whence</i>: + * + * IO::SEEK_CUR | Seeks to _amount_ plus current position + * --------------+---------------------------------------------------- + * IO::SEEK_END | Seeks to _amount_ plus end of stream (you probably + * | want a negative value for _amount_) + * --------------+---------------------------------------------------- + * IO::SEEK_SET | Seeks to the absolute location given by _amount_ + * + * Example: + * + * f = File.new("testfile") + * f.seek(-13, IO::SEEK_END) #=> 0 + * f.readline #=> "And so on...\n" + */ + +static VALUE +rb_io_seek_m(int argc, VALUE *argv, VALUE io) +{ + VALUE offset, ptrname; + int whence = SEEK_SET; + + if (rb_scan_args(argc, argv, "11", &offset, &ptrname) == 2) { + whence = NUM2INT(ptrname); + } + + return rb_io_seek(io, offset, whence); +} + +/* + * call-seq: + * ios.pos = integer => integer + * + * Seeks to the given position (in bytes) in <em>ios</em>. + * + * f = File.new("testfile") + * f.pos = 17 + * f.gets #=> "This is line two\n" + */ + +static VALUE +rb_io_set_pos(VALUE io, VALUE offset) +{ + rb_io_t *fptr; + off_t pos; + + pos = NUM2OFFT(offset); + GetOpenFile(io, fptr); + pos = io_seek(fptr, pos, SEEK_SET); + if (pos < 0) rb_sys_fail_path(fptr->pathv); + + return OFFT2NUM(pos); +} + +/* + * call-seq: + * ios.rewind => 0 + * + * Positions <em>ios</em> to the beginning of input, resetting + * <code>lineno</code> to zero. + * + * f = File.new("testfile") + * f.readline #=> "This is line one\n" + * f.rewind #=> 0 + * f.lineno #=> 0 + * f.readline #=> "This is line one\n" + */ + +static VALUE +rb_io_rewind(VALUE io) +{ + rb_io_t *fptr; + + GetOpenFile(io, fptr); + if (io_seek(fptr, 0L, 0) < 0) rb_sys_fail_path(fptr->pathv); + if (io == ARGF.current_file) { + ARGF.gets_lineno -= fptr->lineno; + } + fptr->lineno = 0; + + return INT2FIX(0); +} + +static int +io_fillbuf(rb_io_t *fptr) +{ + int r; + + if (fptr->rbuf == NULL) { + fptr->rbuf_off = 0; + fptr->rbuf_len = 0; + fptr->rbuf_capa = 8192; + fptr->rbuf = ALLOC_N(char, fptr->rbuf_capa); + } + if (fptr->rbuf_len == 0) { + retry: + { + r = rb_read_internal(fptr->fd, fptr->rbuf, fptr->rbuf_capa); + } + if (r < 0) { + if (rb_io_wait_readable(fptr->fd)) + goto retry; + rb_sys_fail_path(fptr->pathv); + } + fptr->rbuf_off = 0; + fptr->rbuf_len = r; + if (r == 0) + return -1; /* EOF */ + } + return 0; +} + +/* + * call-seq: + * ios.eof => true or false + * ios.eof? => true or false + * + * Returns true if <em>ios</em> is at end of file that means + * there are no more data to read. + * The stream must be opened for reading or an <code>IOError</code> will be + * raised. + * + * f = File.new("testfile") + * dummy = f.readlines + * f.eof #=> true + * + * If <em>ios</em> is a stream such as pipe or socket, <code>IO#eof?</code> + * blocks until the other end sends some data or closes it. + * + * r, w = IO.pipe + * Thread.new { sleep 1; w.close } + * r.eof? #=> true after 1 second blocking + * + * r, w = IO.pipe + * Thread.new { sleep 1; w.puts "a" } + * r.eof? #=> false after 1 second blocking + * + * r, w = IO.pipe + * r.eof? # blocks forever + * + * Note that <code>IO#eof?</code> reads data to a input buffer. + * So <code>IO#sysread</code> doesn't work with <code>IO#eof?</code>. + */ + +VALUE +rb_io_eof(VALUE io) +{ + rb_io_t *fptr; + + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + + if (READ_DATA_PENDING(fptr)) return Qfalse; + READ_CHECK(fptr); + if (io_fillbuf(fptr) < 0) { + return Qtrue; + } + return Qfalse; +} + +/* + * call-seq: + * ios.sync => true or false + * + * Returns the current ``sync mode'' of <em>ios</em>. When sync mode is + * true, all output is immediately flushed to the underlying operating + * system and is not buffered by Ruby internally. See also + * <code>IO#fsync</code>. + * + * f = File.new("testfile") + * f.sync #=> false + */ + +static VALUE +rb_io_sync(VALUE io) +{ + rb_io_t *fptr; + + io = GetWriteIO(io); + GetOpenFile(io, fptr); + return (fptr->mode & FMODE_SYNC) ? Qtrue : Qfalse; +} + +/* + * call-seq: + * ios.sync = boolean => boolean + * + * Sets the ``sync mode'' to <code>true</code> or <code>false</code>. + * When sync mode is true, all output is immediately flushed to the + * underlying operating system and is not buffered internally. Returns + * the new state. See also <code>IO#fsync</code>. + * + * f = File.new("testfile") + * f.sync = true + * + * <em>(produces no output)</em> + */ + +static VALUE +rb_io_set_sync(VALUE io, VALUE mode) +{ + rb_io_t *fptr; + + io = GetWriteIO(io); + GetOpenFile(io, fptr); + if (RTEST(mode)) { + fptr->mode |= FMODE_SYNC; + } + else { + fptr->mode &= ~FMODE_SYNC; + } + return mode; +} + +/* + * call-seq: + * ios.fsync => 0 or nil + * + * Immediately writes all buffered data in <em>ios</em> to disk. + * Returns <code>nil</code> if the underlying operating system does not + * support <em>fsync(2)</em>. Note that <code>fsync</code> differs from + * using <code>IO#sync=</code>. The latter ensures that data is flushed + * from Ruby's buffers, but doesn't not guarantee that the underlying + * operating system actually writes it to disk. + */ + +static VALUE +rb_io_fsync(VALUE io) +{ +#ifdef HAVE_FSYNC + rb_io_t *fptr; + + io = GetWriteIO(io); + GetOpenFile(io, fptr); + + io_fflush(fptr); + if (fsync(fptr->fd) < 0) + rb_sys_fail_path(fptr->pathv); + return INT2FIX(0); +#else + rb_notimplement(); + return Qnil; /* not reached */ +#endif +} + +/* + * call-seq: + * ios.fileno => fixnum + * ios.to_i => fixnum + * + * Returns an integer representing the numeric file descriptor for + * <em>ios</em>. + * + * $stdin.fileno #=> 0 + * $stdout.fileno #=> 1 + */ + +static VALUE +rb_io_fileno(VALUE io) +{ + rb_io_t *fptr; + int fd; + + GetOpenFile(io, fptr); + fd = fptr->fd; + return INT2FIX(fd); +} + + +/* + * call-seq: + * ios.pid => fixnum + * + * Returns the process ID of a child process associated with + * <em>ios</em>. This will be set by <code>IO::popen</code>. + * + * pipe = IO.popen("-") + * if pipe + * $stderr.puts "In parent, child pid is #{pipe.pid}" + * else + * $stderr.puts "In child, pid is #{$$}" + * end + * + * <em>produces:</em> + * + * In child, pid is 26209 + * In parent, child pid is 26209 + */ + +static VALUE +rb_io_pid(VALUE io) +{ + rb_io_t *fptr; + + GetOpenFile(io, fptr); + if (!fptr->pid) + return Qnil; + return PIDT2NUM(fptr->pid); +} + + +/* + * call-seq: + * ios.inspect => string + * + * Return a string describing this IO object. + */ + +static VALUE +rb_io_inspect(VALUE obj) +{ + rb_io_t *fptr; + const char *cname; + const char *st = ""; + + fptr = RFILE(rb_io_taint_check(obj))->fptr; + if (!fptr || NIL_P(fptr->pathv)) return rb_any_to_s(obj); + cname = rb_obj_classname(obj); + if (fptr->fd < 0) { + st = " (closed)"; + } + return rb_sprintf("#<%s:%s%s>", cname, RSTRING_PTR(fptr->pathv), st); +} + +/* + * call-seq: + * ios.to_io -> ios + * + * Returns <em>ios</em>. + */ + +static VALUE +rb_io_to_io(VALUE io) +{ + return io; +} + +/* reading functions */ +static long +read_buffered_data(char *ptr, long len, rb_io_t *fptr) +{ + long n; + + n = READ_DATA_PENDING_COUNT(fptr); + if (n <= 0) return 0; + if (n > len) n = len; + MEMMOVE(ptr, fptr->rbuf+fptr->rbuf_off, char, n); + fptr->rbuf_off += n; + fptr->rbuf_len -= n; + return n; +} + +static long +io_fread(VALUE str, long offset, rb_io_t *fptr) +{ + long len = RSTRING_LEN(str) - offset; + long n = len; + int c; + + if (READ_DATA_PENDING(fptr) == 0) { + while (n > 0) { + c = rb_read_internal(fptr->fd, RSTRING_PTR(str)+offset, n); + if (c == 0) break; + if (c < 0) { + rb_sys_fail_path(fptr->pathv); + } + offset += c; + if ((n -= c) <= 0) break; + rb_thread_wait_fd(fptr->fd); + } + return len - n; + } + + while (n > 0) { + c = read_buffered_data(RSTRING_PTR(str)+offset, n, fptr); + if (c > 0) { + offset += c; + if ((n -= c) <= 0) break; + } + rb_thread_wait_fd(fptr->fd); + rb_io_check_closed(fptr); + if (io_fillbuf(fptr) < 0) { + break; + } + } + return len - n; +} + +long +rb_io_fread(char *ptr, long len, FILE *f) +{ + rb_io_t of; + VALUE str; + long n; + + of.fd = fileno(f); + of.stdio_file = f; + of.mode = FMODE_READABLE; + str = rb_str_new(ptr, len); + n = io_fread(str, 0, &of); + MEMCPY(ptr, RSTRING_PTR(str), char, n); + return n; +} + +#define SMALLBUF 100 + +static long +remain_size(rb_io_t *fptr) +{ + struct stat st; + off_t siz = READ_DATA_PENDING_COUNT(fptr); + off_t pos; + + if (fstat(fptr->fd, &st) == 0 && S_ISREG(st.st_mode) +#ifdef __BEOS__ + && (st.st_dev > 3) +#endif + ) + { + io_fflush(fptr); + pos = lseek(fptr->fd, 0, SEEK_CUR); + if (st.st_size >= pos && pos >= 0) { + siz += st.st_size - pos; + if (siz > LONG_MAX) { + rb_raise(rb_eIOError, "file too big for single read"); + } + } + } + else { + siz += BUFSIZ; + } + return (long)siz; +} + +static VALUE +io_enc_str(VALUE str, rb_io_t *fptr) +{ + OBJ_TAINT(str); + rb_enc_associate(str, io_read_encoding(fptr)); + return str; +} + +static void +make_readconv(rb_io_t *fptr) +{ + if (!fptr->readconv) { + rb_econv_option_t ecopts; + const char *sname, *dname; + ecopts = fptr->encs.opts; + if (NEED_NEWLINE_DECODER(fptr)) + ecopts.flags |= ECONV_UNIVERSAL_NEWLINE_DECODER; + if (fptr->encs.enc2) { + sname = fptr->encs.enc2->name; + dname = fptr->encs.enc->name; + } + else { + sname = dname = ""; + } + fptr->readconv = rb_econv_open(sname, dname, &ecopts); + if (!fptr->readconv) + rb_exc_raise(rb_econv_open_exc(sname, dname, &ecopts)); + fptr->crbuf_off = 0; + fptr->crbuf_len = 0; + fptr->crbuf_capa = 1024; + fptr->crbuf = ALLOC_N(char, fptr->crbuf_capa); + } +} + +static int +more_char(rb_io_t *fptr) +{ + const unsigned char *ss, *sp, *se; + unsigned char *ds, *dp, *de; + rb_econv_result_t res; + int putbackable; + int crbuf_len0; + + if (fptr->crbuf_len == fptr->crbuf_capa) + return 0; /* crbuf full */ + if (fptr->crbuf_len == 0) + fptr->crbuf_off = 0; + else if (fptr->crbuf_off + fptr->crbuf_len == fptr->crbuf_capa) { + memmove(fptr->crbuf, fptr->crbuf+fptr->crbuf_off, fptr->crbuf_len); + fptr->crbuf_off = 0; + } + + crbuf_len0 = fptr->crbuf_len; + + while (1) { + ss = sp = (const unsigned char *)fptr->rbuf + fptr->rbuf_off; + se = sp + fptr->rbuf_len; + ds = dp = (unsigned char *)fptr->crbuf + fptr->crbuf_off + fptr->crbuf_len; + de = (unsigned char *)fptr->crbuf + fptr->crbuf_capa; + res = rb_econv_convert(fptr->readconv, &sp, se, &dp, de, ECONV_PARTIAL_INPUT|ECONV_OUTPUT_FOLLOWED_BY_INPUT); + fptr->rbuf_off += sp - ss; + fptr->rbuf_len -= sp - ss; + fptr->crbuf_len += dp - ds; + + putbackable = rb_econv_putbackable(fptr->readconv); + if (putbackable) { + rb_econv_putback(fptr->readconv, (unsigned char *)fptr->rbuf + fptr->rbuf_off - putbackable, putbackable); + fptr->rbuf_off -= putbackable; + fptr->rbuf_len += putbackable; + } + + rb_econv_check_error(fptr->readconv); + + if (crbuf_len0 != fptr->crbuf_len) + return 0; + + if (res == econv_finished) + return -1; + + if (res == econv_source_buffer_empty) { + if (fptr->rbuf_len == 0) { + rb_thread_wait_fd(fptr->fd); + rb_io_check_closed(fptr); + if (io_fillbuf(fptr) == -1) { + ds = dp = (unsigned char *)fptr->crbuf + fptr->crbuf_off + fptr->crbuf_len; + de = (unsigned char *)fptr->crbuf + fptr->crbuf_capa; + res = rb_econv_convert(fptr->readconv, NULL, NULL, &dp, de, 0); + fptr->crbuf_len += dp - ds; + rb_econv_check_error(fptr->readconv); + } + } + } + } +} + +static VALUE +io_shift_crbuf(rb_io_t *fptr, int len, VALUE *strp) +{ + VALUE str; + if (NIL_P(*strp)) { + *strp = str = rb_str_new(fptr->crbuf+fptr->crbuf_off, len); + } + else { + size_t slen; + str = *strp; + slen = RSTRING_LEN(str); + rb_str_resize(str, RSTRING_LEN(str) + len); + memcpy(RSTRING_PTR(str)+slen, fptr->crbuf+fptr->crbuf_off, len); + } + fptr->crbuf_off += len; + fptr->crbuf_len -= len; + OBJ_TAINT(str); + rb_enc_associate(str, fptr->encs.enc); + /* xxx: set coderange */ + if (fptr->crbuf_len == 0) + fptr->crbuf_off = 0; + if (fptr->crbuf_off < fptr->crbuf_capa/2) { + memmove(fptr->crbuf, fptr->crbuf+fptr->crbuf_off, fptr->crbuf_len); + fptr->crbuf_off = 0; + } + return str; +} + +static VALUE +read_all(rb_io_t *fptr, long siz, VALUE str) +{ + long bytes; + long n; + long pos; + rb_encoding *enc; + int cr; + + if (NEED_READCONV(fptr)) { + VALUE str = rb_str_new(NULL, 0); + make_readconv(fptr); + while (1) { + if (fptr->crbuf_len) { + io_shift_crbuf(fptr, fptr->crbuf_len, &str); + } + if (more_char(fptr) == -1) { + return io_enc_str(str, fptr); + } + } + } + + bytes = 0; + pos = 0; + + enc = io_read_encoding(fptr); + cr = 0; + + if (siz == 0) siz = BUFSIZ; + if (NIL_P(str)) { + str = rb_str_new(0, siz); + } + else { + rb_str_resize(str, siz); + } + for (;;) { + READ_CHECK(fptr); + n = io_fread(str, bytes, fptr); + if (n == 0 && bytes == 0) { + break; + } + bytes += n; + if (cr != ENC_CODERANGE_BROKEN) + pos = rb_str_coderange_scan_restartable(RSTRING_PTR(str) + pos, RSTRING_PTR(str) + bytes, enc, &cr); + if (bytes < siz) break; + siz += BUFSIZ; + rb_str_resize(str, siz); + } + if (bytes != siz) rb_str_resize(str, bytes); + str = io_enc_str(str, fptr); + ENC_CODERANGE_SET(str, cr); + return str; +} + +void +rb_io_set_nonblock(rb_io_t *fptr) +{ + int flags; +#ifdef F_GETFL + flags = fcntl(fptr->fd, F_GETFL); + if (flags == -1) { + rb_sys_fail_path(fptr->pathv); + } +#else + flags = 0; +#endif + if ((flags & O_NONBLOCK) == 0) { + flags |= O_NONBLOCK; + if (fcntl(fptr->fd, F_SETFL, flags) == -1) { + rb_sys_fail_path(fptr->pathv); + } + } +} + +static VALUE +io_getpartial(int argc, VALUE *argv, VALUE io, int nonblock) +{ + rb_io_t *fptr; + VALUE length, str; + long n, len; + + rb_scan_args(argc, argv, "11", &length, &str); + + if ((len = NUM2LONG(length)) < 0) { + rb_raise(rb_eArgError, "negative length %ld given", len); + } + + if (NIL_P(str)) { + str = rb_str_new(0, len); + } + else { + StringValue(str); + rb_str_modify(str); + rb_str_resize(str, len); + } + OBJ_TAINT(str); + + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + + if (len == 0) + return str; + + if (!nonblock) + READ_CHECK(fptr); + if (RSTRING_LEN(str) != len) { + modified: + rb_raise(rb_eRuntimeError, "buffer string modified"); + } + n = read_buffered_data(RSTRING_PTR(str), len, fptr); + if (n <= 0) { + again: + if (RSTRING_LEN(str) != len) goto modified; + if (nonblock) { + rb_io_set_nonblock(fptr); + } + n = rb_read_internal(fptr->fd, RSTRING_PTR(str), len); + if (n < 0) { + if (!nonblock && rb_io_wait_readable(fptr->fd)) + goto again; + rb_sys_fail_path(fptr->pathv); + } + } + rb_str_resize(str, n); + + if (n == 0) + return Qnil; + else + return str; +} + +/* + * call-seq: + * ios.readpartial(maxlen) => string + * ios.readpartial(maxlen, outbuf) => outbuf + * + * Reads at most <i>maxlen</i> bytes from the I/O stream. + * It blocks only if <em>ios</em> has no data immediately available. + * It doesn't block if some data available. + * If the optional <i>outbuf</i> argument is present, + * it must reference a String, which will receive the data. + * It raises <code>EOFError</code> on end of file. + * + * readpartial is designed for streams such as pipe, socket, tty, etc. + * It blocks only when no data immediately available. + * This means that it blocks only when following all conditions hold. + * * the buffer in the IO object is empty. + * * the content of the stream is empty. + * * the stream is not reached to EOF. + * + * When readpartial blocks, it waits data or EOF on the stream. + * If some data is reached, readpartial returns with the data. + * If EOF is reached, readpartial raises EOFError. + * + * When readpartial doesn't blocks, it returns or raises immediately. + * If the buffer is not empty, it returns the data in the buffer. + * Otherwise if the stream has some content, + * it returns the data in the stream. + * Otherwise if the stream is reached to EOF, it raises EOFError. + * + * r, w = IO.pipe # buffer pipe content + * w << "abc" # "" "abc". + * r.readpartial(4096) #=> "abc" "" "" + * r.readpartial(4096) # blocks because buffer and pipe is empty. + * + * r, w = IO.pipe # buffer pipe content + * w << "abc" # "" "abc" + * w.close # "" "abc" EOF + * r.readpartial(4096) #=> "abc" "" EOF + * r.readpartial(4096) # raises EOFError + * + * r, w = IO.pipe # buffer pipe content + * w << "abc\ndef\n" # "" "abc\ndef\n" + * r.gets #=> "abc\n" "def\n" "" + * w << "ghi\n" # "def\n" "ghi\n" + * r.readpartial(4096) #=> "def\n" "" "ghi\n" + * r.readpartial(4096) #=> "ghi\n" "" "" + * + * Note that readpartial behaves similar to sysread. + * The differences are: + * * If the buffer is not empty, read from the buffer instead of "sysread for buffered IO (IOError)". + * * It doesn't cause Errno::EAGAIN and Errno::EINTR. When readpartial meets EAGAIN and EINTR by read system call, readpartial retry the system call. + * + * The later means that readpartial is nonblocking-flag insensitive. + * It blocks on the situation IO#sysread causes Errno::EAGAIN as if the fd is blocking mode. + * + */ + +static VALUE +io_readpartial(int argc, VALUE *argv, VALUE io) +{ + VALUE ret; + + ret = io_getpartial(argc, argv, io, 0); + if (NIL_P(ret)) + rb_eof_error(); + else + return ret; +} + +/* + * call-seq: + * ios.read_nonblock(maxlen) => string + * ios.read_nonblock(maxlen, outbuf) => outbuf + * + * Reads at most <i>maxlen</i> bytes from <em>ios</em> using + * read(2) system call after O_NONBLOCK is set for + * the underlying file descriptor. + * + * If the optional <i>outbuf</i> argument is present, + * it must reference a String, which will receive the data. + * + * read_nonblock just calls read(2). + * It causes all errors read(2) causes: EAGAIN, EINTR, etc. + * The caller should care such errors. + * + * read_nonblock causes EOFError on EOF. + * + * If the read buffer is not empty, + * read_nonblock reads from the buffer like readpartial. + * In this case, read(2) is not called. + * + */ + +static VALUE +io_read_nonblock(int argc, VALUE *argv, VALUE io) +{ + VALUE ret; + + ret = io_getpartial(argc, argv, io, 1); + if (NIL_P(ret)) + rb_eof_error(); + else + return ret; +} + +/* + * call-seq: + * ios.write_nonblock(string) => integer + * + * Writes the given string to <em>ios</em> using + * write(2) system call after O_NONBLOCK is set for + * the underlying file descriptor. + * + * write_nonblock just calls write(2). + * It causes all errors write(2) causes: EAGAIN, EINTR, etc. + * The result may also be smaller than string.length (partial write). + * The caller should care such errors and partial write. + * + * If the write buffer is not empty, it is flushed at first. + * + */ + +static VALUE +rb_io_write_nonblock(VALUE io, VALUE str) +{ + rb_io_t *fptr; + long n; + + rb_secure(4); + if (TYPE(str) != T_STRING) + str = rb_obj_as_string(str); + + io = GetWriteIO(io); + GetOpenFile(io, fptr); + rb_io_check_writable(fptr); + + io_fflush(fptr); + + rb_io_set_nonblock(fptr); + n = write(fptr->fd, RSTRING_PTR(str), RSTRING_LEN(str)); + + if (n == -1) rb_sys_fail_path(fptr->pathv); + + return LONG2FIX(n); +} + +/* + * call-seq: + * ios.read([length [, buffer]]) => string, buffer, or nil + * + * Reads at most <i>length</i> bytes from the I/O stream, or to the + * end of file if <i>length</i> is omitted or is <code>nil</code>. + * <i>length</i> must be a non-negative integer or nil. + * If the optional <i>buffer</i> argument is present, it must reference + * a String, which will receive the data. + * + * At end of file, it returns <code>nil</code> or <code>""</code> + * depend on <i>length</i>. + * <code><i>ios</i>.read()</code> and + * <code><i>ios</i>.read(nil)</code> returns <code>""</code>. + * <code><i>ios</i>.read(<i>positive-integer</i>)</code> returns nil. + * + * <code><i>ios</i>.read(0)</code> returns <code>""</code>. + * + * f = File.new("testfile") + * f.read(16) #=> "This is line one" + */ + +static VALUE +io_read(int argc, VALUE *argv, VALUE io) +{ + rb_io_t *fptr; + long n, len; + VALUE length, str; + + rb_scan_args(argc, argv, "02", &length, &str); + + if (NIL_P(length)) { + if (!NIL_P(str)) StringValue(str); + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + return read_all(fptr, remain_size(fptr), str); + } + len = NUM2LONG(length); + if (len < 0) { + rb_raise(rb_eArgError, "negative length %ld given", len); + } + + if (NIL_P(str)) { + str = rb_str_new(0, len); + } + else { + StringValue(str); + rb_str_modify(str); + rb_str_resize(str,len); + } + + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + if (len == 0) return str; + + READ_CHECK(fptr); + if (RSTRING_LEN(str) != len) { + rb_raise(rb_eRuntimeError, "buffer string modified"); + } + n = io_fread(str, 0, fptr); + if (n == 0) { + if (fptr->fd < 0) return Qnil; + rb_str_resize(str, 0); + return Qnil; + } + rb_str_resize(str, n); + + return str; +} + +static void +rscheck(const char *rsptr, long rslen, VALUE rs) +{ + if (!rs) return; + if (RSTRING_PTR(rs) != rsptr && RSTRING_LEN(rs) != rslen) + rb_raise(rb_eRuntimeError, "rs modified"); +} + +static int +appendline(rb_io_t *fptr, int delim, VALUE *strp, long *lp) +{ + VALUE str = *strp; + long limit = *lp; + + if (NEED_READCONV(fptr)) { + make_readconv(fptr); + while (1) { + const char *p, *e; + int searchlen; + if (fptr->crbuf_len) { + p = fptr->crbuf+fptr->crbuf_off; + searchlen = fptr->crbuf_len; + if (0 < limit && limit < searchlen) + searchlen = limit; + e = memchr(p, delim, searchlen); + if (e) { + if (NIL_P(str)) + *strp = str = rb_str_new(p, e-p+1); + else + rb_str_buf_cat(str, p, e-p+1); + fptr->crbuf_off += e-p+1; + fptr->crbuf_len -= e-p+1; + limit -= e-p+1; + *lp = limit; + return delim; + } + + if (NIL_P(str)) + *strp = str = rb_str_new(p, searchlen); + else + rb_str_buf_cat(str, p, searchlen); + fptr->crbuf_off += searchlen; + fptr->crbuf_len -= searchlen; + limit -= searchlen; + + if (limit == 0) { + *lp = limit; + return (unsigned char)RSTRING_PTR(str)[RSTRING_LEN(str)-1]; + } + } + + if (more_char(fptr) == -1) { + *lp = limit; + return EOF; + } + } + } + + while (1) { + long pending = READ_DATA_PENDING_COUNT(fptr); + if (pending > 0) { + const char *p = READ_DATA_PENDING_PTR(fptr); + const char *e; + long last; + + if (limit > 0 && pending > limit) pending = limit; + e = memchr(p, delim, pending); + if (e) pending = e - p + 1; + if (!NIL_P(str)) { + last = RSTRING_LEN(str); + rb_str_resize(str, last + pending); + } + else { + last = 0; + *strp = str = rb_str_buf_new(pending); + rb_str_set_len(str, pending); + } + read_buffered_data(RSTRING_PTR(str) + last, pending, fptr); /* must not fail */ + limit -= pending; + *lp = limit; + if (e) return delim; + if (limit == 0) + return (unsigned char)RSTRING_PTR(str)[RSTRING_LEN(str)-1]; + } + rb_thread_wait_fd(fptr->fd); + rb_io_check_closed(fptr); + if (io_fillbuf(fptr) < 0) { + *lp = limit; + return EOF; + } + } +} + +static inline int +swallow(rb_io_t *fptr, int term) +{ + do { + long cnt; + while ((cnt = READ_DATA_PENDING_COUNT(fptr)) > 0) { + char buf[1024]; + const char *p = READ_DATA_PENDING_PTR(fptr); + int i; + if (cnt > sizeof buf) cnt = sizeof buf; + if (*p != term) return Qtrue; + i = cnt; + while (--i && *++p == term); + if (!read_buffered_data(buf, cnt - i, fptr)) /* must not fail */ + rb_sys_fail_path(fptr->pathv); + } + rb_thread_wait_fd(fptr->fd); + rb_io_check_closed(fptr); + } while (io_fillbuf(fptr) == 0); + return Qfalse; +} + +static VALUE +rb_io_getline_fast(rb_io_t *fptr, rb_encoding *enc) +{ + VALUE str = Qnil; + int len = 0; + long pos = 0; + int cr = 0; + + for (;;) { + long pending = READ_DATA_PENDING_COUNT(fptr); + + if (pending > 0) { + const char *p = READ_DATA_PENDING_PTR(fptr); + const char *e; + + e = memchr(p, '\n', pending); + if (e) { + pending = e - p + 1; + } + if (NIL_P(str)) { + str = rb_str_new(p, pending); + fptr->rbuf_off += pending; + fptr->rbuf_len -= pending; + } + else { + rb_str_resize(str, len + pending); + read_buffered_data(RSTRING_PTR(str)+len, pending, fptr); + } + len += pending; + if (cr != ENC_CODERANGE_BROKEN) + pos = rb_str_coderange_scan_restartable(RSTRING_PTR(str) + pos, RSTRING_PTR(str) + len, enc, &cr); + if (e) break; + } + rb_thread_wait_fd(fptr->fd); + rb_io_check_closed(fptr); + if (io_fillbuf(fptr) < 0) { + if (NIL_P(str)) return Qnil; + break; + } + } + + str = io_enc_str(str, fptr); + ENC_CODERANGE_SET(str, cr); + fptr->lineno++; + ARGF.lineno = INT2FIX(fptr->lineno); + return str; +} + +static void +prepare_getline_args(int argc, VALUE *argv, VALUE *rsp, long *limit, VALUE io) +{ + VALUE rs = rb_rs, lim = Qnil; + rb_io_t *fptr; + + if (argc == 1) { + VALUE tmp = Qnil; + + if (NIL_P(argv[0]) || !NIL_P(tmp = rb_check_string_type(argv[0]))) { + rs = tmp; + } + else { + lim = argv[0]; + } + } + else if (2 <= argc) { + rb_scan_args(argc, argv, "2", &rs, &lim); + if (!NIL_P(rs)) + StringValue(rs); + } + if (!NIL_P(rs)) { + rb_encoding *enc_rs, *enc_io; + + GetOpenFile(io, fptr); + enc_rs = rb_enc_get(rs); + enc_io = io_read_encoding(fptr); + if (enc_io != enc_rs && + (rb_enc_str_coderange(rs) != ENC_CODERANGE_7BIT || + !rb_enc_asciicompat(enc_io))) { + if (rs == rb_default_rs) { + rs = rb_enc_str_new(0, 0, enc_io); + rb_str_buf_cat_ascii(rs, "\n"); + } + else { + rb_raise(rb_eArgError, "encoding mismatch: %s IO with %s RS", + rb_enc_name(enc_io), + rb_enc_name(enc_rs)); + } + } + } + *rsp = rs; + *limit = NIL_P(lim) ? -1L : NUM2LONG(lim); +} + +static VALUE +rb_io_getline_1(VALUE rs, long limit, VALUE io) +{ + VALUE str = Qnil; + rb_io_t *fptr; + int nolimit = 0; + rb_encoding *enc; + + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + if (NIL_P(rs)) { + str = read_all(fptr, 0, Qnil); + if (RSTRING_LEN(str) == 0) return Qnil; + } + else if (limit == 0) { + return rb_enc_str_new(0, 0, io_read_encoding(fptr)); + } + else if (rs == rb_default_rs && limit < 0 && !NEED_READCONV(fptr) && + rb_enc_asciicompat(enc = io_read_encoding(fptr))) { + return rb_io_getline_fast(fptr, enc); + } + else { + int c, newline; + const char *rsptr; + long rslen; + int rspara = 0; + int extra_limit = 16; + + rslen = RSTRING_LEN(rs); + if (rslen == 0) { + rsptr = "\n\n"; + rslen = 2; + rspara = 1; + swallow(fptr, '\n'); + rs = 0; + } + else { + rsptr = RSTRING_PTR(rs); + } + newline = (unsigned char)rsptr[rslen - 1]; + + if (fptr->encs.enc2) + enc = fptr->encs.enc; + else + enc = io_input_encoding(fptr); + while ((c = appendline(fptr, newline, &str, &limit)) != EOF) { + const char *s, *p, *pp; + + if (c == newline) { + if (RSTRING_LEN(str) < rslen) continue; + s = RSTRING_PTR(str); + p = s + RSTRING_LEN(str) - rslen; + pp = rb_enc_left_char_head(s, p, enc); + if (pp != p) continue; + if (!rspara) rscheck(rsptr, rslen, rs); + if (memcmp(p, rsptr, rslen) == 0) break; + } + if (limit == 0) { + s = RSTRING_PTR(str); + p = s + RSTRING_LEN(str); + pp = rb_enc_left_char_head(s, p-1, enc); + if (extra_limit && + MBCLEN_NEEDMORE_P(rb_enc_precise_mbclen(pp, p, enc))) { + /* relax the limit while incomplete character. + * extra_limit limits the relax length */ + limit = 1; + extra_limit--; + } + else { + nolimit = 1; + break; + } + } + } + + if (rspara) { + if (c != EOF) { + swallow(fptr, '\n'); + } + } + if (!NIL_P(str)) + str = io_enc_str(str, fptr); + } + + if (!NIL_P(str)) { + if (!nolimit) { + fptr->lineno++; + ARGF.lineno = INT2FIX(fptr->lineno); + } + } + + return str; +} + +static VALUE +rb_io_getline(int argc, VALUE *argv, VALUE io) +{ + VALUE rs; + long limit; + + prepare_getline_args(argc, argv, &rs, &limit, io); + return rb_io_getline_1(rs, limit, io); +} + +VALUE +rb_io_gets(VALUE io) +{ + return rb_io_getline_1(rb_default_rs, -1, io); +} + +/* + * call-seq: + * ios.gets(sep=$/) => string or nil + * ios.gets(limit) => string or nil + * ios.gets(sep, limit) => string or nil + * + * Reads the next ``line'' from the I/O stream; lines are separated by + * <i>sep</i>. A separator of <code>nil</code> reads the entire + * contents, and a zero-length separator reads the input a paragraph at + * a time (two successive newlines in the input separate paragraphs). + * The stream must be opened for reading or an <code>IOError</code> + * will be raised. The line read in will be returned and also assigned + * to <code>$_</code>. Returns <code>nil</code> if called at end of + * file. If the first argument is an integer, or optional second + * argument is given, the returning string would not be longer than the + * given value. + * + * File.new("testfile").gets #=> "This is line one\n" + * $_ #=> "This is line one\n" + */ + +static VALUE +rb_io_gets_m(int argc, VALUE *argv, VALUE io) +{ + VALUE str; + + str = rb_io_getline(argc, argv, io); + rb_lastline_set(str); + + return str; +} + +/* + * call-seq: + * ios.lineno => integer + * + * Returns the current line number in <em>ios</em>. The stream must be + * opened for reading. <code>lineno</code> counts the number of times + * <code>gets</code> is called, rather than the number of newlines + * encountered. The two values will differ if <code>gets</code> is + * called with a separator other than newline. See also the + * <code>$.</code> variable. + * + * f = File.new("testfile") + * f.lineno #=> 0 + * f.gets #=> "This is line one\n" + * f.lineno #=> 1 + * f.gets #=> "This is line two\n" + * f.lineno #=> 2 + */ + +static VALUE +rb_io_lineno(VALUE io) +{ + rb_io_t *fptr; + + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + return INT2NUM(fptr->lineno); +} + +/* + * call-seq: + * ios.lineno = integer => integer + * + * Manually sets the current line number to the given value. + * <code>$.</code> is updated only on the next read. + * + * f = File.new("testfile") + * f.gets #=> "This is line one\n" + * $. #=> 1 + * f.lineno = 1000 + * f.lineno #=> 1000 + * $. #=> 1 # lineno of last read + * f.gets #=> "This is line two\n" + * $. #=> 1001 # lineno of last read + */ + +static VALUE +rb_io_set_lineno(VALUE io, VALUE lineno) +{ + rb_io_t *fptr; + + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + fptr->lineno = NUM2INT(lineno); + return lineno; +} + +/* + * call-seq: + * ios.readline(sep=$/) => string + * ios.readline(limit) => string + * ios.readline(sep, limit) => string + * + * Reads a line as with <code>IO#gets</code>, but raises an + * <code>EOFError</code> on end of file. + */ + +static VALUE +rb_io_readline(int argc, VALUE *argv, VALUE io) +{ + VALUE line = rb_io_gets_m(argc, argv, io); + + if (NIL_P(line)) { + rb_eof_error(); + } + return line; +} + +/* + * call-seq: + * ios.readlines(sep=$/) => array + * ios.readlines(limit) => array + * ios.readlines(sep, limit) => array + * + * Reads all of the lines in <em>ios</em>, and returns them in + * <i>anArray</i>. Lines are separated by the optional <i>sep</i>. If + * <i>sep</i> is <code>nil</code>, the rest of the stream is returned + * as a single record. If the first argument is an integer, or + * optional second argument is given, the returning string would not be + * longer than the given value. The stream must be opened for reading + * or an <code>IOError</code> will be raised. + * + * f = File.new("testfile") + * f.readlines[0] #=> "This is line one\n" + */ + +static VALUE +rb_io_readlines(int argc, VALUE *argv, VALUE io) +{ + VALUE line, ary, rs; + long limit; + + prepare_getline_args(argc, argv, &rs, &limit, io); + ary = rb_ary_new(); + while (!NIL_P(line = rb_io_getline_1(rs, limit, io))) { + rb_ary_push(ary, line); + } + return ary; +} + +/* + * call-seq: + * ios.each(sep=$/) {|line| block } => ios + * ios.each(limit) {|line| block } => ios + * ios.each(sep,limit) {|line| block } => ios + * ios.each_line(sep=$/) {|line| block } => ios + * ios.each_line(limit) {|line| block } => ios + * ios.each_line(sep,limit) {|line| block } => ios + * + * Executes the block for every line in <em>ios</em>, where lines are + * separated by <i>sep</i>. <em>ios</em> must be opened for + * reading or an <code>IOError</code> will be raised. + * + * f = File.new("testfile") + * f.each {|line| puts "#{f.lineno}: #{line}" } + * + * <em>produces:</em> + * + * 1: This is line one + * 2: This is line two + * 3: This is line three + * 4: And so on... + */ + +static VALUE +rb_io_each_line(int argc, VALUE *argv, VALUE io) +{ + VALUE str, rs; + long limit; + + RETURN_ENUMERATOR(io, argc, argv); + prepare_getline_args(argc, argv, &rs, &limit, io); + while (!NIL_P(str = rb_io_getline_1(rs, limit, io))) { + rb_yield(str); + } + return io; +} + +/* + * call-seq: + * ios.each_byte {|byte| block } => ios + * + * Calls the given block once for each byte (0..255) in <em>ios</em>, + * passing the byte as an argument. The stream must be opened for + * reading or an <code>IOError</code> will be raised. + * + * f = File.new("testfile") + * checksum = 0 + * f.each_byte {|x| checksum ^= x } #=> #<File:testfile> + * checksum #=> 12 + */ + +static VALUE +rb_io_each_byte(VALUE io) +{ + rb_io_t *fptr; + char *p, *e; + + RETURN_ENUMERATOR(io, 0, 0); + GetOpenFile(io, fptr); + + for (;;) { + p = fptr->rbuf+fptr->rbuf_off; + e = p + fptr->rbuf_len; + while (p < e) { + fptr->rbuf_off++; + fptr->rbuf_len--; + rb_yield(INT2FIX(*p & 0xff)); + p++; + errno = 0; + } + rb_io_check_readable(fptr); + READ_CHECK(fptr); + if (io_fillbuf(fptr) < 0) { + break; + } + } + return io; +} + +static VALUE +io_getc(rb_io_t *fptr, rb_encoding *enc) +{ + int r, n, cr = 0; + VALUE str; + + if (NEED_READCONV(fptr)) { + VALUE str = Qnil; + + make_readconv(fptr); + + while (1) { + if (fptr->crbuf_len) { + if (fptr->encs.enc) + r = rb_enc_precise_mbclen(fptr->crbuf+fptr->crbuf_off, + fptr->crbuf+fptr->crbuf_off+fptr->crbuf_len, + fptr->encs.enc); + else + r = ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(1); + if (!MBCLEN_NEEDMORE_P(r)) + break; + if (fptr->crbuf_len == fptr->crbuf_capa) { + rb_raise(rb_eIOError, "too long character"); + } + } + + if (more_char(fptr) == -1) { + if (fptr->crbuf_len == 0) + return Qnil; + /* return an incomplete character just before EOF */ + return io_shift_crbuf(fptr, fptr->crbuf_len, &str); + } + } + if (MBCLEN_INVALID_P(r)) { + r = rb_enc_mbclen(fptr->crbuf+fptr->crbuf_off, + fptr->crbuf+fptr->crbuf_off+fptr->crbuf_len, + fptr->encs.enc); + return io_shift_crbuf(fptr, r, &str); + } + return io_shift_crbuf(fptr, MBCLEN_CHARFOUND_LEN(r), &str); + } + + if (io_fillbuf(fptr) < 0) { + return Qnil; + } + if (rb_enc_asciicompat(enc) && ISASCII(fptr->rbuf[fptr->rbuf_off])) { + str = rb_str_new(fptr->rbuf+fptr->rbuf_off, 1); + fptr->rbuf_off += 1; + fptr->rbuf_len -= 1; + cr = ENC_CODERANGE_7BIT; + } + else { + r = rb_enc_precise_mbclen(fptr->rbuf+fptr->rbuf_off, fptr->rbuf+fptr->rbuf_off+fptr->rbuf_len, enc); + if (MBCLEN_CHARFOUND_P(r) && + (n = MBCLEN_CHARFOUND_LEN(r)) <= fptr->rbuf_len) { + str = rb_str_new(fptr->rbuf+fptr->rbuf_off, n); + fptr->rbuf_off += n; + fptr->rbuf_len -= n; + cr = ENC_CODERANGE_VALID; + } + else if (MBCLEN_NEEDMORE_P(r)) { + str = rb_str_new(fptr->rbuf+fptr->rbuf_off, fptr->rbuf_len); + fptr->rbuf_len = 0; + getc_needmore: + if (io_fillbuf(fptr) != -1) { + rb_str_cat(str, fptr->rbuf+fptr->rbuf_off, 1); + fptr->rbuf_off++; + fptr->rbuf_len--; + r = rb_enc_precise_mbclen(RSTRING_PTR(str), RSTRING_PTR(str)+RSTRING_LEN(str), enc); + if (MBCLEN_NEEDMORE_P(r)) { + goto getc_needmore; + } + else if (MBCLEN_CHARFOUND_P(r)) { + cr = ENC_CODERANGE_VALID; + } + } + } + else { + str = rb_str_new(fptr->rbuf+fptr->rbuf_off, 1); + fptr->rbuf_off++; + fptr->rbuf_len--; + } + } + if (!cr) cr = ENC_CODERANGE_BROKEN; + str = io_enc_str(str, fptr); + ENC_CODERANGE_SET(str, cr); + return str; +} + +/* + * call-seq: + * ios.each_char {|c| block } => ios + * + * Calls the given block once for each character in <em>ios</em>, + * passing the character as an argument. The stream must be opened for + * reading or an <code>IOError</code> will be raised. + * + * f = File.new("testfile") + * f.each_char {|c| print c, ' ' } #=> #<File:testfile> + */ + +static VALUE +rb_io_each_char(VALUE io) +{ + rb_io_t *fptr; + rb_encoding *enc; + VALUE c; + + RETURN_ENUMERATOR(io, 0, 0); + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + + enc = io_input_encoding(fptr); + READ_CHECK(fptr); + while (!NIL_P(c = io_getc(fptr, enc))) { + rb_yield(c); + } + return io; +} + + + +/* + * call-seq: + * ios.lines(sep=$/) => anEnumerator + * ios.lines(limit) => anEnumerator + * ios.lines(sep, limit) => anEnumerator + * + * Returns an enumerator that gives each line in <em>ios</em>. + * The stream must be opened for reading or an <code>IOError</code> + * will be raised. + * + * f = File.new("testfile") + * f.lines.to_a #=> ["foo\n", "bar\n"] + * f.rewind + * f.lines.sort #=> ["bar\n", "foo\n"] + */ + +static VALUE +rb_io_lines(int argc, VALUE *argv, VALUE io) +{ + return rb_enumeratorize(io, ID2SYM(rb_intern("each_line")), argc, argv); +} + +/* + * call-seq: + * ios.bytes => anEnumerator + * + * Returns an enumerator that gives each byte (0..255) in <em>ios</em>. + * The stream must be opened for reading or an <code>IOError</code> + * will be raised. + * + * f = File.new("testfile") + * f.bytes.to_a #=> [104, 101, 108, 108, 111] + * f.rewind + * f.bytes.sort #=> [101, 104, 108, 108, 111] + */ + +static VALUE +rb_io_bytes(VALUE io) +{ + return rb_enumeratorize(io, ID2SYM(rb_intern("each_byte")), 0, 0); +} + +/* + * call-seq: + * ios.chars => anEnumerator + * + * Returns an enumerator that gives each character in <em>ios</em>. + * The stream must be opened for reading or an <code>IOError</code> + * will be raised. + * + * f = File.new("testfile") + * f.chars.to_a #=> ["h", "e", "l", "l", "o"] + * f.rewind + * f.chars.sort #=> ["e", "h", "l", "l", "o"] + */ + +static VALUE +rb_io_chars(VALUE io) +{ + return rb_enumeratorize(io, ID2SYM(rb_intern("each_char")), 0, 0); +} + +/* + * call-seq: + * ios.getc => fixnum or nil + * + * Reads a one-character string from <em>ios</em>. Returns + * <code>nil</code> if called at end of file. + * + * f = File.new("testfile") + * f.getc #=> "8" + * f.getc #=> "1" + */ + +static VALUE +rb_io_getc(VALUE io) +{ + rb_io_t *fptr; + rb_encoding *enc; + + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + + enc = io_input_encoding(fptr); + READ_CHECK(fptr); + return io_getc(fptr, enc); +} +int +rb_getc(FILE *f) +{ + int c; + + rb_read_check(f); + TRAP_BEG; + c = getc(f); + TRAP_END; + + return c; +} + +/* + * call-seq: + * ios.readchar => string + * + * Reads a one-character string from <em>ios</em>. Raises an + * <code>EOFError</code> on end of file. + * + * f = File.new("testfile") + * f.readchar #=> "8" + * f.readchar #=> "1" + */ + +static VALUE +rb_io_readchar(VALUE io) +{ + VALUE c = rb_io_getc(io); + + if (NIL_P(c)) { + rb_eof_error(); + } + return c; +} + +/* + * call-seq: + * ios.getbyte => fixnum or nil + * + * Gets the next 8-bit byte (0..255) from <em>ios</em>. Returns + * <code>nil</code> if called at end of file. + * + * f = File.new("testfile") + * f.getbyte #=> 84 + * f.getbyte #=> 104 + */ + +VALUE +rb_io_getbyte(VALUE io) +{ + rb_io_t *fptr; + int c; + + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + READ_CHECK(fptr); + if (fptr->fd == 0 && (fptr->mode & FMODE_TTY) && TYPE(rb_stdout) == T_FILE) { + rb_io_t *ofp; + GetOpenFile(rb_stdout, ofp); + if (ofp->mode & FMODE_TTY) { + rb_io_flush(rb_stdout); + } + } + if (io_fillbuf(fptr) < 0) { + return Qnil; + } + fptr->rbuf_off++; + fptr->rbuf_len--; + c = (unsigned char)fptr->rbuf[fptr->rbuf_off-1]; + return INT2FIX(c & 0xff); +} + +/* + * call-seq: + * ios.readbyte => fixnum + * + * Reads a character as with <code>IO#getc</code>, but raises an + * <code>EOFError</code> on end of file. + */ + +static VALUE +rb_io_readbyte(VALUE io) +{ + VALUE c = rb_io_getbyte(io); + + if (NIL_P(c)) { + rb_eof_error(); + } + return c; +} + +/* + * call-seq: + * ios.ungetbyte(string) => nil + * ios.ungetbyte(integer) => nil + * + * Pushes back bytes (passed as a parameter) onto <em>ios</em>, + * such that a subsequent buffered read will return it. Only one byte + * may be pushed back before a subsequent read operation (that is, + * you will be able to read only the last of several bytes that have been pushed + * back). Has no effect with unbuffered reads (such as <code>IO#sysread</code>). + * + * f = File.new("testfile") #=> #<File:testfile> + * b = f.getbyte #=> 0x38 + * f.ungetbyte(b) #=> nil + * f.getbyte #=> 0x38 + */ + +VALUE +rb_io_ungetbyte(VALUE io, VALUE b) +{ + rb_io_t *fptr; + + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + if (NIL_P(b)) return Qnil; + if (FIXNUM_P(b)) { + char cc = FIX2INT(b); + b = rb_str_new(&cc, 1); + } + else { + SafeStringValue(b); + } + io_ungetbyte(b, fptr); + return Qnil; +} + +/* + * call-seq: + * ios.ungetc(string) => nil + * + * Pushes back one character (passed as a parameter) onto <em>ios</em>, + * such that a subsequent buffered read will return it. Only one character + * may be pushed back before a subsequent read operation (that is, + * you will be able to read only the last of several characters that have been pushed + * back). Has no effect with unbuffered reads (such as <code>IO#sysread</code>). + * + * f = File.new("testfile") #=> #<File:testfile> + * c = f.getc #=> "8" + * f.ungetc(c) #=> nil + * f.getc #=> "8" + */ + +VALUE +rb_io_ungetc(VALUE io, VALUE c) +{ + rb_io_t *fptr; + long len; + + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + if (NIL_P(c)) return Qnil; + if (FIXNUM_P(c)) { + int cc = FIX2INT(c); + rb_encoding *enc = io_read_encoding(fptr); + char buf[16]; + + c = rb_str_new(buf, rb_enc_mbcput(cc, buf, enc)); + } + else { + SafeStringValue(c); + } + if (NEED_READCONV(fptr)) { + make_readconv(fptr); + len = RSTRING_LEN(c); + if (fptr->crbuf_capa - fptr->crbuf_len < len) + rb_raise(rb_eIOError, "ungetc failed"); + if (fptr->crbuf_off < len) { + MEMMOVE(fptr->crbuf+fptr->crbuf_capa-fptr->crbuf_len, + fptr->crbuf+fptr->crbuf_off, + char, fptr->crbuf_len); + fptr->crbuf_off = fptr->crbuf_capa-fptr->crbuf_len; + } + fptr->crbuf_off -= len; + fptr->crbuf_len += len; + MEMMOVE(fptr->crbuf+fptr->crbuf_off, RSTRING_PTR(c), char, len); + } + else { + io_ungetbyte(c, fptr); + } + return Qnil; +} + +/* + * call-seq: + * ios.isatty => true or false + * ios.tty? => true or false + * + * Returns <code>true</code> if <em>ios</em> is associated with a + * terminal device (tty), <code>false</code> otherwise. + * + * File.new("testfile").isatty #=> false + * File.new("/dev/tty").isatty #=> true + */ + +static VALUE +rb_io_isatty(VALUE io) +{ + rb_io_t *fptr; + + GetOpenFile(io, fptr); + if (isatty(fptr->fd) == 0) + return Qfalse; + return Qtrue; +} + +/* + * call-seq: + * ios.close_on_exec? => true or false + * + * Returns <code>true</code> if <em>ios</em> will be closed on exec. + * + * f = open("/dev/null") + * f.close_on_exec? #=> false + * f.close_on_exec = true + * f.close_on_exec? #=> true + * f.close_on_exec = false + * f.close_on_exec? #=> false + */ + +static VALUE +rb_io_close_on_exec_p(VALUE io) +{ +#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC) + rb_io_t *fptr; + VALUE write_io; + int fd, ret; + + write_io = GetWriteIO(io); + if (io != write_io) { + GetOpenFile(write_io, fptr); + if (fptr && 0 <= (fd = fptr->fd)) { + if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->pathv); + if (!(ret & FD_CLOEXEC)) return Qfalse; + } + } + + GetOpenFile(io, fptr); + if (fptr && 0 <= (fd = fptr->fd)) { + if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->pathv); + if (!(ret & FD_CLOEXEC)) return Qfalse; + } + return Qtrue; +#else + rb_notimplement(); + return Qnil; /* not reached */ +#endif +} + +/* + * call-seq: + * ios.close_on_exec = bool => true or false + * + * Sets a close-on-exec flag. + * + * f = open("/dev/null") + * f.close_on_exec = true + * system("cat", "/proc/self/fd/#{f.fileno}") # cat: /proc/self/fd/3: No such file or directory + * f.closed? #=> false + */ + +static VALUE +rb_io_set_close_on_exec(VALUE io, VALUE arg) +{ +#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC) + int flag = RTEST(arg) ? FD_CLOEXEC : 0; + rb_io_t *fptr; + VALUE write_io; + int fd, ret; + + write_io = GetWriteIO(io); + if (io != write_io) { + GetOpenFile(write_io, fptr); + if (fptr && 0 <= (fd = fptr->fd)) { + if ((ret = fcntl(fptr->fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->pathv); + if ((ret & FD_CLOEXEC) != flag) { + ret = (ret & ~FD_CLOEXEC) | flag; + ret = fcntl(fd, F_SETFD, ret); + if (ret == -1) rb_sys_fail_path(fptr->pathv); + } + } + + } + + GetOpenFile(io, fptr); + if (fptr && 0 <= (fd = fptr->fd)) { + if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->pathv); + if ((ret & FD_CLOEXEC) != flag) { + ret = (ret & ~FD_CLOEXEC) | flag; + ret = fcntl(fd, F_SETFD, ret); + if (ret == -1) rb_sys_fail_path(fptr->pathv); + } + } +#else + rb_notimplement(); +#endif + return Qnil; +} + +#define FMODE_PREP (1<<16) +#define IS_PREP_STDIO(f) ((f)->mode & FMODE_PREP) +#define PREP_STDIO_NAME(f) (RSTRING_PTR((f)->pathv)) + +static void +finish_writeconv(rb_io_t *fptr, int noraise) +{ + unsigned char *ds, *dp, *de; + rb_econv_result_t res; + + if (!fptr->wbuf) { + unsigned char buf[1024]; + int r; + + res = econv_destination_buffer_full; + while (res == econv_destination_buffer_full) { + ds = dp = buf; + de = buf + sizeof(buf); + res = rb_econv_convert(fptr->writeconv, NULL, NULL, &dp, de, 0); + while (dp-ds) { +retry: + r = rb_write_internal(fptr->fd, ds, dp-ds); + if (r == dp-ds) + break; + if (0 <= r) { + ds += r; + } + if (rb_io_wait_writable(fptr->fd)) { + if (!noraise) + rb_io_check_closed(fptr); + else if (fptr->fd < 0) + return; + goto retry; + } + return; + } + if (!noraise) { + rb_econv_check_error(fptr->writeconv); + } + if (res == econv_invalid_byte_sequence || + res == econv_undefined_conversion) { + break; + } + } + + return; + } + + res = econv_destination_buffer_full; + while (res == econv_destination_buffer_full) { + if (fptr->wbuf_len == fptr->wbuf_capa) { + io_fflush(fptr); + } + + ds = dp = (unsigned char *)fptr->wbuf + fptr->wbuf_off + fptr->wbuf_len; + de = (unsigned char *)fptr->wbuf + fptr->wbuf_capa; + res = rb_econv_convert(fptr->writeconv, NULL, NULL, &dp, de, 0); + fptr->wbuf_len += dp - ds; + if (!noraise) { + rb_econv_check_error(fptr->writeconv); + } + if (res == econv_invalid_byte_sequence || + res == econv_undefined_conversion) { + break; + } + } + +} + +static void +fptr_finalize(rb_io_t *fptr, int noraise) +{ + int ebadf = 0; + if (fptr->writeconv) { + finish_writeconv(fptr, noraise); + } + if (fptr->wbuf_len) { + io_fflush(fptr); + } + if (IS_PREP_STDIO(fptr) || + fptr->fd <= 2) { + return; + } + if (fptr->stdio_file) { + if (fclose(fptr->stdio_file) < 0 && !noraise) { + /* fptr->stdio_file is deallocated anyway */ + fptr->stdio_file = 0; + fptr->fd = -1; + rb_sys_fail_path(fptr->pathv); + } + } + else if (0 <= fptr->fd) { + if (close(fptr->fd) < 0 && !noraise) { + if (errno != EBADF) { + /* fptr->fd is still not closed */ + rb_sys_fail_path(fptr->pathv); + } + else { + /* fptr->fd is already closed. */ + ebadf = 1; + } + } + } + fptr->fd = -1; + fptr->stdio_file = 0; + fptr->mode &= ~(FMODE_READABLE|FMODE_WRITABLE); + if (ebadf) { + rb_sys_fail_path(fptr->pathv); + } +} + +static void +rb_io_fptr_cleanup(rb_io_t *fptr, int noraise) +{ + if (fptr->finalize) { + (*fptr->finalize)(fptr, noraise); + } + else { + fptr_finalize(fptr, noraise); + } +} + +static void +clear_readconv(rb_io_t *fptr) +{ + if (fptr->readconv) { + rb_econv_close(fptr->readconv); + fptr->readconv = NULL; + } + if (fptr->crbuf) { + free(fptr->crbuf); + fptr->crbuf = NULL; + } +} + +static void +clear_writeconv(rb_io_t *fptr) +{ + if (fptr->writeconv) { + rb_econv_close(fptr->writeconv); + fptr->writeconv = NULL; + } + fptr->writeconv_initialized = 0; +} + +static void +clear_codeconv(rb_io_t *fptr) +{ + clear_readconv(fptr); + clear_writeconv(fptr); +} + +int +rb_io_fptr_finalize(rb_io_t *fptr) +{ + if (!fptr) return 0; + if (fptr->refcnt <= 0 || --fptr->refcnt) return 0; + fptr->pathv = Qnil; + if (0 <= fptr->fd) + rb_io_fptr_cleanup(fptr, Qtrue); + if (fptr->rbuf) { + free(fptr->rbuf); + fptr->rbuf = 0; + } + if (fptr->wbuf) { + free(fptr->wbuf); + fptr->wbuf = 0; + } + clear_codeconv(fptr); + free(fptr); + return 1; +} + +VALUE +rb_io_close(VALUE io) +{ + rb_io_t *fptr; + int fd; + VALUE write_io; + rb_io_t *write_fptr; + + write_io = GetWriteIO(io); + if (io != write_io) { + write_fptr = RFILE(write_io)->fptr; + if (write_fptr && 0 <= write_fptr->fd) { + rb_io_fptr_cleanup(write_fptr, Qtrue); + } + } + + fptr = RFILE(io)->fptr; + if (!fptr) return Qnil; + if (fptr->fd < 0) return Qnil; + + fd = fptr->fd; + rb_io_fptr_cleanup(fptr, Qfalse); + rb_thread_fd_close(fd); + + if (fptr->pid) { + rb_syswait(fptr->pid); + fptr->pid = 0; + } + + return Qnil; +} + +/* + * call-seq: + * ios.close => nil + * + * Closes <em>ios</em> and flushes any pending writes to the operating + * system. The stream is unavailable for any further data operations; + * an <code>IOError</code> is raised if such an attempt is made. I/O + * streams are automatically closed when they are claimed by the + * garbage collector. + * + * If <em>ios</em> is opened by <code>IO.popen</code>, + * <code>close</code> sets <code>$?</code>. + */ + +static VALUE +rb_io_close_m(VALUE io) +{ + if (rb_safe_level() >= 4 && !OBJ_UNTRUSTED(io)) { + rb_raise(rb_eSecurityError, "Insecure: can't close"); + } + rb_io_check_closed(RFILE(io)->fptr); + rb_io_close(io); + return Qnil; +} + +static VALUE +io_call_close(VALUE io) +{ + return rb_funcall(io, rb_intern("close"), 0, 0); +} + +static VALUE +io_close(VALUE io) +{ + return rb_rescue(io_call_close, io, 0, 0); +} + +/* + * call-seq: + * ios.closed? => true or false + * + * Returns <code>true</code> if <em>ios</em> is completely closed (for + * duplex streams, both reader and writer), <code>false</code> + * otherwise. + * + * f = File.new("testfile") + * f.close #=> nil + * f.closed? #=> true + * f = IO.popen("/bin/sh","r+") + * f.close_write #=> nil + * f.closed? #=> false + * f.close_read #=> nil + * f.closed? #=> true + */ + + +static VALUE +rb_io_closed(VALUE io) +{ + rb_io_t *fptr; + VALUE write_io; + rb_io_t *write_fptr; + + write_io = GetWriteIO(io); + if (io != write_io) { + write_fptr = RFILE(write_io)->fptr; + if (write_fptr && 0 <= write_fptr->fd) { + return Qfalse; + } + } + + fptr = RFILE(io)->fptr; + rb_io_check_initialized(fptr); + return 0 <= fptr->fd ? Qfalse : Qtrue; +} + +/* + * call-seq: + * ios.close_read => nil + * + * Closes the read end of a duplex I/O stream (i.e., one that contains + * both a read and a write stream, such as a pipe). Will raise an + * <code>IOError</code> if the stream is not duplexed. + * + * f = IO.popen("/bin/sh","r+") + * f.close_read + * f.readlines + * + * <em>produces:</em> + * + * prog.rb:3:in `readlines': not opened for reading (IOError) + * from prog.rb:3 + */ + +static VALUE +rb_io_close_read(VALUE io) +{ + rb_io_t *fptr; + VALUE write_io; + + if (rb_safe_level() >= 4 && !OBJ_UNTRUSTED(io)) { + rb_raise(rb_eSecurityError, "Insecure: can't close"); + } + GetOpenFile(io, fptr); + if (is_socket(fptr->fd, fptr->pathv)) { +#ifndef SHUT_RD +# define SHUT_RD 0 +#endif + if (shutdown(fptr->fd, SHUT_RD) < 0) + rb_sys_fail_path(fptr->pathv); + fptr->mode &= ~FMODE_READABLE; + if (!(fptr->mode & FMODE_WRITABLE)) + return rb_io_close(io); + return Qnil; + } + + write_io = GetWriteIO(io); + if (io != write_io) { + rb_io_t *wfptr; + fptr_finalize(fptr, Qfalse); + GetOpenFile(write_io, wfptr); + if (fptr->refcnt < LONG_MAX) { + wfptr->refcnt++; + RFILE(io)->fptr = wfptr; + rb_io_fptr_finalize(fptr); + } + return Qnil; + } + + if (fptr->mode & FMODE_WRITABLE) { + rb_raise(rb_eIOError, "closing non-duplex IO for reading"); + } + return rb_io_close(io); +} + +/* + * call-seq: + * ios.close_write => nil + * + * Closes the write end of a duplex I/O stream (i.e., one that contains + * both a read and a write stream, such as a pipe). Will raise an + * <code>IOError</code> if the stream is not duplexed. + * + * f = IO.popen("/bin/sh","r+") + * f.close_write + * f.print "nowhere" + * + * <em>produces:</em> + * + * prog.rb:3:in `write': not opened for writing (IOError) + * from prog.rb:3:in `print' + * from prog.rb:3 + */ + +static VALUE +rb_io_close_write(VALUE io) +{ + rb_io_t *fptr; + VALUE write_io; + + if (rb_safe_level() >= 4 && !OBJ_UNTRUSTED(io)) { + rb_raise(rb_eSecurityError, "Insecure: can't close"); + } + write_io = GetWriteIO(io); + GetOpenFile(write_io, fptr); + if (is_socket(fptr->fd, fptr->pathv)) { +#ifndef SHUT_WR +# define SHUT_WR 1 +#endif + if (shutdown(fptr->fd, SHUT_WR) < 0) + rb_sys_fail_path(fptr->pathv); + fptr->mode &= ~FMODE_WRITABLE; + if (!(fptr->mode & FMODE_READABLE)) + return rb_io_close(write_io); + return Qnil; + } + + if (fptr->mode & FMODE_READABLE) { + rb_raise(rb_eIOError, "closing non-duplex IO for writing"); + } + + rb_io_close(write_io); + if (io != write_io) { + GetOpenFile(io, fptr); + fptr->tied_io_for_writing = 0; + fptr->mode &= ~FMODE_DUPLEX; + } + return Qnil; +} + +/* + * call-seq: + * ios.sysseek(offset, whence=SEEK_SET) => integer + * + * Seeks to a given <i>offset</i> in the stream according to the value + * of <i>whence</i> (see <code>IO#seek</code> for values of + * <i>whence</i>). Returns the new offset into the file. + * + * f = File.new("testfile") + * f.sysseek(-13, IO::SEEK_END) #=> 53 + * f.sysread(10) #=> "And so on." + */ + +static VALUE +rb_io_sysseek(int argc, VALUE *argv, VALUE io) +{ + VALUE offset, ptrname; + int whence = SEEK_SET; + rb_io_t *fptr; + off_t pos; + + if (rb_scan_args(argc, argv, "11", &offset, &ptrname) == 2) { + whence = NUM2INT(ptrname); + } + pos = NUM2OFFT(offset); + GetOpenFile(io, fptr); + if ((fptr->mode & FMODE_READABLE) && READ_DATA_BUFFERED(fptr)) { + rb_raise(rb_eIOError, "sysseek for buffered IO"); + } + if ((fptr->mode & FMODE_WRITABLE) && fptr->wbuf_len) { + rb_warn("sysseek for buffered IO"); + } + pos = lseek(fptr->fd, pos, whence); + if (pos == -1) rb_sys_fail_path(fptr->pathv); + + return OFFT2NUM(pos); +} + +/* + * call-seq: + * ios.syswrite(string) => integer + * + * Writes the given string to <em>ios</em> using a low-level write. + * Returns the number of bytes written. Do not mix with other methods + * that write to <em>ios</em> or you may get unpredictable results. + * Raises <code>SystemCallError</code> on error. + * + * f = File.new("out", "w") + * f.syswrite("ABCDEF") #=> 6 + */ + +static VALUE +rb_io_syswrite(VALUE io, VALUE str) +{ + rb_io_t *fptr; + long n; + + rb_secure(4); + if (TYPE(str) != T_STRING) + str = rb_obj_as_string(str); + + io = GetWriteIO(io); + GetOpenFile(io, fptr); + rb_io_check_writable(fptr); + + if (fptr->wbuf_len) { + rb_warn("syswrite for buffered IO"); + } + if (!rb_thread_fd_writable(fptr->fd)) { + rb_io_check_closed(fptr); + } + TRAP_BEG; + n = write(fptr->fd, RSTRING_PTR(str), RSTRING_LEN(str)); + TRAP_END; + + if (n == -1) rb_sys_fail_path(fptr->pathv); + + return LONG2FIX(n); +} + +/* + * call-seq: + * ios.sysread(integer[, outbuf]) => string + * + * Reads <i>integer</i> bytes from <em>ios</em> using a low-level + * read and returns them as a string. Do not mix with other methods + * that read from <em>ios</em> or you may get unpredictable results. + * If the optional <i>outbuf</i> argument is present, it must reference + * a String, which will receive the data. + * Raises <code>SystemCallError</code> on error and + * <code>EOFError</code> at end of file. + * + * f = File.new("testfile") + * f.sysread(16) #=> "This is line one" + */ + +static VALUE +rb_io_sysread(int argc, VALUE *argv, VALUE io) +{ + VALUE len, str; + rb_io_t *fptr; + long n, ilen; + + rb_scan_args(argc, argv, "11", &len, &str); + ilen = NUM2LONG(len); + + if (NIL_P(str)) { + str = rb_str_new(0, ilen); + } + else { + StringValue(str); + rb_str_modify(str); + rb_str_resize(str, ilen); + } + if (ilen == 0) return str; + + GetOpenFile(io, fptr); + rb_io_check_readable(fptr); + + if (READ_DATA_BUFFERED(fptr)) { + rb_raise(rb_eIOError, "sysread for buffered IO"); + } + + n = fptr->fd; + rb_thread_wait_fd(fptr->fd); + rb_io_check_closed(fptr); + if (RSTRING_LEN(str) != ilen) { + rb_raise(rb_eRuntimeError, "buffer string modified"); + } + + n = rb_read_internal(fptr->fd, RSTRING_PTR(str), ilen); + + if (n == -1) { + rb_sys_fail_path(fptr->pathv); + } + rb_str_set_len(str, n); + if (n == 0 && ilen > 0) { + rb_eof_error(); + } + rb_str_resize(str, n); + OBJ_TAINT(str); + + return str; +} + +VALUE +rb_io_binmode(VALUE io) +{ + rb_io_t *fptr; + + GetOpenFile(io, fptr); + if (fptr->readconv) + rb_econv_binmode(fptr->readconv); + if (fptr->writeconv) + rb_econv_binmode(fptr->writeconv); + fptr->mode |= FMODE_BINMODE; + fptr->mode &= ~FMODE_TEXTMODE; + return io; +} + +/* + * call-seq: + * ios.binmode => ios + * + * Puts <em>ios</em> into binary mode. This is useful only in + * MS-DOS/Windows environments. Once a stream is in binary mode, it + * cannot be reset to nonbinary mode. + */ + +static VALUE +rb_io_binmode_m(VALUE io) +{ + VALUE write_io; + + rb_io_binmode(io); + + write_io = GetWriteIO(io); + if (write_io != io) + rb_io_binmode(write_io); + return io; +} + +/* + * call-seq: + * ios.binmode? => true or false + * + * Returns <code>true</code> if <em>ios</em> is binmode. + */ +static VALUE +rb_io_binmode_p(VALUE io) +{ + rb_io_t *fptr; + GetOpenFile(io, fptr); + return fptr->mode & FMODE_BINMODE ? Qtrue : Qfalse; +} + +static const char* +rb_io_flags_mode(int flags) +{ +# define MODE_BTMODE(a,b,c) ((flags & FMODE_BINMODE) ? (b) : \ + (flags & FMODE_TEXTMODE) ? (c) : (a)) + if (flags & FMODE_APPEND) { + if ((flags & FMODE_READWRITE) == FMODE_READWRITE) { + return MODE_BTMODE("a+", "ab+", "at+"); + } + return MODE_BTMODE("a", "ab", "at"); + } + switch (flags & FMODE_READWRITE) { + case FMODE_READABLE: + return MODE_BTMODE("r", "rb", "rt"); + case FMODE_WRITABLE: + return MODE_BTMODE("w", "wb", "wt"); + case FMODE_READWRITE: + if (flags & FMODE_CREATE) { + return MODE_BTMODE("w+", "wb+", "wt+"); + } + return MODE_BTMODE("r+", "rb+", "rt+"); + } + rb_raise(rb_eArgError, "invalid access modenum 0x%x", flags); + return NULL; /* not reached */ +} + +int +rb_io_mode_flags(const char *mode) +{ + int flags = 0; + const char *m = mode; + + switch (*m++) { + case 'r': + flags |= FMODE_READABLE; + break; + case 'w': + flags |= FMODE_WRITABLE | FMODE_TRUNC | FMODE_CREATE; + break; + case 'a': + flags |= FMODE_WRITABLE | FMODE_APPEND | FMODE_CREATE; + break; + default: + error: + rb_raise(rb_eArgError, "invalid access mode %s", mode); + } + + while (*m) { + switch (*m++) { + case 'b': + flags |= FMODE_BINMODE; + break; + case 't': + flags |= FMODE_TEXTMODE; + break; + case '+': + flags |= FMODE_READWRITE; + break; + default: + goto error; + case ':': + goto finished; + } + } + +finished: + if ((flags & FMODE_BINMODE) && (flags & FMODE_TEXTMODE)) + goto error; + + return flags; +} + +int +rb_io_modenum_flags(int mode) +{ + int flags = 0; + + switch (mode & (O_RDONLY|O_WRONLY|O_RDWR)) { + case O_RDONLY: + flags = FMODE_READABLE; + break; + case O_WRONLY: + flags = FMODE_WRITABLE; + break; + case O_RDWR: + flags = FMODE_READWRITE; + break; + } + + if (mode & O_APPEND) { + flags |= FMODE_APPEND; + } + if (mode & O_TRUNC) { + flags |= FMODE_TRUNC; + } + if (mode & O_CREAT) { + flags |= FMODE_CREATE; + } +#ifdef O_BINARY + if (mode & O_BINARY) { + flags |= FMODE_BINMODE; + } +#endif + + return flags; +} + +static int +rb_io_flags_modenum(int flags) +{ + int mode = 0; + + switch (flags & FMODE_READWRITE) { + case FMODE_READABLE: + mode |= O_RDONLY; + break; + case FMODE_WRITABLE: + mode |= O_WRONLY; + break; + case FMODE_READWRITE: + mode |= O_RDWR; + break; + } + + if (flags & FMODE_APPEND) { + mode |= O_APPEND; + } + if (flags & FMODE_TRUNC) { + mode |= O_TRUNC; + } + if (flags & FMODE_CREATE) { + mode |= O_CREAT; + } +#ifdef O_BINARY + if (flags & FMODE_BINMODE) { + mode |= O_BINARY; + } +#endif + + return mode; +} + +int +rb_io_mode_modenum(const char *mode) +{ + return rb_io_flags_modenum(rb_io_mode_flags(mode)); +} + +#define MODENUM_MAX 4 + +static const char* +rb_io_modenum_mode(int flags) +{ +#ifdef O_BINARY +# define MODE_BINARY(a,b) ((flags & O_BINARY) ? (b) : (a)) +#else +# define MODE_BINARY(a,b) (a) +#endif + if (flags & O_APPEND) { + if ((flags & O_RDWR) == O_RDWR) { + return MODE_BINARY("a+", "ab+"); + } + return MODE_BINARY("a", "ab"); + } + switch (flags & (O_RDONLY|O_WRONLY|O_RDWR)) { + case O_RDONLY: + return MODE_BINARY("r", "rb"); + case O_WRONLY: + return MODE_BINARY("w", "wb"); + case O_RDWR: + return MODE_BINARY("r+", "rb+"); + } + rb_raise(rb_eArgError, "invalid access modenum 0x%x", flags); + return NULL; /* not reached */ +} + +static void +parse_mode_enc(const char *estr, rb_encoding **enc_p, rb_encoding **enc2_p) +{ + const char *p0, *p1; + char *enc2name; + int idx, idx2; + + /* parse estr as "enc" or "enc2:enc" */ + + *enc_p = 0; + *enc2_p = 0; + + p0 = strrchr(estr, ':'); + if (!p0) p1 = estr; + else p1 = p0 + 1; + idx = rb_enc_find_index(p1); + if (idx >= 0) { + *enc_p = rb_enc_from_index(idx); + } + else { + rb_warn("Unsupported encoding %s ignored", p1); + } + + if (*enc_p && p0) { + int n = p0 - estr; + if (n > ENCODING_MAXNAMELEN) { + idx2 = -1; + } + else { + enc2name = ALLOCA_N(char, n+1); + memcpy(enc2name, estr, n); + enc2name[n] = '\0'; + estr = enc2name; + idx2 = rb_enc_find_index(enc2name); + } + if (idx2 < 0) { + rb_warn("Unsupported encoding %.*s ignored", n, estr); + } + else if (idx2 == idx) { + rb_warn("Ignoring internal encoding %.*s: it is identical to external encoding %s", + n, estr, p1); + } + else { + *enc2_p = rb_enc_from_index(idx2); + } + } +} + +static void +mode_enc(rb_io_t *fptr, const char *estr) +{ + clear_codeconv(fptr); + + parse_mode_enc(estr, &fptr->encs.enc, &fptr->encs.enc2); +} + +void +rb_io_mode_enc(rb_io_t *fptr, const char *mode) +{ + const char *p = strchr(mode, ':'); + if (p) { + mode_enc(fptr, p+1); + } +} + +static int +io_extract_encoding_option(VALUE opt, rb_encoding **enc_p, rb_encoding **enc2_p) +{ + VALUE encoding=Qnil, extenc=Qnil, intenc=Qnil; + int extracted = 0; + if (!NIL_P(opt)) { + VALUE v; + v = rb_hash_aref(opt, sym_encoding); + if (!NIL_P(v)) encoding = v; + v = rb_hash_aref(opt, sym_extenc); + if (!NIL_P(v)) extenc = v; + v = rb_hash_aref(opt, sym_intenc); + if (!NIL_P(v)) intenc = v; + } + if (!NIL_P(extenc)) { + rb_encoding *extencoding = rb_to_encoding(extenc); + extracted = 1; + *enc_p = 0; + *enc2_p = 0; + if (!NIL_P(encoding)) { + rb_warn("Ignoring encoding parameter '%s': external_encoding is used", + RSTRING_PTR(encoding)); + } + if (!NIL_P(intenc)) { + rb_encoding *intencoding = rb_to_encoding(intenc); + if (extencoding == intencoding) { + rb_warn("Ignoring internal encoding '%s': it is identical to external encoding '%s'", + RSTRING_PTR(rb_inspect(intenc)), + RSTRING_PTR(rb_inspect(extenc))); + } + else { + *enc_p = intencoding; + *enc2_p = extencoding; + } + } + else { + *enc_p = extencoding; + } + } + else { + if (!NIL_P(intenc)) { + rb_raise(rb_eArgError, "External encoding must be specified when internal encoding is given"); + } + if (!NIL_P(encoding)) { + extracted = 1; + parse_mode_enc(StringValueCStr(encoding), enc_p, enc2_p); + } + } + return extracted; +} + +typedef struct rb_io_enc_t convconfig_t; + +static void +rb_io_extract_modeenc(VALUE *mode_p, VALUE opthash, + int *modenum_p, int *flags_p, convconfig_t *convconfig_p) +{ + VALUE mode; + int modenum, flags; + rb_encoding *enc, *enc2; + rb_econv_option_t ecopts; + int has_enc = 0; + VALUE intmode; + + mode = *mode_p; + + enc = NULL; + enc2 = NULL; + + if (NIL_P(mode)) { + flags = FMODE_READABLE; + modenum = O_RDONLY; + } + else if (!NIL_P(intmode = rb_check_to_integer(mode, "to_int"))) { + mode = intmode; + modenum = NUM2INT(intmode); + flags = rb_io_modenum_flags(modenum); + } + else { + const char *p; + SafeStringValue(mode); + p = StringValueCStr(mode); + flags = rb_io_mode_flags(p); + modenum = rb_io_flags_modenum(flags); + p = strchr(p, ':'); + if (p) { + has_enc = 1; + parse_mode_enc(p+1, &enc, &enc2); + } + } + + if (NIL_P(opthash)) { + rb_econv_opts(Qnil, &ecopts); + } + else { + VALUE v; + v = rb_hash_aref(opthash, sym_textmode); + if (RTEST(v)) + flags |= FMODE_TEXTMODE; + v = rb_hash_aref(opthash, sym_binmode); + if (RTEST(v)) { + flags |= FMODE_BINMODE; +#ifdef O_BINARY + modenum |= O_BINARY; +#endif + } + rb_econv_opts(opthash, &ecopts); + + if (io_extract_encoding_option(opthash, &enc, &enc2)) { + if (has_enc) { + rb_raise(rb_eArgError, "encoding sepecified twice"); + } + } + } + + if ((flags & FMODE_BINMODE) && (flags & FMODE_TEXTMODE)) + rb_raise(rb_eArgError, "both textmode and binmode specified"); + + *mode_p = mode; + + *modenum_p = modenum; + *flags_p = flags; + convconfig_p->enc = enc; + convconfig_p->enc2 = enc2; + convconfig_p->opts = ecopts; +} + +struct sysopen_struct { + char *fname; + int flag; + mode_t mode; +}; + +static VALUE +sysopen_func(void *ptr) +{ + struct sysopen_struct *data = ptr; + return (VALUE)open(data->fname, data->flag, data->mode); +} + +static int +rb_sysopen_internal(char *fname, int flags, mode_t mode) +{ + struct sysopen_struct data; + data.fname = fname; + data.flag = flags; + data.mode = mode; + return (int)rb_thread_blocking_region(sysopen_func, &data, RB_UBF_DFL, 0); +} + +static int +rb_sysopen(char *fname, int flags, mode_t mode) +{ + int fd; + +#ifdef O_BINARY + flags |= O_BINARY; +#endif + + fd = rb_sysopen_internal(fname, flags, mode); + if (fd < 0) { + if (errno == EMFILE || errno == ENFILE) { + rb_gc(); + fd = rb_sysopen_internal(fname, flags, mode); + } + if (fd < 0) { + rb_sys_fail(fname); + } + } + UPDATE_MAXFD(fd); + return fd; +} + +FILE * +rb_fdopen(int fd, const char *mode) +{ + FILE *file; + +#if defined(sun) + errno = 0; +#endif + file = fdopen(fd, mode); + if (!file) { + if ( +#if defined(sun) + errno == 0 || +#endif + errno == EMFILE || errno == ENFILE) { + rb_gc(); +#if defined(sun) + errno = 0; +#endif + file = fdopen(fd, mode); + } + if (!file) { +#ifdef _WIN32 + if (errno == 0) errno = EINVAL; +#elif defined(sun) + if (errno == 0) errno = EMFILE; +#endif + rb_sys_fail(0); + } + } + + /* xxx: should be _IONBF? A buffer in FILE may have trouble. */ +#ifdef USE_SETVBUF + if (setvbuf(file, NULL, _IOFBF, 0) != 0) + rb_warn("setvbuf() can't be honoured (fd=%d)", fd); +#endif + return file; +} + +static void +io_check_tty(rb_io_t *fptr) +{ + if (isatty(fptr->fd)) + fptr->mode |= FMODE_TTY|FMODE_DUPLEX; +} + +static VALUE +rb_file_open_generic(VALUE io, VALUE filename, int modenum, int flags, convconfig_t *convconfig, mode_t perm) +{ + rb_io_t *fptr; + + MakeOpenFile(io, fptr); + fptr->mode = flags; + if (convconfig) { + fptr->encs = *convconfig; + } + else { + fptr->encs.enc = NULL; + fptr->encs.enc2 = NULL; + rb_econv_opts(Qnil, &fptr->encs.opts); + } + fptr->pathv = rb_str_new_frozen(filename); + fptr->fd = rb_sysopen(RSTRING_PTR(fptr->pathv), modenum, perm); + io_check_tty(fptr); + + return io; +} + +static VALUE +rb_file_open_internal(VALUE io, VALUE filename, const char *mode) +{ + int flags; + + const char *p = strchr(mode, ':'); + convconfig_t convconfig; + if (p) { + parse_mode_enc(p+1, &convconfig.enc, &convconfig.enc2); + } + else { + convconfig.enc = NULL; + convconfig.enc2 = NULL; + rb_econv_opts(Qnil, &convconfig.opts); + } + + flags = rb_io_mode_flags(mode); + return rb_file_open_generic(io, filename, + rb_io_flags_modenum(flags), + flags, + &convconfig, + 0666); +} + +VALUE +rb_file_open(const char *fname, const char *mode) +{ + return rb_file_open_internal(io_alloc(rb_cFile), rb_str_new_cstr(fname), mode); +} + +#if defined(__CYGWIN__) || !defined(HAVE_FORK) +static struct pipe_list { + rb_io_t *fptr; + struct pipe_list *next; +} *pipe_list; + +static void +pipe_add_fptr(rb_io_t *fptr) +{ + struct pipe_list *list; + + list = ALLOC(struct pipe_list); + list->fptr = fptr; + list->next = pipe_list; + pipe_list = list; +} + +static void +pipe_del_fptr(rb_io_t *fptr) +{ + struct pipe_list *list = pipe_list; + struct pipe_list *tmp; + + if (list->fptr == fptr) { + pipe_list = list->next; + free(list); + return; + } + + while (list->next) { + if (list->next->fptr == fptr) { + tmp = list->next; + list->next = list->next->next; + free(tmp); + return; + } + list = list->next; + } +} + +static void +pipe_atexit(void) +{ + struct pipe_list *list = pipe_list; + struct pipe_list *tmp; + + while (list) { + tmp = list->next; + rb_io_fptr_finalize(list->fptr); + list = tmp; + } +} + +static void +pipe_finalize(rb_io_t *fptr, int noraise) +{ +#if !defined(HAVE_FORK) && !defined(_WIN32) + int status; + if (fptr->stdio_file) { + status = pclose(fptr->stdio_file); + } + fptr->fd = -1; + fptr->stdio_file = 0; +#if defined DJGPP + status <<= 8; +#endif + rb_last_status_set(status, fptr->pid); +#else + fptr_finalize(fptr, noraise); +#endif + pipe_del_fptr(fptr); +} +#endif + +void +rb_io_synchronized(rb_io_t *fptr) +{ + rb_io_check_initialized(fptr); + fptr->mode |= FMODE_SYNC; +} + +void +rb_io_unbuffered(rb_io_t *fptr) +{ + rb_io_synchronized(fptr); +} + +int +rb_pipe(int *pipes) +{ + int ret; + ret = pipe(pipes); + if (ret == -1) { + if (errno == EMFILE || errno == ENFILE) { + rb_gc(); + ret = pipe(pipes); + } + } + if (ret == 0) { + UPDATE_MAXFD(pipes[0]); + UPDATE_MAXFD(pipes[1]); + } + return ret; +} + +#ifdef HAVE_FORK +struct popen_arg { + struct rb_exec_arg *execp; + int modef; + int pair[2]; + int write_pair[2]; +}; + +static void +popen_redirect(struct popen_arg *p) +{ + if ((p->modef & FMODE_READABLE) && (p->modef & FMODE_WRITABLE)) { + close(p->write_pair[1]); + if (p->write_pair[0] != 0) { + dup2(p->write_pair[0], 0); + close(p->write_pair[0]); + } + close(p->pair[0]); + if (p->pair[1] != 1) { + dup2(p->pair[1], 1); + close(p->pair[1]); + } + } + else if (p->modef & FMODE_READABLE) { + close(p->pair[0]); + if (p->pair[1] != 1) { + dup2(p->pair[1], 1); + close(p->pair[1]); + } + } + else { + close(p->pair[1]); + if (p->pair[0] != 0) { + dup2(p->pair[0], 0); + close(p->pair[0]); + } + } +} + +void +rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds) +{ + int fd, ret; + int max = max_file_descriptor; + if (max < maxhint) + max = maxhint; + for (fd = lowfd; fd <= max; fd++) { + if (!NIL_P(noclose_fds) && + RTEST(rb_hash_lookup(noclose_fds, INT2FIX(fd)))) + continue; +#ifdef FD_CLOEXEC + ret = fcntl(fd, F_GETFD); + if (ret != -1 && !(ret & FD_CLOEXEC)) { + fcntl(fd, F_SETFD, ret|FD_CLOEXEC); + } +#else + close(fd); +#endif + } +} + +static int +popen_exec(void *pp) +{ + struct popen_arg *p = (struct popen_arg*)pp; + + rb_thread_atfork_before_exec(); + return rb_exec(p->execp); +} +#endif + +static VALUE +pipe_open(struct rb_exec_arg *eargp, VALUE prog, const char *mode, int flags, convconfig_t *convconfig) +{ + int pid = 0; + rb_io_t *fptr; + VALUE port; + rb_io_t *write_fptr; + VALUE write_port; +#if defined(HAVE_FORK) + int status; + struct popen_arg arg; +#elif defined(_WIN32) + int openmode = rb_io_mode_modenum(mode); + const char *exename = NULL; + volatile VALUE cmdbuf; + struct rb_exec_arg sarg; +#endif + FILE *fp = 0; + int fd = -1; + int write_fd = -1; + const char *cmd = 0; + int argc; + VALUE *argv; + + if (prog) + cmd = StringValueCStr(prog); + + if (!eargp) { + /* fork : IO.popen("-") */ + argc = 0; + argv = 0; + } + else if (eargp->argc) { + /* no shell : IO.popen([prog, arg0], arg1, ...) */ + argc = eargp->argc; + argv = eargp->argv; + } + else { + /* with shell : IO.popen(prog) */ + argc = 0; + argv = 0; + } + +#if defined(HAVE_FORK) + arg.execp = eargp; + arg.modef = flags; + arg.pair[0] = arg.pair[1] = -1; + arg.write_pair[0] = arg.write_pair[1] = -1; + switch (flags & (FMODE_READABLE|FMODE_WRITABLE)) { + case FMODE_READABLE|FMODE_WRITABLE: + if (rb_pipe(arg.write_pair) < 0) + rb_sys_fail(cmd); + if (rb_pipe(arg.pair) < 0) { + int e = errno; + close(arg.write_pair[0]); + close(arg.write_pair[1]); + errno = e; + rb_sys_fail(cmd); + } + if (eargp) { + rb_exec_arg_addopt(eargp, INT2FIX(0), INT2FIX(arg.write_pair[0])); + rb_exec_arg_addopt(eargp, INT2FIX(1), INT2FIX(arg.pair[1])); + } + break; + case FMODE_READABLE: + if (rb_pipe(arg.pair) < 0) + rb_sys_fail(cmd); + if (eargp) + rb_exec_arg_addopt(eargp, INT2FIX(1), INT2FIX(arg.pair[1])); + break; + case FMODE_WRITABLE: + if (rb_pipe(arg.pair) < 0) + rb_sys_fail(cmd); + if (eargp) + rb_exec_arg_addopt(eargp, INT2FIX(0), INT2FIX(arg.pair[0])); + break; + default: + rb_sys_fail(cmd); + } + if (eargp) { + rb_exec_arg_fixup(arg.execp); + pid = rb_fork(&status, popen_exec, &arg, arg.execp->redirect_fds); + } + else { + fflush(stdin); /* is it really needed? */ + rb_io_flush(rb_stdout); + rb_io_flush(rb_stderr); + pid = rb_fork(&status, 0, 0, Qnil); + if (pid == 0) { /* child */ + popen_redirect(&arg); + rb_io_synchronized(RFILE(orig_stdout)->fptr); + rb_io_synchronized(RFILE(orig_stderr)->fptr); + return Qnil; + } + } + + /* parent */ + if (pid == -1) { + int e = errno; + close(arg.pair[0]); + close(arg.pair[1]); + if ((flags & (FMODE_READABLE|FMODE_WRITABLE)) == (FMODE_READABLE|FMODE_WRITABLE)) { + close(arg.write_pair[0]); + close(arg.write_pair[1]); + } + errno = e; + rb_sys_fail(cmd); + } + if ((flags & FMODE_READABLE) && (flags & FMODE_WRITABLE)) { + close(arg.pair[1]); + fd = arg.pair[0]; + close(arg.write_pair[0]); + write_fd = arg.write_pair[1]; + } + else if (flags & FMODE_READABLE) { + close(arg.pair[1]); + fd = arg.pair[0]; + } + else { + close(arg.pair[0]); + fd = arg.pair[1]; + } +#elif defined(_WIN32) + if (argc) { + volatile VALUE argbuf; + char **args; + int i; + + if (argc >= FIXNUM_MAX / sizeof(char *)) { + rb_raise(rb_eArgError, "too many arguments"); + } + argbuf = rb_str_tmp_new((argc+1) * sizeof(char *)); + args = (void *)RSTRING_PTR(argbuf); + for (i = 0; i < argc; ++i) { + args[i] = StringValueCStr(argv[i]); + } + args[i] = NULL; + exename = cmd; + cmdbuf = rb_str_tmp_new(rb_w32_argv_size(args)); + cmd = rb_w32_join_argv(RSTRING_PTR(cmdbuf), args); + rb_str_resize(argbuf, 0); + } + if (eargp) { + rb_exec_arg_fixup(eargp); + rb_run_exec_options(eargp, &sarg); + } + while ((pid = rb_w32_pipe_exec(cmd, exename, openmode, &fd, &write_fd)) == -1) { + /* exec failed */ + switch (errno) { + case EAGAIN: +#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN + case EWOULDBLOCK: +#endif + rb_thread_sleep(1); + break; + default: + if (eargp) + rb_run_exec_options(&sarg, NULL); + rb_sys_fail(cmd); + break; + } + } + if (eargp) + rb_run_exec_options(&sarg, NULL); +#else + if (argc) { + prog = rb_ary_join(rb_ary_new4(argc, argv), rb_str_new2(" ")); + cmd = StringValueCStr(prog); + } + if (eargp) { + rb_exec_arg_fixup(eargp); + rb_run_exec_options(eargp, &sarg); + } + fp = popen(cmd, mode); + if (eargp) + rb_run_exec_options(&sarg, NULL); + if (!fp) rb_sys_fail(RSTRING_PTR(prog)); + fd = fileno(fp); +#endif + + port = io_alloc(rb_cIO); + MakeOpenFile(port, fptr); + fptr->fd = fd; + fptr->stdio_file = fp; + fptr->mode = flags | FMODE_SYNC|FMODE_DUPLEX; + if (convconfig) { + fptr->encs = *convconfig; + } + fptr->pid = pid; + + if (0 <= write_fd) { + write_port = io_alloc(rb_cIO); + MakeOpenFile(write_port, write_fptr); + write_fptr->fd = write_fd; + write_fptr->mode = (flags & ~FMODE_READABLE)| FMODE_SYNC|FMODE_DUPLEX; + fptr->mode &= ~FMODE_WRITABLE; + fptr->tied_io_for_writing = write_port; + rb_ivar_set(port, rb_intern("@tied_io_for_writing"), write_port); + } + +#if defined (__CYGWIN__) || !defined(HAVE_FORK) + fptr->finalize = pipe_finalize; + pipe_add_fptr(fptr); +#endif + return port; +} + +static VALUE +pipe_open_v(int argc, VALUE *argv, const char *mode, int flags, convconfig_t *convconfig) +{ + VALUE prog; + struct rb_exec_arg earg; + prog = rb_exec_arg_init(argc, argv, Qfalse, &earg); + return pipe_open(&earg, prog, mode, flags, convconfig); +} + +static VALUE +pipe_open_s(VALUE prog, const char *mode, int flags, convconfig_t *convconfig) +{ + const char *cmd = RSTRING_PTR(prog); + int argc = 1; + VALUE *argv = &prog; + struct rb_exec_arg earg; + + if (RSTRING_LEN(prog) == 1 && cmd[0] == '-') { +#if !defined(HAVE_FORK) + rb_raise(rb_eNotImpError, + "fork() function is unimplemented on this machine"); +#endif + return pipe_open(0, 0, mode, flags, convconfig); + } + + rb_exec_arg_init(argc, argv, Qtrue, &earg); + return pipe_open(&earg, prog, mode, flags, convconfig); +} + +static VALUE +pop_last_hash(int *argc_p, VALUE **argv_p) +{ + VALUE last, tmp; + if (*argc_p == 0) + return Qnil; + last = (*argv_p)[*argc_p-1]; + tmp = rb_check_convert_type(last, T_HASH, "Hash", "to_hash"); + if (NIL_P(tmp)) + return Qnil; + (*argc_p)--; + return tmp; +} + +/* + * call-seq: + * IO.popen(cmd, mode="r" [, opt]) => io + * IO.popen(cmd, mode="r" [, opt]) {|io| block } => obj + * + * Runs the specified command as a subprocess; the subprocess's + * standard input and output will be connected to the returned + * <code>IO</code> object. If _cmd_ is a +String+ + * ``<code>-</code>'', then a new instance of Ruby is started as the + * subprocess. If <i>cmd</i> is an +Array+ of +String+, then it will + * be used as the subprocess's +argv+ bypassing a shell. + * The array can contains a hash at first for environments and + * a hash at last for options similar to <code>spawn</code>. The default + * mode for the new file object is ``r'', but <i>mode</i> may be set + * to any of the modes listed in the description for class IO. + * + * Raises exceptions which <code>IO::pipe</code> and + * <code>Kernel::system</code> raise. + * + * If a block is given, Ruby will run the command as a child connected + * to Ruby with a pipe. Ruby's end of the pipe will be passed as a + * parameter to the block. + * At the end of block, Ruby close the pipe and sets <code>$?</code>. + * In this case <code>IO::popen</code> returns + * the value of the block. + * + * If a block is given with a _cmd_ of ``<code>-</code>'', + * the block will be run in two separate processes: once in the parent, + * and once in a child. The parent process will be passed the pipe + * object as a parameter to the block, the child version of the block + * will be passed <code>nil</code>, and the child's standard in and + * standard out will be connected to the parent through the pipe. Not + * available on all platforms. + * + * f = IO.popen("uname") + * p f.readlines + * puts "Parent is #{Process.pid}" + * IO.popen("date") { |f| puts f.gets } + * IO.popen("-") {|f| $stderr.puts "#{Process.pid} is here, f is #{f}"} + * p $? + * IO.popen(%w"sed -e s|^|<foo>| -e s&$&;zot;&", "r+") {|f| + * f.puts "bar"; f.close_write; puts f.gets + * } + * + * <em>produces:</em> + * + * ["Linux\n"] + * Parent is 26166 + * Wed Apr 9 08:53:52 CDT 2003 + * 26169 is here, f is + * 26166 is here, f is #<IO:0x401b3d44> + * #<Process::Status: pid=26166,exited(0)> + * <foo>bar;zot; + */ + +static VALUE +rb_io_s_popen(int argc, VALUE *argv, VALUE klass) +{ + const char *mode; + VALUE pname, pmode, port, tmp, opt; + int modenum, flags; + convconfig_t convconfig; + + opt = pop_last_hash(&argc, &argv); + rb_scan_args(argc, argv, "11", &pname, &pmode); + + rb_io_extract_modeenc(&pmode, opt, &modenum, &flags, &convconfig); + mode = rb_io_modenum_mode(modenum); + + tmp = rb_check_array_type(pname); + if (!NIL_P(tmp)) { + tmp = rb_ary_dup(tmp); + RBASIC(tmp)->klass = 0; + port = pipe_open_v(RARRAY_LEN(tmp), RARRAY_PTR(tmp), mode, flags, &convconfig); + rb_ary_clear(tmp); + } + else { + SafeStringValue(pname); + port = pipe_open_s(pname, mode, flags, &convconfig); + } + if (NIL_P(port)) { + /* child */ + if (rb_block_given_p()) { + rb_yield(Qnil); + rb_io_flush(rb_stdout); + rb_io_flush(rb_stderr); + _exit(0); + } + return Qnil; + } + RBASIC(port)->klass = klass; + if (rb_block_given_p()) { + return rb_ensure(rb_yield, port, io_close, port); + } + return port; +} + +static void +rb_scan_open_args(int argc, VALUE *argv, + VALUE *fname_p, int *modenum_p, int *flags_p, + convconfig_t *convconfig_p, mode_t *perm_p) +{ + VALUE opt=Qnil, fname, vmode, vperm; + int modenum, flags; + mode_t perm; + + opt = pop_last_hash(&argc, &argv); + + rb_scan_args(argc, argv, "12", &fname, &vmode, &vperm); +#if defined _WIN32 || defined __APPLE__ + { + static rb_encoding *fs_encoding; + rb_encoding *fname_encoding = rb_enc_get(fname); + if (!fs_encoding) + fs_encoding = rb_filesystem_encoding(); + if (rb_usascii_encoding() != fname_encoding + && rb_ascii8bit_encoding() != fname_encoding +#if defined __APPLE__ + && rb_utf8_encoding() != fname_encoding +#endif + && fs_encoding != fname_encoding) { + static VALUE fs_enc; + if (!fs_enc) + fs_enc = rb_enc_from_encoding(fs_encoding); + fname = rb_str_transcode(fname, fs_enc, 0); + } + } +#endif + FilePathValue(fname); + + rb_io_extract_modeenc(&vmode, opt, &modenum, &flags, convconfig_p); + + perm = NIL_P(vperm) ? 0666 : NUM2UINT(vperm); + + *fname_p = fname; + *modenum_p = modenum; + *flags_p = flags; + *perm_p = perm; +} + +static VALUE +rb_open_file(int argc, VALUE *argv, VALUE io) +{ + VALUE fname; + int modenum, flags; + convconfig_t convconfig; + mode_t perm; + + rb_scan_open_args(argc, argv, &fname, &modenum, &flags, &convconfig, &perm); + rb_file_open_generic(io, fname, modenum, flags, &convconfig, perm); + + return io; +} + +/* + * call-seq: + * IO.open(fd, mode_string="r" [, opt] ) => io + * IO.open(fd, mode_string="r" [, opt] ) {|io| block } => obj + * + * With no associated block, <code>open</code> is a synonym for + * <code>IO::new</code>. If the optional code block is given, it will + * be passed <i>io</i> as an argument, and the IO object will + * automatically be closed when the block terminates. In this instance, + * <code>IO::open</code> returns the value of the block. + * + */ + +static VALUE +rb_io_s_open(int argc, VALUE *argv, VALUE klass) +{ + VALUE io = rb_class_new_instance(argc, argv, klass); + + if (rb_block_given_p()) { + return rb_ensure(rb_yield, io, io_close, io); + } + + return io; +} + +/* + * call-seq: + * IO.sysopen(path, [mode, [perm]]) => fixnum + * + * Opens the given path, returning the underlying file descriptor as a + * <code>Fixnum</code>. + * + * IO.sysopen("testfile") #=> 3 + * + */ + +static VALUE +rb_io_s_sysopen(int argc, VALUE *argv) +{ + VALUE fname, vmode, vperm; + VALUE intmode; + int modenum, fd; + mode_t perm; + char *path; + + rb_scan_args(argc, argv, "12", &fname, &vmode, &vperm); + FilePathValue(fname); + + if (NIL_P(vmode)) + modenum = O_RDONLY; + else if (!NIL_P(intmode = rb_check_to_integer(vmode, "to_int"))) + modenum = NUM2INT(intmode); + else { + SafeStringValue(vmode); + modenum = rb_io_mode_modenum(StringValueCStr(vmode)); + } + if (NIL_P(vperm)) perm = 0666; + else perm = NUM2UINT(vperm); + + RB_GC_GUARD(fname) = rb_str_new4(fname); + path = RSTRING_PTR(fname); + fd = rb_sysopen(path, modenum, perm); + return INT2NUM(fd); +} + +static VALUE +check_pipe_command(VALUE filename_or_command) +{ + char *s = RSTRING_PTR(filename_or_command); + long l = RSTRING_LEN(filename_or_command); + char *e = s + l; + int chlen; + + if (rb_enc_ascget(s, e, &chlen, rb_enc_get(filename_or_command)) == '|') { + VALUE cmd = rb_str_new(s+chlen, l-chlen); + OBJ_INFECT(cmd, filename_or_command); + return cmd; + } + return Qnil; +} + +/* + * call-seq: + * open(path [, mode_enc [, perm]] [, opt] ) => io or nil + * open(path [, mode_enc [, perm]] [, opt] ) {|io| block } => obj + * + * Creates an <code>IO</code> object connected to the given stream, + * file, or subprocess. + * + * If <i>path</i> does not start with a pipe character + * (``<code>|</code>''), treat it as the name of a file to open using + * the specified mode (defaulting to ``<code>r</code>''). + * + * The mode_enc is + * either a string or an integer. If it is an integer, it must be + * bitwise-or of open(2) flags, such as File::RDWR or File::EXCL. + * If it is a string, it is either "mode", "mode:ext_enc", or + * "mode:ext_enc:int_enc". + * The mode is one of the following: + * + * r: read (default) + * w: write + * a: append + * + * The mode can be followed by "b" (means binary-mode), or "+" + * (means both reading and writing allowed) or both. + * If ext_enc (external encoding) is specified, + * read string will be tagged by the encoding in reading, + * and output string will be converted + * to the specified encoding in writing. + * If two encoding names, + * ext_enc and int_enc (external encoding and internal encoding), + * are specified, the read string is converted from ext_enc + * to int_enc then tagged with the int_enc in read mode, + * and in write mode, the output string will be + * converted from int_enc to ext_enc before writing. + * + * If a file is being created, its initial permissions may be + * set using the integer third parameter. + * + * If a block is specified, it will be invoked with the + * <code>File</code> object as a parameter, and the file will be + * automatically closed when the block terminates. The call + * returns the value of the block. + * + * If <i>path</i> starts with a pipe character, a subprocess is + * created, connected to the caller by a pair of pipes. The returned + * <code>IO</code> object may be used to write to the standard input + * and read from the standard output of this subprocess. If the command + * following the ``<code>|</code>'' is a single minus sign, Ruby forks, + * and this subprocess is connected to the parent. In the subprocess, + * the <code>open</code> call returns <code>nil</code>. If the command + * is not ``<code>-</code>'', the subprocess runs the command. If a + * block is associated with an <code>open("|-")</code> call, that block + * will be run twice---once in the parent and once in the child. The + * block parameter will be an <code>IO</code> object in the parent and + * <code>nil</code> in the child. The parent's <code>IO</code> object + * will be connected to the child's <code>$stdin</code> and + * <code>$stdout</code>. The subprocess will be terminated at the end + * of the block. + * + * open("testfile") do |f| + * print f.gets + * end + * + * <em>produces:</em> + * + * This is line one + * + * Open a subprocess and read its output: + * + * cmd = open("|date") + * print cmd.gets + * cmd.close + * + * <em>produces:</em> + * + * Wed Apr 9 08:56:31 CDT 2003 + * + * Open a subprocess running the same Ruby program: + * + * f = open("|-", "w+") + * if f == nil + * puts "in Child" + * exit + * else + * puts "Got: #{f.gets}" + * end + * + * <em>produces:</em> + * + * Got: in Child + * + * Open a subprocess using a block to receive the I/O object: + * + * open("|-") do |f| + * if f == nil + * puts "in Child" + * else + * puts "Got: #{f.gets}" + * end + * end + * + * <em>produces:</em> + * + * Got: in Child + */ + +static VALUE +rb_f_open(int argc, VALUE *argv) +{ + ID to_open = 0; + int redirect = Qfalse; + + if (argc >= 1) { + CONST_ID(to_open, "to_open"); + if (rb_respond_to(argv[0], to_open)) { + redirect = Qtrue; + } + else { + VALUE tmp = argv[0]; + FilePathValue(tmp); + if (NIL_P(tmp)) { + redirect = Qtrue; + } + else { + VALUE cmd = check_pipe_command(tmp); + if (!NIL_P(cmd)) { + argv[0] = cmd; + return rb_io_s_popen(argc, argv, rb_cIO); + } + } + } + } + if (redirect) { + VALUE io = rb_funcall2(argv[0], to_open, argc-1, argv+1); + + if (rb_block_given_p()) { + return rb_ensure(rb_yield, io, io_close, io); + } + return io; + } + return rb_io_s_open(argc, argv, rb_cFile); +} + +static VALUE +rb_io_open(VALUE filename, VALUE mode, VALUE vperm, VALUE opt) +{ + VALUE cmd; + int modenum, flags; + convconfig_t convconfig; + mode_t perm; + + rb_io_extract_modeenc(&mode, opt, &modenum, &flags, &convconfig); + perm = NIL_P(vperm) ? 0666 : NUM2UINT(vperm); + + if (!NIL_P(cmd = check_pipe_command(filename))) { + return pipe_open_s(cmd, rb_io_modenum_mode(modenum), flags, &convconfig); + } + else { + return rb_file_open_generic(io_alloc(rb_cFile), filename, + modenum, flags, &convconfig, perm); + } +} + +static VALUE +rb_io_open_with_args(int argc, VALUE *argv) +{ + VALUE io; + + io = io_alloc(rb_cFile); + rb_open_file(argc, argv, io); + return io; +} + +static VALUE +io_reopen(VALUE io, VALUE nfile) +{ + rb_io_t *fptr, *orig; + int fd, fd2; + off_t pos = 0; + + nfile = rb_io_get_io(nfile); + if (rb_safe_level() >= 4 && + (!OBJ_UNTRUSTED(io) || !OBJ_UNTRUSTED(nfile))) { + rb_raise(rb_eSecurityError, "Insecure: can't reopen"); + } + GetOpenFile(io, fptr); + GetOpenFile(nfile, orig); + + if (fptr == orig) return io; + if (IS_PREP_STDIO(fptr)) { + if ((fptr->stdio_file == stdin && !(orig->mode & FMODE_READABLE)) || + (fptr->stdio_file == stdout && !(orig->mode & FMODE_WRITABLE)) || + (fptr->stdio_file == stderr && !(orig->mode & FMODE_WRITABLE))) { + rb_raise(rb_eArgError, + "%s can't change access mode from \"%s\" to \"%s\"", + PREP_STDIO_NAME(fptr), rb_io_flags_mode(fptr->mode), + rb_io_flags_mode(orig->mode)); + } + } + if (orig->mode & FMODE_READABLE) { + pos = io_tell(orig); + } + if (orig->mode & FMODE_WRITABLE) { + io_fflush(orig); + } + if (fptr->mode & FMODE_WRITABLE) { + io_fflush(fptr); + } + + /* copy rb_io_t structure */ + fptr->mode = orig->mode | (fptr->mode & FMODE_PREP); + fptr->pid = orig->pid; + fptr->lineno = orig->lineno; + if (orig->pathv) fptr->pathv = orig->pathv; + else fptr->pathv = Qnil; + fptr->finalize = orig->finalize; + + fd = fptr->fd; + fd2 = orig->fd; + if (fd != fd2) { + if (IS_PREP_STDIO(fptr)) { + /* need to keep stdio objects */ + if (dup2(fd2, fd) < 0) + rb_sys_fail_path(orig->pathv); + } + else { + if (fptr->stdio_file) + fclose(fptr->stdio_file); + else + close(fptr->fd); + fptr->stdio_file = 0; + fptr->fd = -1; + if (dup2(fd2, fd) < 0) + rb_sys_fail_path(orig->pathv); + fptr->fd = fd; + } + rb_thread_fd_close(fd); + if ((orig->mode & FMODE_READABLE) && pos >= 0) { + if (io_seek(fptr, pos, SEEK_SET) < 0) { + rb_sys_fail_path(fptr->pathv); + } + if (io_seek(orig, pos, SEEK_SET) < 0) { + rb_sys_fail_path(orig->pathv); + } + } + } + + if (fptr->mode & FMODE_BINMODE) { + rb_io_binmode(io); + } + + RBASIC(io)->klass = rb_obj_class(nfile); + return io; +} + +/* + * call-seq: + * ios.reopen(other_IO) => ios + * ios.reopen(path, mode_str) => ios + * + * Reassociates <em>ios</em> with the I/O stream given in + * <i>other_IO</i> or to a new stream opened on <i>path</i>. This may + * dynamically change the actual class of this stream. + * + * f1 = File.new("testfile") + * f2 = File.new("testfile") + * f2.readlines[0] #=> "This is line one\n" + * f2.reopen(f1) #=> #<File:testfile> + * f2.readlines[0] #=> "This is line one\n" + */ + +static VALUE +rb_io_reopen(int argc, VALUE *argv, VALUE file) +{ + VALUE fname, nmode; + int modenum; + rb_io_t *fptr; + + rb_secure(4); + if (rb_scan_args(argc, argv, "11", &fname, &nmode) == 1) { + VALUE tmp = rb_io_check_io(fname); + if (!NIL_P(tmp)) { + return io_reopen(file, tmp); + } + } + + FilePathValue(fname); + rb_io_taint_check(file); + fptr = RFILE(file)->fptr; + if (!fptr) { + fptr = RFILE(file)->fptr = ALLOC(rb_io_t); + MEMZERO(fptr, rb_io_t, 1); + } + + if (!NIL_P(nmode)) { + int flags = rb_io_mode_flags(StringValueCStr(nmode)); + if (IS_PREP_STDIO(fptr) && + ((fptr->mode & FMODE_READWRITE) & (flags & FMODE_READWRITE)) != + (fptr->mode & FMODE_READWRITE)) { + rb_raise(rb_eArgError, + "%s can't change access mode from \"%s\" to \"%s\"", + PREP_STDIO_NAME(fptr), rb_io_flags_mode(fptr->mode), + rb_io_flags_mode(flags)); + } + fptr->mode = flags; + rb_io_mode_enc(fptr, StringValueCStr(nmode)); + rb_econv_opts(Qnil, &fptr->encs.opts); + } + + fptr->pathv = rb_str_new_frozen(fname); + modenum = rb_io_flags_modenum(fptr->mode); + if (fptr->fd < 0) { + fptr->fd = rb_sysopen(RSTRING_PTR(fptr->pathv), modenum, 0666); + fptr->stdio_file = 0; + return file; + } + + if (fptr->mode & FMODE_WRITABLE) { + io_fflush(fptr); + } + fptr->rbuf_off = fptr->rbuf_len = 0; + + if (fptr->stdio_file) { + if (freopen(RSTRING_PTR(fptr->pathv), rb_io_modenum_mode(modenum), fptr->stdio_file) == 0) { + rb_sys_fail_path(fptr->pathv); + } + fptr->fd = fileno(fptr->stdio_file); +#ifdef USE_SETVBUF + if (setvbuf(fptr->stdio_file, NULL, _IOFBF, 0) != 0) + rb_warn("setvbuf() can't be honoured for %s", RSTRING_PTR(fptr->pathv)); +#endif + } + else { + if (close(fptr->fd) < 0) + rb_sys_fail_path(fptr->pathv); + fptr->fd = -1; + fptr->fd = rb_sysopen(RSTRING_PTR(fptr->pathv), modenum, 0666); + } + + return file; +} + +/* :nodoc: */ +static VALUE +rb_io_init_copy(VALUE dest, VALUE io) +{ + rb_io_t *fptr, *orig; + int fd; + VALUE write_io; + + io = rb_io_get_io(io); + if (dest == io) return dest; + GetOpenFile(io, orig); + MakeOpenFile(dest, fptr); + + rb_io_flush(io); + + /* copy rb_io_t structure */ + fptr->mode = orig->mode & ~FMODE_PREP; + fptr->encs = orig->encs; + fptr->pid = orig->pid; + fptr->lineno = orig->lineno; + if (!NIL_P(orig->pathv)) fptr->pathv = orig->pathv; + fptr->finalize = orig->finalize; + + fd = ruby_dup(orig->fd); + fptr->fd = fd; + io_seek(fptr, io_tell(orig), SEEK_SET); + if (fptr->mode & FMODE_BINMODE) { + rb_io_binmode(dest); + } + + write_io = GetWriteIO(io); + if (io != write_io) { + write_io = rb_obj_dup(write_io); + fptr->tied_io_for_writing = write_io; + rb_ivar_set(dest, rb_intern("@tied_io_for_writing"), write_io); + } + + return dest; +} + +/* + * call-seq: + * ios.printf(format_string [, obj, ...] ) => nil + * + * Formats and writes to <em>ios</em>, converting parameters under + * control of the format string. See <code>Kernel#sprintf</code> + * for details. + */ + +VALUE +rb_io_printf(int argc, VALUE *argv, VALUE out) +{ + rb_io_write(out, rb_f_sprintf(argc, argv)); + return Qnil; +} + +/* + * call-seq: + * printf(io, string [, obj ... ] ) => nil + * printf(string [, obj ... ] ) => nil + * + * Equivalent to: + * io.write(sprintf(string, obj, ...) + * or + * $stdout.write(sprintf(string, obj, ...) + */ + +static VALUE +rb_f_printf(int argc, VALUE *argv) +{ + VALUE out; + + if (argc == 0) return Qnil; + if (TYPE(argv[0]) == T_STRING) { + out = rb_stdout; + } + else { + out = argv[0]; + argv++; + argc--; + } + rb_io_write(out, rb_f_sprintf(argc, argv)); + + return Qnil; +} + +/* + * call-seq: + * ios.print() => nil + * ios.print(obj, ...) => nil + * + * Writes the given object(s) to <em>ios</em>. The stream must be + * opened for writing. If the output record separator (<code>$\\</code>) + * is not <code>nil</code>, it will be appended to the output. If no + * arguments are given, prints <code>$_</code>. Objects that aren't + * strings will be converted by calling their <code>to_s</code> method. + * With no argument, prints the contents of the variable <code>$_</code>. + * Returns <code>nil</code>. + * + * $stdout.print("This is ", 100, " percent.\n") + * + * <em>produces:</em> + * + * This is 100 percent. + */ + +VALUE +rb_io_print(int argc, VALUE *argv, VALUE out) +{ + int i; + VALUE line; + + /* if no argument given, print `$_' */ + if (argc == 0) { + argc = 1; + line = rb_lastline_get(); + argv = &line; + } + for (i=0; i<argc; i++) { + rb_io_write(out, argv[i]); + if (!NIL_P(rb_output_fs)) { + rb_io_write(out, rb_output_fs); + } + } + if (argc > 0 && !NIL_P(rb_output_rs)) { + rb_io_write(out, rb_output_rs); + } + + return Qnil; +} + +/* + * call-seq: + * print(obj, ...) => nil + * + * Prints each object in turn to <code>$stdout</code>. If the output + * field separator (<code>$,</code>) is not +nil+, its + * contents will appear between each field. If the output record + * separator (<code>$\\</code>) is not +nil+, it will be + * appended to the output. If no arguments are given, prints + * <code>$_</code>. Objects that aren't strings will be converted by + * calling their <code>to_s</code> method. + * + * print "cat", [1,2,3], 99, "\n" + * $, = ", " + * $\ = "\n" + * print "cat", [1,2,3], 99 + * + * <em>produces:</em> + * + * cat12399 + * cat, 1, 2, 3, 99 + */ + +static VALUE +rb_f_print(int argc, VALUE *argv) +{ + rb_io_print(argc, argv, rb_stdout); + return Qnil; +} + +/* + * call-seq: + * ios.putc(obj) => obj + * + * If <i>obj</i> is <code>Numeric</code>, write the character whose + * code is <i>obj</i>, otherwise write the first character of the + * string representation of <i>obj</i> to <em>ios</em>. + * + * $stdout.putc "A" + * $stdout.putc 65 + * + * <em>produces:</em> + * + * AA + */ + +static VALUE +rb_io_putc(VALUE io, VALUE ch) +{ + char c = NUM2CHR(ch); + + rb_io_write(io, rb_str_new(&c, 1)); + return ch; +} + +/* + * call-seq: + * putc(int) => int + * + * Equivalent to: + * + * $stdout.putc(int) + */ + +static VALUE +rb_f_putc(VALUE recv, VALUE ch) +{ + if (recv == rb_stdout) { + return rb_io_putc(recv, ch); + } + return rb_funcall2(rb_stdout, rb_intern("putc"), 1, &ch); +} + +static VALUE +io_puts_ary(VALUE ary, VALUE out, int recur) +{ + VALUE tmp; + long i; + + if (recur) { + tmp = rb_str_new2("[...]"); + rb_io_puts(1, &tmp, out); + return Qnil; + } + for (i=0; i<RARRAY_LEN(ary); i++) { + tmp = RARRAY_PTR(ary)[i]; + rb_io_puts(1, &tmp, out); + } + return Qnil; +} + +/* + * call-seq: + * ios.puts(obj, ...) => nil + * + * Writes the given objects to <em>ios</em> as with + * <code>IO#print</code>. Writes a record separator (typically a + * newline) after any that do not already end with a newline sequence. + * If called with an array argument, writes each element on a new line. + * If called without arguments, outputs a single record separator. + * + * $stdout.puts("this", "is", "a", "test") + * + * <em>produces:</em> + * + * this + * is + * a + * test + */ + +VALUE +rb_io_puts(int argc, VALUE *argv, VALUE out) +{ + int i; + VALUE line; + + /* if no argument given, print newline. */ + if (argc == 0) { + rb_io_write(out, rb_default_rs); + return Qnil; + } + for (i=0; i<argc; i++) { + line = rb_check_array_type(argv[i]); + if (!NIL_P(line)) { + rb_exec_recursive(io_puts_ary, line, out); + continue; + } + line = rb_obj_as_string(argv[i]); + rb_io_write(out, line); + if (RSTRING_LEN(line) == 0 || + RSTRING_PTR(line)[RSTRING_LEN(line)-1] != '\n') { + rb_io_write(out, rb_default_rs); + } + } + + return Qnil; +} + +/* + * call-seq: + * puts(obj, ...) => nil + * + * Equivalent to + * + * $stdout.puts(obj, ...) + */ + +static VALUE +rb_f_puts(int argc, VALUE *argv, VALUE recv) +{ + if (recv == rb_stdout) { + return rb_io_puts(argc, argv, recv); + } + return rb_funcall2(rb_stdout, rb_intern("puts"), argc, argv); +} + +void +rb_p(VALUE obj) /* for debug print within C code */ +{ + VALUE str = rb_obj_as_string(rb_inspect(obj)); + rb_str_buf_append(str, rb_default_rs); + rb_io_write(rb_stdout, str); +} + +/* + * call-seq: + * p(obj) => obj + * p(obj1, obj2, ...) => [obj, ...] + * p() => nil + * + * For each object, directly writes + * _obj_.+inspect+ followed by the current output + * record separator to the program's standard output. + * + * S = Struct.new(:name, :state) + * s = S['dave', 'TX'] + * p s + * + * <em>produces:</em> + * + * #<S name="dave", state="TX"> + */ + +static VALUE +rb_f_p(int argc, VALUE *argv, VALUE self) +{ + int i; + VALUE ret = Qnil; + + for (i=0; i<argc; i++) { + rb_p(argv[i]); + } + if (argc == 1) { + ret = argv[0]; + } + else if (argc > 1) { + ret = rb_ary_new4(argc, argv); + } + if (TYPE(rb_stdout) == T_FILE) { + rb_io_flush(rb_stdout); + } + return ret; +} + +/* + * call-seq: + * obj.display(port=$>) => nil + * + * Prints <i>obj</i> on the given port (default <code>$></code>). + * Equivalent to: + * + * def display(port=$>) + * port.write self + * end + * + * For example: + * + * 1.display + * "cat".display + * [ 4, 5, 6 ].display + * puts + * + * <em>produces:</em> + * + * 1cat456 + */ + +static VALUE +rb_obj_display(int argc, VALUE *argv, VALUE self) +{ + VALUE out; + + if (argc == 0) { + out = rb_stdout; + } + else { + rb_scan_args(argc, argv, "01", &out); + } + rb_io_write(out, self); + + return Qnil; +} + +void +rb_write_error2(const char *mesg, long len) +{ + if (rb_stderr == orig_stderr || RFILE(orig_stderr)->fptr->fd < 0) { + fwrite(mesg, sizeof(char), len, stderr); + } + else { + rb_io_write(rb_stderr, rb_str_new(mesg, len)); + } +} + +void +rb_write_error(const char *mesg) +{ + rb_write_error2(mesg, strlen(mesg)); +} + +static void +must_respond_to(ID mid, VALUE val, ID id) +{ + if (!rb_respond_to(val, mid)) { + rb_raise(rb_eTypeError, "%s must have %s method, %s given", + rb_id2name(id), rb_id2name(mid), + rb_obj_classname(val)); + } +} + +static void +stdout_setter(VALUE val, ID id, VALUE *variable) +{ + must_respond_to(id_write, val, id); + *variable = val; +} + +static VALUE +prep_io(int fd, int flags, VALUE klass, const char *path) +{ + rb_io_t *fp; + VALUE io = io_alloc(klass); + + MakeOpenFile(io, fp); + fp->fd = fd; +#ifdef __CYGWIN__ + if (!isatty(fd)) { + flags |= FMODE_BINMODE; + setmode(fd, O_BINARY); + } +#endif + fp->mode = flags; + io_check_tty(fp); + if (path) fp->pathv = rb_obj_freeze(rb_str_new_cstr(path)); + + return io; +} + +VALUE +rb_io_fdopen(int fd, int modenum, const char *path) +{ + VALUE klass = rb_cIO; + + if (path && strcmp(path, "-")) klass = rb_cFile; + return prep_io(fd, rb_io_modenum_flags(modenum), klass, path); +} + +static VALUE +prep_stdio(FILE *f, int flags, VALUE klass, const char *path) +{ + rb_io_t *fptr; + VALUE io = prep_io(fileno(f), flags|FMODE_PREP, klass, path); + + GetOpenFile(io, fptr); + fptr->stdio_file = f; + + return io; +} + +FILE * +rb_io_stdio_file(rb_io_t *fptr) +{ + if (!fptr->stdio_file) { + int modenum = rb_io_flags_modenum(fptr->mode); + fptr->stdio_file = rb_fdopen(fptr->fd, rb_io_modenum_mode(modenum)); + } + return fptr->stdio_file; +} + +/* + * call-seq: + * IO.new(fd [, mode] [, opt]) => io + * + * Returns a new <code>IO</code> object (a stream) for the given + * <code>IO</code> object or integer file descriptor and mode + * string. See also <code>IO#fileno</code> and + * <code>IO::for_fd</code>. + * + * puts IO.new($stdout).fileno # => 1 + * + * a = IO.new(2,"w") # '2' is standard error + * $stderr.puts "Hello" + * a.puts "World" + * + * <em>produces:</em> + * + * Hello + * World + */ + +static VALUE +rb_io_initialize(int argc, VALUE *argv, VALUE io) +{ + VALUE fnum, mode, orig; + rb_io_t *fp, *ofp = NULL; + int fd, flags, modenum = O_RDONLY; + convconfig_t convconfig; + VALUE opt; + + rb_secure(4); + + opt = pop_last_hash(&argc, &argv); + rb_scan_args(argc, argv, "11", &fnum, &mode); + rb_io_extract_modeenc(&mode, opt, &modenum, &flags, &convconfig); + orig = rb_io_check_io(fnum); + if (NIL_P(orig)) { + fd = NUM2INT(fnum); + UPDATE_MAXFD(fd); + if (NIL_P(mode)) { +#if defined(HAVE_FCNTL) && defined(F_GETFL) + modenum = fcntl(fd, F_GETFL); + if (modenum == -1) rb_sys_fail(0); + flags = rb_io_modenum_flags(modenum); +#endif + } + MakeOpenFile(io, fp); + fp->fd = fd; + fp->mode = flags; + fp->encs = convconfig; + clear_codeconv(fp); + io_check_tty(fp); + } + else if (RFILE(io)->fptr) { + rb_raise(rb_eRuntimeError, "reinitializing IO"); + } + else { + GetOpenFile(orig, ofp); + if (ofp->refcnt == LONG_MAX) { + VALUE s = rb_inspect(orig); + rb_raise(rb_eIOError, "too many shared IO for %s", StringValueCStr(s)); + } + if (!NIL_P(mode)) { + if ((ofp->mode ^ flags) & (FMODE_READWRITE|FMODE_BINMODE)) { + if (TYPE(mode) != T_STRING) { + rb_raise(rb_eArgError, "incompatible mode 0x%x", modenum); + } + else { + rb_raise(rb_eArgError, "incompatible mode \"%s\"", RSTRING_PTR(mode)); + } + } + } + if (convconfig.enc || convconfig.enc2) { + rb_raise(rb_eArgError, "encoding specified for shared IO"); + } + ofp->refcnt++; + RFILE(io)->fptr = ofp; + } + + return io; +} + + +/* + * call-seq: + * File.new(filename, mode="r" [, opt]) => file + * File.new(filename [, mode [, perm]] [, opt]) => file + * + + * Opens the file named by _filename_ according to + * _mode_ (default is ``r'') and returns a new + * <code>File</code> object. See the description of class +IO+ for + * a description of _mode_. The file mode may optionally be + * specified as a +Fixnum+ by _or_-ing together the + * flags (O_RDONLY etc, again described under +IO+). Optional + * permission bits may be given in _perm_. These mode and permission + * bits are platform dependent; on Unix systems, see + * <code>open(2)</code> for details. + * + * f = File.new("testfile", "r") + * f = File.new("newfile", "w+") + * f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644) + */ + +static VALUE +rb_file_initialize(int argc, VALUE *argv, VALUE io) +{ + if (RFILE(io)->fptr) { + rb_raise(rb_eRuntimeError, "reinitializing File"); + } + if (0 < argc && argc < 3) { + VALUE fd = rb_check_convert_type(argv[0], T_FIXNUM, "Fixnum", "to_int"); + + if (!NIL_P(fd)) { + argv[0] = fd; + return rb_io_initialize(argc, argv, io); + } + } + rb_open_file(argc, argv, io); + + return io; +} + +/* + * call-seq: + * IO.new(fd, mode_string [, opt]) => io + * + * Returns a new <code>IO</code> object (a stream) for the given + * integer file descriptor and mode string. See also + * <code>IO#fileno</code> and <code>IO::for_fd</code>. + * + * a = IO.new(2,"w") # '2' is standard error + * $stderr.puts "Hello" + * a.puts "World" + * + * <em>produces:</em> + * + * Hello + * World + */ + +static VALUE +rb_io_s_new(int argc, VALUE *argv, VALUE klass) +{ + if (rb_block_given_p()) { + const char *cname = rb_class2name(klass); + + rb_warn("%s::new() does not take block; use %s::open() instead", + cname, cname); + } + return rb_class_new_instance(argc, argv, klass); +} + + +/* + * call-seq: + * IO.for_fd(fd, mode [, opt]) => io + * + * Synonym for <code>IO::new</code>. + * + */ + +static VALUE +rb_io_s_for_fd(int argc, VALUE *argv, VALUE klass) +{ + VALUE io = rb_obj_alloc(klass); + rb_io_initialize(argc, argv, io); + return io; +} + +static void +argf_mark(void *ptr) +{ + struct argf *p = ptr; + rb_gc_mark(p->filename); + rb_gc_mark(p->current_file); + rb_gc_mark(p->lineno); + rb_gc_mark(p->argv); +} + +static void +argf_free(void *ptr) +{ + struct argf *p = ptr; + free(p->inplace); +} + +static inline void +argf_init(struct argf *p, VALUE v) +{ + p->filename = Qnil; + p->current_file = Qnil; + p->lineno = Qnil; + p->argv = v; +} + +static VALUE +argf_alloc(VALUE klass) +{ + struct argf *p; + VALUE argf = Data_Make_Struct(klass, struct argf, argf_mark, argf_free, p); + + argf_init(p, Qnil); + return argf; +} + +#undef rb_argv +#define filename ARGF.filename +#define current_file ARGF.current_file +#define gets_lineno ARGF.gets_lineno +#define init_p ARGF.init_p +#define next_p ARGF.next_p +#define lineno ARGF.lineno +#define ruby_inplace_mode ARGF.inplace +#define argf_binmode ARGF.binmode +#define argf_enc ARGF.encs.enc +#define argf_enc2 ARGF.encs.enc2 +#define argf_ecopts ARGF.encs.opts +#define rb_argv ARGF.argv + +static VALUE +argf_initialize(VALUE argf, VALUE argv) +{ + memset(&ARGF, 0, sizeof(ARGF)); + argf_init(&ARGF, argv); + + return argf; +} + +static VALUE +argf_initialize_copy(VALUE argf, VALUE orig) +{ + ARGF = argf_of(orig); + rb_argv = rb_obj_dup(rb_argv); + if (ARGF.inplace) { + const char *inplace = ARGF.inplace; + ARGF.inplace = 0; + ARGF.inplace = ruby_strdup(inplace); + } + return argf; +} + +static VALUE +argf_set_lineno(VALUE argf, VALUE val) +{ + gets_lineno = NUM2INT(val); + lineno = INT2FIX(gets_lineno); + return Qnil; +} + +static VALUE +argf_lineno(VALUE argf) +{ + return lineno; +} + +static VALUE +argf_forward(int argc, VALUE *argv, VALUE argf) +{ + return rb_funcall3(current_file, rb_frame_this_func(), argc, argv); +} + +#define next_argv() argf_next_argv(argf) +#define ARGF_GENERIC_INPUT_P() \ + (current_file == rb_stdin && TYPE(current_file) != T_FILE) +#define ARGF_FORWARD(argc, argv) do {\ + if (ARGF_GENERIC_INPUT_P())\ + return argf_forward(argc, argv, argf);\ +} while (0) +#define NEXT_ARGF_FORWARD(argc, argv) do {\ + if (!next_argv()) return Qnil;\ + ARGF_FORWARD(argc, argv);\ +} while (0) + +static void +argf_close(VALUE file) +{ + rb_funcall3(file, rb_intern("close"), 0, 0); +} + +static int +argf_next_argv(VALUE argf) +{ + char *fn; + rb_io_t *fptr; + int stdout_binmode = 0; + + if (TYPE(rb_stdout) == T_FILE) { + GetOpenFile(rb_stdout, fptr); + if (fptr->mode & FMODE_BINMODE) + stdout_binmode = 1; + } + + if (init_p == 0) { + if (!NIL_P(rb_argv) && RARRAY_LEN(rb_argv) > 0) { + next_p = 1; + } + else { + next_p = -1; + } + init_p = 1; + gets_lineno = 0; + } + + if (next_p == 1) { + next_p = 0; + retry: + if (RARRAY_LEN(rb_argv) > 0) { + filename = rb_ary_shift(rb_argv); + fn = StringValueCStr(filename); + if (strlen(fn) == 1 && fn[0] == '-') { + current_file = rb_stdin; + if (ruby_inplace_mode) { + rb_warn("Can't do inplace edit for stdio; skipping"); + goto retry; + } + } + else { + int fr = rb_sysopen(fn, O_RDONLY, 0); + + if (ruby_inplace_mode) { + struct stat st; +#ifndef NO_SAFE_RENAME + struct stat st2; +#endif + VALUE str; + int fw; + + if (TYPE(rb_stdout) == T_FILE && rb_stdout != orig_stdout) { + rb_io_close(rb_stdout); + } + fstat(fr, &st); + if (*ruby_inplace_mode) { + str = rb_str_new2(fn); +#ifdef NO_LONG_FNAME + ruby_add_suffix(str, ruby_inplace_mode); +#else + rb_str_cat2(str, ruby_inplace_mode); +#endif +#ifdef NO_SAFE_RENAME + (void)close(fr); + (void)unlink(RSTRING_PTR(str)); + (void)rename(fn, RSTRING_PTR(str)); + fr = rb_sysopen(RSTRING_PTR(str), O_RDONLY, 0); +#else + if (rename(fn, RSTRING_PTR(str)) < 0) { + rb_warn("Can't rename %s to %s: %s, skipping file", + fn, RSTRING_PTR(str), strerror(errno)); + close(fr); + goto retry; + } +#endif + } + else { +#ifdef NO_SAFE_RENAME + rb_fatal("Can't do inplace edit without backup"); +#else + if (unlink(fn) < 0) { + rb_warn("Can't remove %s: %s, skipping file", + fn, strerror(errno)); + close(fr); + goto retry; + } +#endif + } + fw = rb_sysopen(fn, O_WRONLY|O_CREAT|O_TRUNC, 0666); +#ifndef NO_SAFE_RENAME + fstat(fw, &st2); +#ifdef HAVE_FCHMOD + fchmod(fw, st.st_mode); +#else + chmod(fn, st.st_mode); +#endif + if (st.st_uid!=st2.st_uid || st.st_gid!=st2.st_gid) { + fchown(fw, st.st_uid, st.st_gid); + } +#endif + rb_stdout = prep_io(fw, FMODE_WRITABLE, rb_cFile, fn); + if (stdout_binmode) rb_io_binmode(rb_stdout); + } + current_file = prep_io(fr, FMODE_READABLE, rb_cFile, fn); + } + if (argf_binmode) rb_io_binmode(current_file); + if (argf_enc) { + rb_io_t *fptr; + + GetOpenFile(current_file, fptr); + fptr->encs.enc = argf_enc; + fptr->encs.enc2 = argf_enc2; + fptr->encs.opts = argf_ecopts; + clear_codeconv(fptr); + } + } + else { + next_p = 1; + return Qfalse; + } + } + else if (next_p == -1) { + current_file = rb_stdin; + filename = rb_str_new2("-"); + if (ruby_inplace_mode) { + rb_warn("Can't do inplace edit for stdio"); + rb_stdout = orig_stdout; + } + } + return Qtrue; +} + +static VALUE +argf_getline(int argc, VALUE *argv, VALUE argf) +{ + VALUE line; + + retry: + if (!next_argv()) return Qnil; + if (ARGF_GENERIC_INPUT_P()) { + line = rb_funcall3(current_file, rb_intern("gets"), argc, argv); + } + else { + if (argc == 0 && rb_rs == rb_default_rs) { + line = rb_io_gets(current_file); + } + else { + line = rb_io_getline(argc, argv, current_file); + } + if (NIL_P(line) && next_p != -1) { + argf_close(current_file); + next_p = 1; + goto retry; + } + } + if (!NIL_P(line)) { + gets_lineno++; + lineno = INT2FIX(gets_lineno); + } + return line; +} + +static VALUE +argf_lineno_getter(ID id, VALUE *var) +{ + VALUE argf = *var; + return lineno; +} + +static void +argf_lineno_setter(VALUE val, ID id, VALUE *var) +{ + VALUE argf = *var; + int n = NUM2INT(val); + gets_lineno = n; + lineno = INT2FIX(n); +} + +static VALUE argf_gets(int, VALUE *, VALUE); + +/* + * call-seq: + * gets(sep=$/) => string or nil + * gets(limit) => string or nil + * gets(sep,limit) => string or nil + * + * Returns (and assigns to <code>$_</code>) the next line from the list + * of files in +ARGV+ (or <code>$*</code>), or from standard input if + * no files are present on the command line. Returns +nil+ at end of + * file. The optional argument specifies the record separator. The + * separator is included with the contents of each record. A separator + * of +nil+ reads the entire contents, and a zero-length separator + * reads the input one paragraph at a time, where paragraphs are + * divided by two consecutive newlines. If the first argument is an + * integer, or optional second argument is given, the returning string + * would not be longer than the given value. If multiple filenames are + * present in +ARGV+, +gets(nil)+ will read the contents one file at a + * time. + * + * ARGV << "testfile" + * print while gets + * + * <em>produces:</em> + * + * This is line one + * This is line two + * This is line three + * And so on... + * + * The style of programming using <code>$_</code> as an implicit + * parameter is gradually losing favor in the Ruby community. + */ + +static VALUE +rb_f_gets(int argc, VALUE *argv, VALUE recv) +{ + if (recv == argf) { + return argf_gets(argc, argv, argf); + } + return rb_funcall2(argf, rb_intern("gets"), argc, argv); +} + +static VALUE +argf_gets(int argc, VALUE *argv, VALUE argf) +{ + VALUE line; + + line = argf_getline(argc, argv, argf); + rb_lastline_set(line); + return line; +} + +VALUE +rb_gets(void) +{ + VALUE line; + + if (rb_rs != rb_default_rs) { + return rb_f_gets(0, 0, argf); + } + + retry: + if (!next_argv()) return Qnil; + line = rb_io_gets(current_file); + if (NIL_P(line) && next_p != -1) { + rb_io_close(current_file); + next_p = 1; + goto retry; + } + rb_lastline_set(line); + if (!NIL_P(line)) { + gets_lineno++; + lineno = INT2FIX(gets_lineno); + } + + return line; +} + +static VALUE argf_readline(int, VALUE *, VALUE); + +/* + * call-seq: + * readline(sep=$/) => string + * readline(limit) => string + * readline(sep, limit) => string + * + * Equivalent to <code>Kernel::gets</code>, except + * +readline+ raises +EOFError+ at end of file. + */ + +static VALUE +rb_f_readline(int argc, VALUE *argv, VALUE recv) +{ + if (recv == argf) { + return argf_readline(argc, argv, argf); + } + return rb_funcall2(argf, rb_intern("readline"), argc, argv); +} + +static VALUE +argf_readline(int argc, VALUE *argv, VALUE argf) +{ + VALUE line; + + if (!next_argv()) rb_eof_error(); + ARGF_FORWARD(argc, argv); + line = argf_gets(argc, argv, argf); + if (NIL_P(line)) { + rb_eof_error(); + } + + return line; +} + +static VALUE argf_readlines(int, VALUE *, VALUE); + +/* + * call-seq: + * readlines(sep=$/) => array + * readlines(limit) => array + * readlines(sep,limit) => array + * + * Returns an array containing the lines returned by calling + * <code>Kernel.gets(<i>sep</i>)</code> until the end of file. + */ + +static VALUE +rb_f_readlines(int argc, VALUE *argv, VALUE recv) +{ + if (recv == argf) { + return argf_readlines(argc, argv, argf); + } + return rb_funcall2(argf, rb_intern("readlines"), argc, argv); +} + +static VALUE +argf_readlines(int argc, VALUE *argv, VALUE argf) +{ + VALUE line, ary; + + ary = rb_ary_new(); + while (!NIL_P(line = argf_getline(argc, argv, argf))) { + rb_ary_push(ary, line); + } + + return ary; +} + +/* + * call-seq: + * `cmd` => string + * + * Returns the standard output of running _cmd_ in a subshell. + * The built-in syntax <code>%x{...}</code> uses + * this method. Sets <code>$?</code> to the process status. + * + * `date` #=> "Wed Apr 9 08:56:30 CDT 2003\n" + * `ls testdir`.split[1] #=> "main.rb" + * `echo oops && exit 99` #=> "oops\n" + * $?.exitstatus #=> 99 + */ + +static VALUE +rb_f_backquote(VALUE obj, VALUE str) +{ + volatile VALUE port; + VALUE result; + rb_io_t *fptr; + + SafeStringValue(str); + port = pipe_open_s(str, "r", FMODE_READABLE, NULL); + if (NIL_P(port)) return rb_str_new(0,0); + + GetOpenFile(port, fptr); + result = read_all(fptr, remain_size(fptr), Qnil); + rb_io_close(port); + + return result; +} + +#ifdef HAVE_SYS_SELECT_H +#include <sys/select.h> +#endif + +static VALUE +select_internal(VALUE read, VALUE write, VALUE except, struct timeval *tp, rb_fdset_t *fds) +{ + VALUE res, list; + fd_set *rp, *wp, *ep; + rb_io_t *fptr; + long i; + int max = 0, n; + int interrupt_flag = 0; + int pending = 0; + struct timeval timerec; + + if (!NIL_P(read)) { + Check_Type(read, T_ARRAY); + for (i=0; i<RARRAY_LEN(read); i++) { + GetOpenFile(rb_io_get_io(RARRAY_PTR(read)[i]), fptr); + rb_fd_set(fptr->fd, &fds[0]); + if (READ_DATA_PENDING(fptr)) { /* check for buffered data */ + pending++; + rb_fd_set(fptr->fd, &fds[3]); + } + if (max < fptr->fd) max = fptr->fd; + } + if (pending) { /* no blocking if there's buffered data */ + timerec.tv_sec = timerec.tv_usec = 0; + tp = &timerec; + } + rp = rb_fd_ptr(&fds[0]); + } + else + rp = 0; + + if (!NIL_P(write)) { + Check_Type(write, T_ARRAY); + for (i=0; i<RARRAY_LEN(write); i++) { + VALUE write_io = GetWriteIO(rb_io_get_io(RARRAY_PTR(write)[i])); + GetOpenFile(write_io, fptr); + rb_fd_set(fptr->fd, &fds[1]); + if (max < fptr->fd) max = fptr->fd; + } + wp = rb_fd_ptr(&fds[1]); + } + else + wp = 0; + + if (!NIL_P(except)) { + Check_Type(except, T_ARRAY); + for (i=0; i<RARRAY_LEN(except); i++) { + VALUE io = rb_io_get_io(RARRAY_PTR(except)[i]); + VALUE write_io = GetWriteIO(io); + GetOpenFile(io, fptr); + rb_fd_set(fptr->fd, &fds[2]); + if (max < fptr->fd) max = fptr->fd; + if (io != write_io) { + GetOpenFile(write_io, fptr); + rb_fd_set(fptr->fd, &fds[2]); + if (max < fptr->fd) max = fptr->fd; + } + } + ep = rb_fd_ptr(&fds[2]); + } + else { + ep = 0; + } + + max++; + + n = rb_thread_select(max, rp, wp, ep, tp); + if (n < 0) { + rb_sys_fail(0); + } + if (!pending && n == 0) return Qnil; /* returns nil on timeout */ + + res = rb_ary_new2(3); + rb_ary_push(res, rp?rb_ary_new():rb_ary_new2(0)); + rb_ary_push(res, wp?rb_ary_new():rb_ary_new2(0)); + rb_ary_push(res, ep?rb_ary_new():rb_ary_new2(0)); + + if (interrupt_flag == 0) { + if (rp) { + list = RARRAY_PTR(res)[0]; + for (i=0; i< RARRAY_LEN(read); i++) { + VALUE obj = rb_ary_entry(read, i); + VALUE io = rb_io_get_io(obj); + GetOpenFile(io, fptr); + if (rb_fd_isset(fptr->fd, &fds[0]) || + rb_fd_isset(fptr->fd, &fds[3])) { + rb_ary_push(list, obj); + } + } + } + + if (wp) { + list = RARRAY_PTR(res)[1]; + for (i=0; i< RARRAY_LEN(write); i++) { + VALUE obj = rb_ary_entry(write, i); + VALUE io = rb_io_get_io(obj); + VALUE write_io = GetWriteIO(io); + GetOpenFile(write_io, fptr); + if (rb_fd_isset(fptr->fd, &fds[1])) { + rb_ary_push(list, obj); + } + } + } + + if (ep) { + list = RARRAY_PTR(res)[2]; + for (i=0; i< RARRAY_LEN(except); i++) { + VALUE obj = rb_ary_entry(except, i); + VALUE io = rb_io_get_io(obj); + VALUE write_io = GetWriteIO(io); + GetOpenFile(io, fptr); + if (rb_fd_isset(fptr->fd, &fds[2])) { + rb_ary_push(list, obj); + } + else if (io != write_io) { + GetOpenFile(write_io, fptr); + if (rb_fd_isset(fptr->fd, &fds[2])) { + rb_ary_push(list, obj); + } + } + } + } + } + + return res; /* returns an empty array on interrupt */ +} + +struct select_args { + VALUE read, write, except; + struct timeval *timeout; + rb_fdset_t fdsets[4]; +}; + +#ifdef HAVE_RB_FD_INIT +static VALUE +select_call(VALUE arg) +{ + struct select_args *p = (struct select_args *)arg; + + return select_internal(p->read, p->write, p->except, p->timeout, p->fdsets); +} + +static VALUE +select_end(VALUE arg) +{ + struct select_args *p = (struct select_args *)arg; + int i; + + for (i = 0; i < sizeof(p->fdsets) / sizeof(p->fdsets[0]); ++i) + rb_fd_term(&p->fdsets[i]); + return Qnil; +} +#endif + +/* + * call-seq: + * IO.select(read_array + * [, write_array + * [, error_array + * [, timeout]]] ) => array or nil + * + * See <code>Kernel#select</code>. + */ + +static VALUE +rb_f_select(int argc, VALUE *argv, VALUE obj) +{ + VALUE timeout; + struct select_args args; + struct timeval timerec; + int i; + + rb_scan_args(argc, argv, "13", &args.read, &args.write, &args.except, &timeout); + if (NIL_P(timeout)) { + args.timeout = 0; + } + else { + timerec = rb_time_interval(timeout); + args.timeout = &timerec; + } + + for (i = 0; i < sizeof(args.fdsets) / sizeof(args.fdsets[0]); ++i) + rb_fd_init(&args.fdsets[i]); + +#ifdef HAVE_RB_FD_INIT + return rb_ensure(select_call, (VALUE)&args, select_end, (VALUE)&args); +#else + return select_internal(args.read, args.write, args.except, + args.timeout, args.fdsets); +#endif + +} + +#if !defined(MSDOS) && !defined(__human68k__) +static int +io_cntl(int fd, int cmd, long narg, int io_p) +{ + int retval; + +#ifdef HAVE_FCNTL + TRAP_BEG; +# if defined(__CYGWIN__) + retval = io_p?ioctl(fd, cmd, (void*)narg):fcntl(fd, cmd, narg); +# else + retval = io_p?ioctl(fd, cmd, narg):fcntl(fd, cmd, narg); +# endif + TRAP_END; +#else + if (!io_p) { + rb_notimplement(); + } + TRAP_BEG; + retval = ioctl(fd, cmd, narg); + TRAP_END; +#endif + return retval; +} +#endif + +static VALUE +rb_io_ctl(VALUE io, VALUE req, VALUE arg, int io_p) +{ +#if !defined(MSDOS) && !defined(__human68k__) + int cmd = NUM2ULONG(req); + rb_io_t *fptr; + long len = 0; + long narg = 0; + int retval; + + rb_secure(2); + + if (NIL_P(arg) || arg == Qfalse) { + narg = 0; + } + else if (FIXNUM_P(arg)) { + narg = FIX2LONG(arg); + } + else if (arg == Qtrue) { + narg = 1; + } + else { + VALUE tmp = rb_check_string_type(arg); + + if (NIL_P(tmp)) { + narg = NUM2LONG(arg); + } + else { + arg = tmp; +#ifdef IOCPARM_MASK +#ifndef IOCPARM_LEN +#define IOCPARM_LEN(x) (((x) >> 16) & IOCPARM_MASK) +#endif +#endif +#ifdef IOCPARM_LEN + len = IOCPARM_LEN(cmd); /* on BSDish systems we're safe */ +#else + len = 256; /* otherwise guess at what's safe */ +#endif + rb_str_modify(arg); + + if (len <= RSTRING_LEN(arg)) { + len = RSTRING_LEN(arg); + } + if (RSTRING_LEN(arg) < len) { + rb_str_resize(arg, len+1); + } + RSTRING_PTR(arg)[len] = 17; /* a little sanity check here */ + narg = (long)RSTRING_PTR(arg); + } + } + GetOpenFile(io, fptr); + retval = io_cntl(fptr->fd, cmd, narg, io_p); + if (retval < 0) rb_sys_fail_path(fptr->pathv); + if (TYPE(arg) == T_STRING && RSTRING_PTR(arg)[len] != 17) { + rb_raise(rb_eArgError, "return value overflowed string"); + } + + if (!io_p && cmd == F_SETFL) { + if (narg & O_NONBLOCK) { + fptr->mode |= FMODE_WSPLIT_INITIALIZED; + fptr->mode &= ~FMODE_WSPLIT; + } + else { + fptr->mode &= ~(FMODE_WSPLIT_INITIALIZED|FMODE_WSPLIT); + } + } + + return INT2NUM(retval); +#else + rb_notimplement(); + return Qnil; /* not reached */ +#endif +} + + +/* + * call-seq: + * ios.ioctl(integer_cmd, arg) => integer + * + * Provides a mechanism for issuing low-level commands to control or + * query I/O devices. Arguments and results are platform dependent. If + * <i>arg</i> is a number, its value is passed directly. If it is a + * string, it is interpreted as a binary sequence of bytes. On Unix + * platforms, see <code>ioctl(2)</code> for details. Not implemented on + * all platforms. + */ + +static VALUE +rb_io_ioctl(int argc, VALUE *argv, VALUE io) +{ + VALUE req, arg; + + rb_scan_args(argc, argv, "11", &req, &arg); + return rb_io_ctl(io, req, arg, 1); +} + +/* + * call-seq: + * ios.fcntl(integer_cmd, arg) => integer + * + * Provides a mechanism for issuing low-level commands to control or + * query file-oriented I/O streams. Arguments and results are platform + * dependent. If <i>arg</i> is a number, its value is passed + * directly. If it is a string, it is interpreted as a binary sequence + * of bytes (<code>Array#pack</code> might be a useful way to build this + * string). On Unix platforms, see <code>fcntl(2)</code> for details. + * Not implemented on all platforms. + */ + +static VALUE +rb_io_fcntl(int argc, VALUE *argv, VALUE io) +{ +#ifdef HAVE_FCNTL + VALUE req, arg; + + rb_scan_args(argc, argv, "11", &req, &arg); + return rb_io_ctl(io, req, arg, 0); +#else + rb_notimplement(); + return Qnil; /* not reached */ +#endif +} + +/* + * call-seq: + * syscall(fixnum [, args...]) => integer + * + * Calls the operating system function identified by _fixnum_, + * passing in the arguments, which must be either +String+ + * objects, or +Integer+ objects that ultimately fit within + * a native +long+. Up to nine parameters may be passed (14 + * on the Atari-ST). The function identified by _fixnum_ is system + * dependent. On some Unix systems, the numbers may be obtained from a + * header file called <code>syscall.h</code>. + * + * syscall 4, 1, "hello\n", 6 # '4' is write(2) on our box + * + * <em>produces:</em> + * + * hello + */ + +static VALUE +rb_f_syscall(int argc, VALUE *argv) +{ +#if defined(HAVE_SYSCALL) && !defined(__CHECKER__) +#ifdef atarist + unsigned long arg[14]; /* yes, we really need that many ! */ +#else + unsigned long arg[8]; +#endif + int retval = -1; + int i = 1; + int items = argc - 1; + + /* This probably won't work on machines where sizeof(long) != sizeof(int) + * or where sizeof(long) != sizeof(char*). But such machines will + * not likely have syscall implemented either, so who cares? + */ + + rb_secure(2); + if (argc == 0) + rb_raise(rb_eArgError, "too few arguments for syscall"); + if (argc > sizeof(arg) / sizeof(arg[0])) + rb_raise(rb_eArgError, "too many arguments for syscall"); + arg[0] = NUM2LONG(argv[0]); argv++; + while (items--) { + VALUE v = rb_check_string_type(*argv); + + if (!NIL_P(v)) { + StringValue(v); + rb_str_modify(v); + arg[i] = (unsigned long)StringValueCStr(v); + } + else { + arg[i] = (unsigned long)NUM2LONG(*argv); + } + argv++; + i++; + } + TRAP_BEG; + switch (argc) { + case 1: + retval = syscall(arg[0]); + break; + case 2: + retval = syscall(arg[0],arg[1]); + break; + case 3: + retval = syscall(arg[0],arg[1],arg[2]); + break; + case 4: + retval = syscall(arg[0],arg[1],arg[2],arg[3]); + break; + case 5: + retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4]); + break; + case 6: + retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5]); + break; + case 7: + retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6]); + break; + case 8: + retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], + arg[7]); + break; +#ifdef atarist + case 9: + retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], + arg[7], arg[8]); + break; + case 10: + retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], + arg[7], arg[8], arg[9]); + break; + case 11: + retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], + arg[7], arg[8], arg[9], arg[10]); + break; + case 12: + retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], + arg[7], arg[8], arg[9], arg[10], arg[11]); + break; + case 13: + retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], + arg[7], arg[8], arg[9], arg[10], arg[11], arg[12]); + break; + case 14: + retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], + arg[7], arg[8], arg[9], arg[10], arg[11], arg[12], arg[13]); + break; +#endif /* atarist */ + } + TRAP_END; + if (retval < 0) rb_sys_fail(0); + return INT2NUM(retval); +#else + rb_notimplement(); + return Qnil; /* not reached */ +#endif +} + +static VALUE +io_new_instance(VALUE args) +{ + return rb_class_new_instance(2, (VALUE*)args+1, *(VALUE*)args); +} + +static void +io_encoding_set(rb_io_t *fptr, int argc, VALUE v1, VALUE v2, VALUE opt) +{ + if (NIL_P(v2)) argc = 1; + if (argc == 2) { + fptr->encs.enc2 = rb_to_encoding(v1); + fptr->encs.enc = rb_to_encoding(v2); + rb_econv_opts(opt, &fptr->encs.opts); + clear_codeconv(fptr); + } + else if (argc == 1) { + if (NIL_P(v1)) { + fptr->encs.enc = NULL; + fptr->encs.enc2 = NULL; + rb_econv_opts(Qnil, &fptr->encs.opts); + clear_codeconv(fptr); + } + else { + VALUE tmp = rb_check_string_type(v1); + if (!NIL_P(tmp)) { + mode_enc(fptr, StringValueCStr(tmp)); + rb_econv_opts(opt, &fptr->encs.opts); + } + else { + fptr->encs.enc = rb_to_encoding(v1); + fptr->encs.enc2 = NULL; + rb_econv_opts(Qnil, &fptr->encs.opts); + clear_codeconv(fptr); + } + } + } +} + +/* + * call-seq: + * IO.pipe -> [read_io, write_io] + * IO.pipe(ext_enc) -> [read_io, write_io] + * IO.pipe("ext_enc:int_enc" [, opt]) -> [read_io, write_io] + * IO.pipe(ext_enc, int_enc [, opt]) -> [read_io, write_io] + * + * Creates a pair of pipe endpoints (connected to each other) and + * returns them as a two-element array of <code>IO</code> objects: + * <code>[</code> <i>read_io</i>, <i>write_io</i> <code>]</code>. Not + * available on all platforms. + * + * If an encoding (encoding name or encoding object) is specified as an optional argument, + * read string from pipe is tagged with the encoding specified. + * If the argument is a colon separated two encoding names "A:B", + * the read string is converted from encoding A (external encoding) + * to encoding B (internal encoding), then tagged with B. + * If two optional arguments are specified, those must be + * encoding objects or encoding names, + * and the first one is the external encoding, + * and the second one is the internal encoding. + * If the external encoding and the internal encoding is specified, + * optional hash argument specify the conversion option. + * + * In the example below, the two processes close the ends of the pipe + * that they are not using. This is not just a cosmetic nicety. The + * read end of a pipe will not generate an end of file condition if + * there are any writers with the pipe still open. In the case of the + * parent process, the <code>rd.read</code> will never return if it + * does not first issue a <code>wr.close</code>. + * + * rd, wr = IO.pipe + * + * if fork + * wr.close + * puts "Parent got: <#{rd.read}>" + * rd.close + * Process.wait + * else + * rd.close + * puts "Sending message to parent" + * wr.write "Hi Dad" + * wr.close + * end + * + * <em>produces:</em> + * + * Sending message to parent + * Parent got: <Hi Dad> + */ + +static VALUE +rb_io_s_pipe(int argc, VALUE *argv, VALUE klass) +{ +#ifdef __human68k__ + rb_notimplement(); + return Qnil; /* not reached */ +#else + int pipes[2], state; + VALUE r, w, args[3], v1, v2; + VALUE opt; + rb_io_t *fptr; + + opt = pop_last_hash(&argc, &argv); + rb_scan_args(argc, argv, "02", &v1, &v2); + if (rb_pipe(pipes) == -1) + rb_sys_fail(0); + + args[0] = klass; + args[1] = INT2NUM(pipes[0]); + args[2] = INT2FIX(O_RDONLY); + r = rb_protect(io_new_instance, (VALUE)args, &state); + if (state) { + close(pipes[0]); + close(pipes[1]); + rb_jump_tag(state); + } + GetOpenFile(r, fptr); + io_encoding_set(fptr, argc, v1, v2, opt); + args[1] = INT2NUM(pipes[1]); + args[2] = INT2FIX(O_WRONLY); + w = rb_protect(io_new_instance, (VALUE)args, &state); + if (state) { + close(pipes[1]); + if (!NIL_P(r)) rb_io_close(r); + rb_jump_tag(state); + } + rb_io_synchronized(RFILE(w)->fptr); + + return rb_assoc_new(r, w); +#endif +} + +struct foreach_arg { + int argc; + VALUE *argv; + VALUE io; +}; + +static void +open_key_args(int argc, VALUE *argv, struct foreach_arg *arg) +{ + VALUE opt, v; + VALUE mode, perm; + + FilePathValue(argv[0]); + arg->io = 0; + arg->argc = argc - 1; + arg->argv = argv + 1; + if (argc == 1) { + no_key: + arg->io = rb_io_open(argv[0], INT2NUM(O_RDONLY), INT2FIX(0666), Qnil); + return; + } + opt = rb_check_convert_type(argv[argc-1], T_HASH, "Hash", "to_hash"); + if (NIL_P(opt)) goto no_key; + arg->argc--; + + v = rb_hash_aref(opt, sym_open_args); + if (!NIL_P(v)) { + VALUE args; + + v = rb_convert_type(v, T_ARRAY, "Array", "to_ary"); + args = rb_ary_new2(RARRAY_LEN(v)+1); + rb_ary_push(args, argv[0]); + rb_ary_concat(args, v); + + arg->io = rb_io_open_with_args(RARRAY_LEN(args), RARRAY_PTR(args)); + return; + } + mode = Qnil; + perm = INT2NUM(O_RDONLY); + v = rb_hash_aref(opt, sym_mode); + if (!NIL_P(v)) + mode = v; + v = rb_hash_aref(opt, sym_perm); + if (!NIL_P(v)) + perm = v; + arg->io = rb_io_open(argv[0], mode, perm, opt); +} + +static VALUE +io_s_foreach(struct foreach_arg *arg) +{ + VALUE str; + + while (!NIL_P(str = rb_io_gets_m(arg->argc, arg->argv, arg->io))) { + rb_yield(str); + } + return Qnil; +} + +/* + * call-seq: + * IO.foreach(name, sep=$/ [, open_args]) {|line| block } => nil + * IO.foreach(name, limit [, open_args]) {|line| block } => nil + * IO.foreach(name, sep, limit [, open_args]) {|line| block } => nil + * + * Executes the block for every line in the named I/O port, where lines + * are separated by <em>sep</em>. + * + * IO.foreach("testfile") {|x| print "GOT ", x } + * + * <em>produces:</em> + * + * GOT This is line one + * GOT This is line two + * GOT This is line three + * GOT And so on... + * + * If the last argument is a hash, it's the keyword argument to open. + * See <code>IO.read</code> for detail. + * + */ + +static VALUE +rb_io_s_foreach(int argc, VALUE *argv, VALUE self) +{ + struct foreach_arg arg; + + rb_scan_args(argc, argv, "13", NULL, NULL, NULL, NULL); + RETURN_ENUMERATOR(self, argc, argv); + open_key_args(argc, argv, &arg); + if (NIL_P(arg.io)) return Qnil; + return rb_ensure(io_s_foreach, (VALUE)&arg, rb_io_close, arg.io); +} + +static VALUE +io_s_readlines(struct foreach_arg *arg) +{ + return rb_io_readlines(arg->argc, arg->argv, arg->io); +} + +/* + * call-seq: + * IO.readlines(name, sep=$/ [, open_args]) => array + * IO.readlines(name, limit [, open_args]) => array + * IO.readlines(name, sep, limit [, open_args]) => array + * + * Reads the entire file specified by <i>name</i> as individual + * lines, and returns those lines in an array. Lines are separated by + * <i>sep</i>. + * + * a = IO.readlines("testfile") + * a[0] #=> "This is line one\n" + * + * If the last argument is a hash, it's the keyword argument to open. + * See <code>IO.read</code> for detail. + * + */ + +static VALUE +rb_io_s_readlines(int argc, VALUE *argv, VALUE io) +{ + struct foreach_arg arg; + + rb_scan_args(argc, argv, "13", NULL, NULL, NULL, NULL); + open_key_args(argc, argv, &arg); + if (NIL_P(arg.io)) return Qnil; + return rb_ensure(io_s_readlines, (VALUE)&arg, rb_io_close, arg.io); +} + +static VALUE +io_s_read(struct foreach_arg *arg) +{ + return io_read(arg->argc, arg->argv, arg->io); +} + +/* + * call-seq: + * IO.read(name, [length [, offset]] ) => string + * IO.read(name, [length [, offset]], open_args) => string + * + * Opens the file, optionally seeks to the given offset, then returns + * <i>length</i> bytes (defaulting to the rest of the file). + * <code>read</code> ensures the file is closed before returning. + * + * If the last argument is a hash, it specifies option for internal + * open(). The key would be the following. open_args: is exclusive + * to others. + * + * encoding: string or encoding + * + * specifies encoding of the read string. encoding will be ignored + * if length is specified. + * + * mode: string + * + * specifies mode argument for open(). it should start with "r" + * otherwise it would cause error. + * + * open_args: array of strings + * + * specifies arguments for open() as an array. + * + * IO.read("testfile") #=> "This is line one\nThis is line two\nThis is line three\nAnd so on...\n" + * IO.read("testfile", 20) #=> "This is line one\nThi" + * IO.read("testfile", 20, 10) #=> "ne one\nThis is line " + */ + +static VALUE +rb_io_s_read(int argc, VALUE *argv, VALUE io) +{ + VALUE offset; + struct foreach_arg arg; + + rb_scan_args(argc, argv, "13", NULL, NULL, &offset, NULL); + open_key_args(argc, argv, &arg); + if (NIL_P(arg.io)) return Qnil; + if (!NIL_P(offset)) { + rb_io_binmode(arg.io); + rb_io_seek(arg.io, offset, SEEK_SET); + if (arg.argc == 2) arg.argc = 1; + } + return rb_ensure(io_s_read, (VALUE)&arg, rb_io_close, arg.io); +} + +struct copy_stream_struct { + VALUE src; + VALUE dst; + off_t copy_length; /* (off_t)-1 if not specified */ + off_t src_offset; /* (off_t)-1 if not specified */ + + int src_fd; + int dst_fd; + int close_src; + int close_dst; + off_t total; + const char *syserr; + int error_no; + const char *notimp; + rb_fdset_t fds; + rb_thread_t *th; +}; + +static int +copy_stream_wait_read(struct copy_stream_struct *stp) +{ + int ret; + rb_fd_zero(&stp->fds); + rb_fd_set(stp->src_fd, &stp->fds); + ret = rb_fd_select(rb_fd_max(&stp->fds), &stp->fds, NULL, NULL, NULL); + if (ret == -1) { + stp->syserr = "select"; + stp->error_no = errno; + return -1; + } + return 0; +} + +static int +copy_stream_wait_write(struct copy_stream_struct *stp) +{ + int ret; + rb_fd_zero(&stp->fds); + rb_fd_set(stp->dst_fd, &stp->fds); + ret = rb_fd_select(rb_fd_max(&stp->fds), NULL, &stp->fds, NULL, NULL); + if (ret == -1) { + stp->syserr = "select"; + stp->error_no = errno; + return -1; + } + return 0; +} + +#ifdef HAVE_SENDFILE + +#ifdef __linux__ +#define USE_SENDFILE + +#ifdef HAVE_SYS_SENDFILE_H +#include <sys/sendfile.h> +#endif + +static ssize_t +simple_sendfile(int out_fd, int in_fd, off_t *offset, size_t count) +{ + return sendfile(out_fd, in_fd, offset, count); +} + +#endif + +#endif + +#ifdef USE_SENDFILE +static int +copy_stream_sendfile(struct copy_stream_struct *stp) +{ + struct stat src_stat, dst_stat; + ssize_t ss; + int ret; + + off_t copy_length; + off_t src_offset; + int use_pread; + + ret = fstat(stp->src_fd, &src_stat); + if (ret == -1) { + stp->syserr = "fstat"; + stp->error_no = errno; + return -1; + } + if (!S_ISREG(src_stat.st_mode)) + return 0; + + ret = fstat(stp->dst_fd, &dst_stat); + if (ret == -1) { + stp->syserr = "fstat"; + stp->error_no = errno; + return -1; + } + if ((dst_stat.st_mode & S_IFMT) != S_IFSOCK) + return 0; + + src_offset = stp->src_offset; + use_pread = src_offset != (off_t)-1; + + copy_length = stp->copy_length; + if (copy_length == (off_t)-1) { + if (use_pread) + copy_length = src_stat.st_size - src_offset; + else { + off_t cur = lseek(stp->src_fd, 0, SEEK_CUR); + if (cur == (off_t)-1) { + stp->syserr = "lseek"; + stp->error_no = errno; + return -1; + } + copy_length = src_stat.st_size - cur; + } + } + +retry_sendfile: + if (use_pread) { + ss = simple_sendfile(stp->dst_fd, stp->src_fd, &src_offset, copy_length); + } + else { + ss = simple_sendfile(stp->dst_fd, stp->src_fd, NULL, copy_length); + } + if (0 < ss) { + stp->total += ss; + copy_length -= ss; + if (0 < copy_length) { + ss = -1; + errno = EAGAIN; + } + } + if (ss == -1) { + switch (errno) { + case EINVAL: +#ifdef ENOSYS + case ENOSYS: +#endif + return 0; + case EAGAIN: +#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN + case EWOULDBLOCK: +#endif + if (copy_stream_wait_write(stp) == -1) + return -1; + if (RUBY_VM_INTERRUPTED(stp->th)) + return -1; + goto retry_sendfile; + } + stp->syserr = "sendfile"; + stp->error_no = errno; + return -1; + } + return 1; +} +#endif + +static ssize_t +copy_stream_read(struct copy_stream_struct *stp, char *buf, int len, off_t offset) +{ + ssize_t ss; +retry_read: + if (offset == (off_t)-1) + ss = read(stp->src_fd, buf, len); + else { +#ifdef HAVE_PREAD + ss = pread(stp->src_fd, buf, len, offset); +#else + stp->notimp = "pread"; + return -1; +#endif + } + if (ss == 0) { + return 0; + } + if (ss == -1) { + switch (errno) { + case EAGAIN: +#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN + case EWOULDBLOCK: +#endif + if (copy_stream_wait_read(stp) == -1) + return -1; + goto retry_read; +#ifdef ENOSYS + case ENOSYS: +#endif + stp->notimp = "pread"; + return -1; + } + stp->syserr = offset == (off_t)-1 ? "read" : "pread"; + stp->error_no = errno; + return -1; + } + return ss; +} + +static int +copy_stream_write(struct copy_stream_struct *stp, char *buf, int len) +{ + ssize_t ss; + int off = 0; + while (len) { + ss = write(stp->dst_fd, buf+off, len); + if (ss == -1) { + if (errno == EAGAIN || errno == EWOULDBLOCK) { + if (copy_stream_wait_write(stp) == -1) + return -1; + continue; + } + stp->syserr = "write"; + stp->error_no = errno; + return -1; + } + off += ss; + len -= ss; + stp->total += ss; + } + return 0; +} + +static void +copy_stream_read_write(struct copy_stream_struct *stp) +{ + char buf[1024*16]; + int len; + ssize_t ss; + int ret; + off_t copy_length; + int use_eof; + off_t src_offset; + int use_pread; + + copy_length = stp->copy_length; + use_eof = copy_length == (off_t)-1; + src_offset = stp->src_offset; + use_pread = src_offset != (off_t)-1; + + if (use_pread && stp->close_src) { + off_t r; + r = lseek(stp->src_fd, src_offset, SEEK_SET); + if (r == (off_t)-1) { + stp->syserr = "lseek"; + stp->error_no = errno; + return; + } + src_offset = (off_t)-1; + use_pread = 0; + } + + while (use_eof || 0 < copy_length) { + if (!use_eof && copy_length < sizeof(buf)) { + len = copy_length; + } + else { + len = sizeof(buf); + } + if (use_pread) { + ss = copy_stream_read(stp, buf, len, src_offset); + if (0 < ss) + src_offset += ss; + } + else { + ss = copy_stream_read(stp, buf, len, (off_t)-1); + } + if (ss <= 0) /* EOF or error */ + return; + + ret = copy_stream_write(stp, buf, ss); + if (ret < 0) + return; + + if (!use_eof) + copy_length -= ss; + + if (RUBY_VM_INTERRUPTED(stp->th)) + return; + } +} + +static VALUE +copy_stream_func(void *arg) +{ + struct copy_stream_struct *stp = (struct copy_stream_struct *)arg; +#ifdef USE_SENDFILE + int ret; +#endif + +#ifdef USE_SENDFILE + ret = copy_stream_sendfile(stp); + if (ret != 0) + goto finish; /* error or success */ +#endif + + copy_stream_read_write(stp); + +#ifdef USE_SENDFILE +finish: +#endif + return Qnil; +} + +static VALUE +copy_stream_fallback_body(VALUE arg) +{ + struct copy_stream_struct *stp = (struct copy_stream_struct *)arg; + const int buflen = 16*1024; + VALUE n; + VALUE buf = rb_str_buf_new(buflen); + long rest = stp->copy_length; + off_t off = stp->src_offset; + + while (1) { + long numwrote; + long l; + if (stp->copy_length == (off_t)-1) { + l = buflen; + } + else { + if (rest == 0) + break; + l = buflen < rest ? buflen : rest; + } + if (stp->src_fd == -1) { + rb_funcall(stp->src, id_readpartial, 2, INT2FIX(l), buf); + } + else { + ssize_t ss; + rb_thread_wait_fd(stp->src_fd); + rb_str_resize(buf, buflen); + ss = copy_stream_read(stp, RSTRING_PTR(buf), l, off); + if (ss == -1) + return Qnil; + if (ss == 0) + rb_eof_error(); + rb_str_resize(buf, ss); + if (off != (off_t)-1) + off += ss; + } + n = rb_io_write(stp->dst, buf); + numwrote = NUM2LONG(n); + stp->total += numwrote; + rest -= numwrote; + } + + return Qnil; +} + +static VALUE +copy_stream_fallback(struct copy_stream_struct *stp) +{ + if (stp->src_fd == -1 && stp->src_offset != (off_t)-1) { + rb_raise(rb_eArgError, "cannot specify src_offset for non-IO"); + } + rb_rescue2(copy_stream_fallback_body, (VALUE)stp, + (VALUE (*) (ANYARGS))0, (VALUE)0, + rb_eEOFError, (VALUE)0); + return Qnil; +} + +static VALUE +copy_stream_body(VALUE arg) +{ + struct copy_stream_struct *stp = (struct copy_stream_struct *)arg; + VALUE src_io, dst_io; + rb_io_t *src_fptr = 0, *dst_fptr = 0; + int src_fd, dst_fd; + + stp->th = GET_THREAD(); + + stp->total = 0; + + if (stp->src == argf || + !(TYPE(stp->src) == T_FILE || + rb_respond_to(stp->src, rb_intern("to_io")) || + TYPE(stp->src) == T_STRING || + rb_respond_to(stp->src, rb_intern("to_path")))) { + src_fd = -1; + } + else { + src_io = rb_check_convert_type(stp->src, T_FILE, "IO", "to_io"); + if (NIL_P(src_io)) { + VALUE args[2]; + int flags = O_RDONLY; +#ifdef O_NOCTTY + flags |= O_NOCTTY; +#endif + FilePathValue(stp->src); + args[0] = stp->src; + args[1] = INT2NUM(flags); + src_io = rb_class_new_instance(2, args, rb_cFile); + stp->src = src_io; + stp->close_src = 1; + } + GetOpenFile(src_io, src_fptr); + rb_io_check_readable(src_fptr); + src_fd = src_fptr->fd; + } + stp->src_fd = src_fd; + + if (stp->dst == argf || + !(TYPE(stp->dst) == T_FILE || + rb_respond_to(stp->dst, rb_intern("to_io")) || + TYPE(stp->dst) == T_STRING || + rb_respond_to(stp->dst, rb_intern("to_path")))) { + dst_fd = -1; + } + else { + dst_io = rb_check_convert_type(stp->dst, T_FILE, "IO", "to_io"); + if (NIL_P(dst_io)) { + VALUE args[3]; + int flags = O_WRONLY|O_CREAT|O_TRUNC; +#ifdef O_NOCTTY + flags |= O_NOCTTY; +#endif + FilePathValue(stp->dst); + args[0] = stp->dst; + args[1] = INT2NUM(flags); + args[2] = INT2FIX(0600); + dst_io = rb_class_new_instance(3, args, rb_cFile); + stp->dst = dst_io; + stp->close_dst = 1; + } + else { + dst_io = GetWriteIO(dst_io); + stp->dst = dst_io; + } + GetOpenFile(dst_io, dst_fptr); + rb_io_check_writable(dst_fptr); + dst_fd = dst_fptr->fd; + } + stp->dst_fd = dst_fd; + + if (stp->src_offset == (off_t)-1 && src_fptr && src_fptr->rbuf_len) { + long len = src_fptr->rbuf_len; + VALUE str; + if (stp->copy_length != (off_t)-1 && stp->copy_length < len) { + len = stp->copy_length; + } + str = rb_str_buf_new(len); + rb_str_resize(str,len); + read_buffered_data(RSTRING_PTR(str), len, src_fptr); + if (dst_fptr) /* IO or filename */ + io_fwrite(str, dst_fptr); + else /* others such as StringIO */ + rb_io_write(stp->dst, str); + stp->total += len; + if (stp->copy_length != (off_t)-1) + stp->copy_length -= len; + } + + if (dst_fptr && io_fflush(dst_fptr) < 0) { + rb_raise(rb_eIOError, "flush failed"); + } + + if (stp->copy_length == 0) + return Qnil; + + if (src_fd == -1 || dst_fd == -1) { + return copy_stream_fallback(stp); + } + + rb_fd_init(&stp->fds); + rb_fd_set(src_fd, &stp->fds); + rb_fd_set(dst_fd, &stp->fds); + + return rb_thread_blocking_region(copy_stream_func, (void*)stp, RB_UBF_DFL, 0); +} + +static VALUE +copy_stream_finalize(VALUE arg) +{ + struct copy_stream_struct *stp = (struct copy_stream_struct *)arg; + if (stp->close_src) { + rb_io_close_m(stp->src); + } + if (stp->close_dst) { + rb_io_close_m(stp->dst); + } + rb_fd_term(&stp->fds); + if (stp->syserr) { + errno = stp->error_no; + rb_sys_fail(stp->syserr); + } + if (stp->notimp) { + rb_raise(rb_eNotImpError, "%s() not implemented", stp->notimp); + } + return Qnil; +} + +/* + * call-seq: + * IO.copy_stream(src, dst) + * IO.copy_stream(src, dst, copy_length) + * IO.copy_stream(src, dst, copy_length, src_offset) + * + * IO.copy_stream copies <i>src</i> to <i>dst</i>. + * <i>src</i> and <i>dst</i> is either a filename or an IO. + * + * This method returns the number of bytes copied. + * + * If optional arguments are not given, + * the start position of the copy is + * the beginning of the filename or + * the current file offset of the IO. + * The end position of the copy is the end of file. + * + * If <i>copy_length</i> is given, + * No more than <i>copy_length</i> bytes are copied. + * + * If <i>src_offset</i> is given, + * it specifies the start position of the copy. + * + * When <i>src_offset</i> is specified and + * <i>src</i> is an IO, + * IO.copy_stream doesn't move the current file offset. + * + */ +static VALUE +rb_io_s_copy_stream(int argc, VALUE *argv, VALUE io) +{ + VALUE src, dst, length, src_offset; + struct copy_stream_struct st; + + MEMZERO(&st, struct copy_stream_struct, 1); + + rb_scan_args(argc, argv, "22", &src, &dst, &length, &src_offset); + + st.src = src; + st.dst = dst; + + if (NIL_P(length)) + st.copy_length = (off_t)-1; + else + st.copy_length = NUM2OFFT(length); + + if (NIL_P(src_offset)) + st.src_offset = (off_t)-1; + else + st.src_offset = NUM2OFFT(src_offset); + + rb_ensure(copy_stream_body, (VALUE)&st, copy_stream_finalize, (VALUE)&st); + + return OFFT2NUM(st.total); +} + +/* + * call-seq: + * io.external_encoding => encoding + * + * Returns the Encoding object that represents the encoding of the file. + * If io is write mode and no encoding is specified, returns <code>nil</code>. + */ + +static VALUE +rb_io_external_encoding(VALUE io) +{ + rb_io_t *fptr; + + GetOpenFile(io, fptr); + if (fptr->encs.enc2) { + return rb_enc_from_encoding(fptr->encs.enc2); + } + if (fptr->mode & FMODE_WRITABLE) { + if (fptr->encs.enc) + return rb_enc_from_encoding(fptr->encs.enc); + return Qnil; + } + return rb_enc_from_encoding(io_read_encoding(fptr)); +} + +/* + * call-seq: + * io.internal_encoding => encoding + * + * Returns the Encoding of the internal string if conversion is + * specified. Otherwise returns nil. + */ + +static VALUE +rb_io_internal_encoding(VALUE io) +{ + rb_io_t *fptr; + + GetOpenFile(io, fptr); + if (!fptr->encs.enc2) return Qnil; + return rb_enc_from_encoding(io_read_encoding(fptr)); +} + +/* + * call-seq: + * io.set_encoding(ext_enc) => io + * io.set_encoding("ext_enc:int_enc") => io + * io.set_encoding(ext_enc, int_enc) => io + * io.set_encoding("ext_enc:int_enc", opt) => io + * io.set_encoding(ext_enc, int_enc, opt) => io + * + * If single argument is specified, read string from io is tagged + * with the encoding specified. If encoding is a colon separated two + * encoding names "A:B", the read string is converted from encoding A + * (external encoding) to encoding B (internal encoding), then tagged + * with B. If two arguments are specified, those must be encoding + * objects or encoding names, and the first one is the external encoding, and the + * second one is the internal encoding. + * If the external encoding and the internal encoding is specified, + * optional hash argument specify the conversion option. + */ + +static VALUE +rb_io_set_encoding(int argc, VALUE *argv, VALUE io) +{ + rb_io_t *fptr; + VALUE v1, v2, opt; + + opt = pop_last_hash(&argc, &argv); + rb_scan_args(argc, argv, "11", &v1, &v2); + GetOpenFile(io, fptr); + io_encoding_set(fptr, argc, v1, v2, opt); + return io; +} + +static VALUE +argf_external_encoding(VALUE argf) +{ + if (!RTEST(current_file)) { + return rb_enc_from_encoding(rb_default_external_encoding()); + } + return rb_io_external_encoding(rb_io_check_io(current_file)); +} + +static VALUE +argf_internal_encoding(VALUE argf) +{ + if (!RTEST(current_file)) { + return rb_enc_from_encoding(rb_default_external_encoding()); + } + return rb_io_internal_encoding(rb_io_check_io(current_file)); +} + +static VALUE +argf_set_encoding(int argc, VALUE *argv, VALUE argf) +{ + rb_io_t *fptr; + + if (!next_argv()) { + rb_raise(rb_eArgError, "no stream to set encoding"); + } + rb_io_set_encoding(argc, argv, current_file); + GetOpenFile(current_file, fptr); + argf_enc = fptr->encs.enc; + argf_enc2 = fptr->encs.enc2; + argf_ecopts = fptr->encs.opts; + return argf; +} + +static VALUE +argf_tell(VALUE argf) +{ + if (!next_argv()) { + rb_raise(rb_eArgError, "no stream to tell"); + } + ARGF_FORWARD(0, 0); + return rb_io_tell(current_file); +} + +static VALUE +argf_seek_m(int argc, VALUE *argv, VALUE argf) +{ + if (!next_argv()) { + rb_raise(rb_eArgError, "no stream to seek"); + } + ARGF_FORWARD(argc, argv); + return rb_io_seek_m(argc, argv, current_file); +} + +static VALUE +argf_set_pos(VALUE argf, VALUE offset) +{ + if (!next_argv()) { + rb_raise(rb_eArgError, "no stream to set position"); + } + ARGF_FORWARD(1, &offset); + return rb_io_set_pos(current_file, offset); +} + +static VALUE +argf_rewind(VALUE argf) +{ + if (!next_argv()) { + rb_raise(rb_eArgError, "no stream to rewind"); + } + ARGF_FORWARD(0, 0); + return rb_io_rewind(current_file); +} + +static VALUE +argf_fileno(VALUE argf) +{ + if (!next_argv()) { + rb_raise(rb_eArgError, "no stream"); + } + ARGF_FORWARD(0, 0); + return rb_io_fileno(current_file); +} + +static VALUE +argf_to_io(VALUE argf) +{ + next_argv(); + ARGF_FORWARD(0, 0); + return current_file; +} + +static VALUE +argf_eof(VALUE argf) +{ + if (current_file) { + if (init_p == 0) return Qtrue; + ARGF_FORWARD(0, 0); + if (rb_io_eof(current_file)) { + return Qtrue; + } + } + return Qfalse; +} + +static VALUE +argf_read(int argc, VALUE *argv, VALUE argf) +{ + VALUE tmp, str, length; + long len = 0; + + rb_scan_args(argc, argv, "02", &length, &str); + if (!NIL_P(length)) { + len = NUM2LONG(argv[0]); + } + if (!NIL_P(str)) { + StringValue(str); + rb_str_resize(str,0); + argv[1] = Qnil; + } + + retry: + if (!next_argv()) { + return str; + } + if (ARGF_GENERIC_INPUT_P()) { + tmp = argf_forward(argc, argv, argf); + } + else { + tmp = io_read(argc, argv, current_file); + } + if (NIL_P(str)) str = tmp; + else if (!NIL_P(tmp)) rb_str_append(str, tmp); + if (NIL_P(tmp) || NIL_P(length)) { + if (next_p != -1) { + argf_close(current_file); + next_p = 1; + goto retry; + } + } + else if (argc >= 1) { + if (RSTRING_LEN(str) < len) { + len -= RSTRING_LEN(str); + argv[0] = INT2NUM(len); + goto retry; + } + } + return str; +} + +struct argf_call_arg { + int argc; + VALUE *argv; + VALUE argf; +}; + +static VALUE +argf_forward_call(VALUE arg) +{ + struct argf_call_arg *p = (struct argf_call_arg *)arg; + argf_forward(p->argc, p->argv, p->argf); + return Qnil; +} + +static VALUE +argf_readpartial(int argc, VALUE *argv, VALUE argf) +{ + VALUE tmp, str, length; + + rb_scan_args(argc, argv, "11", &length, &str); + if (!NIL_P(str)) { + StringValue(str); + argv[1] = str; + } + + if (!next_argv()) { + rb_str_resize(str, 0); + rb_eof_error(); + } + if (ARGF_GENERIC_INPUT_P()) { + struct argf_call_arg arg; + arg.argc = argc; + arg.argv = argv; + arg.argf = argf; + tmp = rb_rescue2(argf_forward_call, (VALUE)&arg, + RUBY_METHOD_FUNC(0), Qnil, rb_eEOFError, (VALUE)0); + } + else { + tmp = io_getpartial(argc, argv, current_file, 0); + } + if (NIL_P(tmp)) { + if (next_p == -1) { + rb_eof_error(); + } + argf_close(current_file); + next_p = 1; + if (RARRAY_LEN(rb_argv) == 0) + rb_eof_error(); + if (NIL_P(str)) + str = rb_str_new(NULL, 0); + return str; + } + return tmp; +} + +static VALUE +argf_getc(VALUE argf) +{ + VALUE ch; + + retry: + if (!next_argv()) return Qnil; + if (ARGF_GENERIC_INPUT_P()) { + ch = rb_funcall3(current_file, rb_intern("getc"), 0, 0); + } + else { + ch = rb_io_getc(current_file); + } + if (NIL_P(ch) && next_p != -1) { + argf_close(current_file); + next_p = 1; + goto retry; + } + + return ch; +} + +static VALUE +argf_getbyte(VALUE argf) +{ + VALUE ch; + + retry: + if (!next_argv()) return Qnil; + if (TYPE(current_file) != T_FILE) { + ch = rb_funcall3(current_file, rb_intern("getbyte"), 0, 0); + } + else { + ch = rb_io_getbyte(current_file); + } + if (NIL_P(ch) && next_p != -1) { + argf_close(current_file); + next_p = 1; + goto retry; + } + + return ch; +} + +static VALUE +argf_readchar(VALUE argf) +{ + VALUE ch; + + retry: + if (!next_argv()) rb_eof_error(); + if (TYPE(current_file) != T_FILE) { + ch = rb_funcall3(current_file, rb_intern("getc"), 0, 0); + } + else { + ch = rb_io_getc(current_file); + } + if (NIL_P(ch) && next_p != -1) { + argf_close(current_file); + next_p = 1; + goto retry; + } + + return ch; +} + +static VALUE +argf_readbyte(VALUE argf) +{ + VALUE c; + + NEXT_ARGF_FORWARD(0, 0); + c = argf_getbyte(argf); + if (NIL_P(c)) { + rb_eof_error(); + } + return c; +} + +static VALUE +argf_each_line(int argc, VALUE *argv, VALUE argf) +{ + RETURN_ENUMERATOR(argf, argc, argv); + for (;;) { + if (!next_argv()) return Qnil; + rb_block_call(current_file, rb_intern("each_line"), argc, argv, rb_yield, 0); + next_p = 1; + } + return argf; +} + +static VALUE +argf_each_byte(VALUE argf) +{ + RETURN_ENUMERATOR(argf, 0, 0); + for (;;) { + if (!next_argv()) return Qnil; + rb_block_call(current_file, rb_intern("each_byte"), 0, 0, rb_yield, 0); + next_p = 1; + } +} + +static VALUE +argf_each_char(VALUE argf) +{ + RETURN_ENUMERATOR(argf, 0, 0); + for (;;) { + if (!next_argv()) return Qnil; + rb_block_call(current_file, rb_intern("each_char"), 0, 0, rb_yield, 0); + next_p = 1; + } +} + +static VALUE +argf_filename(VALUE argf) +{ + next_argv(); + return filename; +} + +static VALUE +argf_filename_getter(ID id, VALUE *var) +{ + return argf_filename(*var); +} + +static VALUE +argf_file(VALUE argf) +{ + next_argv(); + return current_file; +} + +static VALUE +argf_binmode_m(VALUE argf) +{ + argf_binmode = 1; + next_argv(); + ARGF_FORWARD(0, 0); + rb_io_binmode(current_file); + return argf; +} + +static VALUE +argf_binmode_p(VALUE argf) +{ + return argf_binmode ? Qtrue : Qfalse; +} + +static VALUE +argf_skip(VALUE argf) +{ + if (next_p != -1) { + argf_close(current_file); + next_p = 1; + } + return argf; +} + +static VALUE +argf_close_m(VALUE argf) +{ + next_argv(); + argf_close(current_file); + if (next_p != -1) { + next_p = 1; + } + gets_lineno = 0; + return argf; +} + +static VALUE +argf_closed(VALUE argf) +{ + next_argv(); + ARGF_FORWARD(0, 0); + return rb_io_closed(current_file); +} + +static VALUE +argf_to_s(VALUE argf) +{ + return rb_str_new2("ARGF"); +} + +static VALUE +argf_inplace_mode_get(VALUE argf) +{ + if (!ruby_inplace_mode) return Qnil; + return rb_str_new2(ruby_inplace_mode); +} + +static VALUE +opt_i_get(ID id, VALUE *var) +{ + return argf_inplace_mode_get(*var); +} + +static VALUE +argf_inplace_mode_set(VALUE argf, VALUE val) +{ + if (!RTEST(val)) { + if (ruby_inplace_mode) free(ruby_inplace_mode); + ruby_inplace_mode = 0; + } + else { + StringValue(val); + if (ruby_inplace_mode) free(ruby_inplace_mode); + ruby_inplace_mode = 0; + ruby_inplace_mode = strdup(RSTRING_PTR(val)); + } + return argf; +} + +static void +opt_i_set(VALUE val, ID id, VALUE *var) +{ + argf_inplace_mode_set(*var, val); +} + +const char * +ruby_get_inplace_mode(void) +{ + return ruby_inplace_mode; +} + +void +ruby_set_inplace_mode(const char *suffix) +{ + if (ruby_inplace_mode) free(ruby_inplace_mode); + ruby_inplace_mode = 0; + if (suffix) ruby_inplace_mode = strdup(suffix); +} + +static VALUE +argf_argv(VALUE argf) +{ + return rb_argv; +} + +static VALUE +argf_argv_getter(ID id, VALUE *var) +{ + return argf_argv(*var); +} + +VALUE +rb_get_argv(void) +{ + return rb_argv; +} + +/* + * Class <code>IO</code> is the basis for all input and output in Ruby. + * An I/O stream may be <em>duplexed</em> (that is, bidirectional), and + * so may use more than one native operating system stream. + * + * Many of the examples in this section use class <code>File</code>, + * the only standard subclass of <code>IO</code>. The two classes are + * closely associated. + * + * As used in this section, <em>portname</em> may take any of the + * following forms. + * + * * A plain string represents a filename suitable for the underlying + * operating system. + * + * * A string starting with ``<code>|</code>'' indicates a subprocess. + * The remainder of the string following the ``<code>|</code>'' is + * invoked as a process with appropriate input/output channels + * connected to it. + * + * * A string equal to ``<code>|-</code>'' will create another Ruby + * instance as a subprocess. + * + * Ruby will convert pathnames between different operating system + * conventions if possible. For instance, on a Windows system the + * filename ``<code>/gumby/ruby/test.rb</code>'' will be opened as + * ``<code>\gumby\ruby\test.rb</code>''. When specifying a + * Windows-style filename in a Ruby string, remember to escape the + * backslashes: + * + * "c:\\gumby\\ruby\\test.rb" + * + * Our examples here will use the Unix-style forward slashes; + * <code>File::SEPARATOR</code> can be used to get the + * platform-specific separator character. + * + * I/O ports may be opened in any one of several different modes, which + * are shown in this section as <em>mode</em>. The mode may + * either be a Fixnum or a String. If numeric, it should be + * one of the operating system specific constants (O_RDONLY, + * O_WRONLY, O_RDWR, O_APPEND and so on). See man open(2) for + * more information. + * + * If the mode is given as a String, it must be one of the + * values listed in the following table. + * + * Mode | Meaning + * -----+-------------------------------------------------------- + * "r" | Read-only, starts at beginning of file (default mode). + * -----+-------------------------------------------------------- + * "r+" | Read-write, starts at beginning of file. + * -----+-------------------------------------------------------- + * "w" | Write-only, truncates existing file + * | to zero length or creates a new file for writing. + * -----+-------------------------------------------------------- + * "w+" | Read-write, truncates existing file to zero length + * | or creates a new file for reading and writing. + * -----+-------------------------------------------------------- + * "a" | Write-only, starts at end of file if file exists, + * | otherwise creates a new file for writing. + * -----+-------------------------------------------------------- + * "a+" | Read-write, starts at end of file if file exists, + * | otherwise creates a new file for reading and + * | writing. + * -----+-------------------------------------------------------- + * "b" | (DOS/Windows only) Binary file mode (may appear with + * | any of the key letters listed above). + * -----+-------------------------------------------------------- + * "t" | Text file mode (may appear with + * | any of the key letters listed above except "b"). + * + * + * The global constant ARGF (also accessible as $<) provides an + * IO-like stream which allows access to all files mentioned on the + * command line (or STDIN if no files are mentioned). ARGF provides + * the methods <code>#path</code> and <code>#filename</code> to access + * the name of the file currently being read. + */ + +void +Init_IO(void) +{ +#undef rb_intern +#define rb_intern(str) rb_intern_const(str) + + VALUE rb_cARGF; +#ifdef __CYGWIN__ +#include <sys/cygwin.h> + static struct __cygwin_perfile pf[] = + { + {"", O_RDONLY | O_BINARY}, + {"", O_WRONLY | O_BINARY}, + {"", O_RDWR | O_BINARY}, + {"", O_APPEND | O_BINARY}, + {NULL, 0} + }; + cygwin_internal(CW_PERFILE, pf); +#endif + + rb_eIOError = rb_define_class("IOError", rb_eStandardError); + rb_eEOFError = rb_define_class("EOFError", rb_eIOError); + + id_write = rb_intern("write"); + id_read = rb_intern("read"); + id_getc = rb_intern("getc"); + id_flush = rb_intern("flush"); + id_readpartial = rb_intern("readpartial"); + + rb_define_global_function("syscall", rb_f_syscall, -1); + + rb_define_global_function("open", rb_f_open, -1); + rb_define_global_function("printf", rb_f_printf, -1); + rb_define_global_function("print", rb_f_print, -1); + rb_define_global_function("putc", rb_f_putc, 1); + rb_define_global_function("puts", rb_f_puts, -1); + rb_define_global_function("gets", rb_f_gets, -1); + rb_define_global_function("readline", rb_f_readline, -1); + rb_define_global_function("select", rb_f_select, -1); + + rb_define_global_function("readlines", rb_f_readlines, -1); + + rb_define_global_function("`", rb_f_backquote, 1); + + rb_define_global_function("p", rb_f_p, -1); + rb_define_method(rb_mKernel, "display", rb_obj_display, -1); + + rb_cIO = rb_define_class("IO", rb_cObject); + rb_include_module(rb_cIO, rb_mEnumerable); + + rb_define_alloc_func(rb_cIO, io_alloc); + rb_define_singleton_method(rb_cIO, "new", rb_io_s_new, -1); + rb_define_singleton_method(rb_cIO, "open", rb_io_s_open, -1); + rb_define_singleton_method(rb_cIO, "sysopen", rb_io_s_sysopen, -1); + rb_define_singleton_method(rb_cIO, "for_fd", rb_io_s_for_fd, -1); + rb_define_singleton_method(rb_cIO, "popen", rb_io_s_popen, -1); + rb_define_singleton_method(rb_cIO, "foreach", rb_io_s_foreach, -1); + rb_define_singleton_method(rb_cIO, "readlines", rb_io_s_readlines, -1); + rb_define_singleton_method(rb_cIO, "read", rb_io_s_read, -1); + rb_define_singleton_method(rb_cIO, "select", rb_f_select, -1); + rb_define_singleton_method(rb_cIO, "pipe", rb_io_s_pipe, -1); + rb_define_singleton_method(rb_cIO, "try_convert", rb_io_s_try_convert, 1); + rb_define_singleton_method(rb_cIO, "copy_stream", rb_io_s_copy_stream, -1); + + rb_define_method(rb_cIO, "initialize", rb_io_initialize, -1); + + rb_output_fs = Qnil; + rb_define_hooked_variable("$,", &rb_output_fs, 0, rb_str_setter); + + rb_global_variable(&rb_default_rs); + rb_rs = rb_default_rs = rb_str_new2("\n"); + rb_output_rs = Qnil; + OBJ_FREEZE(rb_default_rs); /* avoid modifying RS_default */ + rb_define_hooked_variable("$/", &rb_rs, 0, rb_str_setter); + rb_define_hooked_variable("$-0", &rb_rs, 0, rb_str_setter); + rb_define_hooked_variable("$\\", &rb_output_rs, 0, rb_str_setter); + + rb_define_virtual_variable("$_", rb_lastline_get, rb_lastline_set); + + rb_define_method(rb_cIO, "initialize_copy", rb_io_init_copy, 1); + rb_define_method(rb_cIO, "reopen", rb_io_reopen, -1); + + rb_define_method(rb_cIO, "print", rb_io_print, -1); + rb_define_method(rb_cIO, "putc", rb_io_putc, 1); + rb_define_method(rb_cIO, "puts", rb_io_puts, -1); + rb_define_method(rb_cIO, "printf", rb_io_printf, -1); + + rb_define_method(rb_cIO, "each", rb_io_each_line, -1); + rb_define_method(rb_cIO, "each_line", rb_io_each_line, -1); + rb_define_method(rb_cIO, "each_byte", rb_io_each_byte, 0); + rb_define_method(rb_cIO, "each_char", rb_io_each_char, 0); + rb_define_method(rb_cIO, "lines", rb_io_lines, -1); + rb_define_method(rb_cIO, "bytes", rb_io_bytes, 0); + rb_define_method(rb_cIO, "chars", rb_io_chars, 0); + + rb_define_method(rb_cIO, "syswrite", rb_io_syswrite, 1); + rb_define_method(rb_cIO, "sysread", rb_io_sysread, -1); + + rb_define_method(rb_cIO, "fileno", rb_io_fileno, 0); + rb_define_alias(rb_cIO, "to_i", "fileno"); + rb_define_method(rb_cIO, "to_io", rb_io_to_io, 0); + + rb_define_method(rb_cIO, "fsync", rb_io_fsync, 0); + rb_define_method(rb_cIO, "sync", rb_io_sync, 0); + rb_define_method(rb_cIO, "sync=", rb_io_set_sync, 1); + + rb_define_method(rb_cIO, "lineno", rb_io_lineno, 0); + rb_define_method(rb_cIO, "lineno=", rb_io_set_lineno, 1); + + rb_define_method(rb_cIO, "readlines", rb_io_readlines, -1); + + rb_define_method(rb_cIO, "read_nonblock", io_read_nonblock, -1); + rb_define_method(rb_cIO, "write_nonblock", rb_io_write_nonblock, 1); + rb_define_method(rb_cIO, "readpartial", io_readpartial, -1); + rb_define_method(rb_cIO, "read", io_read, -1); + rb_define_method(rb_cIO, "write", io_write, 1); + rb_define_method(rb_cIO, "gets", rb_io_gets_m, -1); + rb_define_method(rb_cIO, "readline", rb_io_readline, -1); + rb_define_method(rb_cIO, "getc", rb_io_getc, 0); + rb_define_method(rb_cIO, "getbyte", rb_io_getbyte, 0); + rb_define_method(rb_cIO, "readchar", rb_io_readchar, 0); + rb_define_method(rb_cIO, "readbyte", rb_io_readbyte, 0); + rb_define_method(rb_cIO, "ungetbyte",rb_io_ungetbyte, 1); + rb_define_method(rb_cIO, "ungetc",rb_io_ungetc, 1); + rb_define_method(rb_cIO, "<<", rb_io_addstr, 1); + rb_define_method(rb_cIO, "flush", rb_io_flush, 0); + rb_define_method(rb_cIO, "tell", rb_io_tell, 0); + rb_define_method(rb_cIO, "seek", rb_io_seek_m, -1); + rb_define_const(rb_cIO, "SEEK_SET", INT2FIX(SEEK_SET)); + rb_define_const(rb_cIO, "SEEK_CUR", INT2FIX(SEEK_CUR)); + rb_define_const(rb_cIO, "SEEK_END", INT2FIX(SEEK_END)); + rb_define_method(rb_cIO, "rewind", rb_io_rewind, 0); + rb_define_method(rb_cIO, "pos", rb_io_tell, 0); + rb_define_method(rb_cIO, "pos=", rb_io_set_pos, 1); + rb_define_method(rb_cIO, "eof", rb_io_eof, 0); + rb_define_method(rb_cIO, "eof?", rb_io_eof, 0); + + rb_define_method(rb_cIO, "close_on_exec?", rb_io_close_on_exec_p, 0); + rb_define_method(rb_cIO, "close_on_exec=", rb_io_set_close_on_exec, 1); + + rb_define_method(rb_cIO, "close", rb_io_close_m, 0); + rb_define_method(rb_cIO, "closed?", rb_io_closed, 0); + rb_define_method(rb_cIO, "close_read", rb_io_close_read, 0); + rb_define_method(rb_cIO, "close_write", rb_io_close_write, 0); + + rb_define_method(rb_cIO, "isatty", rb_io_isatty, 0); + rb_define_method(rb_cIO, "tty?", rb_io_isatty, 0); + rb_define_method(rb_cIO, "binmode", rb_io_binmode_m, 0); + rb_define_method(rb_cIO, "binmode?", rb_io_binmode_p, 0); + rb_define_method(rb_cIO, "sysseek", rb_io_sysseek, -1); + + rb_define_method(rb_cIO, "ioctl", rb_io_ioctl, -1); + rb_define_method(rb_cIO, "fcntl", rb_io_fcntl, -1); + rb_define_method(rb_cIO, "pid", rb_io_pid, 0); + rb_define_method(rb_cIO, "inspect", rb_io_inspect, 0); + + rb_define_method(rb_cIO, "external_encoding", rb_io_external_encoding, 0); + rb_define_method(rb_cIO, "internal_encoding", rb_io_internal_encoding, 0); + rb_define_method(rb_cIO, "set_encoding", rb_io_set_encoding, -1); + + rb_define_variable("$stdin", &rb_stdin); + rb_stdin = prep_stdio(stdin, FMODE_READABLE, rb_cIO, "<STDIN>"); + rb_define_hooked_variable("$stdout", &rb_stdout, 0, stdout_setter); + rb_stdout = prep_stdio(stdout, FMODE_WRITABLE, rb_cIO, "<STDOUT>"); + rb_define_hooked_variable("$stderr", &rb_stderr, 0, stdout_setter); + rb_stderr = prep_stdio(stderr, FMODE_WRITABLE|FMODE_SYNC, rb_cIO, "<STDERR>"); + rb_define_hooked_variable("$>", &rb_stdout, 0, stdout_setter); + orig_stdout = rb_stdout; + rb_deferr = orig_stderr = rb_stderr; + + /* constants to hold original stdin/stdout/stderr */ + rb_define_global_const("STDIN", rb_stdin); + rb_define_global_const("STDOUT", rb_stdout); + rb_define_global_const("STDERR", rb_stderr); + + rb_cARGF = rb_class_new(rb_cObject); + rb_set_class_path(rb_cARGF, rb_cObject, "ARGF.class"); + rb_define_alloc_func(rb_cARGF, argf_alloc); + + rb_include_module(rb_cARGF, rb_mEnumerable); + + rb_define_method(rb_cARGF, "initialize", argf_initialize, -2); + rb_define_method(rb_cARGF, "initialize_copy", argf_initialize_copy, 1); + rb_define_method(rb_cARGF, "to_s", argf_to_s, 0); + rb_define_method(rb_cARGF, "argv", argf_argv, 0); + + rb_define_method(rb_cARGF, "fileno", argf_fileno, 0); + rb_define_method(rb_cARGF, "to_i", argf_fileno, 0); + rb_define_method(rb_cARGF, "to_io", argf_to_io, 0); + rb_define_method(rb_cARGF, "each", argf_each_line, -1); + rb_define_method(rb_cARGF, "each_line", argf_each_line, -1); + rb_define_method(rb_cARGF, "each_byte", argf_each_byte, 0); + rb_define_method(rb_cARGF, "each_char", argf_each_char, 0); + rb_define_method(rb_cARGF, "lines", argf_each_line, -1); + rb_define_method(rb_cARGF, "bytes", argf_each_byte, 0); + rb_define_method(rb_cARGF, "chars", argf_each_char, 0); + + rb_define_method(rb_cARGF, "read", argf_read, -1); + rb_define_method(rb_cARGF, "readpartial", argf_readpartial, -1); + rb_define_method(rb_cARGF, "readlines", argf_readlines, -1); + rb_define_method(rb_cARGF, "to_a", argf_readlines, -1); + rb_define_method(rb_cARGF, "gets", argf_gets, -1); + rb_define_method(rb_cARGF, "readline", argf_readline, -1); + rb_define_method(rb_cARGF, "getc", argf_getc, 0); + rb_define_method(rb_cARGF, "getbyte", argf_getbyte, 0); + rb_define_method(rb_cARGF, "readchar", argf_readchar, 0); + rb_define_method(rb_cARGF, "readbyte", argf_readbyte, 0); + rb_define_method(rb_cARGF, "tell", argf_tell, 0); + rb_define_method(rb_cARGF, "seek", argf_seek_m, -1); + rb_define_method(rb_cARGF, "rewind", argf_rewind, 0); + rb_define_method(rb_cARGF, "pos", argf_tell, 0); + rb_define_method(rb_cARGF, "pos=", argf_set_pos, 1); + rb_define_method(rb_cARGF, "eof", argf_eof, 0); + rb_define_method(rb_cARGF, "eof?", argf_eof, 0); + rb_define_method(rb_cARGF, "binmode", argf_binmode_m, 0); + rb_define_method(rb_cARGF, "binmode?", argf_binmode_p, 0); + + rb_define_method(rb_cARGF, "filename", argf_filename, 0); + rb_define_method(rb_cARGF, "path", argf_filename, 0); + rb_define_method(rb_cARGF, "file", argf_file, 0); + rb_define_method(rb_cARGF, "skip", argf_skip, 0); + rb_define_method(rb_cARGF, "close", argf_close_m, 0); + rb_define_method(rb_cARGF, "closed?", argf_closed, 0); + + rb_define_method(rb_cARGF, "lineno", argf_lineno, 0); + rb_define_method(rb_cARGF, "lineno=", argf_set_lineno, 1); + + rb_define_method(rb_cARGF, "inplace_mode", argf_inplace_mode_get, 0); + rb_define_method(rb_cARGF, "inplace_mode=", argf_inplace_mode_set, 1); + + rb_define_method(rb_cARGF, "external_encoding", argf_external_encoding, 0); + rb_define_method(rb_cARGF, "internal_encoding", argf_internal_encoding, 0); + rb_define_method(rb_cARGF, "set_encoding", argf_set_encoding, -1); + + argf = rb_class_new_instance(0, 0, rb_cARGF); + + rb_define_readonly_variable("$<", &argf); + rb_define_global_const("ARGF", argf); + + rb_define_hooked_variable("$.", &argf, argf_lineno_getter, argf_lineno_setter); + rb_define_hooked_variable("$FILENAME", &argf, argf_filename_getter, 0); + filename = rb_str_new2("-"); + + rb_define_hooked_variable("$-i", &argf, opt_i_get, opt_i_set); + rb_define_hooked_variable("$*", &argf, argf_argv_getter, 0); + +#if defined (_WIN32) || defined(DJGPP) || defined(__CYGWIN__) || defined(__human68k__) + atexit(pipe_atexit); +#endif + + Init_File(); + + rb_define_method(rb_cFile, "initialize", rb_file_initialize, -1); + + rb_file_const("RDONLY", INT2FIX(O_RDONLY)); + rb_file_const("WRONLY", INT2FIX(O_WRONLY)); + rb_file_const("RDWR", INT2FIX(O_RDWR)); + rb_file_const("APPEND", INT2FIX(O_APPEND)); + rb_file_const("CREAT", INT2FIX(O_CREAT)); + rb_file_const("EXCL", INT2FIX(O_EXCL)); +#if defined(O_NDELAY) || defined(O_NONBLOCK) +# ifdef O_NONBLOCK + rb_file_const("NONBLOCK", INT2FIX(O_NONBLOCK)); +# else + rb_file_const("NONBLOCK", INT2FIX(O_NDELAY)); +# endif +#endif + rb_file_const("TRUNC", INT2FIX(O_TRUNC)); +#ifdef O_NOCTTY + rb_file_const("NOCTTY", INT2FIX(O_NOCTTY)); +#endif +#ifdef O_BINARY + rb_file_const("BINARY", INT2FIX(O_BINARY)); +#else + rb_file_const("BINARY", INT2FIX(0)); +#endif +#ifdef O_SYNC + rb_file_const("SYNC", INT2FIX(O_SYNC)); +#endif +#ifdef O_DSYNC + rb_file_const("DSYNC", INT2FIX(O_DSYNC)); +#endif +#ifdef O_RSYNC + rb_file_const("RSYNC", INT2FIX(O_RSYNC)); +#endif +#ifdef O_NOFOLLOW + rb_file_const("NOFOLLOW", INT2FIX(O_NOFOLLOW)); /* FreeBSD, Linux */ +#endif + + sym_mode = ID2SYM(rb_intern("mode")); + sym_perm = ID2SYM(rb_intern("perm")); + sym_extenc = ID2SYM(rb_intern("external_encoding")); + sym_intenc = ID2SYM(rb_intern("internal_encoding")); + sym_encoding = ID2SYM(rb_intern("encoding")); + sym_open_args = ID2SYM(rb_intern("open_args")); + sym_textmode = ID2SYM(rb_intern("textmode")); + sym_binmode = ID2SYM(rb_intern("binmode")); +} |