mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
f8bdd8dd08
This caused failure when test/ruby/test_argf.rb is executed with GC.stress = true in mswin32_90 git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@28114 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
10109 lines
255 KiB
C
10109 lines
255 KiB
C
/**********************************************************************
|
|
|
|
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 "dln.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(__BOW__) || defined(__CYGWIN__) || defined(_WIN32) || defined(__EMX__) || defined(__BEOS__) || defined(__HAIKU__)
|
|
# define NO_SAFE_RENAME
|
|
#endif
|
|
|
|
#if 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(_WIN32)
|
|
#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);
|
|
|
|
#if defined(__BEOS__) || defined(__HAIKU__)
|
|
# 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
|
|
|
|
#define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
|
|
|
|
#define IO_RBUF_CAPA_MIN 8192
|
|
#define IO_CBUF_CAPA_MIN (128*1024)
|
|
#define IO_RBUF_CAPA_FOR(fptr) (NEED_READCONV(fptr) ? IO_CBUF_CAPA_MIN : IO_RBUF_CAPA_MIN)
|
|
#define IO_WBUF_CAPA_MIN 8192
|
|
|
|
/* define system APIs */
|
|
#ifdef _WIN32
|
|
#undef open
|
|
#define open rb_w32_uopen
|
|
#endif
|
|
|
|
VALUE rb_cIO;
|
|
VALUE rb_eEOFError;
|
|
VALUE rb_eIOError;
|
|
VALUE rb_mWaitReadable;
|
|
VALUE rb_mWaitWritable;
|
|
|
|
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, sym_autoclose;
|
|
|
|
struct timeval rb_time_interval(VALUE);
|
|
|
|
struct argf {
|
|
VALUE filename, current_file;
|
|
int last_lineno; /* $. */
|
|
int lineno;
|
|
int init_p, next_p;
|
|
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__) || defined(__HAIKU__)
|
|
# define STDIO_READ_DATA_PENDING(fp) (fp->_state._eof == 0)
|
|
#else
|
|
# define STDIO_READ_DATA_PENDING(fp) (!feof(fp))
|
|
#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_CHAR_PENDING(fptr) ((fptr)->cbuf_len)
|
|
#define READ_CHAR_PENDING_COUNT(fptr) ((fptr)->cbuf_len)
|
|
#define READ_CHAR_PENDING_PTR(fptr) ((fptr)->cbuf+(fptr)->cbuf_off)
|
|
|
|
#if defined(_WIN32)
|
|
#define WAIT_FD_IN_WIN32(fptr) \
|
|
(rb_w32_has_cancel_io() ? 0 : rb_thread_wait_fd((fptr)->fd))
|
|
#else
|
|
#define WAIT_FD_IN_WIN32(fptr)
|
|
#endif
|
|
|
|
#define READ_CHECK(fptr) do {\
|
|
if (!READ_DATA_PENDING(fptr)) {\
|
|
WAIT_FD_IN_WIN32(fptr);\
|
|
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(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
|
|
/* Windows */
|
|
# define NEED_NEWLINE_DECORATOR_ON_READ(fptr) (!(fptr->mode & FMODE_BINMODE))
|
|
# define NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) (!(fptr->mode & FMODE_BINMODE))
|
|
# define TEXTMODE_NEWLINE_DECORATOR_ON_WRITE ECONV_CRLF_NEWLINE_DECORATOR
|
|
#else
|
|
/* Unix */
|
|
# define NEED_NEWLINE_DECORATOR_ON_READ(fptr) (fptr->mode & FMODE_TEXTMODE)
|
|
# define NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) 0
|
|
#endif
|
|
#define NEED_READCONV(fptr) (fptr->encs.enc2 != NULL || NEED_NEWLINE_DECORATOR_ON_READ(fptr))
|
|
#define NEED_WRITECONV(fptr) ((fptr->encs.enc != NULL && fptr->encs.enc != rb_ascii8bit_encoding()) || NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) || (fptr->encs.ecflags & (ECONV_DECORATOR_MASK|ECONV_STATEFUL_DECORATOR_MASK)))
|
|
|
|
#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
|
|
*
|
|
* require 'zlib'
|
|
* f = open("/tmp/zz.gz") #=> #<File:/tmp/zz.gz>
|
|
* z = Zlib::GzipReader.open(f) #=> #<Zlib::GzipReader:0x81d8744>
|
|
* IO.try_convert(z) #=> #<File:/tmp/zz.gz>
|
|
*
|
|
*/
|
|
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 */
|
|
errno = 0;
|
|
r = lseek(fptr->fd, -fptr->rbuf_len, SEEK_CUR);
|
|
if (r < 0 && errno) {
|
|
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)
|
|
{
|
|
long len = RSTRING_LEN(str);
|
|
|
|
if (fptr->rbuf == NULL) {
|
|
const int min_capa = IO_RBUF_CAPA_FOR(fptr);
|
|
fptr->rbuf_off = 0;
|
|
fptr->rbuf_len = 0;
|
|
#if SIZEOF_LONG > SIZEOF_INT
|
|
if (len > INT_MAX)
|
|
rb_raise(rb_eIOError, "ungetbyte failed");
|
|
#endif
|
|
if (len > min_capa)
|
|
fptr->rbuf_capa = (int)len;
|
|
else
|
|
fptr->rbuf_capa = min_capa;
|
|
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-=(int)len;
|
|
fptr->rbuf_len+=(int)len;
|
|
MEMMOVE(fptr->rbuf+fptr->rbuf_off, RSTRING_PTR(str), char, len);
|
|
}
|
|
|
|
static rb_io_t *
|
|
flush_before_seek(rb_io_t *fptr)
|
|
{
|
|
if (io_fflush(fptr) < 0)
|
|
rb_sys_fail(0);
|
|
io_unread(fptr);
|
|
errno = 0;
|
|
return fptr;
|
|
}
|
|
|
|
#define io_set_eof(fptr) (void)(((fptr)->mode & FMODE_TTY) && ((fptr)->mode |= FMODE_EOF))
|
|
#define io_unset_eof(fptr) (fptr->mode &= ~FMODE_EOF)
|
|
#define io_seek(fptr, ofs, whence) (errno = 0, io_unset_eof(fptr), 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_char_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) {
|
|
if (io_fflush(fptr) < 0)
|
|
rb_sys_fail(0);
|
|
}
|
|
if (fptr->tied_io_for_writing) {
|
|
rb_io_t *wfptr;
|
|
GetOpenFile(fptr->tied_io_for_writing, wfptr);
|
|
if (io_fflush(wfptr) < 0)
|
|
rb_sys_fail(0);
|
|
}
|
|
}
|
|
|
|
void
|
|
rb_io_check_byte_readable(rb_io_t *fptr)
|
|
{
|
|
rb_io_check_char_readable(fptr);
|
|
if (READ_CHAR_PENDING(fptr)) {
|
|
rb_raise(rb_eIOError, "byte oriented read for character buffered IO");
|
|
}
|
|
}
|
|
|
|
void
|
|
rb_io_check_readable(rb_io_t *fptr)
|
|
{
|
|
rb_io_check_byte_readable(fptr);
|
|
}
|
|
|
|
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_io_read_pending(rb_io_t *fptr)
|
|
{
|
|
/* This function is used for bytes and chars. Confusing. */
|
|
if (READ_CHAR_PENDING(fptr))
|
|
return 1; /* should raise? */
|
|
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);
|
|
}
|
|
}
|
|
UPDATE_MAXFD(fd);
|
|
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 ssize_t
|
|
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 (ssize_t)rb_thread_blocking_region(internal_read_func, &iis, RUBY_UBF_IO, 0);
|
|
}
|
|
|
|
static ssize_t
|
|
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 (ssize_t)rb_thread_blocking_region(internal_write_func, &iis, RUBY_UBF_IO, 0);
|
|
}
|
|
|
|
static long
|
|
io_writable_length(rb_io_t *fptr, long l)
|
|
{
|
|
if (PIPE_BUF < l &&
|
|
!rb_thread_alone() &&
|
|
wsplit_p(fptr)) {
|
|
l = PIPE_BUF;
|
|
}
|
|
return l;
|
|
}
|
|
|
|
static VALUE
|
|
io_flush_buffer(VALUE arg)
|
|
{
|
|
rb_io_t *fptr = (rb_io_t *)arg;
|
|
long l = io_writable_length(fptr, fptr->wbuf_len);
|
|
return rb_write_internal(fptr->fd, fptr->wbuf+fptr->wbuf_off, l);
|
|
}
|
|
|
|
static int
|
|
io_fflush(rb_io_t *fptr)
|
|
{
|
|
long r;
|
|
|
|
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;
|
|
if (fptr->write_lock) {
|
|
r = rb_mutex_synchronize(fptr->write_lock, io_flush_buffer, (VALUE)fptr);
|
|
}
|
|
else {
|
|
long l = io_writable_length(fptr, fptr->wbuf_len);
|
|
r = rb_write_internal(fptr->fd, fptr->wbuf+fptr->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 += (int)r;
|
|
fptr->wbuf_len -= (int)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 TRUE;
|
|
|
|
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, rb_fd_ptr(&rfds), NULL, NULL, NULL);
|
|
#endif
|
|
return TRUE;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
#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 TRUE;
|
|
|
|
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, rb_fd_ptr(&wfds), NULL, NULL);
|
|
#endif
|
|
return TRUE;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
static void
|
|
make_writeconv(rb_io_t *fptr)
|
|
{
|
|
if (!fptr->writeconv_initialized) {
|
|
const char *senc, *denc;
|
|
rb_encoding *enc;
|
|
int ecflags;
|
|
VALUE ecopts;
|
|
|
|
fptr->writeconv_initialized = 1;
|
|
|
|
ecflags = fptr->encs.ecflags;
|
|
ecopts = fptr->encs.ecopts;
|
|
#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
|
|
if (NEED_NEWLINE_DECORATOR_ON_WRITE(fptr))
|
|
ecflags |= TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;
|
|
#endif
|
|
|
|
if (!fptr->encs.enc || (fptr->encs.enc == rb_ascii8bit_encoding() && !fptr->encs.enc2)) {
|
|
/* no encoding conversion */
|
|
fptr->writeconv_pre_ecflags = 0;
|
|
fptr->writeconv_pre_ecopts = Qnil;
|
|
fptr->writeconv = rb_econv_open_opts("", "", ecflags, ecopts);
|
|
if (!fptr->writeconv)
|
|
rb_exc_raise(rb_econv_open_exc("", "", ecflags));
|
|
fptr->writeconv_asciicompat = Qnil;
|
|
}
|
|
else {
|
|
enc = fptr->encs.enc2 ? fptr->encs.enc2 : fptr->encs.enc;
|
|
senc = rb_econv_asciicompat_encoding(rb_enc_name(enc));
|
|
if (!senc && !(fptr->encs.ecflags & ECONV_STATEFUL_DECORATOR_MASK)) {
|
|
/* single conversion */
|
|
fptr->writeconv_pre_ecflags = ecflags;
|
|
fptr->writeconv_pre_ecopts = ecopts;
|
|
fptr->writeconv = NULL;
|
|
fptr->writeconv_asciicompat = Qnil;
|
|
}
|
|
else {
|
|
/* double conversion */
|
|
fptr->writeconv_pre_ecflags = ecflags & ~ECONV_STATEFUL_DECORATOR_MASK;
|
|
fptr->writeconv_pre_ecopts = ecopts;
|
|
if (senc) {
|
|
denc = rb_enc_name(enc);
|
|
fptr->writeconv_asciicompat = rb_str_new2(senc);
|
|
}
|
|
else {
|
|
senc = denc = "";
|
|
fptr->writeconv_asciicompat = rb_str_new2(rb_enc_name(enc));
|
|
}
|
|
ecflags = fptr->encs.ecflags & (ECONV_ERROR_HANDLER_MASK|ECONV_STATEFUL_DECORATOR_MASK);
|
|
ecopts = fptr->encs.ecopts;
|
|
fptr->writeconv = rb_econv_open_opts(senc, denc, ecflags, ecopts);
|
|
if (!fptr->writeconv)
|
|
rb_exc_raise(rb_econv_open_exc(senc, denc, ecflags));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* writing functions */
|
|
struct binwrite_arg {
|
|
rb_io_t *fptr;
|
|
VALUE str;
|
|
long offset;
|
|
long length;
|
|
};
|
|
|
|
static VALUE
|
|
io_binwrite_string(VALUE arg)
|
|
{
|
|
struct binwrite_arg *p = (struct binwrite_arg *)arg;
|
|
long l = io_writable_length(p->fptr, p->length);
|
|
return rb_write_internal(p->fptr->fd, RSTRING_PTR(p->str)+p->offset, l);
|
|
}
|
|
|
|
static long
|
|
io_binwrite(VALUE str, rb_io_t *fptr, int nosync)
|
|
{
|
|
long len, n, r, offset = 0;
|
|
|
|
len = RSTRING_LEN(str);
|
|
if ((n = len) <= 0) return n;
|
|
if (fptr->wbuf == NULL && !(!nosync && (fptr->mode & FMODE_SYNC))) {
|
|
fptr->wbuf_off = 0;
|
|
fptr->wbuf_len = 0;
|
|
fptr->wbuf_capa = IO_WBUF_CAPA_MIN;
|
|
fptr->wbuf = ALLOC_N(char, fptr->wbuf_capa);
|
|
fptr->write_lock = rb_mutex_new();
|
|
}
|
|
if ((!nosync && (fptr->mode & (FMODE_SYNC|FMODE_TTY))) ||
|
|
(fptr->wbuf && fptr->wbuf_capa <= fptr->wbuf_len + len)) {
|
|
struct binwrite_arg arg;
|
|
|
|
/* 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 += (int)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);
|
|
}
|
|
arg.fptr = fptr;
|
|
arg.str = str;
|
|
retry:
|
|
arg.offset = offset;
|
|
arg.length = n;
|
|
if (fptr->write_lock) {
|
|
r = rb_mutex_synchronize(fptr->write_lock, io_binwrite_string, (VALUE)&arg);
|
|
}
|
|
else {
|
|
long l = io_writable_length(fptr, n);
|
|
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 += (int)len;
|
|
return len;
|
|
}
|
|
|
|
static VALUE
|
|
do_writeconv(VALUE str, rb_io_t *fptr)
|
|
{
|
|
if (NEED_WRITECONV(fptr)) {
|
|
VALUE common_encoding = Qnil;
|
|
|
|
make_writeconv(fptr);
|
|
|
|
if (fptr->writeconv) {
|
|
if (!NIL_P(fptr->writeconv_asciicompat))
|
|
common_encoding = fptr->writeconv_asciicompat;
|
|
else if (!rb_enc_asciicompat(rb_enc_get(str))) {
|
|
rb_raise(rb_eArgError, "ASCII incompatible string written for text mode IO without encoding conversion: %s",
|
|
rb_enc_name(rb_enc_get(str)));
|
|
}
|
|
}
|
|
else {
|
|
if (fptr->encs.enc2)
|
|
common_encoding = rb_enc_from_encoding(fptr->encs.enc2);
|
|
else if (fptr->encs.enc != rb_ascii8bit_encoding())
|
|
common_encoding = rb_enc_from_encoding(fptr->encs.enc);
|
|
}
|
|
|
|
if (!NIL_P(common_encoding)) {
|
|
str = rb_str_encode(str, common_encoding,
|
|
fptr->writeconv_pre_ecflags, fptr->writeconv_pre_ecopts);
|
|
}
|
|
|
|
if (fptr->writeconv) {
|
|
str = rb_econv_str_convert(fptr->writeconv, str, ECONV_PARTIAL_INPUT);
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static long
|
|
io_fwrite(VALUE str, rb_io_t *fptr, int nosync)
|
|
{
|
|
str = do_writeconv(str, fptr);
|
|
return io_binwrite(str, fptr, nosync);
|
|
}
|
|
|
|
static VALUE
|
|
io_write(VALUE io, VALUE str, int nosync)
|
|
{
|
|
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, nosync);
|
|
if (n == -1L) rb_sys_fail_path(fptr->pathv);
|
|
|
|
return LONG2FIX(n);
|
|
}
|
|
|
|
/*
|
|
* 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_m(VALUE io, VALUE str)
|
|
{
|
|
return io_write(io, str, 0);
|
|
}
|
|
|
|
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) {
|
|
if (io_fflush(fptr) < 0)
|
|
rb_sys_fail(0);
|
|
#ifdef _WIN32
|
|
fsync(fptr->fd);
|
|
#endif
|
|
}
|
|
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);
|
|
pos -= fptr->rbuf_len;
|
|
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=IO::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 && errno) rb_sys_fail_path(fptr->pathv);
|
|
|
|
return OFFT2NUM(pos);
|
|
}
|
|
|
|
static void clear_readconv(rb_io_t *fptr);
|
|
|
|
/*
|
|
* 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"
|
|
*
|
|
* Note that it cannot be used with streams such as pipes, ttys, and sockets.
|
|
*/
|
|
|
|
static VALUE
|
|
rb_io_rewind(VALUE io)
|
|
{
|
|
rb_io_t *fptr;
|
|
|
|
GetOpenFile(io, fptr);
|
|
if (io_seek(fptr, 0L, 0) < 0 && errno) rb_sys_fail_path(fptr->pathv);
|
|
if (io == ARGF.current_file) {
|
|
ARGF.lineno -= fptr->lineno;
|
|
}
|
|
fptr->lineno = 0;
|
|
if (fptr->readconv) {
|
|
clear_readconv(fptr);
|
|
}
|
|
|
|
return INT2FIX(0);
|
|
}
|
|
|
|
static int
|
|
io_fillbuf(rb_io_t *fptr)
|
|
{
|
|
ssize_t r;
|
|
|
|
if (fptr->mode & FMODE_EOF) {
|
|
return -1;
|
|
}
|
|
if (fptr->rbuf == NULL) {
|
|
fptr->rbuf_off = 0;
|
|
fptr->rbuf_len = 0;
|
|
fptr->rbuf_capa = IO_RBUF_CAPA_FOR(fptr);
|
|
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 = (int)r; /* r should be <= rbuf_capa */
|
|
if (r == 0) {
|
|
io_set_eof(fptr);
|
|
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 the input byte buffer.
|
|
* So <code>IO#sysread</code> may not behave as you intend with
|
|
* <code>IO#eof?</code>, unless you call <code>IO#rewind</code>
|
|
* first (which is not available for some streams).
|
|
*/
|
|
|
|
VALUE
|
|
rb_io_eof(VALUE io)
|
|
{
|
|
rb_io_t *fptr;
|
|
|
|
GetOpenFile(io, fptr);
|
|
rb_io_check_char_readable(fptr);
|
|
|
|
if (READ_CHAR_PENDING(fptr)) return Qfalse;
|
|
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 sync)
|
|
{
|
|
rb_io_t *fptr;
|
|
|
|
io = GetWriteIO(io);
|
|
GetOpenFile(io, fptr);
|
|
if (RTEST(sync)) {
|
|
fptr->mode |= FMODE_SYNC;
|
|
}
|
|
else {
|
|
fptr->mode &= ~FMODE_SYNC;
|
|
}
|
|
return sync;
|
|
}
|
|
|
|
#ifdef HAVE_FSYNC
|
|
/*
|
|
* call-seq:
|
|
* ios.fsync -> 0 or nil
|
|
*
|
|
* Immediately writes all buffered data in <em>ios</em> to disk.
|
|
* 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.
|
|
*
|
|
* <code>NotImplementedError</code> is raised
|
|
* if the underlying operating system does not support <em>fsync(2)</em>.
|
|
*/
|
|
|
|
static VALUE
|
|
rb_io_fsync(VALUE io)
|
|
{
|
|
rb_io_t *fptr;
|
|
|
|
io = GetWriteIO(io);
|
|
GetOpenFile(io, fptr);
|
|
|
|
if (io_fflush(fptr) < 0)
|
|
rb_sys_fail(0);
|
|
if (fsync(fptr->fd) < 0)
|
|
rb_sys_fail_path(fptr->pathv);
|
|
return INT2FIX(0);
|
|
}
|
|
#else
|
|
#define rb_io_fsync rb_f_notimplement
|
|
#endif
|
|
|
|
#ifdef HAVE_FDATASYNC
|
|
/*
|
|
* call-seq:
|
|
* ios.fdatasync -> 0 or nil
|
|
*
|
|
* Immediately writes all buffered data in <em>ios</em> to disk.
|
|
*
|
|
* <code>NotImplementedError</code> is raised
|
|
* if the underlying operating system does not support <em>fdatasync(2)</em>.
|
|
*/
|
|
|
|
static VALUE
|
|
rb_io_fdatasync(VALUE io)
|
|
{
|
|
rb_io_t *fptr;
|
|
|
|
io = GetWriteIO(io);
|
|
GetOpenFile(io, fptr);
|
|
|
|
if (io_fflush(fptr) < 0)
|
|
rb_sys_fail(0);
|
|
if (fdatasync(fptr->fd) < 0)
|
|
rb_sys_fail_path(fptr->pathv);
|
|
return INT2FIX(0);
|
|
}
|
|
#else
|
|
#define rb_io_fdatasync rb_f_notimplement
|
|
#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;
|
|
char fd_desc[4+sizeof(int)*3];
|
|
const char *path;
|
|
const char *st = "";
|
|
|
|
fptr = RFILE(rb_io_taint_check(obj))->fptr;
|
|
if (!fptr) return rb_any_to_s(obj);
|
|
cname = rb_obj_classname(obj);
|
|
if (NIL_P(fptr->pathv)) {
|
|
if (fptr->fd < 0) {
|
|
path = "";
|
|
st = "(closed)";
|
|
}
|
|
else {
|
|
snprintf(fd_desc, sizeof(fd_desc), "fd %d", fptr->fd);
|
|
path = fd_desc;
|
|
}
|
|
}
|
|
else {
|
|
path = RSTRING_PTR(fptr->pathv);
|
|
if (fptr->fd < 0) {
|
|
st = " (closed)";
|
|
}
|
|
}
|
|
return rb_sprintf("#<%s:%s%s>", cname, path, 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)
|
|
{
|
|
int n;
|
|
|
|
n = READ_DATA_PENDING_COUNT(fptr);
|
|
if (n <= 0) return 0;
|
|
if (n > len) n = (int)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;
|
|
long c;
|
|
|
|
rb_str_locktmp(str);
|
|
if (READ_DATA_PENDING(fptr) == 0) {
|
|
while (n > 0) {
|
|
again:
|
|
c = rb_read_internal(fptr->fd, RSTRING_PTR(str)+offset, n);
|
|
if (c == 0) {
|
|
io_set_eof(fptr);
|
|
break;
|
|
}
|
|
if (c < 0) {
|
|
if (rb_io_wait_readable(fptr->fd))
|
|
goto again;
|
|
rb_sys_fail_path(fptr->pathv);
|
|
}
|
|
offset += c;
|
|
if ((n -= c) <= 0) break;
|
|
rb_thread_wait_fd(fptr->fd);
|
|
}
|
|
rb_str_unlocktmp(str);
|
|
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;
|
|
}
|
|
}
|
|
rb_str_unlocktmp(str);
|
|
return len - 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)
|
|
#if defined(__BEOS__) || defined(__HAIKU__)
|
|
&& (st.st_dev > 3)
|
|
#endif
|
|
)
|
|
{
|
|
if (io_fflush(fptr) < 0)
|
|
rb_sys_fail(0);
|
|
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, int size)
|
|
{
|
|
if (!fptr->readconv) {
|
|
int ecflags;
|
|
VALUE ecopts;
|
|
const char *sname, *dname;
|
|
ecflags = fptr->encs.ecflags;
|
|
ecopts = fptr->encs.ecopts;
|
|
if (NEED_NEWLINE_DECORATOR_ON_READ(fptr))
|
|
ecflags |= ECONV_UNIVERSAL_NEWLINE_DECORATOR;
|
|
if (fptr->encs.enc2) {
|
|
sname = rb_enc_name(fptr->encs.enc2);
|
|
dname = rb_enc_name(fptr->encs.enc);
|
|
}
|
|
else {
|
|
sname = dname = "";
|
|
}
|
|
fptr->readconv = rb_econv_open_opts(sname, dname, ecflags, ecopts);
|
|
if (!fptr->readconv)
|
|
rb_exc_raise(rb_econv_open_exc(sname, dname, ecflags));
|
|
fptr->cbuf_off = 0;
|
|
fptr->cbuf_len = 0;
|
|
if (size < IO_CBUF_CAPA_MIN) size = IO_CBUF_CAPA_MIN;
|
|
fptr->cbuf_capa = size;
|
|
fptr->cbuf = ALLOC_N(char, fptr->cbuf_capa);
|
|
}
|
|
}
|
|
|
|
#define MORE_CHAR_SUSPENDED Qtrue
|
|
#define MORE_CHAR_FINISHED Qnil
|
|
static VALUE
|
|
fill_cbuf(rb_io_t *fptr, int ec_flags)
|
|
{
|
|
const unsigned char *ss, *sp, *se;
|
|
unsigned char *ds, *dp, *de;
|
|
rb_econv_result_t res;
|
|
int putbackable;
|
|
int cbuf_len0;
|
|
VALUE exc;
|
|
|
|
ec_flags |= ECONV_PARTIAL_INPUT;
|
|
|
|
if (fptr->cbuf_len == fptr->cbuf_capa)
|
|
return MORE_CHAR_SUSPENDED; /* cbuf full */
|
|
if (fptr->cbuf_len == 0)
|
|
fptr->cbuf_off = 0;
|
|
else if (fptr->cbuf_off + fptr->cbuf_len == fptr->cbuf_capa) {
|
|
memmove(fptr->cbuf, fptr->cbuf+fptr->cbuf_off, fptr->cbuf_len);
|
|
fptr->cbuf_off = 0;
|
|
}
|
|
|
|
cbuf_len0 = fptr->cbuf_len;
|
|
|
|
while (1) {
|
|
ss = sp = (const unsigned char *)fptr->rbuf + fptr->rbuf_off;
|
|
se = sp + fptr->rbuf_len;
|
|
ds = dp = (unsigned char *)fptr->cbuf + fptr->cbuf_off + fptr->cbuf_len;
|
|
de = (unsigned char *)fptr->cbuf + fptr->cbuf_capa;
|
|
res = rb_econv_convert(fptr->readconv, &sp, se, &dp, de, ec_flags);
|
|
fptr->rbuf_off += (int)(sp - ss);
|
|
fptr->rbuf_len -= (int)(sp - ss);
|
|
fptr->cbuf_len += (int)(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;
|
|
}
|
|
|
|
exc = rb_econv_make_exception(fptr->readconv);
|
|
if (!NIL_P(exc))
|
|
return exc;
|
|
|
|
if (cbuf_len0 != fptr->cbuf_len)
|
|
return MORE_CHAR_SUSPENDED;
|
|
|
|
if (res == econv_finished) {
|
|
return MORE_CHAR_FINISHED;
|
|
}
|
|
|
|
if (res == econv_source_buffer_empty) {
|
|
if (fptr->rbuf_len == 0) {
|
|
READ_CHECK(fptr);
|
|
if (io_fillbuf(fptr) == -1) {
|
|
ds = dp = (unsigned char *)fptr->cbuf + fptr->cbuf_off + fptr->cbuf_len;
|
|
de = (unsigned char *)fptr->cbuf + fptr->cbuf_capa;
|
|
res = rb_econv_convert(fptr->readconv, NULL, NULL, &dp, de, 0);
|
|
fptr->cbuf_len += (int)(dp - ds);
|
|
rb_econv_check_error(fptr->readconv);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
more_char(rb_io_t *fptr)
|
|
{
|
|
VALUE v;
|
|
v = fill_cbuf(fptr, ECONV_AFTER_OUTPUT);
|
|
if (v != MORE_CHAR_SUSPENDED && v != MORE_CHAR_FINISHED)
|
|
rb_exc_raise(v);
|
|
return v;
|
|
}
|
|
|
|
static VALUE
|
|
io_shift_cbuf(rb_io_t *fptr, int len, VALUE *strp)
|
|
{
|
|
VALUE str = Qnil;
|
|
if (strp) {
|
|
str = *strp;
|
|
if (NIL_P(str)) {
|
|
*strp = str = rb_str_new(fptr->cbuf+fptr->cbuf_off, len);
|
|
}
|
|
else {
|
|
rb_str_cat(str, fptr->cbuf+fptr->cbuf_off, len);
|
|
}
|
|
OBJ_TAINT(str);
|
|
rb_enc_associate(str, fptr->encs.enc);
|
|
}
|
|
fptr->cbuf_off += len;
|
|
fptr->cbuf_len -= len;
|
|
/* xxx: set coderange */
|
|
if (fptr->cbuf_len == 0)
|
|
fptr->cbuf_off = 0;
|
|
else if (fptr->cbuf_capa/2 < fptr->cbuf_off) {
|
|
memmove(fptr->cbuf, fptr->cbuf+fptr->cbuf_off, fptr->cbuf_len);
|
|
fptr->cbuf_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)) {
|
|
if (NIL_P(str)) str = rb_str_new(NULL, 0);
|
|
else rb_str_set_len(str, 0);
|
|
make_readconv(fptr, 0);
|
|
while (1) {
|
|
VALUE v;
|
|
if (fptr->cbuf_len) {
|
|
io_shift_cbuf(fptr, fptr->cbuf_len, &str);
|
|
}
|
|
v = fill_cbuf(fptr, 0);
|
|
if (v != MORE_CHAR_SUSPENDED && v != MORE_CHAR_FINISHED) {
|
|
if (fptr->cbuf_len) {
|
|
io_shift_cbuf(fptr, fptr->cbuf_len, &str);
|
|
}
|
|
rb_exc_raise(v);
|
|
}
|
|
if (v == MORE_CHAR_FINISHED) {
|
|
clear_readconv(fptr);
|
|
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 oflags;
|
|
#ifdef F_GETFL
|
|
oflags = fcntl(fptr->fd, F_GETFL);
|
|
if (oflags == -1) {
|
|
rb_sys_fail_path(fptr->pathv);
|
|
}
|
|
#else
|
|
oflags = 0;
|
|
#endif
|
|
if ((oflags & O_NONBLOCK) == 0) {
|
|
oflags |= O_NONBLOCK;
|
|
if (fcntl(fptr->fd, F_SETFL, oflags) == -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_byte_readable(fptr);
|
|
|
|
if (len == 0)
|
|
return str;
|
|
|
|
if (!nonblock)
|
|
READ_CHECK(fptr);
|
|
n = read_buffered_data(RSTRING_PTR(str), len, fptr);
|
|
if (n <= 0) {
|
|
again:
|
|
if (nonblock) {
|
|
rb_io_set_nonblock(fptr);
|
|
}
|
|
rb_str_locktmp(str);
|
|
n = rb_read_internal(fptr->fd, RSTRING_PTR(str), len);
|
|
rb_str_unlocktmp(str);
|
|
if (n < 0) {
|
|
if (!nonblock && rb_io_wait_readable(fptr->fd))
|
|
goto again;
|
|
if (nonblock && (errno == EWOULDBLOCK || errno == EAGAIN))
|
|
rb_mod_sys_fail(rb_mWaitReadable, "read would block");
|
|
rb_sys_fail_path(fptr->pathv);
|
|
}
|
|
else if (n == 0) {
|
|
io_set_eof(fptr);
|
|
}
|
|
}
|
|
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 byte 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 byte 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 byte buffer is not empty, read from the byte buffer instead of "sysread for buffered IO (IOError)".
|
|
* * It doesn't cause Errno::EWOULDBLOCK and Errno::EINTR. When readpartial meets EWOULDBLOCK 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::EWOULDBLOCK 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
|
|
* the 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 the read(2) system call.
|
|
* It causes all errors the read(2) system call causes: Errno::EWOULDBLOCK, Errno::EINTR, etc.
|
|
* The caller should care such errors.
|
|
*
|
|
* If the exception is Errno::EWOULDBLOCK or Errno::AGAIN,
|
|
* it is extended by IO::WaitReadable.
|
|
* So IO::WaitReadable can be used to rescue the exceptions for retrying read_nonblock.
|
|
*
|
|
* read_nonblock causes EOFError on EOF.
|
|
*
|
|
* If the read byte buffer is not empty,
|
|
* read_nonblock reads from the buffer like readpartial.
|
|
* In this case, the read(2) system call is not called.
|
|
*
|
|
* When read_nonblock raises an exception kind of IO::WaitReadable,
|
|
* read_nonblock should not be called
|
|
* until io is readable for avoiding busy loop.
|
|
* This can be done as follows.
|
|
*
|
|
* # emulates blocking read (readpartial).
|
|
* begin
|
|
* result = io.read_nonblock(maxlen)
|
|
* rescue IO::WaitReadable
|
|
* IO.select([io])
|
|
* retry
|
|
* end
|
|
*
|
|
* Although IO#read_nonblock doesn't raise IO::WaitWritable.
|
|
* OpenSSL::Buffering#read_nonblock can raise IO::WaitWritable.
|
|
* If IO and SSL should be used polymorphically,
|
|
* IO::WaitWritable should be rescued too.
|
|
* See the document of OpenSSL::Buffering#read_nonblock for sample code.
|
|
*
|
|
* Note that this method is identical to readpartial
|
|
* except the non-blocking flag is set.
|
|
*/
|
|
|
|
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
|
|
* the write(2) system call after O_NONBLOCK is set for
|
|
* the underlying file descriptor.
|
|
*
|
|
* It returns the number of bytes written.
|
|
*
|
|
* write_nonblock just calls the write(2) system call.
|
|
* It causes all errors the write(2) system call causes: Errno::EWOULDBLOCK, Errno::EINTR, etc.
|
|
* The result may also be smaller than string.length (partial write).
|
|
* The caller should care such errors and partial write.
|
|
*
|
|
* If the exception is Errno::EWOULDBLOCK or Errno::AGAIN,
|
|
* it is extended by IO::WaitWritable.
|
|
* So IO::WaitWritable can be used to rescue the exceptions for retrying write_nonblock.
|
|
*
|
|
* # Creates a pipe.
|
|
* r, w = IO.pipe
|
|
*
|
|
* # write_nonblock writes only 65536 bytes and return 65536.
|
|
* # (The pipe size is 65536 bytes on this environment.)
|
|
* s = "a" * 100000
|
|
* p w.write_nonblock(s) #=> 65536
|
|
*
|
|
* # write_nonblock cannot write a byte and raise EWOULDBLOCK (EAGAIN).
|
|
* p w.write_nonblock("b") # Resource temporarily unavailable (Errno::EAGAIN)
|
|
*
|
|
* If the write buffer is not empty, it is flushed at first.
|
|
*
|
|
* When write_nonblock raises an exception kind of IO::WaitWritable,
|
|
* write_nonblock should not be called
|
|
* until io is writable for avoiding busy loop.
|
|
* This can be done as follows.
|
|
*
|
|
* begin
|
|
* result = io.write_nonblock(string)
|
|
* rescue IO::WaitWritable, Errno::EINTR
|
|
* IO.select(nil, [io])
|
|
* retry
|
|
* end
|
|
*
|
|
* Note that this doesn't guarantee to write all data in string.
|
|
* The length written is reported as result and it should be checked later.
|
|
*
|
|
* On some platforms such as Windows, write_nonblock is not supported
|
|
* according to the kind of the IO object.
|
|
* In such cases, write_nonblock raises <code>Errno::EBADF</code>.
|
|
*
|
|
*/
|
|
|
|
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);
|
|
|
|
if (io_fflush(fptr) < 0)
|
|
rb_sys_fail(0);
|
|
|
|
rb_io_set_nonblock(fptr);
|
|
n = write(fptr->fd, RSTRING_PTR(str), RSTRING_LEN(str));
|
|
|
|
if (n == -1) {
|
|
if (errno == EWOULDBLOCK || errno == EAGAIN)
|
|
rb_mod_sys_fail(rb_mWaitWritable, "write would block");
|
|
rb_sys_fail_path(fptr->pathv);
|
|
}
|
|
|
|
return LONG2FIX(n);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ios.read([length [, buffer]]) -> string, buffer, or nil
|
|
*
|
|
* Reads <i>length</i> bytes from the I/O stream.
|
|
*
|
|
* <i>length</i> must be a non-negative integer or <code>nil</code>.
|
|
*
|
|
* If <i>length</i> is a positive integer,
|
|
* it try to read <i>length</i> bytes without any conversion (binary mode).
|
|
* It returns <code>nil</code> or a string whose length is 1 to <i>length</i> bytes.
|
|
* <code>nil</code> means it met EOF at beginning.
|
|
* The 1 to <i>length</i>-1 bytes string means it met EOF after reading the result.
|
|
* The <i>length</i> bytes string means it doesn't meet EOF.
|
|
* The resulted string is always ASCII-8BIT encoding.
|
|
*
|
|
* If <i>length</i> is omitted or is <code>nil</code>,
|
|
* it reads until EOF and the encoding conversion is applied.
|
|
* It returns a string even if EOF is met at beginning.
|
|
*
|
|
* If <i>length</i> is zero, it returns <code>""</code>.
|
|
*
|
|
* 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 <code>nil</code>.
|
|
*
|
|
* f = File.new("testfile")
|
|
* f.read(16) #=> "This is line one"
|
|
*
|
|
* # reads whole file
|
|
* open("file") {|f|
|
|
* data = f.read # This returns a string even if the file is empty.
|
|
* ...
|
|
* }
|
|
*
|
|
* # iterate over fixed length records.
|
|
* open("fixed-record-file") {|f|
|
|
* while record = f.read(256)
|
|
* ...
|
|
* end
|
|
* }
|
|
*
|
|
* # iterate over variable length records.
|
|
* # record is prefixed by 32-bit length.
|
|
* open("variable-record-file") {|f|
|
|
* while len = f.read(4)
|
|
* len = len.unpack("N")[0] # 32-bit length
|
|
* record = f.read(len) # This returns a string even if len is 0.
|
|
* end
|
|
* }
|
|
*
|
|
* Note that this method behaves like fread() function in C.
|
|
* If you need the behavior like read(2) system call,
|
|
* consider readpartial, read_nonblock and sysread.
|
|
*/
|
|
|
|
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_char_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_byte_readable(fptr);
|
|
if (len == 0) return str;
|
|
|
|
READ_CHECK(fptr);
|
|
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);
|
|
OBJ_TAINT(str);
|
|
|
|
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, 0);
|
|
do {
|
|
const char *p, *e;
|
|
int searchlen;
|
|
if (fptr->cbuf_len) {
|
|
p = fptr->cbuf+fptr->cbuf_off;
|
|
searchlen = fptr->cbuf_len;
|
|
if (0 < limit && limit < searchlen)
|
|
searchlen = (int)limit;
|
|
e = memchr(p, delim, searchlen);
|
|
if (e) {
|
|
int len = (int)(e-p+1);
|
|
if (NIL_P(str))
|
|
*strp = str = rb_str_new(p, len);
|
|
else
|
|
rb_str_buf_cat(str, p, len);
|
|
fptr->cbuf_off += len;
|
|
fptr->cbuf_len -= len;
|
|
limit -= len;
|
|
*lp = limit;
|
|
return delim;
|
|
}
|
|
|
|
if (NIL_P(str))
|
|
*strp = str = rb_str_new(p, searchlen);
|
|
else
|
|
rb_str_buf_cat(str, p, searchlen);
|
|
fptr->cbuf_off += searchlen;
|
|
fptr->cbuf_len -= searchlen;
|
|
limit -= searchlen;
|
|
|
|
if (limit == 0) {
|
|
*lp = limit;
|
|
return (unsigned char)RSTRING_PTR(str)[RSTRING_LEN(str)-1];
|
|
}
|
|
}
|
|
} while (more_char(fptr) != MORE_CHAR_FINISHED);
|
|
clear_readconv(fptr);
|
|
*lp = limit;
|
|
return EOF;
|
|
}
|
|
|
|
do {
|
|
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];
|
|
}
|
|
READ_CHECK(fptr);
|
|
} while (io_fillbuf(fptr) >= 0);
|
|
*lp = limit;
|
|
return EOF;
|
|
}
|
|
|
|
static inline int
|
|
swallow(rb_io_t *fptr, int term)
|
|
{
|
|
if (NEED_READCONV(fptr)) {
|
|
rb_encoding *enc = io_read_encoding(fptr);
|
|
int needconv = rb_enc_mbminlen(enc) != 1;
|
|
make_readconv(fptr, 0);
|
|
do {
|
|
size_t cnt;
|
|
while ((cnt = READ_CHAR_PENDING_COUNT(fptr)) > 0) {
|
|
const char *p = READ_CHAR_PENDING_PTR(fptr);
|
|
int i;
|
|
if (needconv) {
|
|
if (*p != term) return TRUE;
|
|
while (--i && *++p == term);
|
|
}
|
|
else {
|
|
const char *e = p + cnt;
|
|
if (rb_enc_ascget(p, e, &i, enc) != term) return TRUE;
|
|
while ((p += i) < e && rb_enc_ascget(p, e, &i, enc) == term);
|
|
i = (int)(e - p);
|
|
}
|
|
io_shift_cbuf(fptr, (int)cnt - i, NULL);
|
|
}
|
|
} while (more_char(fptr) != MORE_CHAR_FINISHED);
|
|
return FALSE;
|
|
}
|
|
|
|
do {
|
|
size_t 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 TRUE;
|
|
i = (int)cnt;
|
|
while (--i && *++p == term);
|
|
if (!read_buffered_data(buf, cnt - i, fptr)) /* must not fail */
|
|
rb_sys_fail_path(fptr->pathv);
|
|
}
|
|
READ_CHECK(fptr);
|
|
} while (io_fillbuf(fptr) == 0);
|
|
return FALSE;
|
|
}
|
|
|
|
static VALUE
|
|
rb_io_getline_fast(rb_io_t *fptr, rb_encoding *enc, VALUE io)
|
|
{
|
|
VALUE str = Qnil;
|
|
int len = 0;
|
|
long pos = 0;
|
|
int cr = 0;
|
|
|
|
for (;;) {
|
|
int 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 = (int)(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;
|
|
}
|
|
READ_CHECK(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++;
|
|
if (io == ARGF.current_file) {
|
|
ARGF.lineno++;
|
|
ARGF.last_lineno = ARGF.lineno;
|
|
}
|
|
else {
|
|
ARGF.last_lineno = 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_char_readable(fptr);
|
|
if (NIL_P(rs) && limit < 0) {
|
|
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, io);
|
|
}
|
|
else {
|
|
int c, newline = -1;
|
|
const char *rsptr = 0;
|
|
long rslen = 0;
|
|
int rspara = 0;
|
|
int extra_limit = 16;
|
|
|
|
if (!NIL_P(rs)) {
|
|
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];
|
|
}
|
|
|
|
/* MS - Optimisation */
|
|
enc = io_read_encoding(fptr);
|
|
while ((c = appendline(fptr, newline, &str, &limit)) != EOF) {
|
|
const char *s, *p, *pp, *e;
|
|
|
|
if (c == newline) {
|
|
if (RSTRING_LEN(str) < rslen) continue;
|
|
s = RSTRING_PTR(str);
|
|
e = s + RSTRING_LEN(str);
|
|
p = e - rslen;
|
|
pp = rb_enc_left_char_head(s, p, e, 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, p, 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++;
|
|
if (io == ARGF.current_file) {
|
|
ARGF.lineno++;
|
|
ARGF.last_lineno = ARGF.lineno;
|
|
}
|
|
else {
|
|
ARGF.last_lineno = 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 in bytes.
|
|
*
|
|
* 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_char_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_char_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 in bytes. 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(...) -> an_enumerator
|
|
*
|
|
* ios.each_line(sep=$/) {|line| block } -> ios
|
|
* ios.each_line(limit) {|line| block } -> ios
|
|
* ios.each_line(sep,limit) {|line| block } -> ios
|
|
* ios.each_line(...) -> an_enumerator
|
|
*
|
|
* ios.lines(sep=$/) {|line| block } -> ios
|
|
* ios.lines(limit) {|line| block } -> ios
|
|
* ios.lines(sep,limit) {|line| block } -> ios
|
|
* ios.lines(...) -> an_enumerator
|
|
*
|
|
* 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.
|
|
*
|
|
* If no block is given, an enumerator is returned instead.
|
|
*
|
|
* 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.bytes {|byte| block } -> ios
|
|
* ios.bytes -> an_enumerator
|
|
*
|
|
* ios.each_byte {|byte| block } -> ios
|
|
* ios.each_byte -> an_enumerator
|
|
*
|
|
* 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.
|
|
*
|
|
* If no block is given, an enumerator is returned instead.
|
|
*
|
|
* 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_byte_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;
|
|
rb_encoding *read_enc = io_read_encoding(fptr);
|
|
|
|
make_readconv(fptr, 0);
|
|
|
|
while (1) {
|
|
if (fptr->cbuf_len) {
|
|
r = rb_enc_precise_mbclen(fptr->cbuf+fptr->cbuf_off,
|
|
fptr->cbuf+fptr->cbuf_off+fptr->cbuf_len,
|
|
read_enc);
|
|
if (!MBCLEN_NEEDMORE_P(r))
|
|
break;
|
|
if (fptr->cbuf_len == fptr->cbuf_capa) {
|
|
rb_raise(rb_eIOError, "too long character");
|
|
}
|
|
}
|
|
|
|
if (more_char(fptr) == MORE_CHAR_FINISHED) {
|
|
if (fptr->cbuf_len == 0) {
|
|
clear_readconv(fptr);
|
|
return Qnil;
|
|
}
|
|
/* return an unit of an incomplete character just before EOF */
|
|
str = rb_enc_str_new(fptr->cbuf+fptr->cbuf_off, 1, read_enc);
|
|
fptr->cbuf_off += 1;
|
|
fptr->cbuf_len -= 1;
|
|
if (fptr->cbuf_len == 0) clear_readconv(fptr);
|
|
ENC_CODERANGE_SET(str, ENC_CODERANGE_BROKEN);
|
|
return str;
|
|
}
|
|
}
|
|
if (MBCLEN_INVALID_P(r)) {
|
|
r = rb_enc_mbclen(fptr->cbuf+fptr->cbuf_off,
|
|
fptr->cbuf+fptr->cbuf_off+fptr->cbuf_len,
|
|
read_enc);
|
|
io_shift_cbuf(fptr, r, &str);
|
|
cr = ENC_CODERANGE_BROKEN;
|
|
}
|
|
else {
|
|
io_shift_cbuf(fptr, MBCLEN_CHARFOUND_LEN(r), &str);
|
|
cr = ENC_CODERANGE_VALID;
|
|
}
|
|
str = io_enc_str(str, fptr);
|
|
ENC_CODERANGE_SET(str, cr);
|
|
return 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.chars {|c| block } -> ios
|
|
* ios.chars -> an_enumerator
|
|
*
|
|
* ios.each_char {|c| block } -> ios
|
|
* ios.each_char -> an_enumerator
|
|
*
|
|
* 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.
|
|
*
|
|
* If no block is given, an enumerator is returned instead.
|
|
*
|
|
* 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_char_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.each_codepoint {|c| block } -> ios
|
|
* ios.codepoints {|c| block } -> ios
|
|
* ios.each_codepoint -> an_enumerator
|
|
* ios.codepoints -> an_enumerator
|
|
*
|
|
* Passes the <code>Integer</code> ordinal of each character in <i>ios</i>,
|
|
* passing the codepoint as an argument. The stream must be opened for
|
|
* reading or an <code>IOError</code> will be raised.
|
|
*
|
|
* If no block is given, an enumerator is returned instead.
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
rb_io_each_codepoint(VALUE io)
|
|
{
|
|
rb_io_t *fptr;
|
|
rb_encoding *enc;
|
|
unsigned int c;
|
|
int r, n;
|
|
|
|
RETURN_ENUMERATOR(io, 0, 0);
|
|
GetOpenFile(io, fptr);
|
|
rb_io_check_char_readable(fptr);
|
|
|
|
READ_CHECK(fptr);
|
|
if (NEED_READCONV(fptr)) {
|
|
for (;;) {
|
|
make_readconv(fptr, 0);
|
|
for (;;) {
|
|
if (fptr->cbuf_len) {
|
|
if (fptr->encs.enc)
|
|
r = rb_enc_precise_mbclen(fptr->cbuf+fptr->cbuf_off,
|
|
fptr->cbuf+fptr->cbuf_off+fptr->cbuf_len,
|
|
fptr->encs.enc);
|
|
else
|
|
r = ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(1);
|
|
if (!MBCLEN_NEEDMORE_P(r))
|
|
break;
|
|
if (fptr->cbuf_len == fptr->cbuf_capa) {
|
|
rb_raise(rb_eIOError, "too long character");
|
|
}
|
|
}
|
|
if (more_char(fptr) == MORE_CHAR_FINISHED) {
|
|
clear_readconv(fptr);
|
|
/* ignore an incomplete character before EOF */
|
|
return io;
|
|
}
|
|
}
|
|
if (MBCLEN_INVALID_P(r)) {
|
|
rb_raise(rb_eArgError, "invalid byte sequence in %s",
|
|
rb_enc_name(fptr->encs.enc));
|
|
}
|
|
n = MBCLEN_CHARFOUND_LEN(r);
|
|
if (fptr->encs.enc) {
|
|
c = rb_enc_codepoint(fptr->cbuf+fptr->cbuf_off,
|
|
fptr->cbuf+fptr->cbuf_off+fptr->cbuf_len,
|
|
fptr->encs.enc);
|
|
}
|
|
else {
|
|
c = (unsigned char)fptr->cbuf[fptr->cbuf_off];
|
|
}
|
|
fptr->cbuf_off += n;
|
|
fptr->cbuf_len -= n;
|
|
rb_yield(UINT2NUM(c));
|
|
}
|
|
}
|
|
enc = io_input_encoding(fptr);
|
|
for (;;) {
|
|
if (io_fillbuf(fptr) < 0) {
|
|
return io;
|
|
}
|
|
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) {
|
|
c = rb_enc_codepoint(fptr->rbuf+fptr->rbuf_off,
|
|
fptr->rbuf+fptr->rbuf_off+fptr->rbuf_len, enc);
|
|
fptr->rbuf_off += n;
|
|
fptr->rbuf_len -= n;
|
|
rb_yield(UINT2NUM(c));
|
|
}
|
|
else if (MBCLEN_INVALID_P(r)) {
|
|
rb_raise(rb_eArgError, "invalid byte sequence in %s", rb_enc_name(enc));
|
|
}
|
|
else {
|
|
continue;
|
|
}
|
|
}
|
|
return io;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* call-seq:
|
|
* ios.getc -> string 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 #=> "h"
|
|
* f.getc #=> "e"
|
|
*/
|
|
|
|
static VALUE
|
|
rb_io_getc(VALUE io)
|
|
{
|
|
rb_io_t *fptr;
|
|
rb_encoding *enc;
|
|
|
|
GetOpenFile(io, fptr);
|
|
rb_io_check_char_readable(fptr);
|
|
|
|
enc = io_input_encoding(fptr);
|
|
READ_CHECK(fptr);
|
|
return io_getc(fptr, enc);
|
|
}
|
|
|
|
/*
|
|
* 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 #=> "h"
|
|
* f.readchar #=> "e"
|
|
*/
|
|
|
|
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_byte_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 byte as with <code>IO#getbyte</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_byte_readable(fptr);
|
|
io_unset_eof(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 character 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_char_readable(fptr);
|
|
io_unset_eof(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)) {
|
|
len = RSTRING_LEN(c);
|
|
#if SIZEOF_LONG > SIZEOF_INT
|
|
if (len > INT_MAX)
|
|
rb_raise(rb_eIOError, "ungetc failed");
|
|
#endif
|
|
make_readconv(fptr, (int)len);
|
|
if (fptr->cbuf_capa - fptr->cbuf_len < len)
|
|
rb_raise(rb_eIOError, "ungetc failed");
|
|
if (fptr->cbuf_off < len) {
|
|
MEMMOVE(fptr->cbuf+fptr->cbuf_capa-fptr->cbuf_len,
|
|
fptr->cbuf+fptr->cbuf_off,
|
|
char, fptr->cbuf_len);
|
|
fptr->cbuf_off = fptr->cbuf_capa-fptr->cbuf_len;
|
|
}
|
|
fptr->cbuf_off -= (int)len;
|
|
fptr->cbuf_len += (int)len;
|
|
MEMMOVE(fptr->cbuf+fptr->cbuf_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;
|
|
}
|
|
|
|
#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
|
|
/*
|
|
* 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)
|
|
{
|
|
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
|
|
#define rb_io_close_on_exec_p rb_f_notimplement
|
|
#endif
|
|
|
|
#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
|
|
/*
|
|
* 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)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
return Qnil;
|
|
}
|
|
#else
|
|
#define rb_io_set_close_on_exec rb_f_notimplement
|
|
#endif
|
|
|
|
#define FMODE_PREP (1<<16)
|
|
#define IS_PREP_STDIO(f) ((f)->mode & FMODE_PREP)
|
|
#define PREP_STDIO_NAME(f) (RSTRING_PTR((f)->pathv))
|
|
|
|
static VALUE
|
|
finish_writeconv(rb_io_t *fptr, int noalloc)
|
|
{
|
|
unsigned char *ds, *dp, *de;
|
|
rb_econv_result_t res;
|
|
|
|
if (!fptr->wbuf) {
|
|
unsigned char buf[1024];
|
|
long 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 (fptr->fd < 0)
|
|
return noalloc ? Qtrue : rb_exc_new3(rb_eIOError, rb_str_new_cstr("closed stream"));
|
|
goto retry;
|
|
}
|
|
return noalloc ? Qtrue : INT2NUM(errno);
|
|
}
|
|
if (res == econv_invalid_byte_sequence ||
|
|
res == econv_incomplete_input ||
|
|
res == econv_undefined_conversion) {
|
|
return noalloc ? Qtrue : rb_econv_make_exception(fptr->writeconv);
|
|
}
|
|
}
|
|
|
|
return Qnil;
|
|
}
|
|
|
|
res = econv_destination_buffer_full;
|
|
while (res == econv_destination_buffer_full) {
|
|
if (fptr->wbuf_len == fptr->wbuf_capa) {
|
|
if (io_fflush(fptr) < 0)
|
|
return noalloc ? Qtrue : INT2NUM(errno);
|
|
}
|
|
|
|
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 += (int)(dp - ds);
|
|
if (res == econv_invalid_byte_sequence ||
|
|
res == econv_incomplete_input ||
|
|
res == econv_undefined_conversion) {
|
|
return noalloc ? Qtrue : rb_econv_make_exception(fptr->writeconv);
|
|
}
|
|
}
|
|
return Qnil;
|
|
}
|
|
|
|
struct finish_writeconv_arg {
|
|
rb_io_t *fptr;
|
|
int noalloc;
|
|
};
|
|
|
|
static VALUE
|
|
finish_writeconv_sync(VALUE arg)
|
|
{
|
|
struct finish_writeconv_arg *p = (struct finish_writeconv_arg *)arg;
|
|
return finish_writeconv(p->fptr, p->noalloc);
|
|
}
|
|
|
|
static void
|
|
fptr_finalize(rb_io_t *fptr, int noraise)
|
|
{
|
|
VALUE err = Qnil;
|
|
if (fptr->writeconv) {
|
|
if (fptr->write_lock) {
|
|
struct finish_writeconv_arg arg;
|
|
arg.fptr = fptr;
|
|
arg.noalloc = noraise;
|
|
err = rb_mutex_synchronize(fptr->write_lock, finish_writeconv_sync, (VALUE)&arg);
|
|
}
|
|
else {
|
|
err = finish_writeconv(fptr, noraise);
|
|
}
|
|
}
|
|
if (fptr->wbuf_len) {
|
|
if (io_fflush(fptr) < 0 && NIL_P(err))
|
|
err = noraise ? Qtrue : INT2NUM(errno);
|
|
}
|
|
if (IS_PREP_STDIO(fptr) || fptr->fd <= 2) {
|
|
goto skip_fd_close;
|
|
}
|
|
if (fptr->stdio_file) {
|
|
/* fptr->stdio_file is deallocated anyway
|
|
* even if fclose failed. */
|
|
if (fclose(fptr->stdio_file) < 0 && NIL_P(err))
|
|
err = noraise ? Qtrue : INT2NUM(errno);
|
|
}
|
|
else if (0 <= fptr->fd) {
|
|
/* fptr->fd may be closed even if close fails.
|
|
* POSIX doesn't specify it.
|
|
* We assumes it is closed. */
|
|
if (close(fptr->fd) < 0 && NIL_P(err))
|
|
err = noraise ? Qtrue : INT2NUM(errno);
|
|
}
|
|
skip_fd_close:
|
|
fptr->fd = -1;
|
|
fptr->stdio_file = 0;
|
|
fptr->mode &= ~(FMODE_READABLE|FMODE_WRITABLE);
|
|
|
|
if (!NIL_P(err) && !noraise) {
|
|
switch(TYPE(err)) {
|
|
case T_FIXNUM:
|
|
case T_BIGNUM:
|
|
errno = NUM2INT(err);
|
|
rb_sys_fail_path(fptr->pathv);
|
|
|
|
default:
|
|
rb_exc_raise(err);
|
|
}
|
|
}
|
|
}
|
|
|
|
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->cbuf) {
|
|
free(fptr->cbuf);
|
|
fptr->cbuf = 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;
|
|
fptr->pathv = Qnil;
|
|
fptr->write_lock = 0;
|
|
if (0 <= fptr->fd)
|
|
rb_io_fptr_cleanup(fptr, TRUE);
|
|
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;
|
|
}
|
|
|
|
size_t rb_econv_memsize(rb_econv_t *);
|
|
|
|
size_t
|
|
rb_io_memsize(rb_io_t *fptr)
|
|
{
|
|
size_t size = sizeof(rb_io_t);
|
|
size += fptr->rbuf_capa;
|
|
size += fptr->wbuf_capa;
|
|
size += fptr->cbuf_capa;
|
|
if (fptr->readconv) size += rb_econv_memsize(fptr->readconv);
|
|
if (fptr->writeconv) size += rb_econv_memsize(fptr->writeconv);
|
|
return size;
|
|
}
|
|
|
|
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, TRUE);
|
|
}
|
|
}
|
|
|
|
fptr = RFILE(io)->fptr;
|
|
if (!fptr) return Qnil;
|
|
if (fptr->fd < 0) return Qnil;
|
|
|
|
fd = fptr->fd;
|
|
rb_io_fptr_cleanup(fptr, FALSE);
|
|
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;
|
|
rb_io_fptr_cleanup(fptr, FALSE);
|
|
GetOpenFile(write_io, wfptr);
|
|
RFILE(io)->fptr = wfptr;
|
|
RFILE(write_io)->fptr = NULL;
|
|
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=IO::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) || READ_CHAR_PENDING(fptr))) {
|
|
rb_raise(rb_eIOError, "sysseek for buffered IO");
|
|
}
|
|
if ((fptr->mode & FMODE_WRITABLE) && fptr->wbuf_len) {
|
|
rb_warn("sysseek for buffered IO");
|
|
}
|
|
errno = 0;
|
|
pos = lseek(fptr->fd, pos, whence);
|
|
if (pos == -1 && errno) 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);
|
|
}
|
|
|
|
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.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_byte_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);
|
|
|
|
rb_str_locktmp(str);
|
|
n = rb_read_internal(fptr->fd, RSTRING_PTR(str), ilen);
|
|
rb_str_unlocktmp(str);
|
|
|
|
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;
|
|
fptr->writeconv_pre_ecflags &= ~(ECONV_UNIVERSAL_NEWLINE_DECORATOR|ECONV_CRLF_NEWLINE_DECORATOR|ECONV_CR_NEWLINE_DECORATOR);
|
|
return io;
|
|
}
|
|
|
|
VALUE
|
|
rb_io_ascii8bit_binmode(VALUE io)
|
|
{
|
|
rb_io_t *fptr;
|
|
|
|
GetOpenFile(io, fptr);
|
|
if (fptr->readconv) {
|
|
rb_econv_close(fptr->readconv);
|
|
fptr->readconv = NULL;
|
|
}
|
|
if (fptr->writeconv) {
|
|
rb_econv_close(fptr->writeconv);
|
|
fptr->writeconv = NULL;
|
|
}
|
|
fptr->mode |= FMODE_BINMODE;
|
|
fptr->mode &= ~FMODE_TEXTMODE;
|
|
|
|
fptr->encs.enc = rb_ascii8bit_encoding();
|
|
fptr->encs.enc2 = NULL;
|
|
fptr->encs.ecflags = 0;
|
|
fptr->encs.ecopts = Qnil;
|
|
clear_codeconv(fptr);
|
|
|
|
return io;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ios.binmode -> ios
|
|
*
|
|
* Puts <em>ios</em> into binary mode.
|
|
* Once a stream is in binary mode, it cannot be reset to nonbinary mode.
|
|
*
|
|
* - newline conversion disabled
|
|
* - encoding conversion disabled
|
|
* - content is treated as ASCII-8BIT
|
|
*
|
|
*/
|
|
|
|
static VALUE
|
|
rb_io_binmode_m(VALUE io)
|
|
{
|
|
VALUE write_io;
|
|
|
|
rb_io_ascii8bit_binmode(io);
|
|
|
|
write_io = GetWriteIO(io);
|
|
if (write_io != io)
|
|
rb_io_ascii8bit_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_fmode_modestr(int fmode)
|
|
{
|
|
# define MODE_BTMODE(a,b,c) ((fmode & FMODE_BINMODE) ? (b) : \
|
|
(fmode & FMODE_TEXTMODE) ? (c) : (a))
|
|
if (fmode & FMODE_APPEND) {
|
|
if ((fmode & FMODE_READWRITE) == FMODE_READWRITE) {
|
|
return MODE_BTMODE("a+", "ab+", "at+");
|
|
}
|
|
return MODE_BTMODE("a", "ab", "at");
|
|
}
|
|
switch (fmode & FMODE_READWRITE) {
|
|
case FMODE_READABLE:
|
|
return MODE_BTMODE("r", "rb", "rt");
|
|
case FMODE_WRITABLE:
|
|
return MODE_BTMODE("w", "wb", "wt");
|
|
case FMODE_READWRITE:
|
|
if (fmode & FMODE_CREATE) {
|
|
return MODE_BTMODE("w+", "wb+", "wt+");
|
|
}
|
|
return MODE_BTMODE("r+", "rb+", "rt+");
|
|
}
|
|
rb_raise(rb_eArgError, "invalid access fmode 0x%x", fmode);
|
|
return NULL; /* not reached */
|
|
}
|
|
|
|
static int
|
|
io_encname_bom_p(const char *name, long len)
|
|
{
|
|
static const char bom_prefix[] = "bom|utf-";
|
|
enum {bom_prefix_len = (int)sizeof(bom_prefix) - 1};
|
|
if (!len) {
|
|
const char *p = strchr(name, ':');
|
|
len = p ? (long)(p - name) : (long)strlen(name);
|
|
}
|
|
return len > bom_prefix_len && STRNCASECMP(name, bom_prefix, bom_prefix_len) == 0;
|
|
}
|
|
|
|
int
|
|
rb_io_modestr_fmode(const char *modestr)
|
|
{
|
|
int fmode = 0;
|
|
const char *m = modestr, *p = NULL;
|
|
|
|
switch (*m++) {
|
|
case 'r':
|
|
fmode |= FMODE_READABLE;
|
|
break;
|
|
case 'w':
|
|
fmode |= FMODE_WRITABLE | FMODE_TRUNC | FMODE_CREATE;
|
|
break;
|
|
case 'a':
|
|
fmode |= FMODE_WRITABLE | FMODE_APPEND | FMODE_CREATE;
|
|
break;
|
|
default:
|
|
error:
|
|
rb_raise(rb_eArgError, "invalid access mode %s", modestr);
|
|
}
|
|
|
|
while (*m) {
|
|
switch (*m++) {
|
|
case 'b':
|
|
fmode |= FMODE_BINMODE;
|
|
break;
|
|
case 't':
|
|
fmode |= FMODE_TEXTMODE;
|
|
break;
|
|
case '+':
|
|
fmode |= FMODE_READWRITE;
|
|
break;
|
|
default:
|
|
goto error;
|
|
case ':':
|
|
p = m;
|
|
goto finished;
|
|
}
|
|
}
|
|
|
|
finished:
|
|
if ((fmode & FMODE_BINMODE) && (fmode & FMODE_TEXTMODE))
|
|
goto error;
|
|
if (p && io_encname_bom_p(p, 0))
|
|
fmode |= FMODE_SETENC_BY_BOM;
|
|
|
|
return fmode;
|
|
}
|
|
|
|
int
|
|
rb_io_oflags_fmode(int oflags)
|
|
{
|
|
int fmode = 0;
|
|
|
|
switch (oflags & (O_RDONLY|O_WRONLY|O_RDWR)) {
|
|
case O_RDONLY:
|
|
fmode = FMODE_READABLE;
|
|
break;
|
|
case O_WRONLY:
|
|
fmode = FMODE_WRITABLE;
|
|
break;
|
|
case O_RDWR:
|
|
fmode = FMODE_READWRITE;
|
|
break;
|
|
}
|
|
|
|
if (oflags & O_APPEND) {
|
|
fmode |= FMODE_APPEND;
|
|
}
|
|
if (oflags & O_TRUNC) {
|
|
fmode |= FMODE_TRUNC;
|
|
}
|
|
if (oflags & O_CREAT) {
|
|
fmode |= FMODE_CREATE;
|
|
}
|
|
#ifdef O_BINARY
|
|
if (oflags & O_BINARY) {
|
|
fmode |= FMODE_BINMODE;
|
|
}
|
|
#endif
|
|
|
|
return fmode;
|
|
}
|
|
|
|
static int
|
|
rb_io_fmode_oflags(int fmode)
|
|
{
|
|
int oflags = 0;
|
|
|
|
switch (fmode & FMODE_READWRITE) {
|
|
case FMODE_READABLE:
|
|
oflags |= O_RDONLY;
|
|
break;
|
|
case FMODE_WRITABLE:
|
|
oflags |= O_WRONLY;
|
|
break;
|
|
case FMODE_READWRITE:
|
|
oflags |= O_RDWR;
|
|
break;
|
|
}
|
|
|
|
if (fmode & FMODE_APPEND) {
|
|
oflags |= O_APPEND;
|
|
}
|
|
if (fmode & FMODE_TRUNC) {
|
|
oflags |= O_TRUNC;
|
|
}
|
|
if (fmode & FMODE_CREATE) {
|
|
oflags |= O_CREAT;
|
|
}
|
|
#ifdef O_BINARY
|
|
if (fmode & FMODE_BINMODE) {
|
|
oflags |= O_BINARY;
|
|
}
|
|
#endif
|
|
|
|
return oflags;
|
|
}
|
|
|
|
int
|
|
rb_io_modestr_oflags(const char *modestr)
|
|
{
|
|
return rb_io_fmode_oflags(rb_io_modestr_fmode(modestr));
|
|
}
|
|
|
|
static const char*
|
|
rb_io_oflags_modestr(int oflags)
|
|
{
|
|
#ifdef O_BINARY
|
|
# define MODE_BINARY(a,b) ((oflags & O_BINARY) ? (b) : (a))
|
|
#else
|
|
# define MODE_BINARY(a,b) (a)
|
|
#endif
|
|
int accmode = oflags & (O_RDONLY|O_WRONLY|O_RDWR);
|
|
if (oflags & O_APPEND) {
|
|
if (accmode == O_WRONLY) {
|
|
return MODE_BINARY("a", "ab");
|
|
}
|
|
if (accmode == O_RDWR) {
|
|
return MODE_BINARY("a+", "ab+");
|
|
}
|
|
}
|
|
switch (oflags & (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 oflags 0x%x", oflags);
|
|
return NULL; /* not reached */
|
|
}
|
|
|
|
/*
|
|
* Convert external/internal encodings to enc/enc2
|
|
* NULL => use default encoding
|
|
* Qnil => no encoding specified (internal only)
|
|
*/
|
|
static void
|
|
rb_io_ext_int_to_encs(rb_encoding *ext, rb_encoding *intern, rb_encoding **enc, rb_encoding **enc2)
|
|
{
|
|
int default_ext = 0;
|
|
|
|
if (ext == NULL) {
|
|
ext = rb_default_external_encoding();
|
|
default_ext = 1;
|
|
}
|
|
if (intern == NULL && ext != rb_ascii8bit_encoding())
|
|
/* If external is ASCII-8BIT, no default transcoding */
|
|
intern = rb_default_internal_encoding();
|
|
if (intern == NULL || intern == (rb_encoding *)Qnil || intern == ext) {
|
|
/* No internal encoding => use external + no transcoding */
|
|
*enc = (default_ext && intern != ext) ? NULL : ext;
|
|
*enc2 = NULL;
|
|
}
|
|
else {
|
|
*enc = intern;
|
|
*enc2 = ext;
|
|
}
|
|
}
|
|
|
|
static void
|
|
parse_mode_enc(const char *estr, rb_encoding **enc_p, rb_encoding **enc2_p)
|
|
{
|
|
const char *p;
|
|
char encname[ENCODING_MAXNAMELEN+1];
|
|
int idx, idx2;
|
|
rb_encoding *ext_enc, *int_enc;
|
|
|
|
/* parse estr as "enc" or "enc2:enc" or "enc:-" */
|
|
|
|
p = strrchr(estr, ':');
|
|
if (p) {
|
|
long len = (p++) - estr;
|
|
if (len == 0 || len > ENCODING_MAXNAMELEN)
|
|
idx = -1;
|
|
else {
|
|
if (io_encname_bom_p(estr, len)) {
|
|
estr += 4;
|
|
len -= 4;
|
|
}
|
|
memcpy(encname, estr, len);
|
|
encname[len] = '\0';
|
|
estr = encname;
|
|
idx = rb_enc_find_index(encname);
|
|
}
|
|
}
|
|
else {
|
|
long len = strlen(estr);
|
|
if (io_encname_bom_p(estr, len)) {
|
|
estr += 4;
|
|
len -= 4;
|
|
memcpy(encname, estr, len);
|
|
encname[len] = '\0';
|
|
estr = encname;
|
|
}
|
|
idx = rb_enc_find_index(estr);
|
|
}
|
|
|
|
if (idx >= 0)
|
|
ext_enc = rb_enc_from_index(idx);
|
|
else {
|
|
if (idx != -2)
|
|
rb_warn("Unsupported encoding %s ignored", estr);
|
|
ext_enc = NULL;
|
|
}
|
|
|
|
int_enc = NULL;
|
|
if (p) {
|
|
if (*p == '-' && *(p+1) == '\0') {
|
|
/* Special case - "-" => no transcoding */
|
|
int_enc = (rb_encoding *)Qnil;
|
|
}
|
|
else {
|
|
idx2 = rb_enc_find_index(p);
|
|
if (idx2 < 0)
|
|
rb_warn("Unsupported encoding %s ignored", p);
|
|
else if (idx2 == idx) {
|
|
rb_warn("Ignoring internal encoding %s: it is identical to external encoding %s", p, estr);
|
|
int_enc = (rb_encoding *)Qnil;
|
|
}
|
|
else
|
|
int_enc = rb_enc_from_index(idx2);
|
|
}
|
|
}
|
|
|
|
rb_io_ext_int_to_encs(ext_enc, int_enc, enc_p, enc2_p);
|
|
}
|
|
|
|
static void
|
|
mode_enc(rb_io_t *fptr, const char *estr)
|
|
{
|
|
clear_codeconv(fptr);
|
|
|
|
parse_mode_enc(estr, &fptr->encs.enc, &fptr->encs.enc2);
|
|
}
|
|
|
|
static void
|
|
rb_io_mode_enc(rb_io_t *fptr, const char *modestr)
|
|
{
|
|
const char *p = strchr(modestr, ':');
|
|
if (p) {
|
|
mode_enc(fptr, p+1);
|
|
}
|
|
}
|
|
|
|
int
|
|
rb_io_extract_encoding_option(VALUE opt, rb_encoding **enc_p, rb_encoding **enc2_p)
|
|
{
|
|
VALUE encoding=Qnil, extenc=Qundef, intenc=Qundef, tmp;
|
|
int extracted = 0;
|
|
rb_encoding *extencoding = NULL;
|
|
rb_encoding *intencoding = NULL;
|
|
|
|
if (!NIL_P(opt)) {
|
|
VALUE v;
|
|
v = rb_hash_lookup2(opt, sym_encoding, Qnil);
|
|
if (v != Qnil) encoding = v;
|
|
v = rb_hash_lookup2(opt, sym_extenc, Qundef);
|
|
if (v != Qnil) extenc = v;
|
|
v = rb_hash_lookup2(opt, sym_intenc, Qundef);
|
|
if (v != Qundef) intenc = v;
|
|
}
|
|
if ((extenc != Qundef || intenc != Qundef) && !NIL_P(encoding)) {
|
|
rb_warn("Ignoring encoding parameter '%s': %s_encoding is used",
|
|
StringValueCStr(encoding),
|
|
extenc == Qundef ? "internal" : "external");
|
|
encoding = Qnil;
|
|
}
|
|
if (extenc != Qundef && !NIL_P(extenc)) {
|
|
extencoding = rb_to_encoding(extenc);
|
|
}
|
|
if (intenc != Qundef) {
|
|
if (NIL_P(intenc)) {
|
|
/* internal_encoding: nil => no transcoding */
|
|
intencoding = (rb_encoding *)Qnil;
|
|
}
|
|
else if (!NIL_P(tmp = rb_check_string_type(intenc))) {
|
|
char *p = StringValueCStr(tmp);
|
|
|
|
if (*p == '-' && *(p+1) == '\0') {
|
|
/* Special case - "-" => no transcoding */
|
|
intencoding = (rb_encoding *)Qnil;
|
|
}
|
|
else {
|
|
intencoding = rb_to_encoding(intenc);
|
|
}
|
|
}
|
|
else {
|
|
intencoding = rb_to_encoding(intenc);
|
|
}
|
|
if (extencoding == intencoding) {
|
|
intencoding = (rb_encoding *)Qnil;
|
|
}
|
|
}
|
|
if (!NIL_P(encoding)) {
|
|
extracted = 1;
|
|
parse_mode_enc(StringValueCStr(encoding), enc_p, enc2_p);
|
|
}
|
|
else if (extenc != Qundef || intenc != Qundef) {
|
|
extracted = 1;
|
|
rb_io_ext_int_to_encs(extencoding, intencoding, enc_p, enc2_p);
|
|
}
|
|
return extracted;
|
|
}
|
|
|
|
typedef struct rb_io_enc_t convconfig_t;
|
|
|
|
static void
|
|
validate_enc_binmode(int fmode, rb_encoding *enc, rb_encoding *enc2)
|
|
{
|
|
if ((fmode & FMODE_READABLE) &&
|
|
!enc2 &&
|
|
!(fmode & FMODE_BINMODE) &&
|
|
!rb_enc_asciicompat(enc ? enc : rb_default_external_encoding()))
|
|
rb_raise(rb_eArgError, "ASCII incompatible encoding needs binmode");
|
|
}
|
|
|
|
static void
|
|
extract_binmode(VALUE opthash, int *fmode)
|
|
{
|
|
if (!NIL_P(opthash)) {
|
|
VALUE v;
|
|
v = rb_hash_aref(opthash, sym_textmode);
|
|
if (!NIL_P(v) && RTEST(v))
|
|
*fmode |= FMODE_TEXTMODE;
|
|
v = rb_hash_aref(opthash, sym_binmode);
|
|
if (!NIL_P(v) && RTEST(v))
|
|
*fmode |= FMODE_BINMODE;
|
|
|
|
if ((*fmode & FMODE_BINMODE) && (*fmode & FMODE_TEXTMODE))
|
|
rb_raise(rb_eArgError, "both textmode and binmode specified");
|
|
}
|
|
}
|
|
|
|
static void
|
|
rb_io_extract_modeenc(VALUE *vmode_p, VALUE *vperm_p, VALUE opthash,
|
|
int *oflags_p, int *fmode_p, convconfig_t *convconfig_p)
|
|
{
|
|
VALUE vmode;
|
|
int oflags, fmode;
|
|
rb_encoding *enc, *enc2;
|
|
int ecflags;
|
|
VALUE ecopts;
|
|
int has_enc = 0, has_vmode = 0;
|
|
VALUE intmode;
|
|
|
|
vmode = *vmode_p;
|
|
|
|
/* Set to defaults */
|
|
rb_io_ext_int_to_encs(NULL, NULL, &enc, &enc2);
|
|
|
|
if (NIL_P(vmode)) {
|
|
fmode = FMODE_READABLE;
|
|
oflags = O_RDONLY;
|
|
}
|
|
else if (!NIL_P(intmode = rb_check_to_integer(vmode, "to_int"))) {
|
|
vmode = intmode;
|
|
oflags = NUM2INT(intmode);
|
|
fmode = rb_io_oflags_fmode(oflags);
|
|
}
|
|
else {
|
|
const char *p;
|
|
|
|
vmode_handle:
|
|
SafeStringValue(vmode);
|
|
p = StringValueCStr(vmode);
|
|
fmode = rb_io_modestr_fmode(p);
|
|
oflags = rb_io_fmode_oflags(fmode);
|
|
p = strchr(p, ':');
|
|
if (p) {
|
|
has_enc = 1;
|
|
parse_mode_enc(p+1, &enc, &enc2);
|
|
if (io_encname_bom_p(p+1, 0))
|
|
fmode |= FMODE_SETENC_BY_BOM;
|
|
}
|
|
else {
|
|
rb_encoding *e;
|
|
|
|
e = (fmode & FMODE_BINMODE) ? rb_ascii8bit_encoding() : NULL;
|
|
rb_io_ext_int_to_encs(e, NULL, &enc, &enc2);
|
|
}
|
|
}
|
|
|
|
if (NIL_P(opthash)) {
|
|
ecflags = 0;
|
|
ecopts = Qnil;
|
|
}
|
|
else {
|
|
VALUE v;
|
|
extract_binmode(opthash, &fmode);
|
|
#ifdef O_BINARY
|
|
if (fmode & FMODE_BINMODE)
|
|
oflags |= O_BINARY;
|
|
#endif
|
|
if (!has_vmode) {
|
|
v = rb_hash_aref(opthash, sym_mode);
|
|
if (!NIL_P(v)) {
|
|
if (!NIL_P(vmode)) {
|
|
rb_raise(rb_eArgError, "mode specified twice");
|
|
}
|
|
has_vmode = 1;
|
|
vmode = v;
|
|
goto vmode_handle;
|
|
}
|
|
}
|
|
v = rb_hash_aref(opthash, sym_perm);
|
|
if (!NIL_P(v)) {
|
|
if (vperm_p) {
|
|
if (!NIL_P(*vperm_p)) {
|
|
rb_raise(rb_eArgError, "perm specified twice");
|
|
}
|
|
*vperm_p = v;
|
|
}
|
|
else {
|
|
/* perm no use, just ignore */
|
|
}
|
|
}
|
|
ecflags = rb_econv_prepare_opts(opthash, &ecopts);
|
|
|
|
if (rb_io_extract_encoding_option(opthash, &enc, &enc2)) {
|
|
if (has_enc) {
|
|
rb_raise(rb_eArgError, "encoding specified twice");
|
|
}
|
|
}
|
|
}
|
|
|
|
validate_enc_binmode(fmode, enc, enc2);
|
|
|
|
*vmode_p = vmode;
|
|
|
|
*oflags_p = oflags;
|
|
*fmode_p = fmode;
|
|
convconfig_p->enc = enc;
|
|
convconfig_p->enc2 = enc2;
|
|
convconfig_p->ecflags = ecflags;
|
|
convconfig_p->ecopts = ecopts;
|
|
}
|
|
|
|
struct sysopen_struct {
|
|
VALUE fname;
|
|
int oflags;
|
|
mode_t perm;
|
|
};
|
|
|
|
static VALUE
|
|
sysopen_func(void *ptr)
|
|
{
|
|
const struct sysopen_struct *data = ptr;
|
|
const char *fname = RSTRING_PTR(data->fname);
|
|
return (VALUE)open(fname, data->oflags, data->perm);
|
|
}
|
|
|
|
static inline int
|
|
rb_sysopen_internal(struct sysopen_struct *data)
|
|
{
|
|
return (int)rb_thread_blocking_region(sysopen_func, data, RUBY_UBF_IO, 0);
|
|
}
|
|
|
|
static int
|
|
rb_sysopen(VALUE fname, int oflags, mode_t perm)
|
|
{
|
|
int fd;
|
|
struct sysopen_struct data;
|
|
|
|
#ifdef O_BINARY
|
|
oflags |= O_BINARY;
|
|
#endif
|
|
data.fname = rb_str_encode_ospath(fname);
|
|
data.oflags = oflags;
|
|
data.perm = perm;
|
|
|
|
fd = rb_sysopen_internal(&data);
|
|
if (fd < 0) {
|
|
if (errno == EMFILE || errno == ENFILE) {
|
|
rb_gc();
|
|
fd = rb_sysopen_internal(&data);
|
|
}
|
|
if (fd < 0) {
|
|
rb_sys_fail(RSTRING_PTR(fname));
|
|
}
|
|
}
|
|
UPDATE_MAXFD(fd);
|
|
return fd;
|
|
}
|
|
|
|
FILE *
|
|
rb_fdopen(int fd, const char *modestr)
|
|
{
|
|
FILE *file;
|
|
|
|
#if defined(sun)
|
|
errno = 0;
|
|
#endif
|
|
file = fdopen(fd, modestr);
|
|
if (!file) {
|
|
if (
|
|
#if defined(sun)
|
|
errno == 0 ||
|
|
#endif
|
|
errno == EMFILE || errno == ENFILE) {
|
|
rb_gc();
|
|
#if defined(sun)
|
|
errno = 0;
|
|
#endif
|
|
file = fdopen(fd, modestr);
|
|
}
|
|
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_io_internal_encoding(VALUE);
|
|
static void io_encoding_set(rb_io_t *, VALUE, VALUE, VALUE);
|
|
|
|
static int
|
|
io_strip_bom(VALUE io)
|
|
{
|
|
int b1, b2, b3, b4;
|
|
switch (b1 = FIX2INT(rb_io_getbyte(io))) {
|
|
case 0xEF:
|
|
b2 = FIX2INT(rb_io_getbyte(io));
|
|
if (b2 == 0xBB) {
|
|
b3 = FIX2INT(rb_io_getbyte(io));
|
|
if (b3 == 0xBF) {
|
|
return rb_utf8_encindex();
|
|
}
|
|
rb_io_ungetbyte(io, INT2FIX(b3));
|
|
}
|
|
rb_io_ungetbyte(io, INT2FIX(b2));
|
|
break;
|
|
|
|
case 0xFE:
|
|
b2 = FIX2INT(rb_io_getbyte(io));
|
|
if (b2 == 0xFF) {
|
|
return rb_enc_find_index("UTF-16BE");
|
|
}
|
|
rb_io_ungetbyte(io, INT2FIX(b2));
|
|
break;
|
|
|
|
case 0xFF:
|
|
b2 = FIX2INT(rb_io_getbyte(io));
|
|
if (b2 == 0xFE) {
|
|
b3 = FIX2INT(rb_io_getbyte(io));
|
|
if (b3 == 0) {
|
|
b4 = FIX2INT(rb_io_getbyte(io));
|
|
if (b4 == 0) {
|
|
return rb_enc_find_index("UTF-32LE");
|
|
}
|
|
rb_io_ungetbyte(io, INT2FIX(b4));
|
|
}
|
|
else {
|
|
rb_io_ungetbyte(io, INT2FIX(b3));
|
|
return rb_enc_find_index("UTF-16LE");
|
|
}
|
|
rb_io_ungetbyte(io, INT2FIX(b3));
|
|
}
|
|
rb_io_ungetbyte(io, INT2FIX(b2));
|
|
break;
|
|
|
|
case 0:
|
|
b2 = FIX2INT(rb_io_getbyte(io));
|
|
if (b2 == 0) {
|
|
b3 = FIX2INT(rb_io_getbyte(io));
|
|
if (b3 == 0xFE) {
|
|
b4 = FIX2INT(rb_io_getbyte(io));
|
|
if (b4 == 0xFF) {
|
|
return rb_enc_find_index("UTF-32BE");
|
|
}
|
|
rb_io_ungetbyte(io, INT2FIX(b4));
|
|
}
|
|
rb_io_ungetbyte(io, INT2FIX(b3));
|
|
}
|
|
rb_io_ungetbyte(io, INT2FIX(b2));
|
|
break;
|
|
}
|
|
rb_io_ungetbyte(io, INT2FIX(b1));
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
io_set_encoding_by_bom(VALUE io)
|
|
{
|
|
int idx = io_strip_bom(io);
|
|
|
|
if (idx) {
|
|
rb_io_t *fptr;
|
|
GetOpenFile(io, fptr);
|
|
io_encoding_set(fptr, rb_enc_from_encoding(rb_enc_from_index(idx)),
|
|
rb_io_internal_encoding(io), Qnil);
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
rb_file_open_generic(VALUE io, VALUE filename, int oflags, int fmode, convconfig_t *convconfig, mode_t perm)
|
|
{
|
|
rb_io_t *fptr;
|
|
convconfig_t cc;
|
|
if (!convconfig) {
|
|
/* Set to default encodings */
|
|
rb_io_ext_int_to_encs(NULL, NULL, &cc.enc, &cc.enc2);
|
|
cc.ecflags = 0;
|
|
cc.ecopts = Qnil;
|
|
convconfig = &cc;
|
|
}
|
|
validate_enc_binmode(fmode, convconfig->enc, convconfig->enc2);
|
|
|
|
MakeOpenFile(io, fptr);
|
|
fptr->mode = fmode;
|
|
fptr->encs = *convconfig;
|
|
fptr->pathv = rb_str_new_frozen(filename);
|
|
fptr->fd = rb_sysopen(fptr->pathv, oflags, perm);
|
|
io_check_tty(fptr);
|
|
if (fmode & FMODE_SETENC_BY_BOM) io_set_encoding_by_bom(io);
|
|
|
|
return io;
|
|
}
|
|
|
|
static VALUE
|
|
rb_file_open_internal(VALUE io, VALUE filename, const char *modestr)
|
|
{
|
|
int fmode = rb_io_modestr_fmode(modestr);
|
|
const char *p = strchr(modestr, ':');
|
|
convconfig_t convconfig;
|
|
|
|
if (p) {
|
|
parse_mode_enc(p+1, &convconfig.enc, &convconfig.enc2);
|
|
}
|
|
else {
|
|
rb_encoding *e;
|
|
/* Set to default encodings */
|
|
|
|
e = (fmode & FMODE_BINMODE) ? rb_ascii8bit_encoding() : NULL;
|
|
rb_io_ext_int_to_encs(e, NULL, &convconfig.enc, &convconfig.enc2);
|
|
convconfig.ecflags = 0;
|
|
convconfig.ecopts = Qnil;
|
|
}
|
|
|
|
return rb_file_open_generic(io, filename,
|
|
rb_io_fmode_oflags(fmode),
|
|
fmode,
|
|
&convconfig,
|
|
0666);
|
|
}
|
|
|
|
VALUE
|
|
rb_file_open_str(VALUE fname, const char *modestr)
|
|
{
|
|
FilePathValue(fname);
|
|
return rb_file_open_internal(io_alloc(rb_cFile), fname, modestr);
|
|
}
|
|
|
|
VALUE
|
|
rb_file_open(const char *fname, const char *modestr)
|
|
{
|
|
return rb_file_open_internal(io_alloc(rb_cFile), rb_str_new_cstr(fname), modestr);
|
|
}
|
|
|
|
#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;
|
|
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
|
|
ret = close(fd);
|
|
#endif
|
|
#define CONTIGUOUS_CLOSED_FDS 20
|
|
if (ret != -1) {
|
|
if (max < fd + CONTIGUOUS_CLOSED_FDS)
|
|
max = fd + CONTIGUOUS_CLOSED_FDS;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int
|
|
popen_exec(void *pp, char *errmsg, size_t errmsg_len)
|
|
{
|
|
struct popen_arg *p = (struct popen_arg*)pp;
|
|
|
|
rb_thread_atfork_before_exec();
|
|
return rb_exec_err(p->execp, errmsg, errmsg_len);
|
|
}
|
|
#endif
|
|
|
|
static VALUE
|
|
pipe_open(struct rb_exec_arg *eargp, VALUE prog, const char *modestr, int fmode, convconfig_t *convconfig)
|
|
{
|
|
rb_pid_t 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;
|
|
char errmsg[80] = { '\0' };
|
|
#elif defined(_WIN32)
|
|
volatile VALUE argbuf;
|
|
char **args = NULL;
|
|
int pair[2], write_pair[2];
|
|
#endif
|
|
#if !defined(HAVE_FORK)
|
|
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 = fmode;
|
|
arg.pair[0] = arg.pair[1] = -1;
|
|
arg.write_pair[0] = arg.write_pair[1] = -1;
|
|
switch (fmode & (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_err(&status, popen_exec, &arg, arg.execp->redirect_fds, errmsg, sizeof(errmsg));
|
|
}
|
|
else {
|
|
fflush(stdin); /* is it really needed? */
|
|
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 ((fmode & (FMODE_READABLE|FMODE_WRITABLE)) == (FMODE_READABLE|FMODE_WRITABLE)) {
|
|
close(arg.write_pair[0]);
|
|
close(arg.write_pair[1]);
|
|
}
|
|
errno = e;
|
|
if (errmsg[0])
|
|
rb_sys_fail(errmsg);
|
|
rb_sys_fail(cmd);
|
|
}
|
|
if ((fmode & FMODE_READABLE) && (fmode & FMODE_WRITABLE)) {
|
|
close(arg.pair[1]);
|
|
fd = arg.pair[0];
|
|
close(arg.write_pair[0]);
|
|
write_fd = arg.write_pair[1];
|
|
}
|
|
else if (fmode & FMODE_READABLE) {
|
|
close(arg.pair[1]);
|
|
fd = arg.pair[0];
|
|
}
|
|
else {
|
|
close(arg.pair[0]);
|
|
fd = arg.pair[1];
|
|
}
|
|
#elif defined(_WIN32)
|
|
if (argc) {
|
|
int i;
|
|
|
|
if (argc >= (int)(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;
|
|
}
|
|
switch (fmode & (FMODE_READABLE|FMODE_WRITABLE)) {
|
|
case FMODE_READABLE|FMODE_WRITABLE:
|
|
if (rb_pipe(write_pair) < 0)
|
|
rb_sys_fail(cmd);
|
|
if (rb_pipe(pair) < 0) {
|
|
int e = errno;
|
|
close(write_pair[0]);
|
|
close(write_pair[1]);
|
|
errno = e;
|
|
rb_sys_fail(cmd);
|
|
}
|
|
if (eargp) {
|
|
rb_exec_arg_addopt(eargp, INT2FIX(0), INT2FIX(write_pair[0]));
|
|
rb_exec_arg_addopt(eargp, INT2FIX(1), INT2FIX(pair[1]));
|
|
}
|
|
break;
|
|
case FMODE_READABLE:
|
|
if (rb_pipe(pair) < 0)
|
|
rb_sys_fail(cmd);
|
|
if (eargp)
|
|
rb_exec_arg_addopt(eargp, INT2FIX(1), INT2FIX(pair[1]));
|
|
break;
|
|
case FMODE_WRITABLE:
|
|
if (rb_pipe(pair) < 0)
|
|
rb_sys_fail(cmd);
|
|
if (eargp)
|
|
rb_exec_arg_addopt(eargp, INT2FIX(0), INT2FIX(pair[0]));
|
|
break;
|
|
default:
|
|
rb_sys_fail(cmd);
|
|
}
|
|
if (eargp) {
|
|
rb_exec_arg_fixup(eargp);
|
|
rb_run_exec_options(eargp, &sarg);
|
|
}
|
|
while ((pid = (args ?
|
|
rb_w32_aspawn(P_NOWAIT, cmd, args) :
|
|
rb_w32_spawn(P_NOWAIT, cmd, 0))) == -1) {
|
|
/* exec failed */
|
|
switch (errno) {
|
|
case EAGAIN:
|
|
#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
|
|
case EWOULDBLOCK:
|
|
#endif
|
|
rb_thread_sleep(1);
|
|
break;
|
|
default:
|
|
{
|
|
int e = errno;
|
|
if (eargp)
|
|
rb_run_exec_options(&sarg, NULL);
|
|
close(pair[0]);
|
|
close(pair[1]);
|
|
if ((fmode & (FMODE_READABLE|FMODE_WRITABLE)) == (FMODE_READABLE|FMODE_WRITABLE)) {
|
|
close(write_pair[0]);
|
|
close(write_pair[1]);
|
|
}
|
|
errno = e;
|
|
rb_sys_fail(cmd);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
RB_GC_GUARD(argbuf);
|
|
|
|
if (eargp)
|
|
rb_run_exec_options(&sarg, NULL);
|
|
if ((fmode & FMODE_READABLE) && (fmode & FMODE_WRITABLE)) {
|
|
close(pair[1]);
|
|
fd = pair[0];
|
|
close(write_pair[0]);
|
|
write_fd = write_pair[1];
|
|
}
|
|
else if (fmode & FMODE_READABLE) {
|
|
close(pair[1]);
|
|
fd = pair[0];
|
|
}
|
|
else {
|
|
close(pair[0]);
|
|
fd = pair[1];
|
|
}
|
|
#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, modestr);
|
|
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 = fmode | 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 = (fmode & ~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 *modestr, int fmode, convconfig_t *convconfig)
|
|
{
|
|
VALUE prog;
|
|
struct rb_exec_arg earg;
|
|
prog = rb_exec_arg_init(argc, argv, FALSE, &earg);
|
|
return pipe_open(&earg, prog, modestr, fmode, convconfig);
|
|
}
|
|
|
|
static VALUE
|
|
pipe_open_s(VALUE prog, const char *modestr, int fmode, 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, modestr, fmode, convconfig);
|
|
}
|
|
|
|
rb_exec_arg_init(argc, argv, TRUE, &earg);
|
|
return pipe_open(&earg, prog, modestr, fmode, convconfig);
|
|
}
|
|
|
|
static VALUE
|
|
pop_last_hash(int *argc_p, VALUE *argv)
|
|
{
|
|
VALUE last, tmp;
|
|
if (*argc_p == 0)
|
|
return Qnil;
|
|
last = argv[*argc_p-1];
|
|
if (NIL_P(last)) return Qnil;
|
|
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.
|
|
*
|
|
* The PID of the started process can be obtained by IO#pid method.
|
|
*
|
|
* _cmd_ is a string or an array as follows.
|
|
*
|
|
* cmd:
|
|
* "-" : fork
|
|
* commandline : command line string which is passed to a shell
|
|
* [env, cmdname, arg1, ..., opts] : command name and zero or more arguments (no shell)
|
|
* [env, [cmdname, argv0], arg1, ..., opts] : command name, argv[0] and zero or more arguments (no shell)
|
|
* (env and opts are optional.)
|
|
*
|
|
* 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.
|
|
* The last argument <i>opt</i> qualifies <i>mode</i>.
|
|
*
|
|
* # set IO encoding
|
|
* IO.popen("nkf -e filename", :external_encoding=>"EUC-JP") {|nkf_io|
|
|
* euc_jp_string = nkf_io.read
|
|
* }
|
|
*
|
|
* # merge standard output and standard error using
|
|
* # spawn option. See the document of Kernel.spawn.
|
|
* IO.popen(["ls", "/", :err=>[:child, :out]]) {|ls_io|
|
|
* ls_result_with_error = ls_io.read
|
|
* }
|
|
*
|
|
* Raises exceptions which <code>IO.pipe</code> and
|
|
* <code>Kernel.spawn</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
|
|
* f.close
|
|
* puts "Parent is #{Process.pid}"
|
|
* IO.popen("date") { |f| puts f.gets }
|
|
* IO.popen("-") {|f| $stderr.puts "#{Process.pid} is here, f is #{f.inspect}"}
|
|
* 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 21346
|
|
* Thu Jan 15 22:41:19 JST 2009
|
|
* 21346 is here, f is #<IO:fd 3>
|
|
* 21352 is here, f is nil
|
|
* #<Process::Status: pid 21352 exit 0>
|
|
* <foo>bar;zot;
|
|
*/
|
|
|
|
static VALUE
|
|
rb_io_s_popen(int argc, VALUE *argv, VALUE klass)
|
|
{
|
|
const char *modestr;
|
|
VALUE pname, pmode, port, tmp, opt;
|
|
int oflags, fmode;
|
|
convconfig_t convconfig;
|
|
|
|
opt = pop_last_hash(&argc, argv);
|
|
rb_scan_args(argc, argv, "11", &pname, &pmode);
|
|
|
|
rb_io_extract_modeenc(&pmode, 0, opt, &oflags, &fmode, &convconfig);
|
|
modestr = rb_io_oflags_modestr(oflags);
|
|
|
|
tmp = rb_check_array_type(pname);
|
|
if (!NIL_P(tmp)) {
|
|
long len = RARRAY_LEN(tmp);
|
|
#if SIZEOF_LONG > SIZEOF_INT
|
|
if (len > INT_MAX) {
|
|
rb_raise(rb_eArgError, "too many arguments");
|
|
}
|
|
#endif
|
|
tmp = rb_ary_dup(tmp);
|
|
RBASIC(tmp)->klass = 0;
|
|
port = pipe_open_v((int)len, RARRAY_PTR(tmp), modestr, fmode, &convconfig);
|
|
rb_ary_clear(tmp);
|
|
}
|
|
else {
|
|
SafeStringValue(pname);
|
|
port = pipe_open_s(pname, modestr, fmode, &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 *oflags_p, int *fmode_p,
|
|
convconfig_t *convconfig_p, mode_t *perm_p)
|
|
{
|
|
VALUE opt=Qnil, fname, vmode, vperm;
|
|
int oflags, fmode;
|
|
mode_t perm;
|
|
|
|
opt = pop_last_hash(&argc, argv);
|
|
rb_scan_args(argc, argv, "12", &fname, &vmode, &vperm);
|
|
FilePathValue(fname);
|
|
|
|
rb_io_extract_modeenc(&vmode, &vperm, opt, &oflags, &fmode, convconfig_p);
|
|
|
|
perm = NIL_P(vperm) ? 0666 : NUM2UINT(vperm);
|
|
|
|
*fname_p = fname;
|
|
*oflags_p = oflags;
|
|
*fmode_p = fmode;
|
|
*perm_p = perm;
|
|
}
|
|
|
|
static VALUE
|
|
rb_open_file(int argc, VALUE *argv, VALUE io)
|
|
{
|
|
VALUE fname;
|
|
int oflags, fmode;
|
|
convconfig_t convconfig;
|
|
mode_t perm;
|
|
|
|
rb_scan_open_args(argc, argv, &fname, &oflags, &fmode, &convconfig, &perm);
|
|
rb_file_open_generic(io, fname, oflags, fmode, &convconfig, perm);
|
|
|
|
return io;
|
|
}
|
|
|
|
|
|
/*
|
|
* Document-method: File::open
|
|
*
|
|
* call-seq:
|
|
* File.open(filename, mode="r" [, opt]) -> file
|
|
* File.open(filename [, mode [, perm]] [, opt]) -> file
|
|
* File.open(filename, mode="r" [, opt]) {|file| block } -> obj
|
|
* File.open(filename [, mode [, perm]] [, opt]) {|file| block } -> obj
|
|
*
|
|
* With no associated block, <code>open</code> is a synonym for
|
|
* <code>File.new</code>. If the optional code block is given, it will
|
|
* be passed <i>file</i> as an argument, and the File object will
|
|
* automatically be closed when the block terminates. In this instance,
|
|
* <code>File.open</code> returns the value of the block.
|
|
*/
|
|
|
|
/*
|
|
* Document-method: IO::open
|
|
*
|
|
* 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 oflags, fd;
|
|
mode_t perm;
|
|
|
|
rb_scan_args(argc, argv, "12", &fname, &vmode, &vperm);
|
|
FilePathValue(fname);
|
|
|
|
if (NIL_P(vmode))
|
|
oflags = O_RDONLY;
|
|
else if (!NIL_P(intmode = rb_check_to_integer(vmode, "to_int")))
|
|
oflags = NUM2INT(intmode);
|
|
else {
|
|
SafeStringValue(vmode);
|
|
oflags = rb_io_modestr_oflags(StringValueCStr(vmode));
|
|
}
|
|
if (NIL_P(vperm)) perm = 0666;
|
|
else perm = NUM2UINT(vperm);
|
|
|
|
RB_GC_GUARD(fname) = rb_str_new4(fname);
|
|
fd = rb_sysopen(fname, oflags, 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 ext_enc starts with 'BOM|', check whether the input has a BOM. If
|
|
* there is a BOM, strip it and set external encoding as
|
|
* what the BOM tells. If there is no BOM, use ext_enc without 'BOM|'.
|
|
* 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 = FALSE;
|
|
|
|
if (argc >= 1) {
|
|
CONST_ID(to_open, "to_open");
|
|
if (rb_respond_to(argv[0], to_open)) {
|
|
redirect = TRUE;
|
|
}
|
|
else {
|
|
VALUE tmp = argv[0];
|
|
FilePathValue(tmp);
|
|
if (NIL_P(tmp)) {
|
|
redirect = TRUE;
|
|
}
|
|
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 vmode, VALUE vperm, VALUE opt)
|
|
{
|
|
VALUE cmd;
|
|
int oflags, fmode;
|
|
convconfig_t convconfig;
|
|
mode_t perm;
|
|
|
|
rb_io_extract_modeenc(&vmode, &vperm, opt, &oflags, &fmode, &convconfig);
|
|
perm = NIL_P(vperm) ? 0666 : NUM2UINT(vperm);
|
|
|
|
if (!NIL_P(cmd = check_pipe_command(filename))) {
|
|
return pipe_open_s(cmd, rb_io_oflags_modestr(oflags), fmode, &convconfig);
|
|
}
|
|
else {
|
|
return rb_file_open_generic(io_alloc(rb_cFile), filename,
|
|
oflags, fmode, &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_fmode_modestr(fptr->mode),
|
|
rb_io_fmode_modestr(orig->mode));
|
|
}
|
|
}
|
|
if (fptr->mode & FMODE_WRITABLE) {
|
|
if (io_fflush(fptr) < 0)
|
|
rb_sys_fail(0);
|
|
}
|
|
else {
|
|
io_tell(fptr);
|
|
}
|
|
if (orig->mode & FMODE_READABLE) {
|
|
pos = io_tell(orig);
|
|
}
|
|
if (orig->mode & FMODE_WRITABLE) {
|
|
if (io_fflush(orig) < 0)
|
|
rb_sys_fail(0);
|
|
}
|
|
|
|
/* copy rb_io_t structure */
|
|
fptr->mode = orig->mode | (fptr->mode & FMODE_PREP);
|
|
fptr->pid = orig->pid;
|
|
fptr->lineno = orig->lineno;
|
|
if (RTEST(orig->pathv)) fptr->pathv = orig->pathv;
|
|
else if (!IS_PREP_STDIO(fptr)) fptr->pathv = Qnil;
|
|
fptr->finalize = orig->finalize;
|
|
#if defined (__CYGWIN__) || !defined(HAVE_FORK)
|
|
if (fptr->finalize == pipe_finalize)
|
|
pipe_add_fptr(fptr);
|
|
#endif
|
|
|
|
fd = fptr->fd;
|
|
fd2 = orig->fd;
|
|
if (fd != fd2) {
|
|
if (IS_PREP_STDIO(fptr) || fd <= 2 || !fptr->stdio_file) {
|
|
/* need to keep FILE objects of stdin, stdout and stderr */
|
|
if (dup2(fd2, fd) < 0)
|
|
rb_sys_fail_path(orig->pathv);
|
|
}
|
|
else {
|
|
fclose(fptr->stdio_file);
|
|
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 && errno) {
|
|
rb_sys_fail_path(fptr->pathv);
|
|
}
|
|
if (io_seek(orig, pos, SEEK_SET) < 0 && errno) {
|
|
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 oflags;
|
|
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 fmode = rb_io_modestr_fmode(StringValueCStr(nmode));
|
|
if (IS_PREP_STDIO(fptr) &&
|
|
((fptr->mode & FMODE_READWRITE) & (fmode & 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_fmode_modestr(fptr->mode),
|
|
rb_io_fmode_modestr(fmode));
|
|
}
|
|
fptr->mode = fmode;
|
|
rb_io_mode_enc(fptr, StringValueCStr(nmode));
|
|
fptr->encs.ecflags = 0;
|
|
fptr->encs.ecopts = Qnil;
|
|
}
|
|
|
|
fptr->pathv = rb_str_new_frozen(fname);
|
|
oflags = rb_io_fmode_oflags(fptr->mode);
|
|
if (fptr->fd < 0) {
|
|
fptr->fd = rb_sysopen(fptr->pathv, oflags, 0666);
|
|
fptr->stdio_file = 0;
|
|
return file;
|
|
}
|
|
|
|
if (fptr->mode & FMODE_WRITABLE) {
|
|
if (io_fflush(fptr) < 0)
|
|
rb_sys_fail(0);
|
|
}
|
|
fptr->rbuf_off = fptr->rbuf_len = 0;
|
|
|
|
if (fptr->stdio_file) {
|
|
if (freopen(RSTRING_PTR(fptr->pathv), rb_io_oflags_modestr(oflags), 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(fptr->pathv, oflags, 0666);
|
|
}
|
|
|
|
return file;
|
|
}
|
|
|
|
/* :nodoc: */
|
|
static VALUE
|
|
rb_io_init_copy(VALUE dest, VALUE io)
|
|
{
|
|
rb_io_t *fptr, *orig;
|
|
int fd;
|
|
VALUE write_io;
|
|
off_t pos;
|
|
|
|
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;
|
|
#if defined (__CYGWIN__) || !defined(HAVE_FORK)
|
|
if (fptr->finalize == pipe_finalize)
|
|
pipe_add_fptr(fptr);
|
|
#endif
|
|
|
|
fd = ruby_dup(orig->fd);
|
|
fptr->fd = fd;
|
|
pos = io_tell(orig);
|
|
if (0 <= pos)
|
|
io_seek(fptr, pos, 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 field separator (<code>$,</code>)
|
|
* is not <code>nil</code>, it will be inserted between each object.
|
|
* 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++) {
|
|
if (!NIL_P(rb_output_fs) && i>0) {
|
|
rb_io_write(out, rb_output_fs);
|
|
}
|
|
rb_io_write(out, argv[i]);
|
|
}
|
|
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++) {
|
|
if (TYPE(argv[i]) == T_STRING) {
|
|
line = argv[i];
|
|
goto string;
|
|
}
|
|
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]);
|
|
string:
|
|
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));
|
|
if (TYPE(rb_stdout) == T_FILE &&
|
|
rb_method_basic_definition_p(CLASS_OF(rb_stdout), id_write)) {
|
|
io_write(rb_stdout, str, 1);
|
|
io_write(rb_stdout, rb_default_rs, 0);
|
|
}
|
|
else {
|
|
rb_io_write(rb_stdout, str);
|
|
rb_io_write(rb_stdout, rb_default_rs);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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) {
|
|
(void)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 fmode, 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)) {
|
|
fmode |= FMODE_BINMODE;
|
|
setmode(fd, O_BINARY);
|
|
}
|
|
#endif
|
|
fp->mode = fmode;
|
|
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 oflags, const char *path)
|
|
{
|
|
VALUE klass = rb_cIO;
|
|
|
|
if (path && strcmp(path, "-")) klass = rb_cFile;
|
|
return prep_io(fd, rb_io_oflags_fmode(oflags), klass, path);
|
|
}
|
|
|
|
static VALUE
|
|
prep_stdio(FILE *f, int fmode, VALUE klass, const char *path)
|
|
{
|
|
rb_io_t *fptr;
|
|
VALUE io = prep_io(fileno(f), fmode|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 oflags = rb_io_fmode_oflags(fptr->mode);
|
|
fptr->stdio_file = rb_fdopen(fptr->fd, rb_io_oflags_modestr(oflags));
|
|
}
|
|
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.sysopen</code> and
|
|
* <code>IO.for_fd</code>.
|
|
*
|
|
* === Parameters
|
|
* fd:: numeric file descriptor
|
|
* mode:: file mode. a string or an integer
|
|
* opt:: hash for specifying mode by name.
|
|
*
|
|
* ==== Mode
|
|
* When <code>mode</code> is an integer it must be combination of
|
|
* the modes defined in <code>File::Constants</code>.
|
|
*
|
|
* When <code>mode</code> is a string it must be in one of the
|
|
* following forms:
|
|
* - "fmode",
|
|
* - "fmode:extern",
|
|
* - "fmode:extern:intern".
|
|
* <code>extern</code> is the external encoding name for the IO.
|
|
* <code>intern</code> is the internal encoding.
|
|
* <code>fmode</code> must be combination of the directives. See
|
|
* the description of class +IO+ for a description of the directives.
|
|
*
|
|
* When the mode of original IO is read only, the mode cannot be changed to
|
|
* be writable. Similarly, the mode cannot be changed from write only to
|
|
* readable.
|
|
* If such a wrong change is directed, timing where the error actually occurs
|
|
* is different according to the platform.
|
|
*
|
|
* ==== Options
|
|
* <code>opt</code> can have the following keys
|
|
* :mode ::
|
|
* same as <code>mode</code> parameter
|
|
* :external_encoding ::
|
|
* external encoding for the IO. "-" is a
|
|
* synonym for the default external encoding.
|
|
* :internal_encoding ::
|
|
* internal encoding for the IO.
|
|
* "-" is a synonym for the default internal encoding.
|
|
* If the value is nil no conversion occurs.
|
|
* :encoding ::
|
|
* specifies external and internal encodings as "extern:intern".
|
|
* :textmode ::
|
|
* If the value is truth value, same as "t" in argument <code>mode</code>.
|
|
* :binmode ::
|
|
* If the value is truth value, same as "b" in argument <code>mode</code>.
|
|
* :autoclose ::
|
|
* If the value is +false+, the _fd_ will be kept open after this
|
|
* +IO+ instance gets finalized.
|
|
*
|
|
* Also <code>opt</code> can have same keys in <code>String#encode</code> for
|
|
* controlling conversion between the external encoding and the internal encoding.
|
|
*
|
|
* === Example1
|
|
*
|
|
* fd = IO.sysopen("/dev/tty", "w")
|
|
* a = IO.new(fd,"w")
|
|
* $stderr.puts "Hello"
|
|
* a.puts "World"
|
|
*
|
|
* <em>produces:</em>
|
|
*
|
|
* Hello
|
|
* World
|
|
*
|
|
* === Example2
|
|
*
|
|
* require 'fcntl'
|
|
*
|
|
* fd = STDERR.fcntl(Fcntl::F_DUPFD)
|
|
* io = IO.new(fd, mode: 'w:UTF-16LE', cr_newline: true)
|
|
* io.puts "Hello, World!"
|
|
*
|
|
* fd = STDERR.fcntl(Fcntl::F_DUPFD)
|
|
* io = IO.new(fd, mode: 'w', cr_newline: true, external_encoding: Encoding::UTF_16LE)
|
|
* io.puts "Hello, World!"
|
|
*
|
|
* both of above print "Hello, World!" in UTF-16LE to standard error output with
|
|
* converting EOL generated by <code>puts</code> to CR.
|
|
*/
|
|
|
|
static VALUE
|
|
rb_io_initialize(int argc, VALUE *argv, VALUE io)
|
|
{
|
|
VALUE fnum, vmode;
|
|
rb_io_t *fp;
|
|
int fd, fmode, oflags = O_RDONLY;
|
|
convconfig_t convconfig;
|
|
VALUE opt;
|
|
#if defined(HAVE_FCNTL) && defined(F_GETFL)
|
|
int ofmode;
|
|
#else
|
|
struct stat st;
|
|
#endif
|
|
|
|
rb_secure(4);
|
|
|
|
opt = pop_last_hash(&argc, argv);
|
|
rb_scan_args(argc, argv, "11", &fnum, &vmode);
|
|
rb_io_extract_modeenc(&vmode, 0, opt, &oflags, &fmode, &convconfig);
|
|
|
|
fd = NUM2INT(fnum);
|
|
#if defined(HAVE_FCNTL) && defined(F_GETFL)
|
|
oflags = fcntl(fd, F_GETFL);
|
|
if (oflags == -1) rb_sys_fail(0);
|
|
#else
|
|
if (fstat(fd, &st) == -1) rb_sys_fail(0);
|
|
#endif
|
|
UPDATE_MAXFD(fd);
|
|
#if defined(HAVE_FCNTL) && defined(F_GETFL)
|
|
ofmode = rb_io_oflags_fmode(oflags);
|
|
if (NIL_P(vmode)) {
|
|
fmode = ofmode;
|
|
}
|
|
else if ((~ofmode & fmode) & FMODE_READWRITE) {
|
|
VALUE error = INT2FIX(EINVAL);
|
|
rb_exc_raise(rb_class_new_instance(1, &error, rb_eSystemCallError));
|
|
}
|
|
#endif
|
|
if (!NIL_P(opt) && rb_hash_aref(opt, sym_autoclose) == Qfalse) {
|
|
fmode |= FMODE_PREP;
|
|
}
|
|
MakeOpenFile(io, fp);
|
|
fp->fd = fd;
|
|
fp->mode = fmode;
|
|
fp->encs = convconfig;
|
|
clear_codeconv(fp);
|
|
io_check_tty(fp);
|
|
if (fileno(stdin) == fd)
|
|
fp->stdio_file = stdin;
|
|
else if (fileno(stdout) == fd)
|
|
fp->stdio_file = stdout;
|
|
else if (fileno(stderr) == fd)
|
|
fp->stdio_file = stderr;
|
|
|
|
if (fmode & FMODE_SETENC_BY_BOM) io_set_encoding_by_bom(io);
|
|
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.
|
|
*
|
|
* === Parameters
|
|
* 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.
|
|
*
|
|
* Optional _opt_ parameter is same as in <code.IO.open</code>.
|
|
*
|
|
* === Examples
|
|
*
|
|
* 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;
|
|
}
|
|
|
|
/* :nodoc: */
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ios.autoclose? -> true or false
|
|
*
|
|
* Returns +true+ if the underlying file descriptor of _ios_ will be
|
|
* closed automatically at its finalization, otherwise +false+.
|
|
*/
|
|
|
|
static VALUE
|
|
rb_io_autoclose_p(VALUE io)
|
|
{
|
|
rb_io_t *fptr;
|
|
rb_secure(4);
|
|
GetOpenFile(io, fptr);
|
|
return (fptr->mode & FMODE_PREP) ? Qfalse : Qtrue;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* io.autoclose = bool -> true or false
|
|
*
|
|
* Sets auto-close flag.
|
|
*
|
|
* f = open("/dev/null")
|
|
* IO.for_fd(f.fileno)
|
|
* # ...
|
|
* f.gets # may cause IOError
|
|
*
|
|
* f = open("/dev/null")
|
|
* IO.for_fd(f.fileno).autoclose = true
|
|
* # ...
|
|
* f.gets # won't cause IOError
|
|
*/
|
|
|
|
static VALUE
|
|
rb_io_set_autoclose(VALUE io, VALUE autoclose)
|
|
{
|
|
rb_io_t *fptr;
|
|
rb_secure(4);
|
|
GetOpenFile(io, fptr);
|
|
if (!RTEST(autoclose))
|
|
fptr->mode |= FMODE_PREP;
|
|
else
|
|
fptr->mode &= ~FMODE_PREP;
|
|
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->argv);
|
|
rb_gc_mark(p->encs.ecopts);
|
|
}
|
|
|
|
static void
|
|
argf_free(void *ptr)
|
|
{
|
|
struct argf *p = ptr;
|
|
xfree(p->inplace);
|
|
xfree(p);
|
|
}
|
|
|
|
static inline void
|
|
argf_init(struct argf *p, VALUE v)
|
|
{
|
|
p->filename = Qnil;
|
|
p->current_file = Qnil;
|
|
p->lineno = 0;
|
|
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
|
|
|
|
/* :nodoc: */
|
|
static VALUE
|
|
argf_initialize(VALUE argf, VALUE argv)
|
|
{
|
|
memset(&ARGF, 0, sizeof(ARGF));
|
|
argf_init(&ARGF, argv);
|
|
|
|
return argf;
|
|
}
|
|
|
|
/* :nodoc: */
|
|
static VALUE
|
|
argf_initialize_copy(VALUE argf, VALUE orig)
|
|
{
|
|
ARGF = argf_of(orig);
|
|
ARGF.argv = rb_obj_dup(ARGF.argv);
|
|
if (ARGF.inplace) {
|
|
const char *inplace = ARGF.inplace;
|
|
ARGF.inplace = 0;
|
|
ARGF.inplace = ruby_strdup(inplace);
|
|
}
|
|
return argf;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.lineno = number -> nil
|
|
*
|
|
* Sets the line number of the current file in +ARGF+ to the given +Integer+.
|
|
*
|
|
* +ARGF+ sets the line number automatically as you read data, so normally
|
|
* you will not need to set it explicitly. To access the current line number
|
|
* use +ARGF.lineno+.
|
|
*
|
|
* For example:
|
|
*
|
|
* ARGF.lineno #=> 0
|
|
* ARGF.readline #=> "This is line 1\n"
|
|
* ARGF.lineno #=> 1
|
|
* ARGF.lineno = 0 #=> nil
|
|
* ARGF.lineno #=> 0
|
|
*/
|
|
static VALUE
|
|
argf_set_lineno(VALUE argf, VALUE val)
|
|
{
|
|
ARGF.lineno = NUM2INT(val);
|
|
ARGF.last_lineno = ARGF.lineno;
|
|
return Qnil;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.lineno -> integer
|
|
*
|
|
* Returns the current line number of the current file in +ARGF+. This value
|
|
* can be set manually with +ARGF.lineno=+.
|
|
*
|
|
* For example:
|
|
*
|
|
* ARGF.lineno #=> 0
|
|
* ARGF.readline #=> "This is line 1\n"
|
|
* ARGF.lineno #=> 1
|
|
*/
|
|
static VALUE
|
|
argf_lineno(VALUE argf)
|
|
{
|
|
return INT2FIX(ARGF.lineno);
|
|
}
|
|
|
|
static VALUE
|
|
argf_forward(int argc, VALUE *argv, VALUE argf)
|
|
{
|
|
return rb_funcall3(ARGF.current_file, rb_frame_this_func(), argc, argv);
|
|
}
|
|
|
|
#define next_argv() argf_next_argv(argf)
|
|
#define ARGF_GENERIC_INPUT_P() \
|
|
(ARGF.current_file == rb_stdin && TYPE(ARGF.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 (ARGF.init_p == 0) {
|
|
if (!NIL_P(ARGF.argv) && RARRAY_LEN(ARGF.argv) > 0) {
|
|
ARGF.next_p = 1;
|
|
}
|
|
else {
|
|
ARGF.next_p = -1;
|
|
}
|
|
ARGF.init_p = 1;
|
|
}
|
|
|
|
if (ARGF.next_p == 1) {
|
|
ARGF.next_p = 0;
|
|
retry:
|
|
if (RARRAY_LEN(ARGF.argv) > 0) {
|
|
ARGF.filename = rb_ary_shift(ARGF.argv);
|
|
fn = StringValueCStr(ARGF.filename);
|
|
if (strlen(fn) == 1 && fn[0] == '-') {
|
|
ARGF.current_file = rb_stdin;
|
|
if (ARGF.inplace) {
|
|
rb_warn("Can't do inplace edit for stdio; skipping");
|
|
goto retry;
|
|
}
|
|
}
|
|
else {
|
|
int fr = rb_sysopen(ARGF.filename, O_RDONLY, 0);
|
|
|
|
if (ARGF.inplace) {
|
|
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 (*ARGF.inplace) {
|
|
str = rb_str_new2(fn);
|
|
#ifdef NO_LONG_FNAME
|
|
ruby_add_suffix(str, ARGF.inplace);
|
|
#else
|
|
rb_str_cat2(str, ARGF.inplace);
|
|
#endif
|
|
#ifdef NO_SAFE_RENAME
|
|
(void)close(fr);
|
|
(void)unlink(RSTRING_PTR(str));
|
|
(void)rename(fn, RSTRING_PTR(str));
|
|
fr = rb_sysopen(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(ARGF.filename, 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) {
|
|
#ifdef HAVE_FCHOWN
|
|
(void)fchown(fw, st.st_uid, st.st_gid);
|
|
#else
|
|
(void)chown(fn, st.st_uid, st.st_gid);
|
|
#endif
|
|
}
|
|
#endif
|
|
rb_stdout = prep_io(fw, FMODE_WRITABLE, rb_cFile, fn);
|
|
if (stdout_binmode) rb_io_binmode(rb_stdout);
|
|
}
|
|
ARGF.current_file = prep_io(fr, FMODE_READABLE, rb_cFile, fn);
|
|
}
|
|
if (ARGF.binmode) rb_io_ascii8bit_binmode(ARGF.current_file);
|
|
if (ARGF.encs.enc) {
|
|
rb_io_t *fptr;
|
|
|
|
GetOpenFile(ARGF.current_file, fptr);
|
|
fptr->encs = ARGF.encs;
|
|
clear_codeconv(fptr);
|
|
}
|
|
}
|
|
else {
|
|
ARGF.next_p = 1;
|
|
return FALSE;
|
|
}
|
|
}
|
|
else if (ARGF.next_p == -1) {
|
|
ARGF.current_file = rb_stdin;
|
|
ARGF.filename = rb_str_new2("-");
|
|
if (ARGF.inplace) {
|
|
rb_warn("Can't do inplace edit for stdio");
|
|
rb_stdout = orig_stdout;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static VALUE
|
|
argf_getline(int argc, VALUE *argv, VALUE argf)
|
|
{
|
|
VALUE line;
|
|
int lineno = ARGF.lineno;
|
|
|
|
retry:
|
|
if (!next_argv()) return Qnil;
|
|
if (ARGF_GENERIC_INPUT_P()) {
|
|
line = rb_funcall3(ARGF.current_file, rb_intern("gets"), argc, argv);
|
|
}
|
|
else {
|
|
if (argc == 0 && rb_rs == rb_default_rs) {
|
|
line = rb_io_gets(ARGF.current_file);
|
|
}
|
|
else {
|
|
line = rb_io_getline(argc, argv, ARGF.current_file);
|
|
}
|
|
if (NIL_P(line) && ARGF.next_p != -1) {
|
|
argf_close(ARGF.current_file);
|
|
ARGF.next_p = 1;
|
|
goto retry;
|
|
}
|
|
}
|
|
if (!NIL_P(line)) {
|
|
ARGF.lineno = ++lineno;
|
|
ARGF.last_lineno = ARGF.lineno;
|
|
}
|
|
return line;
|
|
}
|
|
|
|
static VALUE
|
|
argf_lineno_getter(ID id, VALUE *var)
|
|
{
|
|
VALUE argf = *var;
|
|
return INT2FIX(ARGF.last_lineno);
|
|
}
|
|
|
|
static void
|
|
argf_lineno_setter(VALUE val, ID id, VALUE *var)
|
|
{
|
|
VALUE argf = *var;
|
|
int n = NUM2INT(val);
|
|
ARGF.last_lineno = ARGF.lineno = 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 in bytes. 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);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.gets(sep=$/) -> string
|
|
* ARGF.gets(limit) -> string
|
|
* ARGF.gets(sep, limit) -> string
|
|
*
|
|
* Returns the next line from the current file in +ARGF+.
|
|
*
|
|
* By default lines are assumed to be separated by +$/+; to use a different
|
|
* character as a separator, supply it as a +String+ for the _sep_ argument.
|
|
*
|
|
* The optional _limit_ argument specifies how many characters of each line
|
|
* to return. By default all characters are returned.
|
|
*
|
|
*/
|
|
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(ARGF.current_file);
|
|
if (NIL_P(line) && ARGF.next_p != -1) {
|
|
rb_io_close(ARGF.current_file);
|
|
ARGF.next_p = 1;
|
|
goto retry;
|
|
}
|
|
rb_lastline_set(line);
|
|
if (!NIL_P(line)) {
|
|
ARGF.lineno++;
|
|
ARGF.last_lineno = ARGF.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);
|
|
}
|
|
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.readline(sep=$/) -> string
|
|
* ARGF.readline(limit) -> string
|
|
* ARGF.readline(sep, limit) -> string
|
|
*
|
|
* Returns the next line from the current file in +ARGF+.
|
|
*
|
|
* By default lines are assumed to be separated by +$/+; to use a different
|
|
* character as a separator, supply it as a +String+ for the _sep_ argument.
|
|
*
|
|
* The optional _limit_ argument specifies how many characters of each line
|
|
* to return. By default all characters are returned.
|
|
*
|
|
* An +EOFError+ is raised at the end of the file.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.readlines(sep=$/) -> array
|
|
* ARGF.readlines(limit) -> array
|
|
* ARGF.readlines(sep, limit) -> array
|
|
*
|
|
* ARGF.to_a(sep=$/) -> array
|
|
* ARGF.to_a(limit) -> array
|
|
* ARGF.to_a(sep, limit) -> array
|
|
*
|
|
* Reads +ARGF+'s current file in its entirety, returning an +Array+ of its
|
|
* lines, one line per element. Lines are assumed to be separated by _sep_.
|
|
*
|
|
* lines = ARGF.readlines
|
|
* lines[0] #=> "This is line one\n"
|
|
*/
|
|
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;
|
|
rb_fdset_t *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) || READ_CHAR_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 = &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 = &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 = &fds[2];
|
|
}
|
|
else {
|
|
ep = 0;
|
|
}
|
|
|
|
max++;
|
|
|
|
n = rb_thread_fd_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 < numberof(p->fdsets); ++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 < numberof(args.fdsets); ++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
|
|
|
|
}
|
|
|
|
static int
|
|
io_cntl(int fd, unsigned long cmd, long narg, int io_p)
|
|
{
|
|
int retval;
|
|
|
|
#ifdef HAVE_FCNTL
|
|
# 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, (int)cmd, narg);
|
|
# endif
|
|
# if defined(F_DUPFD)
|
|
if (!io_p && retval != -1 && cmd == F_DUPFD) {
|
|
UPDATE_MAXFD(retval);
|
|
}
|
|
# endif
|
|
#else
|
|
if (!io_p) {
|
|
rb_notimplement();
|
|
}
|
|
retval = ioctl(fd, cmd, narg);
|
|
#endif
|
|
return retval;
|
|
}
|
|
|
|
static VALUE
|
|
rb_io_ctl(VALUE io, VALUE req, VALUE arg, int io_p)
|
|
{
|
|
unsigned long 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);
|
|
}
|
|
|
|
|
|
/*
|
|
* 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);
|
|
}
|
|
|
|
#ifdef HAVE_FCNTL
|
|
/*
|
|
* 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)
|
|
{
|
|
VALUE req, arg;
|
|
|
|
rb_scan_args(argc, argv, "11", &req, &arg);
|
|
return rb_io_ctl(io, req, arg, 0);
|
|
}
|
|
#else
|
|
#define rb_io_fcntl rb_f_notimplement
|
|
#endif
|
|
|
|
#if defined(HAVE_SYSCALL) && SIZEOF_LONG == SIZEOF_INT
|
|
/*
|
|
* 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)
|
|
{
|
|
#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 > numberof(arg))
|
|
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++;
|
|
}
|
|
|
|
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 */
|
|
}
|
|
|
|
if (retval < 0) rb_sys_fail(0);
|
|
return INT2NUM(retval);
|
|
}
|
|
#else
|
|
#define rb_f_syscall rb_f_notimplement
|
|
#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, VALUE v1, VALUE v2, VALUE opt)
|
|
{
|
|
rb_encoding *enc, *enc2;
|
|
int ecflags;
|
|
VALUE ecopts, tmp;
|
|
|
|
if (!NIL_P(v2)) {
|
|
enc2 = rb_to_encoding(v1);
|
|
tmp = rb_check_string_type(v2);
|
|
if (!NIL_P(tmp)) {
|
|
if (RSTRING_LEN(tmp) == 1 && RSTRING_PTR(tmp)[0] == '-') {
|
|
/* Special case - "-" => no transcoding */
|
|
enc = enc2;
|
|
enc2 = NULL;
|
|
}
|
|
else
|
|
enc = rb_to_encoding(v2);
|
|
if (enc == enc2) {
|
|
/* Special case - "-" => no transcoding */
|
|
enc2 = NULL;
|
|
}
|
|
}
|
|
else
|
|
enc = rb_to_encoding(v2);
|
|
ecflags = rb_econv_prepare_opts(opt, &ecopts);
|
|
}
|
|
else {
|
|
if (NIL_P(v1)) {
|
|
/* Set to default encodings */
|
|
rb_io_ext_int_to_encs(NULL, NULL, &enc, &enc2);
|
|
ecflags = 0;
|
|
ecopts = Qnil;
|
|
}
|
|
else {
|
|
tmp = rb_check_string_type(v1);
|
|
if (!NIL_P(tmp) && rb_enc_asciicompat(rb_enc_get(tmp))) {
|
|
parse_mode_enc(RSTRING_PTR(tmp), &enc, &enc2);
|
|
ecflags = rb_econv_prepare_opts(opt, &ecopts);
|
|
}
|
|
else {
|
|
rb_io_ext_int_to_encs(rb_to_encoding(v1), NULL, &enc, &enc2);
|
|
ecflags = 0;
|
|
ecopts = Qnil;
|
|
}
|
|
}
|
|
}
|
|
validate_enc_binmode(fptr->mode, enc, enc2);
|
|
fptr->encs.enc = enc;
|
|
fptr->encs.enc2 = enc2;
|
|
fptr->encs.ecflags = ecflags;
|
|
fptr->encs.ecopts = ecopts;
|
|
clear_codeconv(fptr);
|
|
|
|
}
|
|
|
|
static VALUE
|
|
pipe_pair_close(VALUE rw)
|
|
{
|
|
VALUE *rwp = (VALUE *)rw;
|
|
return rb_ensure(io_close, rwp[0], io_close, rwp[1]);
|
|
}
|
|
|
|
/*
|
|
* 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]
|
|
*
|
|
* IO.pipe(...) {|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>.
|
|
*
|
|
* If a block is given, the block is called and
|
|
* returns the value of the block.
|
|
* <i>read_io</i> and <i>write_io</i> are sent to the block as arguments.
|
|
* If read_io and write_io are not closed when the block exits, they are closed.
|
|
* i.e. closing read_io and/or write_io doesn't cause an error.
|
|
*
|
|
* 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)
|
|
{
|
|
int pipes[2], state;
|
|
VALUE r, w, args[3], v1, v2;
|
|
VALUE opt;
|
|
rb_io_t *fptr, *fptr2;
|
|
int fmode = 0;
|
|
VALUE ret;
|
|
|
|
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, 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);
|
|
}
|
|
GetOpenFile(w, fptr2);
|
|
rb_io_synchronized(fptr2);
|
|
|
|
extract_binmode(opt, &fmode);
|
|
fptr->mode |= fmode;
|
|
fptr2->mode |= fmode;
|
|
|
|
ret = rb_assoc_new(r, w);
|
|
if (rb_block_given_p()) {
|
|
VALUE rw[2];
|
|
rw[0] = r;
|
|
rw[1] = w;
|
|
return rb_ensure(rb_yield, ret, pipe_pair_close, (VALUE)rw);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
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;
|
|
|
|
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 = pop_last_hash(&arg->argc, arg->argv);
|
|
if (NIL_P(opt)) goto no_key;
|
|
|
|
v = rb_hash_aref(opt, sym_open_args);
|
|
if (!NIL_P(v)) {
|
|
VALUE args;
|
|
long n;
|
|
|
|
v = rb_convert_type(v, T_ARRAY, "Array", "to_ary");
|
|
n = RARRAY_LEN(v) + 1;
|
|
#if SIZEOF_LONG > SIZEOF_INT
|
|
if (n > INT_MAX) {
|
|
rb_raise(rb_eArgError, "too many arguments");
|
|
}
|
|
#endif
|
|
args = rb_ary_tmp_new(n);
|
|
rb_ary_push(args, argv[0]);
|
|
rb_ary_concat(args, v);
|
|
arg->io = rb_io_open_with_args((int)n, RARRAY_PTR(args));
|
|
rb_ary_clear(args); /* prevent from GC */
|
|
return;
|
|
}
|
|
arg->io = rb_io_open(argv[0], Qnil, Qnil, 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
|
|
* IO.foreach(...) -> an_enumerator
|
|
*
|
|
* Executes the block for every line in the named I/O port, where lines
|
|
* are separated by <em>sep</em>.
|
|
*
|
|
* If no block is given, an enumerator is returned instead.
|
|
*
|
|
* 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);
|
|
}
|
|
|
|
struct seek_arg {
|
|
VALUE io;
|
|
VALUE offset;
|
|
int mode;
|
|
};
|
|
|
|
static VALUE
|
|
seek_before_access(VALUE argp)
|
|
{
|
|
struct seek_arg *arg = (struct seek_arg *)argp;
|
|
rb_io_binmode(arg->io);
|
|
return rb_io_seek(arg->io, arg->offset, arg->mode);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* IO.read(name, [length [, offset]] ) -> string
|
|
* IO.read(name, [length [, offset]], open_args) -> string
|
|
*
|
|
* Opens the file, optionally seeks to the given <i>offset</i>, 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)) {
|
|
struct seek_arg sarg;
|
|
int state = 0;
|
|
sarg.io = arg.io;
|
|
sarg.offset = offset;
|
|
sarg.mode = SEEK_SET;
|
|
rb_protect(seek_before_access, (VALUE)&sarg, &state);
|
|
if (state) {
|
|
rb_io_close(arg.io);
|
|
rb_jump_tag(state);
|
|
}
|
|
if (arg.argc == 2) arg.argc = 1;
|
|
}
|
|
return rb_ensure(io_s_read, (VALUE)&arg, rb_io_close, arg.io);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* IO.binread(name, [length [, offset]] ) -> string
|
|
*
|
|
* Opens the file, optionally seeks to the given <i>offset</i>, then returns
|
|
* <i>length</i> bytes (defaulting to the rest of the file).
|
|
* <code>binread</code> ensures the file is closed before returning.
|
|
* The open mode would be "rb:ASCII-8BIT".
|
|
*
|
|
* IO.binread("testfile") #=> "This is line one\nThis is line two\nThis is line three\nAnd so on...\n"
|
|
* IO.binread("testfile", 20) #=> "This is line one\nThi"
|
|
* IO.binread("testfile", 20, 10) #=> "ne one\nThis is line "
|
|
*/
|
|
|
|
static VALUE
|
|
rb_io_s_binread(int argc, VALUE *argv, VALUE io)
|
|
{
|
|
VALUE offset;
|
|
struct foreach_arg arg;
|
|
|
|
rb_scan_args(argc, argv, "12", NULL, NULL, &offset);
|
|
FilePathValue(argv[0]);
|
|
arg.io = rb_io_open(argv[0], rb_str_new_cstr("rb:ASCII-8BIT"), Qnil, Qnil);
|
|
if (NIL_P(arg.io)) return Qnil;
|
|
arg.argv = argv+1;
|
|
arg.argc = (argc > 1) ? 1 : 0;
|
|
if (!NIL_P(offset)) {
|
|
rb_io_seek(arg.io, offset, SEEK_SET);
|
|
}
|
|
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;
|
|
VALUE th;
|
|
};
|
|
|
|
static int
|
|
maygvl_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
|
|
nogvl_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
|
|
nogvl_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;
|
|
errno = 0;
|
|
cur = lseek(stp->src_fd, 0, SEEK_CUR);
|
|
if (cur == (off_t)-1 && errno) {
|
|
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 (nogvl_copy_stream_wait_write(stp) == -1)
|
|
return -1;
|
|
if (rb_thread_interrupted(stp->th))
|
|
return -1;
|
|
goto retry_sendfile;
|
|
}
|
|
stp->syserr = "sendfile";
|
|
stp->error_no = errno;
|
|
return -1;
|
|
}
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
static ssize_t
|
|
maygvl_copy_stream_read(struct copy_stream_struct *stp, char *buf, size_t 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 (maygvl_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
|
|
nogvl_copy_stream_write(struct copy_stream_struct *stp, char *buf, size_t 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 (nogvl_copy_stream_wait_write(stp) == -1)
|
|
return -1;
|
|
continue;
|
|
}
|
|
stp->syserr = "write";
|
|
stp->error_no = errno;
|
|
return -1;
|
|
}
|
|
off += (int)ss;
|
|
len -= (int)ss;
|
|
stp->total += ss;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
nogvl_copy_stream_read_write(struct copy_stream_struct *stp)
|
|
{
|
|
char buf[1024*16];
|
|
size_t 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;
|
|
errno = 0;
|
|
r = lseek(stp->src_fd, src_offset, SEEK_SET);
|
|
if (r == (off_t)-1 && errno) {
|
|
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 < (off_t)sizeof(buf)) {
|
|
len = (size_t)copy_length;
|
|
}
|
|
else {
|
|
len = sizeof(buf);
|
|
}
|
|
if (use_pread) {
|
|
ss = maygvl_copy_stream_read(stp, buf, len, src_offset);
|
|
if (0 < ss)
|
|
src_offset += ss;
|
|
}
|
|
else {
|
|
ss = maygvl_copy_stream_read(stp, buf, len, (off_t)-1);
|
|
}
|
|
if (ss <= 0) /* EOF or error */
|
|
return;
|
|
|
|
ret = nogvl_copy_stream_write(stp, buf, ss);
|
|
if (ret < 0)
|
|
return;
|
|
|
|
if (!use_eof)
|
|
copy_length -= ss;
|
|
|
|
if (rb_thread_interrupted(stp->th))
|
|
return;
|
|
}
|
|
}
|
|
|
|
static VALUE
|
|
nogvl_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 = nogvl_copy_stream_sendfile(stp);
|
|
if (ret != 0)
|
|
goto finish; /* error or success */
|
|
#endif
|
|
|
|
nogvl_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);
|
|
off_t rest = stp->copy_length;
|
|
off_t off = stp->src_offset;
|
|
ID read_method = id_readpartial;
|
|
|
|
if (stp->src_fd == -1) {
|
|
if (!rb_respond_to(stp->src, read_method)) {
|
|
read_method = id_read;
|
|
}
|
|
}
|
|
|
|
while (1) {
|
|
long numwrote;
|
|
long l;
|
|
if (stp->copy_length == (off_t)-1) {
|
|
l = buflen;
|
|
}
|
|
else {
|
|
if (rest == 0)
|
|
break;
|
|
l = buflen < rest ? buflen : (long)rest;
|
|
}
|
|
if (stp->src_fd == -1) {
|
|
rb_funcall(stp->src, read_method, 2, INT2FIX(l), buf);
|
|
}
|
|
else {
|
|
ssize_t ss;
|
|
rb_thread_wait_fd(stp->src_fd);
|
|
rb_str_resize(buf, buflen);
|
|
ss = maygvl_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;
|
|
if (read_method == id_read && RSTRING_LEN(buf) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
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 = rb_thread_current();
|
|
|
|
stp->total = 0;
|
|
|
|
if (stp->src == argf ||
|
|
!(TYPE(stp->src) == T_FILE ||
|
|
TYPE(stp->src) == T_STRING ||
|
|
rb_respond_to(stp->src, rb_intern("to_path")))) {
|
|
src_fd = -1;
|
|
}
|
|
else {
|
|
src_io = TYPE(stp->src) == T_FILE ? stp->src : Qnil;
|
|
if (NIL_P(src_io)) {
|
|
VALUE args[2];
|
|
int oflags = O_RDONLY;
|
|
#ifdef O_NOCTTY
|
|
oflags |= O_NOCTTY;
|
|
#endif
|
|
FilePathValue(stp->src);
|
|
args[0] = stp->src;
|
|
args[1] = INT2NUM(oflags);
|
|
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_byte_readable(src_fptr);
|
|
src_fd = src_fptr->fd;
|
|
}
|
|
stp->src_fd = src_fd;
|
|
|
|
if (stp->dst == argf ||
|
|
!(TYPE(stp->dst) == T_FILE ||
|
|
TYPE(stp->dst) == T_STRING ||
|
|
rb_respond_to(stp->dst, rb_intern("to_path")))) {
|
|
dst_fd = -1;
|
|
}
|
|
else {
|
|
dst_io = TYPE(stp->dst) == T_FILE ? stp->dst : Qnil;
|
|
if (NIL_P(dst_io)) {
|
|
VALUE args[3];
|
|
int oflags = O_WRONLY|O_CREAT|O_TRUNC;
|
|
#ifdef O_NOCTTY
|
|
oflags |= O_NOCTTY;
|
|
#endif
|
|
FilePathValue(stp->dst);
|
|
args[0] = stp->dst;
|
|
args[1] = INT2NUM(oflags);
|
|
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) {
|
|
size_t len = src_fptr->rbuf_len;
|
|
VALUE str;
|
|
if (stp->copy_length != (off_t)-1 && stp->copy_length < (off_t)len) {
|
|
len = (size_t)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 */
|
|
if (io_binwrite(str, dst_fptr, 0) < 0)
|
|
rb_sys_fail(0);
|
|
}
|
|
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(nogvl_copy_stream_func, (void*)stp, RUBY_UBF_IO, 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, v1, v2, opt);
|
|
return io;
|
|
}
|
|
|
|
void
|
|
rb_stdio_set_default_encoding(void)
|
|
{
|
|
extern VALUE rb_stdin, rb_stdout, rb_stderr;
|
|
VALUE val = Qnil;
|
|
|
|
rb_io_set_encoding(1, &val, rb_stdin);
|
|
rb_io_set_encoding(1, &val, rb_stdout);
|
|
rb_io_set_encoding(1, &val, rb_stderr);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.external_encoding -> encoding
|
|
*
|
|
* Returns the external encoding for files read from +ARGF+ as an +Encoding+
|
|
* object. The external encoding is the encoding of the text as stored in a
|
|
* file. Contrast with +ARGF.internal_encoding+, which is the encoding used
|
|
* to represent this text within Ruby.
|
|
*
|
|
* To set the external encoding use +ARGF.set_encoding+.
|
|
*
|
|
* For example:
|
|
*
|
|
* ARGF.external_encoding #=> #<Encoding:UTF-8>
|
|
*
|
|
*/
|
|
static VALUE
|
|
argf_external_encoding(VALUE argf)
|
|
{
|
|
if (!RTEST(ARGF.current_file)) {
|
|
return rb_enc_from_encoding(rb_default_external_encoding());
|
|
}
|
|
return rb_io_external_encoding(rb_io_check_io(ARGF.current_file));
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.internal_encoding -> encoding
|
|
*
|
|
* Returns the internal encoding for strings read from +ARGF+ as an
|
|
* +Encoding+ object.
|
|
*
|
|
* If +ARGF.set_encoding+ has been called with two encoding names, the second
|
|
* is returned. Otherwise, if +Encoding.default_external+ has been set, that
|
|
* value is returned. Failing that, if a default external encoding was
|
|
* specified on the command-line, that value is used. If the encoding is
|
|
* unknown, nil is returned.
|
|
*/
|
|
static VALUE
|
|
argf_internal_encoding(VALUE argf)
|
|
{
|
|
if (!RTEST(ARGF.current_file)) {
|
|
return rb_enc_from_encoding(rb_default_external_encoding());
|
|
}
|
|
return rb_io_internal_encoding(rb_io_check_io(ARGF.current_file));
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.set_encoding(ext_enc) -> ARGF
|
|
* ARGF.set_encoding("ext_enc:int_enc") -> ARGF
|
|
* ARGF.set_encoding(ext_enc, int_enc) -> ARGF
|
|
* ARGF.set_encoding("ext_enc:int_enc", opt) -> ARGF
|
|
* ARGF.set_encoding(ext_enc, int_enc, opt) -> ARGF
|
|
*
|
|
* If single argument is specified, strings read from ARGF are tagged with
|
|
* the encoding specified.
|
|
*
|
|
* If two encoding names separated by a colon are given, e.g. "ascii:utf-8",
|
|
* the read string is converted from the first encoding (external encoding)
|
|
* to the second encoding (internal encoding), then tagged with the second
|
|
* encoding.
|
|
*
|
|
* If two arguments are specified, they must be encoding objects or encoding
|
|
* names. Again, the first specifies the external encoding; the second
|
|
* specifies the internal encoding.
|
|
*
|
|
* If the external encoding and the internal encoding are specified, the
|
|
* optional +Hash+ argument can be used to adjust the conversion process. The
|
|
* structure of this hash is explained in the +String#encode+ documentation.
|
|
*
|
|
* For example:
|
|
*
|
|
* ARGF.set_encoding('ascii') # Tag the input as US-ASCII text
|
|
* ARGF.set_encoding(Encoding::UTF_8) # Tag the input as UTF-8 text
|
|
* ARGF.set_encoding('utf-8','ascii') # Transcode the input from US-ASCII
|
|
* # to UTF-8.
|
|
*/
|
|
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, ARGF.current_file);
|
|
GetOpenFile(ARGF.current_file, fptr);
|
|
ARGF.encs = fptr->encs;
|
|
return argf;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.tell -> Integer
|
|
* ARGF.pos -> Integer
|
|
*
|
|
* Returns the current offset (in bytes) of the current file in +ARGF+.
|
|
*
|
|
* ARGF.pos #=> 0
|
|
* ARGF.gets #=> "This is line one\n"
|
|
* ARGF.pos #=> 17
|
|
*
|
|
*/
|
|
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(ARGF.current_file);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.seek(amount, whence=IO::SEEK_SET) -> 0
|
|
*
|
|
* Seeks to offset _amount_ (an +Integer+) in the +ARGF+ stream according to
|
|
* the value of _whence_. See +IO#seek+ for further details.
|
|
*/
|
|
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, ARGF.current_file);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.pos = position -> Integer
|
|
*
|
|
* Seeks to the position given by _position_ (in bytes) in +ARGF+.
|
|
*
|
|
* For example:
|
|
*
|
|
* ARGF.pos = 17
|
|
* ARGF.gets #=> "This is line two\n"
|
|
*/
|
|
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(ARGF.current_file, offset);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.rewind -> 0
|
|
*
|
|
* Positions the current file to the beginning of input, resetting
|
|
* +ARGF.lineno+ to zero.
|
|
*
|
|
* ARGF.readline #=> "This is line one\n"
|
|
* ARGF.rewind #=> 0
|
|
* ARGF.lineno #=> 0
|
|
* ARGF.readline #=> "This is line one\n"
|
|
*/
|
|
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(ARGF.current_file);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.fileno -> fixnum
|
|
* ARGF.to_i -> fixnum
|
|
*
|
|
* Returns an integer representing the numeric file descriptor for
|
|
* the current file. Raises an +ArgumentError+ if there isn't a current file.
|
|
*
|
|
* ARGF.fileno #=> 3
|
|
*/
|
|
static VALUE
|
|
argf_fileno(VALUE argf)
|
|
{
|
|
if (!next_argv()) {
|
|
rb_raise(rb_eArgError, "no stream");
|
|
}
|
|
ARGF_FORWARD(0, 0);
|
|
return rb_io_fileno(ARGF.current_file);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.to_io -> IO
|
|
*
|
|
* Returns an +IO+ object representing the current file. This will be a
|
|
* +File+ object unless the current file is a stream such as STDIN.
|
|
*
|
|
* For example:
|
|
*
|
|
* ARGF.to_io #=> #<File:glark.txt>
|
|
* ARGF.to_io #=> #<IO:<STDIN>>
|
|
*/
|
|
static VALUE
|
|
argf_to_io(VALUE argf)
|
|
{
|
|
next_argv();
|
|
ARGF_FORWARD(0, 0);
|
|
return ARGF.current_file;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.eof? -> true or false
|
|
* ARGF.eof -> true or false
|
|
*
|
|
* Returns true if the current file in +ARGF+ is at end of file, i.e. it has
|
|
* no data to read. The stream must be opened for reading or an +IOError+
|
|
* will be raised.
|
|
*
|
|
* $ echo "eof" | ruby argf.rb
|
|
*
|
|
* ARGF.eof? #=> false
|
|
* 3.times { ARGF.readchar }
|
|
* ARGF.eof? #=> false
|
|
* ARGF.readchar #=> "\n"
|
|
* ARGF.eof? #=> true
|
|
*/
|
|
|
|
static VALUE
|
|
argf_eof(VALUE argf)
|
|
{
|
|
next_argv();
|
|
if (RTEST(ARGF.current_file)) {
|
|
if (ARGF.init_p == 0) return Qtrue;
|
|
next_argv();
|
|
ARGF_FORWARD(0, 0);
|
|
if (rb_io_eof(ARGF.current_file)) {
|
|
return Qtrue;
|
|
}
|
|
}
|
|
return Qfalse;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.read([length [, buffer]]) -> string, buffer, or nil
|
|
*
|
|
* Reads _length_ bytes from ARGF. The files named on the command line
|
|
* are concatenated and treated as a single file by this method, so when
|
|
* called without arguments the contents of this pseudo file are returned in
|
|
* their entirety.
|
|
*
|
|
* _length_ must be a non-negative integer or nil. If it is a positive
|
|
* integer, +read+ tries to read at most _length_ bytes. It returns nil
|
|
* if an EOF was encountered before anything could be read. Fewer than
|
|
* _length_ bytes may be returned if an EOF is encountered during the read.
|
|
*
|
|
* If _length_ is omitted or is _nil_, it reads until EOF. A String is
|
|
* returned even if EOF is encountered before any data is read.
|
|
*
|
|
* If _length_ is zero, it returns _""_.
|
|
*
|
|
* If the optional _buffer_ argument is present, it must reference a String,
|
|
* which will receive the data.
|
|
*
|
|
* For example:
|
|
*
|
|
* $ echo "small" > small.txt
|
|
* $ echo "large" > large.txt
|
|
* $ ./glark.rb small.txt large.txt
|
|
*
|
|
* ARGF.read #=> "small\nlarge"
|
|
* ARGF.read(200) #=> "small\nlarge"
|
|
* ARGF.read(2) #=> "sm"
|
|
* ARGF.read(0) #=> ""
|
|
*
|
|
* Note that this method behaves like fread() function in C. If you need the
|
|
* behavior like read(2) system call, consider +ARGF.readpartial+.
|
|
*/
|
|
|
|
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, ARGF.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 (ARGF.next_p != -1) {
|
|
argf_close(ARGF.current_file);
|
|
ARGF.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;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.readpartial(maxlen) -> string
|
|
* ARGF.readpartial(maxlen, outbuf) -> outbuf
|
|
*
|
|
* Reads at most _maxlen_ bytes from the ARGF stream. It blocks only if
|
|
* +ARGF+ has no data immediately available. If the optional _outbuf_
|
|
* 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 pipes, sockets, and ttys. It
|
|
* blocks only when no data is immediately available. This means that it
|
|
* blocks only when following all conditions hold:
|
|
*
|
|
* * The byte buffer in the +IO+ object is empty.
|
|
* * The content of the stream is empty.
|
|
* * The stream has not reached EOF.
|
|
*
|
|
* When +readpartial+ blocks, it waits for data or EOF. If some data is read,
|
|
* +readpartial+ returns with the data. If EOF is reached, readpartial raises
|
|
* an +EOFError+.
|
|
*
|
|
* When +readpartial+ doesn't block, it returns or raises immediately. If
|
|
* the byte 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. If the
|
|
* stream reaches EOF an +EOFError+ is raised.
|
|
*/
|
|
|
|
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, ARGF.current_file, 0);
|
|
}
|
|
if (NIL_P(tmp)) {
|
|
if (ARGF.next_p == -1) {
|
|
rb_eof_error();
|
|
}
|
|
argf_close(ARGF.current_file);
|
|
ARGF.next_p = 1;
|
|
if (RARRAY_LEN(ARGF.argv) == 0)
|
|
rb_eof_error();
|
|
if (NIL_P(str))
|
|
str = rb_str_new(NULL, 0);
|
|
return str;
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.getc -> String or nil
|
|
*
|
|
* Reads the next character from +ARGF+ and returns it as a +String+. Returns
|
|
* +nil+ at the end of the stream.
|
|
*
|
|
* +ARGF+ treats the files named on the command line as a single file created
|
|
* by concatenating their contents. After returning the last character of the
|
|
* first file, it returns the first character of the second file, and so on.
|
|
*
|
|
* For example:
|
|
*
|
|
* $ echo "foo" > file
|
|
* $ ruby argf.rb file
|
|
*
|
|
* ARGF.getc #=> "f"
|
|
* ARGF.getc #=> "o"
|
|
* ARGF.getc #=> "o"
|
|
* ARGF.getc #=> "\n"
|
|
* ARGF.getc #=> nil
|
|
* ARGF.getc #=> nil
|
|
*/
|
|
static VALUE
|
|
argf_getc(VALUE argf)
|
|
{
|
|
VALUE ch;
|
|
|
|
retry:
|
|
if (!next_argv()) return Qnil;
|
|
if (ARGF_GENERIC_INPUT_P()) {
|
|
ch = rb_funcall3(ARGF.current_file, rb_intern("getc"), 0, 0);
|
|
}
|
|
else {
|
|
ch = rb_io_getc(ARGF.current_file);
|
|
}
|
|
if (NIL_P(ch) && ARGF.next_p != -1) {
|
|
argf_close(ARGF.current_file);
|
|
ARGF.next_p = 1;
|
|
goto retry;
|
|
}
|
|
|
|
return ch;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.getbyte -> Fixnum or nil
|
|
*
|
|
* Gets the next 8-bit byte (0..255) from +ARGF+. Returns +nil+ if called at
|
|
* the end of the stream.
|
|
*
|
|
* For example:
|
|
*
|
|
* $ echo "foo" > file
|
|
* $ ruby argf.rb file
|
|
*
|
|
* ARGF.getbyte #=> 102
|
|
* ARGF.getbyte #=> 111
|
|
* ARGF.getbyte #=> 111
|
|
* ARGF.getbyte #=> 10
|
|
* ARGF.getbyte #=> nil
|
|
*/
|
|
static VALUE
|
|
argf_getbyte(VALUE argf)
|
|
{
|
|
VALUE ch;
|
|
|
|
retry:
|
|
if (!next_argv()) return Qnil;
|
|
if (TYPE(ARGF.current_file) != T_FILE) {
|
|
ch = rb_funcall3(ARGF.current_file, rb_intern("getbyte"), 0, 0);
|
|
}
|
|
else {
|
|
ch = rb_io_getbyte(ARGF.current_file);
|
|
}
|
|
if (NIL_P(ch) && ARGF.next_p != -1) {
|
|
argf_close(ARGF.current_file);
|
|
ARGF.next_p = 1;
|
|
goto retry;
|
|
}
|
|
|
|
return ch;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.readchar -> String or nil
|
|
*
|
|
* Reads the next character from +ARGF+ and returns it as a +String+. Raises
|
|
* an +EOFError+ after the last character of the last file has been read.
|
|
*
|
|
* For example:
|
|
*
|
|
* $ echo "foo" > file
|
|
* $ ruby argf.rb file
|
|
*
|
|
* ARGF.readchar #=> "f"
|
|
* ARGF.readchar #=> "o"
|
|
* ARGF.readchar #=> "o"
|
|
* ARGF.readchar #=> "\n"
|
|
* ARGF.readchar #=> end of file reached (EOFError)
|
|
*/
|
|
static VALUE
|
|
argf_readchar(VALUE argf)
|
|
{
|
|
VALUE ch;
|
|
|
|
retry:
|
|
if (!next_argv()) rb_eof_error();
|
|
if (TYPE(ARGF.current_file) != T_FILE) {
|
|
ch = rb_funcall3(ARGF.current_file, rb_intern("getc"), 0, 0);
|
|
}
|
|
else {
|
|
ch = rb_io_getc(ARGF.current_file);
|
|
}
|
|
if (NIL_P(ch) && ARGF.next_p != -1) {
|
|
argf_close(ARGF.current_file);
|
|
ARGF.next_p = 1;
|
|
goto retry;
|
|
}
|
|
|
|
return ch;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.readbyte -> Fixnum
|
|
*
|
|
* Reads the next 8-bit byte from ARGF and returns it as a +Fixnum+. Raises
|
|
* an +EOFError+ after the last byte of the last file has been read.
|
|
*
|
|
* For example:
|
|
*
|
|
* $ echo "foo" > file
|
|
* $ ruby argf.rb file
|
|
*
|
|
* ARGF.readbyte #=> 102
|
|
* ARGF.readbyte #=> 111
|
|
* ARGF.readbyte #=> 111
|
|
* ARGF.readbyte #=> 10
|
|
* ARGF.readbyte #=> end of file reached (EOFError)
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.each(sep=$/) {|line| block } -> ARGF
|
|
* ARGF.each(sep=$/,limit) {|line| block } -> ARGF
|
|
* ARGF.each(...) -> an_enumerator
|
|
*
|
|
* ARGF.each_line(sep=$/) {|line| block } -> ARGF
|
|
* ARGF.each_line(sep=$/,limit) {|line| block } -> ARGF
|
|
* ARGF.each_line(...) -> an_enumerator
|
|
*
|
|
* ARGF.lines(sep=$/) {|line| block } -> ARGF
|
|
* ARGF.lines(sep=$/,limit) {|line| block } -> ARGF
|
|
* ARGF.lines(...) -> an_enumerator
|
|
*
|
|
* Returns an enumerator which iterates over each line (separated by _sep_,
|
|
* which defaults to your platform's newline character) of each file in
|
|
* +ARGV+. If a block is supplied, each line in turn will be yielded to the
|
|
* block, otherwise an enumerator is returned.
|
|
* The optional _limit_ argument is a +Fixnum+ specifying the maximum
|
|
* length of each line; longer lines will be split according to this limit.
|
|
*
|
|
* This method allows you to treat the files supplied on the command line as
|
|
* a single file consisting of the concatenation of each named file. After
|
|
* the last line of the first file has been returned, the first line of the
|
|
* second file is returned. The +ARGF.filename+ and +ARGF.lineno+ methods can
|
|
* be used to determine the filename and line number, respectively, of the
|
|
* current line.
|
|
*
|
|
* For example, the following code prints out each line of each named file
|
|
* prefixed with its line number, displaying the filename once per file:
|
|
*
|
|
* ARGF.lines do |line|
|
|
* puts ARGF.filename if ARGF.lineno == 1
|
|
* puts "#{ARGF.lineno}: #{line}"
|
|
* end
|
|
*/
|
|
static VALUE
|
|
argf_each_line(int argc, VALUE *argv, VALUE argf)
|
|
{
|
|
RETURN_ENUMERATOR(argf, argc, argv);
|
|
for (;;) {
|
|
if (!next_argv()) return argf;
|
|
rb_block_call(ARGF.current_file, rb_intern("each_line"), argc, argv, 0, 0);
|
|
ARGF.next_p = 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.bytes {|byte| block } -> ARGF
|
|
* ARGF.bytes -> an_enumerator
|
|
*
|
|
* ARGF.each_byte {|byte| block } -> ARGF
|
|
* ARGF.each_byte -> an_enumerator
|
|
*
|
|
* Iterates over each byte of each file in +ARGV+.
|
|
* A byte is returned as a +Fixnum+ in the range 0..255.
|
|
*
|
|
* This method allows you to treat the files supplied on the command line as
|
|
* a single file consisting of the concatenation of each named file. After
|
|
* the last byte of the first file has been returned, the first byte of the
|
|
* second file is returned. The +ARGF.filename+ method can be used to
|
|
* determine the filename of the current byte.
|
|
*
|
|
* If no block is given, an enumerator is returned instead.
|
|
*
|
|
* For example:
|
|
*
|
|
* ARGF.bytes.to_a #=> [35, 32, ... 95, 10]
|
|
*
|
|
*/
|
|
static VALUE
|
|
argf_each_byte(VALUE argf)
|
|
{
|
|
RETURN_ENUMERATOR(argf, 0, 0);
|
|
for (;;) {
|
|
if (!next_argv()) return argf;
|
|
rb_block_call(ARGF.current_file, rb_intern("each_byte"), 0, 0, 0, 0);
|
|
ARGF.next_p = 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.chars {|char| block } -> ARGF
|
|
* ARGF.chars -> an_enumerator
|
|
*
|
|
* ARGF.each_char {|char| block } -> ARGF
|
|
* ARGF.each_char -> an_enumerator
|
|
*
|
|
* Iterates over each character of each file in +ARGF+.
|
|
*
|
|
* This method allows you to treat the files supplied on the command line as
|
|
* a single file consisting of the concatenation of each named file. After
|
|
* the last character of the first file has been returned, the first
|
|
* character of the second file is returned. The +ARGF.filename+ method can
|
|
* be used to determine the name of the file in which the current character
|
|
* appears.
|
|
*
|
|
* If no block is given, an enumerator is returned instead.
|
|
*/
|
|
static VALUE
|
|
argf_each_char(VALUE argf)
|
|
{
|
|
RETURN_ENUMERATOR(argf, 0, 0);
|
|
for (;;) {
|
|
if (!next_argv()) return argf;
|
|
rb_block_call(ARGF.current_file, rb_intern("each_char"), 0, 0, 0, 0);
|
|
ARGF.next_p = 1;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.filename -> String
|
|
* ARGF.path -> String
|
|
*
|
|
* Returns the current filename. "-" is returned when the current file is
|
|
* STDIN.
|
|
*
|
|
* For example:
|
|
*
|
|
* $ echo "foo" > foo
|
|
* $ echo "bar" > bar
|
|
* $ echo "glark" > glark
|
|
*
|
|
* $ ruby argf.rb foo bar glark
|
|
*
|
|
* ARGF.filename #=> "foo"
|
|
* ARGF.read(5) #=> "foo\nb"
|
|
* ARGF.filename #=> "bar"
|
|
* ARGF.skip
|
|
* ARGF.filename #=> "glark"
|
|
*/
|
|
static VALUE
|
|
argf_filename(VALUE argf)
|
|
{
|
|
next_argv();
|
|
return ARGF.filename;
|
|
}
|
|
|
|
static VALUE
|
|
argf_filename_getter(ID id, VALUE *var)
|
|
{
|
|
return argf_filename(*var);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.file -> IO or File object
|
|
*
|
|
* Returns the current file as an +IO+ or +File+ object. #<IO:<STDIN>> is
|
|
* returned when the current file is STDIN.
|
|
*
|
|
* For example:
|
|
*
|
|
* $ echo "foo" > foo
|
|
* $ echo "bar" > bar
|
|
*
|
|
* $ ruby argf.rb foo bar
|
|
*
|
|
* ARGF.file #=> #<File:foo>
|
|
* ARGF.read(5) #=> "foo\nb"
|
|
* ARGF.file #=> #<File:bar>
|
|
*/
|
|
static VALUE
|
|
argf_file(VALUE argf)
|
|
{
|
|
next_argv();
|
|
return ARGF.current_file;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.binmode -> ARGF
|
|
*
|
|
* Puts +ARGF+ into binary mode. Once a stream is in binary mode, it cannot
|
|
* be reset to non-binary mode. This option has the following effects:
|
|
*
|
|
* * Newline conversion is disabled.
|
|
* * Encoding conversion is disabled.
|
|
* * Content is treated as ASCII-8BIT.
|
|
*/
|
|
static VALUE
|
|
argf_binmode_m(VALUE argf)
|
|
{
|
|
ARGF.binmode = 1;
|
|
next_argv();
|
|
ARGF_FORWARD(0, 0);
|
|
rb_io_ascii8bit_binmode(ARGF.current_file);
|
|
return argf;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.binmode? -> true or false
|
|
*
|
|
* Returns true if +ARGF+ is being read in binary mode; false otherwise. (To
|
|
* enable binary mode use +ARGF.binmode+.
|
|
*
|
|
* For example:
|
|
*
|
|
* ARGF.binmode? #=> false
|
|
* ARGF.binmode
|
|
* ARGF.binmode? #=> true
|
|
*/
|
|
static VALUE
|
|
argf_binmode_p(VALUE argf)
|
|
{
|
|
return ARGF.binmode ? Qtrue : Qfalse;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.skip -> ARGF
|
|
*
|
|
* Sets the current file to the next file in ARGV. If there aren't any more
|
|
* files it has no effect.
|
|
*
|
|
* For example:
|
|
*
|
|
* $ ruby argf.rb foo bar
|
|
* ARGF.filename #=> "foo"
|
|
* ARGF.skip
|
|
* ARGF.filename #=> "bar"
|
|
*/
|
|
static VALUE
|
|
argf_skip(VALUE argf)
|
|
{
|
|
if (ARGF.init_p && ARGF.next_p == 0) {
|
|
argf_close(ARGF.current_file);
|
|
ARGF.next_p = 1;
|
|
}
|
|
return argf;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.close -> ARGF
|
|
*
|
|
* Closes the current file and skips to the next in the stream. Trying to
|
|
* close a file that has already been closed causes an +IOError+ to be
|
|
* raised.
|
|
*
|
|
* For example:
|
|
*
|
|
* $ ruby argf.rb foo bar
|
|
*
|
|
* ARGF.filename #=> "foo"
|
|
* ARGF.close
|
|
* ARGF.filename #=> "bar"
|
|
* ARGF.close
|
|
* ARGF.close #=> closed stream (IOError)
|
|
*/
|
|
static VALUE
|
|
argf_close_m(VALUE argf)
|
|
{
|
|
next_argv();
|
|
argf_close(ARGF.current_file);
|
|
if (ARGF.next_p != -1) {
|
|
ARGF.next_p = 1;
|
|
}
|
|
ARGF.lineno = 0;
|
|
return argf;
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.closed? -> true or false
|
|
*
|
|
* Returns _true_ if the current file has been closed; _false_ otherwise. Use
|
|
* +ARGF.close+ to actually close the current file.
|
|
*/
|
|
static VALUE
|
|
argf_closed(VALUE argf)
|
|
{
|
|
next_argv();
|
|
ARGF_FORWARD(0, 0);
|
|
return rb_io_closed(ARGF.current_file);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.to_s -> String
|
|
*
|
|
* Returns "ARGF".
|
|
*/
|
|
static VALUE
|
|
argf_to_s(VALUE argf)
|
|
{
|
|
return rb_str_new2("ARGF");
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.inplace_mode -> String
|
|
*
|
|
* Returns the file extension appended to the names of modified files under
|
|
* inplace-edit mode. This value can be set using +ARGF.inplace_mode=+ or
|
|
* passing the +-i+ switch to the Ruby binary.
|
|
*/
|
|
static VALUE
|
|
argf_inplace_mode_get(VALUE argf)
|
|
{
|
|
if (!ARGF.inplace) return Qnil;
|
|
return rb_str_new2(ARGF.inplace);
|
|
}
|
|
|
|
static VALUE
|
|
opt_i_get(ID id, VALUE *var)
|
|
{
|
|
return argf_inplace_mode_get(*var);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.inplace_mode = ext -> ARGF
|
|
*
|
|
* Sets the filename extension for inplace editing mode to the given String.
|
|
* Each file being edited has this value appended to its filename. The
|
|
* modified file is saved under this new name.
|
|
*
|
|
* For example:
|
|
*
|
|
* $ ruby argf.rb file.txt
|
|
*
|
|
* ARGF.inplace_mode = '.bak'
|
|
* ARGF.lines do |line|
|
|
* print line.sub("foo","bar")
|
|
* end
|
|
*
|
|
* Each line of _file.txt_ has the first occurrence of "foo" replaced with
|
|
* "bar", then the new line is written out to _file.txt.bak_.
|
|
*/
|
|
static VALUE
|
|
argf_inplace_mode_set(VALUE argf, VALUE val)
|
|
{
|
|
if (!RTEST(val)) {
|
|
if (ARGF.inplace) free(ARGF.inplace);
|
|
ARGF.inplace = 0;
|
|
}
|
|
else {
|
|
StringValue(val);
|
|
if (ARGF.inplace) free(ARGF.inplace);
|
|
ARGF.inplace = 0;
|
|
ARGF.inplace = 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 ARGF.inplace;
|
|
}
|
|
|
|
void
|
|
ruby_set_inplace_mode(const char *suffix)
|
|
{
|
|
if (ARGF.inplace) free(ARGF.inplace);
|
|
ARGF.inplace = 0;
|
|
if (suffix) ARGF.inplace = strdup(suffix);
|
|
}
|
|
|
|
/*
|
|
* call-seq:
|
|
* ARGF.argv -> ARGV
|
|
*
|
|
* Returns the +ARGV+ array, which contains the arguments passed to your
|
|
* script, one per element.
|
|
*
|
|
* For example:
|
|
*
|
|
* $ ruby argf.rb -v glark.txt
|
|
*
|
|
* ARGF.argv #=> ["-v", "glark.txt"]
|
|
*
|
|
*/
|
|
static VALUE
|
|
argf_argv(VALUE argf)
|
|
{
|
|
return ARGF.argv;
|
|
}
|
|
|
|
static VALUE
|
|
argf_argv_getter(ID id, VALUE *var)
|
|
{
|
|
return argf_argv(*var);
|
|
}
|
|
|
|
VALUE
|
|
rb_get_argv(void)
|
|
{
|
|
return ARGF.argv;
|
|
}
|
|
|
|
/*
|
|
* Document-class: IOError
|
|
*
|
|
* Raised when an IO operation fails.
|
|
*
|
|
* File.open("/etc/hosts") {|f| f << "example"}
|
|
* #=> IOError: not opened for writing
|
|
*
|
|
* File.open("/etc/hosts") {|f| f.close; f.read }
|
|
* #=> IOError: closed stream
|
|
*
|
|
* Note that some IO failures raise +SystemCallError+s and these are not
|
|
* subclasses of IOError:
|
|
*
|
|
* File.open("does/not/exist")
|
|
* #=> Errno::ENOENT: No such file or directory - does/not/exist
|
|
*/
|
|
|
|
/*
|
|
* Document-class: EOFError
|
|
*
|
|
* Raised by some IO operations when reaching the end of file. Many IO
|
|
* methods exist in two forms,
|
|
*
|
|
* one that returns +nil+ when the end of file is reached, the other
|
|
* raises EOFError +EOFError+.
|
|
*
|
|
* +EOFError+ is a subclass of +IOError+.
|
|
*
|
|
* file = File.open("/etc/hosts")
|
|
* file.read
|
|
* file.gets #=> nil
|
|
* file.readline #=> EOFError: end of file reached
|
|
*/
|
|
|
|
/*
|
|
* Document-class: ARGF
|
|
*
|
|
* +ARGF+ is a stream designed for use in scripts that process files given as
|
|
* command-line arguments, or passed in via STDIN.
|
|
*
|
|
* The arguments passed to your script are stored in the +ARGV+ Array, one
|
|
* argument per element. +ARGF+ assumes that any arguments that aren't
|
|
* filenames have been removed from +ARGV+. For example:
|
|
*
|
|
* $ ruby argf.rb --verbose file1 file2
|
|
*
|
|
* ARGV #=> ["--verbose", "file1", "file2"]
|
|
* option = ARGV.shift #=> "--verbose"
|
|
* ARGV #=> ["file1", "file2"]
|
|
*
|
|
* You can now use +ARGF+ to work with a concatenation of each of these named
|
|
* files. For instance, +ARGF.read+ will return the contents of _file1_
|
|
* followed by the contents of _file2_.
|
|
*
|
|
* After a file in +ARGV+ has been read, +ARGF+ removes it from the Array.
|
|
* Thus, after all files have been read +ARGV+ will be empty.
|
|
*
|
|
* You can manipulate +ARGV+ yourself to control what +ARGF+ operates on. If
|
|
* you remove a file from +ARGV+, it is ignored by +ARGF+; if you add files to
|
|
* +ARGV+, they are treated as if they were named on the command line. For
|
|
* example:
|
|
*
|
|
* ARGV.replace ["file1"]
|
|
* ARGF.readlines # Returns the contents of file1 as an Array
|
|
* ARGV #=> []
|
|
* ARGV.replace ["file2", "file3"]
|
|
* ARGF.read # Returns the contents of file2 and file3
|
|
*
|
|
* If +ARGV+ is empty, +ARGF+ acts as if it contained STDIN, i.e. the data
|
|
* piped to your script. For example:
|
|
*
|
|
* $ echo "glark" | ruby -e 'p ARGF.read'
|
|
* "glark\n"
|
|
*/
|
|
|
|
/*
|
|
* 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" | Binary file mode (may appear with
|
|
* | any of the key letters listed above).
|
|
* | Suppresses EOL <-> CRLF conversion on Windows. And
|
|
* | sets external encoding to ASCII-8BIT unless explicitly
|
|
* | specified.
|
|
* -----+--------------------------------------------------------
|
|
* "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_mWaitReadable = rb_define_module_under(rb_cIO, "WaitReadable");
|
|
rb_mWaitWritable = rb_define_module_under(rb_cIO, "WaitWritable");
|
|
|
|
#if 0
|
|
/* This is necessary only for forcing rdoc handle File::open */
|
|
rb_define_singleton_method(rb_cFile, "open", rb_io_s_open, -1);
|
|
#endif
|
|
|
|
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, "binread", rb_io_s_binread, -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_rs = rb_default_rs = rb_usascii_str_new2("\n");
|
|
rb_gc_register_mark_object(rb_default_rs);
|
|
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, "each_codepoint", rb_io_each_codepoint, 0);
|
|
rb_define_method(rb_cIO, "lines", rb_io_each_line, -1);
|
|
rb_define_method(rb_cIO, "bytes", rb_io_each_byte, 0);
|
|
rb_define_method(rb_cIO, "chars", rb_io_each_char, 0);
|
|
rb_define_method(rb_cIO, "codepoints", rb_io_each_codepoint, 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, "fdatasync", rb_io_fdatasync, 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_m, 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_method(rb_cIO, "autoclose?", rb_io_autoclose_p, 0);
|
|
rb_define_method(rb_cIO, "autoclose=", rb_io_set_autoclose, 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);
|
|
|
|
/*
|
|
* Hack to get rdoc to regard ARGF as a class:
|
|
* rb_cARGF = rb_define_class("ARGF", rb_cObject);
|
|
*/
|
|
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, rb_gvar_readonly_setter);
|
|
ARGF.filename = rb_str_new2("-");
|
|
|
|
rb_define_hooked_variable("$-i", &argf, opt_i_get, opt_i_set);
|
|
rb_define_hooked_variable("$*", &argf, argf_argv_getter, rb_gvar_readonly_setter);
|
|
|
|
#if defined (_WIN32) || defined(__CYGWIN__)
|
|
atexit(pipe_atexit);
|
|
#endif
|
|
|
|
Init_File();
|
|
|
|
rb_define_method(rb_cFile, "initialize", rb_file_initialize, -1);
|
|
|
|
/* open for reading only */
|
|
rb_file_const("RDONLY", INT2FIX(O_RDONLY));
|
|
/* open for writing only */
|
|
rb_file_const("WRONLY", INT2FIX(O_WRONLY));
|
|
/* open for reading and writing */
|
|
rb_file_const("RDWR", INT2FIX(O_RDWR));
|
|
/* append on each write */
|
|
rb_file_const("APPEND", INT2FIX(O_APPEND));
|
|
/* create file if it does not exist */
|
|
rb_file_const("CREAT", INT2FIX(O_CREAT));
|
|
/* error if CREAT and the file exists */
|
|
rb_file_const("EXCL", INT2FIX(O_EXCL));
|
|
#if defined(O_NDELAY) || defined(O_NONBLOCK)
|
|
# ifndef O_NONBLOCK
|
|
# define O_NONBLOCK O_NDELAY
|
|
# endif
|
|
/* do not block on open or for data to become available */
|
|
rb_file_const("NONBLOCK", INT2FIX(O_NONBLOCK));
|
|
#endif
|
|
/* truncate size to 0 */
|
|
rb_file_const("TRUNC", INT2FIX(O_TRUNC));
|
|
#ifdef O_NOCTTY
|
|
/* not to make opened IO the controlling terminal device */
|
|
rb_file_const("NOCTTY", INT2FIX(O_NOCTTY));
|
|
#endif
|
|
#ifndef O_BINARY
|
|
# define O_BINARY 0
|
|
#endif
|
|
/* disable line code conversion and make ASCII-8BIT */
|
|
rb_file_const("BINARY", INT2FIX(O_BINARY));
|
|
#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
|
|
/* do not follow symlinks */
|
|
rb_file_const("NOFOLLOW", INT2FIX(O_NOFOLLOW)); /* FreeBSD, Linux */
|
|
#endif
|
|
#ifdef O_NOATIME
|
|
/* do not change atime */
|
|
rb_file_const("NOATIME", INT2FIX(O_NOATIME)); /* 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"));
|
|
sym_autoclose = ID2SYM(rb_intern("autoclose"));
|
|
}
|