/********************************************************************** io.c - $Author$ $Date$ created at: Fri Oct 15 18:08:59 JST 1993 Copyright (C) 1993-2003 Yukihiro Matsumoto Copyright (C) 2000 Network Applied Communication Laboratory, Inc. Copyright (C) 2000 Information-technology Promotion Agency, Japan **********************************************************************/ #include "ruby.h" #include "rubyio.h" #include "rubysig.h" #include #include #include #if !defined(_WIN32) && !defined(__DJGPP__) # if defined(__BEOS__) # include # else # include # endif #endif #if defined(MSDOS) || defined(__BOW__) || defined(__CYGWIN__) || defined(_WIN32) || defined(__human68k__) || defined(__EMX__) || defined(__BEOS__) # define NO_SAFE_RENAME #endif #if defined(MSDOS) || defined(__CYGWIN__) || defined(_WIN32) # define NO_LONG_FNAME #endif #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(sun) || defined(_nec_ews) # define USE_SETVBUF #endif #ifdef __QNXNTO__ #include "unix.h" #endif #include #if defined(HAVE_SYS_IOCTL_H) && !defined(DJGPP) && !defined(_WIN32) && !defined(__human68k__) #include #endif #if defined(HAVE_FCNTL_H) || defined(_WIN32) #include #elif defined(HAVE_SYS_FCNTL_H) #include #endif #if !HAVE_OFF_T && !defined(off_t) # define off_t long #endif #include /* EMX has sys/param.h, but.. */ #if defined(HAVE_SYS_PARAM_H) && !(defined(__EMX__) || defined(__HIUX_MPP__)) # include #endif #if !defined NOFILE # define NOFILE 64 #endif #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_SYSCALL_H #include #elif defined HAVE_SYS_SYSCALL_H #include #endif extern void Init_File(void); #ifdef __BEOS__ # ifndef NOFILE # define NOFILE (OPEN_MAX) # endif #include #endif #include "util.h" #ifndef O_ACCMODE #define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR) #endif #if SIZEOF_OFF_T > SIZEOF_LONG && !defined(HAVE_LONG_LONG) # error off_t is bigger than long, but you have no long long... #endif #ifndef PIPE_BUF # ifdef _POSIX_PIPE_BUF # define PIPE_BUF _POSIX_PIPE_BUF # else # define PIPE_BUF 512 /* is this ok? */ # endif #endif VALUE rb_cIO; VALUE rb_eEOFError; VALUE rb_eIOError; VALUE rb_stdin, rb_stdout, rb_stderr; VALUE rb_deferr; /* rescue VIM plugin */ static VALUE orig_stdout, orig_stderr; VALUE rb_output_fs; VALUE rb_rs; VALUE rb_output_rs; VALUE rb_default_rs; static VALUE argf; static ID id_write, id_read, id_getc, id_flush; extern char *ruby_inplace_mode; struct timeval rb_time_interval(VALUE); static VALUE filename, current_file; static int gets_lineno; static int init_p = 0, next_p = 0; static VALUE lineno = INT2FIX(0); #ifdef _STDIO_USES_IOSTREAM /* GNU libc */ # ifdef _IO_fpos_t # define STDIO_READ_DATA_PENDING(fp) ((fp)->_IO_read_ptr != (fp)->_IO_read_end) # else # define STDIO_READ_DATA_PENDING(fp) ((fp)->_gptr < (fp)->_egptr) # endif #elif defined(FILE_COUNT) # define STDIO_READ_DATA_PENDING(fp) ((fp)->FILE_COUNT > 0) #elif defined(FILE_READEND) # define STDIO_READ_DATA_PENDING(fp) ((fp)->FILE_READPTR < (fp)->FILE_READEND) #elif defined(__BEOS__) # define STDIO_READ_DATA_PENDING(fp) (fp->_state._eof == 0) #elif defined(__VMS) # define STDIO_READ_DATA_PENDING(fp) (((unsigned int)(*(fp))->_cnt) > 0) #else # define STDIO_READ_DATA_PENDING(fp) (!feof(fp)) #endif #if defined(__VMS) #define fopen(file_spec, mode) fopen(file_spec, mode, "rfm=stmlf") #define open(file_spec, flags, mode) open(file_spec, flags, mode, "rfm=stmlf") #endif #define READ_DATA_PENDING(fptr) ((fptr)->rbuf_len) #define READ_DATA_PENDING_COUNT(fptr) ((fptr)->rbuf_len) #define READ_DATA_PENDING_PTR(fptr) ((fptr)->rbuf+(fptr)->rbuf_off) #define READ_DATA_BUFFERED(fptr) READ_DATA_PENDING(fptr) #define READ_CHECK(fptr) do {\ if (!READ_DATA_PENDING(fptr)) {\ rb_thread_wait_fd((fptr)->fd);\ rb_io_check_closed(fptr);\ }\ } while(0) #ifndef S_ISSOCK # ifdef _S_ISSOCK # define S_ISSOCK(m) _S_ISSOCK(m) # else # ifdef _S_IFSOCK # define S_ISSOCK(m) ((m & S_IFMT) == _S_IFSOCK) # else # ifdef S_IFSOCK # define S_ISSOCK(m) ((m & S_IFMT) == S_IFSOCK) # endif # endif # endif #endif #if defined(_WIN32) #define is_socket(fd, path) rb_w32_is_socket(fd) #elif !defined(S_ISSOCK) #define is_socket(fd, path) 0 #define shutdown(a,b) 0 #else static int is_socket(int fd, const char *path) { struct stat sbuf; if (fstat(fd, &sbuf) < 0) rb_sys_fail(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_TAINTED(io) && rb_safe_level() >= 4) rb_raise(rb_eSecurityError, "Insecure: operation on untainted 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 *); static 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"); } static void io_unread(rb_io_t *fptr) { off_t r; rb_io_check_closed(fptr); if (fptr->rbuf_len == 0 || fptr->mode & FMODE_DUPLEX) return; /* xxx: target position may be negative if buffer is filled by ungetc */ r = lseek(fptr->fd, -fptr->rbuf_len, SEEK_CUR); if (r < 0) { if (errno == ESPIPE) fptr->mode |= FMODE_DUPLEX; return; } fptr->rbuf_off = 0; fptr->rbuf_len = 0; return; } static int io_ungetc(int c, rb_io_t *fptr) { if (fptr->rbuf == NULL) { fptr->rbuf_off = 0; fptr->rbuf_len = 0; fptr->rbuf_capa = 8192; fptr->rbuf = ALLOC_N(char, fptr->rbuf_capa); } if (c < 0 || fptr->rbuf_len == fptr->rbuf_capa) { return -1; } if (fptr->rbuf_off == 0) { if (fptr->rbuf_len) MEMMOVE(fptr->rbuf+1, fptr->rbuf, char, fptr->rbuf_len); fptr->rbuf_off = 1; } fptr->rbuf_off--; fptr->rbuf_len++; fptr->rbuf[fptr->rbuf_off] = c; return c; } static rb_io_t * flush_before_seek(rb_io_t *fptr) { io_fflush(fptr); io_unread(fptr); return fptr; } #define io_seek(fptr, ofs, whence) lseek(flush_before_seek(fptr)->fd, ofs, whence) #define io_tell(fptr) lseek(flush_before_seek(fptr)->fd, 0, SEEK_CUR) #ifndef SEEK_CUR # define SEEK_SET 0 # define SEEK_CUR 1 # define SEEK_END 2 #endif #define FMODE_SYNCWRITE (FMODE_SYNC|FMODE_WRITABLE) void rb_io_check_readable(rb_io_t *fptr) { rb_io_check_closed(fptr); if (!(fptr->mode & FMODE_READABLE)) { rb_raise(rb_eIOError, "not opened for reading"); } if (fptr->wbuf_len) { io_fflush(fptr); } } void rb_io_check_writable(rb_io_t *fptr) { rb_io_check_closed(fptr); if (!(fptr->mode & FMODE_WRITABLE)) { rb_raise(rb_eIOError, "not opened for writing"); } if (fptr->rbuf_len) { io_unread(fptr); } } int rb_read_pending(FILE *fp) { return STDIO_READ_DATA_PENDING(fp); } int rb_io_read_pending(rb_io_t *fptr) { return READ_DATA_PENDING(fptr); } void rb_read_check(FILE *fp) { if (!STDIO_READ_DATA_PENDING(fp)) { rb_thread_wait_fd(fileno(fp)); } } void rb_io_read_check(rb_io_t *fptr) { if (!READ_DATA_PENDING(fptr)) { rb_thread_wait_fd(fptr->fd); } return; } static int ruby_dup(int orig) { int fd; fd = dup(orig); if (fd < 0) { if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) { rb_gc(); fd = dup(orig); } if (fd < 0) { rb_sys_fail(0); } } return fd; } static VALUE io_alloc(VALUE klass) { NEWOBJ(io, struct RFile); OBJSETUP(io, klass, T_FILE); io->fptr = 0; return (VALUE)io; } #ifndef S_ISREG # define S_ISREG(m) ((m & S_IFMT) == S_IFREG) #endif static int wsplit_p(rb_io_t *fptr) { int r; 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; } static int io_fflush(rb_io_t *fptr) { int r, l; int wbuf_off, wbuf_len; rb_io_check_closed(fptr); if (fptr->wbuf_len == 0) return 0; if (!rb_thread_fd_writable(fptr->fd)) { rb_io_check_closed(fptr); } retry: if (fptr->wbuf_len == 0) return 0; wbuf_off = fptr->wbuf_off; wbuf_len = fptr->wbuf_len; l = fptr->wbuf_len; if (PIPE_BUF < l && !rb_thread_critical && !rb_thread_alone() && wsplit_p(fptr)) { l = PIPE_BUF; } TRAP_BEG; r = write(fptr->fd, fptr->wbuf+fptr->wbuf_off, l); TRAP_END; /* xxx: signal handler may modify wbuf */ if (r == fptr->wbuf_len) { fptr->wbuf_off = 0; fptr->wbuf_len = 0; return 0; } if (0 <= r) { fptr->wbuf_off = (wbuf_off += r); fptr->wbuf_len = (wbuf_len -= r); errno = EAGAIN; } if (rb_io_wait_writable(fptr->fd)) { rb_io_check_closed(fptr); goto retry; } return -1; } #ifdef HAVE_RB_FD_INIT static VALUE wait_readable(VALUE p) { rb_fdset_t *rfds = (rb_fdset_t *)p; return rb_thread_select(rb_fd_max(rfds), rb_fd_ptr(rfds), NULL, NULL, NULL); } #endif int rb_io_wait_readable(int f) { rb_fdset_t rfds; switch (errno) { case EINTR: #if defined(ERESTART) case ERESTART: #endif rb_thread_wait_fd(f); return Qtrue; case EAGAIN: #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN case EWOULDBLOCK: #endif rb_fd_init(&rfds); rb_fd_set(f, &rfds); #ifdef HAVE_RB_FD_INIT rb_ensure(wait_readable, (VALUE)&rfds, (VALUE (*)(VALUE))rb_fd_term, (VALUE)&rfds); #else rb_thread_select(f + 1, &rfds, NULL, NULL, NULL); #endif return Qtrue; default: return Qfalse; } } #ifdef HAVE_RB_FD_INIT static VALUE wait_writable(VALUE p) { rb_fdset_t *wfds = (rb_fdset_t *)p; return rb_thread_select(rb_fd_max(wfds), NULL, rb_fd_ptr(wfds), NULL, NULL); } #endif int rb_io_wait_writable(int f) { rb_fdset_t wfds; switch (errno) { case EINTR: #if defined(ERESTART) case ERESTART: #endif rb_thread_fd_writable(f); return Qtrue; case EAGAIN: #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN case EWOULDBLOCK: #endif rb_fd_init(&wfds); rb_fd_set(f, &wfds); #ifdef HAVE_RB_FD_INIT rb_ensure(wait_writable, (VALUE)&wfds, (VALUE (*)(VALUE))rb_fd_term, (VALUE)&wfds); #else rb_thread_select(f + 1, NULL, &wfds, NULL, NULL); #endif return Qtrue; default: return Qfalse; } } /* writing functions */ static long io_fwrite(VALUE str, rb_io_t *fptr) { long len, n, r, l, offset = 0; len = RSTRING_LEN(str); if ((n = len) <= 0) return n; if (fptr->wbuf == NULL && !(fptr->mode & FMODE_SYNC)) { fptr->wbuf_off = 0; fptr->wbuf_len = 0; fptr->wbuf_capa = 8192; fptr->wbuf = ALLOC_N(char, fptr->wbuf_capa); } if ((fptr->mode & FMODE_SYNC) || (fptr->wbuf && fptr->wbuf_capa <= fptr->wbuf_len + len) || ((fptr->mode & FMODE_TTY) && memchr(RSTRING_PTR(str)+offset, '\n', len))) { /* xxx: use writev to avoid double write if available */ if (fptr->wbuf_len && fptr->wbuf_len+len <= fptr->wbuf_capa) { if (fptr->wbuf_capa < fptr->wbuf_off+fptr->wbuf_len+len) { MEMMOVE(fptr->wbuf, fptr->wbuf+fptr->wbuf_off, char, fptr->wbuf_len); fptr->wbuf_off = 0; } MEMMOVE(fptr->wbuf+fptr->wbuf_off+fptr->wbuf_len, RSTRING_PTR(str)+offset, char, len); fptr->wbuf_len += len; n = 0; } if (io_fflush(fptr) < 0) return -1L; if (n == 0) return len; /* avoid context switch between "a" and "\n" in STDERR.puts "a". [ruby-dev:25080] */ if (fptr->stdio_file != stderr && !rb_thread_fd_writable(fptr->fd)) { rb_io_check_closed(fptr); } retry: l = n; if (PIPE_BUF < l && !rb_thread_critical && !rb_thread_alone() && wsplit_p(fptr)) { l = PIPE_BUF; } TRAP_BEG; r = write(fptr->fd, RSTRING_PTR(str)+offset, l); TRAP_END; /* xxx: signal handler may modify given string. */ if (r == n) return len; if (0 <= r) { offset += r; n -= r; errno = EAGAIN; } if (rb_io_wait_writable(fptr->fd)) { rb_io_check_closed(fptr); if (offset < RSTRING_LEN(str)) goto retry; } return -1L; } if (fptr->wbuf_off) { if (fptr->wbuf_len) MEMMOVE(fptr->wbuf, fptr->wbuf+fptr->wbuf_off, char, fptr->wbuf_len); fptr->wbuf_off = 0; } MEMMOVE(fptr->wbuf+fptr->wbuf_off+fptr->wbuf_len, RSTRING_PTR(str)+offset, char, len); fptr->wbuf_len += len; return len; } long rb_io_fwrite(const char *ptr, long len, FILE *f) { rb_io_t of; of.fd = fileno(f); of.stdio_file = f; of.mode = FMODE_WRITABLE; of.path = NULL; return io_fwrite(rb_str_new(ptr, len), &of); } /* * call-seq: * ios.write(string) => integer * * Writes the given string to ios. The stream must be opened * for writing. If the argument is not a string, it will be converted * to a string using to_s. Returns the number of bytes * written. * * count = $stdout.write( "This is a test\n" ) * puts "That was #{count} bytes of data" * * produces: * * This is a test * That was 15 bytes of data */ static VALUE io_write(VALUE io, VALUE str) { rb_io_t *fptr; long n; VALUE tmp; rb_secure(4); str = rb_obj_as_string(str); tmp = rb_io_check_io(io); if (NIL_P(tmp)) { /* port is not IO, call write method for it. */ return rb_funcall(io, id_write, 1, str); } io = tmp; if (RSTRING_LEN(str) == 0) return INT2FIX(0); GetOpenFile(io, fptr); rb_io_check_writable(fptr); n = io_fwrite(str, fptr); if (n == -1L) rb_sys_fail(fptr->path); return LONG2FIX(n); } VALUE rb_io_write(VALUE io, VALUE str) { return rb_funcall(io, id_write, 1, str); } /* * call-seq: * ios << obj => ios * * String Output---Writes obj to ios. * obj will be converted to a string using * to_s. * * $stdout << "Hello " << "world!\n" * * produces: * * 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 ios 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 * * produces: * * no newline */ VALUE rb_io_flush(VALUE io) { rb_io_t *fptr; if (TYPE(io) != T_FILE) { return rb_funcall(io, id_flush, 0); } GetOpenFile(io, fptr); if (fptr->mode & FMODE_WRITABLE) { io_fflush(fptr); } if (fptr->mode & FMODE_READABLE) { io_unread(fptr); } return io; } /* * call-seq: * ios.pos => integer * ios.tell => integer * * Returns the current offset (in bytes) of ios. * * 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) rb_sys_fail(fptr->path); 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) rb_sys_fail(fptr->path); return INT2FIX(0); } /* * call-seq: * ios.seek(amount, whence=SEEK_SET) -> 0 * * Seeks to a given offset anInteger in the stream according to * the value of whence: * * 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 ios. * * f = File.new("testfile") * f.pos = 17 * f.gets #=> "This is line two\n" */ static VALUE rb_io_set_pos(VALUE io, VALUE offset) { rb_io_t *fptr; off_t pos; pos = NUM2OFFT(offset); GetOpenFile(io, fptr); pos = io_seek(fptr, pos, SEEK_SET); if (pos < 0) rb_sys_fail(fptr->path); return OFFT2NUM(pos); } /* * call-seq: * ios.rewind => 0 * * Positions ios to the beginning of input, resetting * lineno to zero. * * f = File.new("testfile") * f.readline #=> "This is line one\n" * f.rewind #=> 0 * f.lineno #=> 0 * f.readline #=> "This is line one\n" */ static VALUE rb_io_rewind(VALUE io) { rb_io_t *fptr; GetOpenFile(io, fptr); if (io_seek(fptr, 0L, 0) < 0) rb_sys_fail(fptr->path); if (io == current_file) { gets_lineno -= fptr->lineno; } fptr->lineno = 0; return INT2FIX(0); } static int io_getc(rb_io_t *fptr) { int r; 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 (fptr->rbuf == NULL) { fptr->rbuf_off = 0; fptr->rbuf_len = 0; fptr->rbuf_capa = 8192; fptr->rbuf = ALLOC_N(char, fptr->rbuf_capa); } if (fptr->rbuf_len == 0) { retry: TRAP_BEG; r = read(fptr->fd, fptr->rbuf, fptr->rbuf_capa); TRAP_END; /* xxx: signal handler may modify rbuf */ if (r < 0) { if (rb_io_wait_readable(fptr->fd)) goto retry; rb_sys_fail(fptr->path); } fptr->rbuf_off = 0; fptr->rbuf_len = r; if (r == 0) return -1; /* EOF */ } fptr->rbuf_off++; fptr->rbuf_len--; return (unsigned char)fptr->rbuf[fptr->rbuf_off-1]; } /* * call-seq: * ios.eof => true or false * ios.eof? => true or false * * Returns true if ios is at end of file that means * there are no more data to read. * The stream must be opened for reading or an IOError will be * raised. * * f = File.new("testfile") * dummy = f.readlines * f.eof #=> true * * If ios is a stream such as pipe or socket, IO#eof? * 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 IO#eof? reads data to a input buffer. * So IO#sysread doesn't work with IO#eof?. */ VALUE rb_io_eof(VALUE io) { rb_io_t *fptr; int ch; GetOpenFile(io, fptr); rb_io_check_readable(fptr); if (READ_DATA_PENDING(fptr)) return Qfalse; READ_CHECK(fptr); ch = io_getc(fptr); if (ch != EOF) { io_ungetc(ch, fptr); return Qfalse; } return Qtrue; } /* * call-seq: * ios.sync => true or false * * Returns the current ``sync mode'' of ios. When sync mode is * true, all output is immediately flushed to the underlying operating * system and is not buffered by Ruby internally. See also * IO#fsync. * * f = File.new("testfile") * f.sync #=> false */ static VALUE rb_io_sync(VALUE io) { rb_io_t *fptr; GetOpenFile(io, fptr); return (fptr->mode & FMODE_SYNC) ? Qtrue : Qfalse; } /* * call-seq: * ios.sync = boolean => boolean * * Sets the ``sync mode'' to true or false. * 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 IO#fsync. * * f = File.new("testfile") * f.sync = true * * (produces no output) */ static VALUE rb_io_set_sync(VALUE io, VALUE mode) { rb_io_t *fptr; GetOpenFile(io, fptr); if (RTEST(mode)) { fptr->mode |= FMODE_SYNC; } else { fptr->mode &= ~FMODE_SYNC; } return mode; } /* * call-seq: * ios.fsync => 0 or nil * * Immediately writes all buffered data in ios to disk. * Returns nil if the underlying operating system does not * support fsync(2). Note that fsync differs from * using IO#sync=. The latter ensures that data is flushed * from Ruby's buffers, but doesn't not guarantee that the underlying * operating system actually writes it to disk. */ static VALUE rb_io_fsync(VALUE io) { #ifdef HAVE_FSYNC rb_io_t *fptr; GetOpenFile(io, fptr); io_fflush(fptr); if (fsync(fptr->fd) < 0) rb_sys_fail(fptr->path); return INT2FIX(0); #else rb_notimplement(); return Qnil; /* not reached */ #endif } /* * call-seq: * ios.fileno => fixnum * ios.to_i => fixnum * * Returns an integer representing the numeric file descriptor for * ios. * * $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 * ios. This will be set by IO::popen. * * pipe = IO.popen("-") * if pipe * $stderr.puts "In parent, child pid is #{pipe.pid}" * else * $stderr.puts "In child, pid is #{$$}" * end * * produces: * * 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 INT2FIX(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; char *cname; const char *st = ""; fptr = RFILE(rb_io_taint_check(obj))->fptr; if (!fptr || !fptr->path) return rb_any_to_s(obj); cname = rb_obj_classname(obj); if (fptr->fd < 0) { st = " (closed)"; } return rb_sprintf("#<%s:%s%s>", cname, fptr->path, st); } /* * call-seq: * ios.to_io -> ios * * Returns ios. */ static VALUE rb_io_to_io(VALUE io) { return io; } /* reading functions */ static long read_buffered_data(char *ptr, long len, rb_io_t *fptr) { long n; n = READ_DATA_PENDING_COUNT(fptr); if (n <= 0) return 0; if (n > len) n = len; MEMMOVE(ptr, fptr->rbuf+fptr->rbuf_off, char, n); fptr->rbuf_off += n; fptr->rbuf_len -= n; return n; } static long io_fread(VALUE str, long offset, rb_io_t *fptr) { long len = RSTRING_LEN(str) - offset; long n = len; int c; 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); c = io_getc(fptr); if (c < 0) { break; } RSTRING_PTR(str)[offset++] = c; if (offset > RSTRING_LEN(str)) break; n--; } return len - n; } long rb_io_fread(char *ptr, long len, FILE *f) { rb_io_t of; VALUE str; long n; of.fd = fileno(f); of.stdio_file = f; of.mode = FMODE_READABLE; str = rb_str_new(ptr, len); n = io_fread(str, 0, &of); MEMCPY(ptr, RSTRING_PTR(str), char, n); return n; } #define SMALLBUF 100 static long remain_size(rb_io_t *fptr) { struct stat st; off_t siz = READ_DATA_PENDING_COUNT(fptr); off_t pos; if (fstat(fptr->fd, &st) == 0 && S_ISREG(st.st_mode) #ifdef __BEOS__ && (st.st_dev > 3) #endif ) { io_fflush(fptr); pos = lseek(fptr->fd, 0, SEEK_CUR); if (st.st_size >= pos && pos >= 0) { siz += st.st_size - pos + 1; if (siz > LONG_MAX) { rb_raise(rb_eIOError, "file too big for single read"); } } } else { siz += BUFSIZ; } return (long)siz; } static VALUE read_all(rb_io_t *fptr, long siz, VALUE str) { long bytes = 0; long n; 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 (bytes < siz) break; siz += BUFSIZ; rb_str_resize(str, siz); } if (bytes != siz) rb_str_resize(str, bytes); OBJ_TAINT(str); return str; } void rb_io_set_nonblock(rb_io_t *fptr) { int flags; #ifdef F_GETFL flags = fcntl(fptr->fd, F_GETFL); if (flags == -1) { rb_sys_fail(fptr->path); } #else flags = 0; #endif if ((flags & O_NONBLOCK) == 0) { flags |= O_NONBLOCK; if (fcntl(fptr->fd, F_SETFL, flags) == -1) { rb_sys_fail(fptr->path); } } } static VALUE io_getpartial(int argc, VALUE *argv, VALUE io, int nonblock) { rb_io_t *fptr; VALUE length, str; long n, len; rb_scan_args(argc, argv, "11", &length, &str); if ((len = NUM2LONG(length)) < 0) { rb_raise(rb_eArgError, "negative length %ld given", len); } if (NIL_P(str)) { str = rb_str_new(0, len); } else { StringValue(str); rb_str_modify(str); rb_str_resize(str, len); } OBJ_TAINT(str); GetOpenFile(io, fptr); rb_io_check_readable(fptr); if (len == 0) return str; if (!nonblock) READ_CHECK(fptr); if (RSTRING_LEN(str) != len) { modified: rb_raise(rb_eRuntimeError, "buffer string modified"); } n = read_buffered_data(RSTRING_PTR(str), len, fptr); if (n <= 0) { again: if (RSTRING_LEN(str) != len) goto modified; if (nonblock) { rb_io_set_nonblock(fptr); n = read(fptr->fd, RSTRING_PTR(str), len); } else { TRAP_BEG; n = read(fptr->fd, RSTRING_PTR(str), len); TRAP_END; } if (n < 0) { if (!nonblock && rb_io_wait_readable(fptr->fd)) goto again; rb_sys_fail(fptr->path); } } 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 maxlen bytes from the I/O stream. * It blocks only if ios has no data immediately available. * It doesn't block if some data available. * If the optional outbuf argument is present, * it must reference a String, which will receive the data. * It raises EOFError on end of file. * * readpartial is designed for streams such as pipe, socket, tty, etc. * It blocks only when no data immediately available. * This means that it blocks only when following all conditions hold. * * the buffer in the IO object is empty. * * the content of the stream is empty. * * the stream is not reached to EOF. * * When readpartial blocks, it waits data or EOF on the stream. * If some data is reached, readpartial returns with the data. * If EOF is reached, readpartial raises EOFError. * * When readpartial doesn't blocks, it returns or raises immediately. * If the buffer is not empty, it returns the data in the buffer. * Otherwise if the stream has some content, * it returns the data in the stream. * Otherwise if the stream is reached to EOF, it raises EOFError. * * r, w = IO.pipe # buffer pipe content * w << "abc" # "" "abc". * r.readpartial(4096) #=> "abc" "" "" * r.readpartial(4096) # blocks because buffer and pipe is empty. * * r, w = IO.pipe # buffer pipe content * w << "abc" # "" "abc" * w.close # "" "abc" EOF * r.readpartial(4096) #=> "abc" "" EOF * r.readpartial(4096) # raises EOFError * * r, w = IO.pipe # buffer pipe content * w << "abc\ndef\n" # "" "abc\ndef\n" * r.gets #=> "abc\n" "def\n" "" * w << "ghi\n" # "def\n" "ghi\n" * r.readpartial(4096) #=> "def\n" "" "ghi\n" * r.readpartial(4096) #=> "ghi\n" "" "" * * Note that readpartial behaves similar to sysread. * The differences are: * * If the buffer is not empty, read from the buffer instead of "sysread for buffered IO (IOError)". * * It doesn't cause Errno::EAGAIN and Errno::EINTR. When readpartial meets EAGAIN and EINTR by read system call, readpartial retry the system call. * * The later means that readpartial is nonblocking-flag insensitive. * It blocks on the situation IO#sysread causes Errno::EAGAIN as if the fd is blocking mode. * */ static VALUE io_readpartial(int argc, VALUE *argv, VALUE io) { VALUE ret; ret = io_getpartial(argc, argv, io, 0); if (NIL_P(ret)) rb_eof_error(); else return ret; } /* * call-seq: * ios.read_nonblock(maxlen) => string * ios.read_nonblock(maxlen, outbuf) => outbuf * * Reads at most maxlen bytes from ios using * read(2) system call after O_NONBLOCK is set for * the underlying file descriptor. * * If the optional outbuf argument is present, * it must reference a String, which will receive the data. * * read_nonblock just calls read(2). * It causes all errors read(2) causes: EAGAIN, EINTR, etc. * The caller should care such errors. * * read_nonblock causes EOFError on EOF. * * If the read buffer is not empty, * read_nonblock reads from the buffer like readpartial. * In this case, read(2) is not called. * */ static VALUE io_read_nonblock(int argc, VALUE *argv, VALUE io) { VALUE ret; ret = io_getpartial(argc, argv, io, 1); if (NIL_P(ret)) rb_eof_error(); else return ret; } /* * call-seq: * ios.write_nonblock(string) => integer * * Writes the given string to ios using * write(2) system call after O_NONBLOCK is set for * the underlying file descriptor. * * write_nonblock just calls write(2). * It causes all errors write(2) causes: EAGAIN, EINTR, etc. * The result may also be smaller than string.length (partial write). * The caller should care such errors and partial write. * * If the write buffer is not empty, it is flushed at first. * */ static VALUE rb_io_write_nonblock(VALUE io, VALUE str) { rb_io_t *fptr; long n; rb_secure(4); if (TYPE(str) != T_STRING) str = rb_obj_as_string(str); GetOpenFile(io, fptr); rb_io_check_writable(fptr); io_fflush(fptr); rb_io_set_nonblock(fptr); n = write(fptr->fd, RSTRING_PTR(str), RSTRING_LEN(str)); if (n == -1) rb_sys_fail(fptr->path); return LONG2FIX(n); } /* * call-seq: * ios.read([length [, buffer]]) => string, buffer, or nil * * Reads at most length bytes from the I/O stream, or to the * end of file if length is omitted or is nil. * length must be a non-negative integer or nil. * If the optional buffer argument is present, it must reference * a String, which will receive the data. * * At end of file, it returns nil or "" * depend on length. * ios.read() and * ios.read(nil) returns "". * ios.read(positive-integer) returns nil. * * ios.read(0) returns "". * * f = File.new("testfile") * f.read(16) #=> "This is line one" */ static VALUE io_read(int argc, VALUE *argv, VALUE io) { rb_io_t *fptr; long n, len; VALUE length, str; rb_scan_args(argc, argv, "02", &length, &str); if (NIL_P(length)) { if (!NIL_P(str)) StringValue(str); GetOpenFile(io, fptr); rb_io_check_readable(fptr); return read_all(fptr, remain_size(fptr), str); } len = NUM2LONG(length); if (len < 0) { rb_raise(rb_eArgError, "negative length %ld given", len); } if (NIL_P(str)) { str = rb_tainted_str_new(0, len); } else { StringValue(str); rb_str_modify(str); rb_str_resize(str,len); } GetOpenFile(io, fptr); rb_io_check_readable(fptr); if (len == 0) return str; READ_CHECK(fptr); if (RSTRING_LEN(str) != len) { rb_raise(rb_eRuntimeError, "buffer string modified"); } n = io_fread(str, 0, fptr); if (n == 0) { if (fptr->fd < 0) return Qnil; rb_str_resize(str, 0); return Qnil; } rb_str_resize(str, n); OBJ_TAINT(str); return str; } static int appendline(rb_io_t *fptr, int delim, VALUE *strp, long *lp) { VALUE str = *strp; int c = EOF; long limit = *lp; do { long pending = READ_DATA_PENDING_COUNT(fptr); if (pending > 0) { const char *p = READ_DATA_PENDING_PTR(fptr); const char *e; long last = 0, len = (c != EOF); if (limit > 0 && pending > limit) pending = limit; e = memchr(p, delim, pending); if (e) pending = e - p + 1; len += pending; if (!NIL_P(str)) { last = RSTRING_LEN(str); rb_str_resize(str, last + len); } else { *strp = str = rb_str_buf_new(len); rb_str_set_len(str, len); } if (c != EOF) { RSTRING_PTR(str)[last++] = c; } read_buffered_data(RSTRING_PTR(str) + last, pending, fptr); /* must not fail */ limit -= pending; *lp = limit; if (limit == 0) return RSTRING_PTR(str)[RSTRING_LEN(str)-1]; if (e) return delim; } else if (c != EOF) { if (!NIL_P(str)) { char ch = c; rb_str_buf_cat(str, &ch, 1); } else { *strp = str = rb_str_buf_new(1); rb_str_resize(str, 1); RSTRING_PTR(str)[0] = c; } } rb_thread_wait_fd(fptr->fd); rb_io_check_closed(fptr); c = io_getc(fptr); limit--; if (c < 0) { *lp = limit; return c; } } while (c != delim); { char ch = c; if (!NIL_P(str)) { rb_str_cat(str, &ch, 1); } else { *strp = str = rb_str_new(&ch, 1); } } return c; } static inline int swallow(rb_io_t *fptr, int term) { int c; do { long cnt; while ((cnt = READ_DATA_PENDING_COUNT(fptr)) > 0) { char buf[1024]; const char *p = READ_DATA_PENDING_PTR(fptr); int i; if (cnt > sizeof buf) cnt = sizeof buf; if (*p != term) return Qtrue; i = cnt; while (--i && *++p == term); if (!read_buffered_data(buf, cnt - i, fptr)) /* must not fail */ rb_sys_fail(fptr->path); } rb_thread_wait_fd(fptr->fd); rb_io_check_closed(fptr); c = io_getc(fptr); if (c != term) { io_ungetc(c, fptr); return Qtrue; } } while (c != EOF); return Qfalse; } static VALUE rb_io_getline_fast(rb_io_t *fptr, unsigned char delim, long limit) { VALUE str = Qnil; int c, nolimit = 0; for (;;) { c = appendline(fptr, delim, &str, &limit); if (c == EOF || c == delim) break; if (limit == 0) { nolimit = 1; break; } } if (!NIL_P(str)) { if (!nolimit) { fptr->lineno++; lineno = INT2FIX(fptr->lineno); } OBJ_TAINT(str); } return str; } static int rscheck(const char *rsptr, long rslen, VALUE rs) { if (RSTRING_PTR(rs) != rsptr && RSTRING_LEN(rs) != rslen) rb_raise(rb_eRuntimeError, "rs modified"); return 0; } static void prepare_getline_args(int argc, VALUE *argv, VALUE *rsp, long *limit) { VALUE lim, rs; if (argc == 0) { rs = rb_rs; lim = Qnil; } else { rb_scan_args(argc, argv, "11", &rs, &lim); if (NIL_P(lim) && !NIL_P(rs) && TYPE(rs) != T_STRING) { VALUE tmp = rb_check_string_type(rs); if (NIL_P(tmp)) { lim = rs; rs = rb_rs; } else { rs = tmp; } } } *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; GetOpenFile(io, fptr); rb_io_check_readable(fptr); if (NIL_P(rs)) { str = read_all(fptr, 0, Qnil); if (RSTRING_LEN(str) == 0) return Qnil; } else if (limit == 0) { return rb_str_new(0,0); } else if (rs == rb_default_rs) { return rb_io_getline_fast(fptr, '\n', limit); } else { int c, newline; const char *rsptr; long rslen; int rspara = 0; rslen = RSTRING_LEN(rs); if (rslen == 0) { rsptr = "\n\n"; rslen = 2; rspara = 1; swallow(fptr, '\n'); } else if (rslen == 1) { return rb_io_getline_fast(fptr, (unsigned char)RSTRING_PTR(rs)[0], limit); } else { rsptr = RSTRING_PTR(rs); } newline = rsptr[rslen - 1]; while ((c = appendline(fptr, newline, &str, &limit)) != EOF) { if (c == newline) { if (RSTRING_LEN(str) < rslen) continue; if (!rspara) rscheck(rsptr, rslen, rs); if (memcmp(RSTRING_PTR(str) + RSTRING_LEN(str) - rslen, rsptr, rslen) == 0) break; } if (limit == 0) { nolimit = 1; break; } } if (rspara) { if (c != EOF) { swallow(fptr, '\n'); } } } if (!NIL_P(str)) { if (!nolimit) { fptr->lineno++; lineno = INT2FIX(fptr->lineno); } OBJ_TAINT(str); } return str; } static VALUE rb_io_getline(int argc, VALUE *argv, VALUE io) { VALUE rs; long limit; prepare_getline_args(argc, argv, &rs, &limit); return rb_io_getline_1(rs, limit, io); } VALUE rb_io_gets(VALUE io) { rb_io_t *fptr; GetOpenFile(io, fptr); rb_io_check_readable(fptr); return rb_io_getline_fast(fptr, '\n', 0); } /* * 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 * sep. A separator of nil 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 IOError * will be raised. The line read in will be returned and also assigned * to $_. Returns nil if called at end of * file. If the first argument is an integer, or optional second * argument is given, the returning string would not be longer than the * given value. * * File.new("testfile").gets #=> "This is line one\n" * $_ #=> "This is line one\n" */ static VALUE rb_io_gets_m(int argc, VALUE *argv, VALUE io) { VALUE str; str = rb_io_getline(argc, argv, io); rb_lastline_set(str); return str; } /* * call-seq: * ios.lineno => integer * * Returns the current line number in ios. The stream must be * opened for reading. lineno counts the number of times * gets is called, rather than the number of newlines * encountered. The two values will differ if gets is * called with a separator other than newline. See also the * $. variable. * * f = File.new("testfile") * f.lineno #=> 0 * f.gets #=> "This is line one\n" * f.lineno #=> 1 * f.gets #=> "This is line two\n" * f.lineno #=> 2 */ static VALUE rb_io_lineno(VALUE io) { rb_io_t *fptr; GetOpenFile(io, fptr); rb_io_check_readable(fptr); return INT2NUM(fptr->lineno); } /* * call-seq: * ios.lineno = integer => integer * * Manually sets the current line number to the given value. * $. 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 * $. # lineno of last read #=> 1 * f.gets #=> "This is line two\n" * $. # lineno of last read #=> 1001 */ static VALUE rb_io_set_lineno(VALUE io, VALUE lineno) { rb_io_t *fptr; GetOpenFile(io, fptr); rb_io_check_readable(fptr); fptr->lineno = NUM2INT(lineno); return lineno; } static void lineno_setter(VALUE val, ID id, VALUE *var) { gets_lineno = NUM2INT(val); *var = INT2FIX(gets_lineno); } static VALUE argf_set_lineno(VALUE argf, VALUE val) { gets_lineno = NUM2INT(val); lineno = INT2FIX(gets_lineno); return Qnil; } static VALUE argf_lineno(void) { return lineno; } /* * call-seq: * ios.readline(sep=$/) => string * ios.readline(limit) => string * ios.readline(sep, limit) => string * * Reads a line as with IO#gets, but raises an * EOFError 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 ios, and returns them in * anArray. Lines are separated by the optional sep. If * sep is nil, the rest of the stream is returned * as a single record. If the first argument is an integer, or * optional second argument is given, the returning string would not be * longer than the given value. The stream must be opened for reading * or an IOError 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); ary = rb_ary_new(); while (!NIL_P(line = rb_io_getline_1(rs, limit, io))) { rb_ary_push(ary, line); } return ary; } /* * call-seq: * ios.each(sep=$/) {|line| block } => ios * ios.each(limit) {|line| block } => ios * ios.each(sep,limit) {|line| block } => ios * ios.each_line(sep=$/) {|line| block } => ios * ios.each_line(limit) {|line| block } => ios * ios.each_line(sep,limit) {|line| block } => ios * * Executes the block for every line in ios, where lines are * separated by sep. ios must be opened for * reading or an IOError will be raised. * * f = File.new("testfile") * f.each {|line| puts "#{f.lineno}: #{line}" } * * produces: * * 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); while (!NIL_P(str = rb_io_getline_1(rs, limit, io))) { rb_yield(str); } return io; } /* * call-seq: * ios.each_byte {|byte| block } => ios * * Calls the given block once for each byte (0..255) in ios, * passing the byte as an argument. The stream must be opened for * reading or an IOError will be raised. * * f = File.new("testfile") * checksum = 0 * f.each_byte {|x| checksum ^= x } #=> # * checksum #=> 12 */ static VALUE rb_io_each_byte(VALUE io) { rb_io_t *fptr; int c; RETURN_ENUMERATOR(io, 0, 0); GetOpenFile(io, fptr); for (;;) { rb_io_check_readable(fptr); READ_CHECK(fptr); c = io_getc(fptr); if (c < 0) { break; } rb_yield(INT2FIX(c & 0xff)); } return io; } /* * call-seq: * str.lines(sep=$/) => anEnumerator * str.lines(limit) => anEnumerator * str.lines(sep, limit) => anEnumerator * * Returns an enumerator that gives each line in the string. * * "foo\nbar\n".lines.to_a #=> ["foo\n", "bar\n"] * "foo\nb ar".lines.sort #=> ["b ar", "foo\n"] */ static VALUE rb_io_lines(int argc, VALUE *argv, VALUE str) { return rb_enumeratorize(str, ID2SYM(rb_intern("each_line")), argc, argv); } /* * call-seq: * str.bytes => anEnumerator * * Returns an enumerator that gives each byte in the string. * * "hello".bytes.to_a #=> [104, 101, 108, 108, 111] */ static VALUE rb_io_bytes(VALUE str) { return rb_enumeratorize(str, ID2SYM(rb_intern("each_byte")), 0, 0); } VALUE rb_io_getc(VALUE io) { rb_io_t *fptr; int c; GetOpenFile(io, fptr); rb_io_check_readable(fptr); READ_CHECK(fptr); c = io_getc(fptr); if (c < 0) { return Qnil; } return INT2FIX(c & 0xff); } /* * call-seq: * ios.getc => string or nil * * Reads a one-character string from ios. Returns * nil if called at end of file. * * f = File.new("testfile") * f.getc #=> "8" * f.getc #=> "1" */ VALUE rb_io_getc_m(VALUE io) { char ch; rb_io_t *fptr; int c; GetOpenFile(io, fptr); rb_io_check_readable(fptr); READ_CHECK(fptr); c = io_getc(fptr); if (c < 0) { return Qnil; } ch = c & 0xff; return rb_str_new(&ch, 1); } int rb_getc(FILE *f) { int c; if (!STDIO_READ_DATA_PENDING(f)) { rb_thread_wait_fd(fileno(f)); } TRAP_BEG; c = getc(f); TRAP_END; return c; } /* * call-seq: * ios.readchar => string * * Reads a character as with IO#getc, but raises an * EOFError on end of file. */ static VALUE rb_io_readchar(VALUE io) { VALUE c = rb_io_getc_m(io); if (NIL_P(c)) { rb_eof_error(); } return c; } /* * call-seq: * ios.ungetc(string) => nil * * Pushes back one character (passed as a parameter) onto ios, * such that a subsequent buffered read will return it. Only one character * may be pushed back before a subsequent read operation (that is, * you will be able to read only the last of several characters that have been pushed * back). Has no effect with unbuffered reads (such as IO#sysread). * * f = File.new("testfile") #=> # * c = f.getc #=> "8" * f.ungetc(c) #=> nil * f.getc #=> "8" */ VALUE rb_io_ungetc(VALUE io, VALUE c) { rb_io_t *fptr; int cc; GetOpenFile(io, fptr); rb_io_check_readable(fptr); if (NIL_P(c)) return Qnil; if (FIXNUM_P(c)) { cc = FIX2INT(c); } else { SafeStringValue(c); if (RSTRING_LEN(c) > 1) { rb_warn("IO#ungetc pushes back only one byte"); } cc = (unsigned char)RSTRING_PTR(c)[0]; } if (io_ungetc(cc, fptr) == EOF && cc != EOF) { rb_raise(rb_eIOError, "ungetc failed"); } return Qnil; } /* * call-seq: * ios.isatty => true or false * ios.tty? => true or false * * Returns true if ios is associated with a * terminal device (tty), false 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; } #define FMODE_PREP (1<<16) #define IS_PREP_STDIO(f) ((f)->mode & FMODE_PREP) #define PREP_STDIO_NAME(f) ((f)->path) static void fptr_finalize(rb_io_t *fptr, int noraise) { if (fptr->wbuf_len) { io_fflush(fptr); } if (IS_PREP_STDIO(fptr) || fptr->fd <= 2) { return; } if (fptr->stdio_file) { if (fclose(fptr->stdio_file) < 0 && !noraise) { /* fptr->stdio_file is deallocated anyway */ fptr->stdio_file = 0; fptr->fd = -1; rb_sys_fail(fptr->path); } } else if (0 <= fptr->fd) { if (close(fptr->fd) < 0 && !noraise) { /* fptr->fd is still not closed */ rb_sys_fail(fptr->path); } } fptr->fd = -1; fptr->stdio_file = 0; fptr->mode &= ~(FMODE_READABLE|FMODE_WRITABLE); } static void rb_io_fptr_cleanup(rb_io_t *fptr, int noraise) { if (fptr->finalize) { (*fptr->finalize)(fptr, noraise); } else { fptr_finalize(fptr, noraise); } } int rb_io_fptr_finalize(rb_io_t *fptr) { if (!fptr) return 0; if (fptr->refcnt <= 0 || --fptr->refcnt) return 0; if (fptr->path) { free(fptr->path); fptr->path = 0; } if (0 <= fptr->fd) rb_io_fptr_cleanup(fptr, Qtrue); if (fptr->rbuf) { free(fptr->rbuf); fptr->rbuf = 0; } if (fptr->wbuf) { free(fptr->wbuf); fptr->wbuf = 0; } free(fptr); return 1; } VALUE rb_io_close(VALUE io) { rb_io_t *fptr; int fd; fptr = RFILE(io)->fptr; if (!fptr) return Qnil; if (fptr->fd < 0) return Qnil; fd = fptr->fd; rb_io_fptr_cleanup(fptr, Qfalse); rb_thread_fd_close(fd); if (fptr->pid) { rb_syswait(fptr->pid); fptr->pid = 0; } return Qnil; } /* * call-seq: * ios.close => nil * * Closes ios and flushes any pending writes to the operating * system. The stream is unavailable for any further data operations; * an IOError is raised if such an attempt is made. I/O * streams are automatically closed when they are claimed by the * garbage collector. * * If ios is opened by IO.popen, * close sets $?. */ static VALUE rb_io_close_m(VALUE io) { if (rb_safe_level() >= 4 && !OBJ_TAINTED(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 true if ios is completely closed (for * duplex streams, both reader and writer), false * 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; 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 * IOError if the stream is not duplexed. * * f = IO.popen("/bin/sh","r+") * f.close_read * f.readlines * * produces: * * 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; if (rb_safe_level() >= 4 && !OBJ_TAINTED(io)) { rb_raise(rb_eSecurityError, "Insecure: can't close"); } GetOpenFile(io, fptr); if (is_socket(fptr->fd, fptr->path)) { #ifndef SHUT_RD # define SHUT_RD 0 #endif if (shutdown(fptr->fd, SHUT_RD) < 0) rb_sys_fail(fptr->path); fptr->mode &= ~FMODE_READABLE; if (!(fptr->mode & FMODE_WRITABLE)) return rb_io_close(io); 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 * IOError if the stream is not duplexed. * * f = IO.popen("/bin/sh","r+") * f.close_write * f.print "nowhere" * * produces: * * 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; if (rb_safe_level() >= 4 && !OBJ_TAINTED(io)) { rb_raise(rb_eSecurityError, "Insecure: can't close"); } GetOpenFile(io, fptr); if (is_socket(fptr->fd, fptr->path)) { #ifndef SHUT_WR # define SHUT_WR 1 #endif if (shutdown(fptr->fd, SHUT_WR) < 0) rb_sys_fail(fptr->path); fptr->mode &= ~FMODE_WRITABLE; if (!(fptr->mode & FMODE_READABLE)) return rb_io_close(io); return Qnil; } if (fptr->mode & FMODE_READABLE) { rb_raise(rb_eIOError, "closing non-duplex IO for writing"); } return rb_io_close(io); } /* * call-seq: * ios.sysseek(offset, whence=SEEK_SET) => integer * * Seeks to a given offset in the stream according to the value * of whence (see IO#seek for values of * whence). Returns the new offset into the file. * * f = File.new("testfile") * f.sysseek(-13, IO::SEEK_END) #=> 53 * f.sysread(10) #=> "And so on." */ static VALUE rb_io_sysseek(int argc, VALUE *argv, VALUE io) { VALUE offset, ptrname; int whence = SEEK_SET; rb_io_t *fptr; off_t pos; if (rb_scan_args(argc, argv, "11", &offset, &ptrname) == 2) { whence = NUM2INT(ptrname); } pos = NUM2OFFT(offset); GetOpenFile(io, fptr); if ((fptr->mode & FMODE_READABLE) && READ_DATA_BUFFERED(fptr)) { rb_raise(rb_eIOError, "sysseek for buffered IO"); } if ((fptr->mode & FMODE_WRITABLE) && fptr->wbuf_len) { rb_warn("sysseek for buffered IO"); } pos = lseek(fptr->fd, pos, whence); if (pos == -1) rb_sys_fail(fptr->path); return OFFT2NUM(pos); } /* * call-seq: * ios.syswrite(string) => integer * * Writes the given string to ios using a low-level write. * Returns the number of bytes written. Do not mix with other methods * that write to ios or you may get unpredictable results. * Raises SystemCallError 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); GetOpenFile(io, fptr); rb_io_check_writable(fptr); if (fptr->wbuf_len) { rb_warn("syswrite for buffered IO"); } if (!rb_thread_fd_writable(fptr->fd)) { rb_io_check_closed(fptr); } TRAP_BEG; n = write(fptr->fd, RSTRING_PTR(str), RSTRING_LEN(str)); TRAP_END; if (n == -1) rb_sys_fail(fptr->path); return LONG2FIX(n); } /* * call-seq: * ios.sysread(integer[, outbuf]) => string * * Reads integer bytes from ios using a low-level * read and returns them as a string. Do not mix with other methods * that read from ios or you may get unpredictable results. * If the optional outbuf argument is present, it must reference * a String, which will receive the data. * Raises SystemCallError on error and * EOFError at end of file. * * f = File.new("testfile") * f.sysread(16) #=> "This is line one" */ static VALUE rb_io_sysread(int argc, VALUE *argv, VALUE io) { VALUE len, str; rb_io_t *fptr; long n, ilen; rb_scan_args(argc, argv, "11", &len, &str); ilen = NUM2LONG(len); if (NIL_P(str)) { str = rb_str_new(0, ilen); } else { StringValue(str); rb_str_modify(str); rb_str_resize(str, ilen); } if (ilen == 0) return str; GetOpenFile(io, fptr); rb_io_check_readable(fptr); if (READ_DATA_BUFFERED(fptr)) { rb_raise(rb_eIOError, "sysread for buffered IO"); } n = fptr->fd; rb_thread_wait_fd(fptr->fd); rb_io_check_closed(fptr); if (RSTRING_LEN(str) != ilen) { rb_raise(rb_eRuntimeError, "buffer string modified"); } TRAP_BEG; n = read(fptr->fd, RSTRING_PTR(str), ilen); TRAP_END; if (n == -1) { rb_sys_fail(fptr->path); } rb_str_set_len(str, n); if (n == 0 && ilen > 0) { rb_eof_error(); } rb_str_resize(str, n); OBJ_TAINT(str); return str; } /* * call-seq: * ios.binmode => ios * * Puts ios into binary mode. This is useful only in * MS-DOS/Windows environments. Once a stream is in binary mode, it * cannot be reset to nonbinary mode. */ VALUE rb_io_binmode(VALUE io) { #if defined(_WIN32) || defined(DJGPP) || defined(__CYGWIN__) || defined(__human68k__) || defined(__EMX__) rb_io_t *fptr; GetOpenFile(io, fptr); if (!(fptr->mode & FMODE_BINMODE) && READ_DATA_BUFFERED(fptr)) { rb_raise(rb_eIOError, "buffer already filled with text-mode content"); } if (0 <= fptr->fd && setmode(fptr->fd, O_BINARY) == -1) rb_sys_fail(fptr->path); fptr->mode |= FMODE_BINMODE; #endif return io; } static const char* rb_io_flags_mode(int flags) { #ifdef O_BINARY # define MODE_BINMODE(a,b) ((flags & FMODE_BINMODE) ? (b) : (a)) #else # define MODE_BINMODE(a,b) (a) #endif if (flags & FMODE_APPEND) { if ((flags & FMODE_READWRITE) == FMODE_READWRITE) { return MODE_BINMODE("a+", "ab+"); } return MODE_BINMODE("a", "ab"); } switch (flags & FMODE_READWRITE) { case FMODE_READABLE: return MODE_BINMODE("r", "rb"); case FMODE_WRITABLE: return MODE_BINMODE("w", "wb"); case FMODE_READWRITE: if (flags & FMODE_CREATE) { return MODE_BINMODE("w+", "wb+"); } return MODE_BINMODE("r+", "rb+"); } rb_raise(rb_eArgError, "illegal access modenum %o", flags); return NULL; /* not reached */ } int rb_io_mode_flags(const char *mode) { int flags = 0; const char *m = mode; switch (*m++) { case 'r': flags |= FMODE_READABLE; break; case 'w': flags |= FMODE_WRITABLE | FMODE_CREATE; break; case 'a': flags |= FMODE_WRITABLE | FMODE_APPEND | FMODE_CREATE; break; default: error: rb_raise(rb_eArgError, "illegal access mode %s", mode); } while (*m) { switch (*m++) { case 'b': flags |= FMODE_BINMODE; break; case '+': flags |= FMODE_READWRITE; break; default: goto error; } } return flags; } int rb_io_modenum_flags(int mode) { int flags = 0; switch (mode & (O_RDONLY|O_WRONLY|O_RDWR)) { case O_RDONLY: flags = FMODE_READABLE; break; case O_WRONLY: flags = FMODE_WRITABLE; break; case O_RDWR: flags = FMODE_READWRITE; break; } if (mode & O_APPEND) { flags |= FMODE_APPEND; } if (mode & O_CREAT) { flags |= FMODE_CREATE; } #ifdef O_BINARY if (mode & O_BINARY) { flags |= FMODE_BINMODE; } #endif return flags; } static int rb_io_mode_modenum(const char *mode) { int flags = 0; const char *m = mode; switch (*m++) { case 'r': flags |= O_RDONLY; break; case 'w': flags |= O_WRONLY | O_CREAT | O_TRUNC; break; case 'a': flags |= O_WRONLY | O_CREAT | O_APPEND; break; default: error: rb_raise(rb_eArgError, "illegal access mode %s", mode); } while (*m) { switch (*m++) { case 'b': #ifdef O_BINARY flags |= O_BINARY; #endif break; case '+': flags = (flags & ~O_ACCMODE) | O_RDWR; break; default: goto error; } } return flags; } #define MODENUM_MAX 4 static const char* rb_io_modenum_mode(int flags) { #ifdef O_BINARY # define MODE_BINARY(a,b) ((flags & O_BINARY) ? (b) : (a)) #else # define MODE_BINARY(a,b) (a) #endif if (flags & O_APPEND) { if ((flags & O_RDWR) == O_RDWR) { return MODE_BINARY("a+", "ab+"); } return MODE_BINARY("a", "ab"); } switch (flags & (O_RDONLY|O_WRONLY|O_RDWR)) { case O_RDONLY: return MODE_BINARY("r", "rb"); case O_WRONLY: return MODE_BINARY("w", "wb"); case O_RDWR: return MODE_BINARY("r+", "rb+"); } rb_raise(rb_eArgError, "illegal access modenum %o", flags); return NULL; /* not reached */ } static int rb_sysopen(char *fname, int flags, unsigned int mode) { int fd; fd = open(fname, flags, mode); if (fd < 0) { if (errno == EMFILE || errno == ENFILE) { rb_gc(); fd = open(fname, flags, mode); } if (fd < 0) { rb_sys_fail(fname); } } return fd; } FILE * rb_fopen(const char *fname, const char *mode) { FILE *file; file = fopen(fname, mode); if (!file) { if (errno == EMFILE || errno == ENFILE) { rb_gc(); file = fopen(fname, mode); } if (!file) { rb_sys_fail(fname); } } #ifdef USE_SETVBUF if (setvbuf(file, NULL, _IOFBF, 0) != 0) rb_warn("setvbuf() can't be honoured for %s", fname); #endif #ifdef __human68k__ setmode(fileno(file), O_TEXT); #endif return file; } FILE * rb_fdopen(int fd, const char *mode) { FILE *file; #if defined(sun) errno = 0; #endif file = fdopen(fd, mode); if (!file) { if ( #if defined(sun) errno == 0 || #endif errno == EMFILE || errno == ENFILE) { rb_gc(); #if defined(sun) errno = 0; #endif file = fdopen(fd, mode); } if (!file) { #ifdef _WIN32 if (errno == 0) errno = EINVAL; #elif defined(sun) if (errno == 0) errno = EMFILE; #endif rb_sys_fail(0); } } /* xxx: should be _IONBF? A buffer in FILE may have trouble. */ #ifdef USE_SETVBUF if (setvbuf(file, NULL, _IOFBF, 0) != 0) rb_warn("setvbuf() can't be honoured (fd=%d)", fd); #endif return file; } static void io_check_tty(rb_io_t *fptr) { if (isatty(fptr->fd)) fptr->mode |= FMODE_TTY|FMODE_DUPLEX; } static VALUE rb_file_open_internal(VALUE io, const char *fname, const char *mode) { rb_io_t *fptr; MakeOpenFile(io, fptr); fptr->mode = rb_io_mode_flags(mode); fptr->path = strdup(fname); fptr->fd = rb_sysopen(fptr->path, rb_io_mode_modenum(rb_io_flags_mode(fptr->mode)), 0666); io_check_tty(fptr); return io; } VALUE rb_file_open(const char *fname, const char *mode) { return rb_file_open_internal(io_alloc(rb_cFile), fname, mode); } static VALUE rb_file_sysopen_internal(VALUE io, const char *fname, int flags, int mode) { rb_io_t *fptr; MakeOpenFile(io, fptr); fptr->path = strdup(fname); fptr->mode = rb_io_modenum_flags(flags); fptr->fd = rb_sysopen(fptr->path, flags, mode); io_check_tty(fptr); return io; } VALUE rb_file_sysopen(const char *fname, int flags, int mode) { return rb_file_sysopen_internal(io_alloc(rb_cFile), fname, flags, mode); } #if defined(__CYGWIN__) || !defined(HAVE_FORK) static struct pipe_list { rb_io_t *fptr; struct pipe_list *next; } *pipe_list; static void pipe_add_fptr(rb_io_t *fptr) { struct pipe_list *list; list = ALLOC(struct pipe_list); list->fptr = fptr; list->next = pipe_list; pipe_list = list; } static void pipe_del_fptr(rb_io_t *fptr) { struct pipe_list *list = pipe_list; struct pipe_list *tmp; if (list->fptr == fptr) { pipe_list = list->next; free(list); return; } while (list->next) { if (list->next->fptr == fptr) { tmp = list->next; list->next = list->next->next; free(tmp); return; } list = list->next; } } static void pipe_atexit(void) { struct pipe_list *list = pipe_list; struct pipe_list *tmp; while (list) { tmp = list->next; rb_io_fptr_finalize(list->fptr); list = tmp; } } static void pipe_finalize(rb_io_t *fptr, int noraise) { #if !defined(HAVE_FORK) && !defined(_WIN32) int status; if (fptr->stdio_file) { status = pclose(fptr->stdio_file); } fptr->fd = -1; fptr->stdio_file = 0; #if defined DJGPP status <<= 8; #endif rb_last_status_set(status, fptr->pid); #else fptr_finalize(fptr, noraise); #endif pipe_del_fptr(fptr); } #endif void rb_io_synchronized(rb_io_t *fptr) { fptr->mode |= FMODE_SYNC; } void rb_io_unbuffered(rb_io_t *fptr) { rb_io_synchronized(fptr); } struct popen_arg { struct rb_exec_arg exec; int modef; int pair[2]; }; static void popen_redirect(struct popen_arg *p) { if ((p->modef & FMODE_READABLE) && (p->modef & FMODE_WRITABLE)) { close(p->pair[0]); dup2(p->pair[1], 0); dup2(p->pair[1], 1); if (2 <= p->pair[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]); } } } #ifdef HAVE_FORK static int popen_exec(void *pp) { struct popen_arg *p = (struct popen_arg*)pp; int fd; popen_redirect(p); for (fd = 3; fd < NOFILE; fd++) { #ifdef FD_CLOEXEC if (fcntl(fd, F_GETFD) & FD_CLOEXEC) continue; #endif close(fd); } return rb_exec(&p->exec); } #endif static VALUE pipe_open(int argc, VALUE *argv, const char *mode) { int modef = rb_io_mode_flags(mode); int pid = 0; rb_io_t *fptr; VALUE port, prog; #if defined(HAVE_FORK) int status; struct popen_arg arg; #elif defined(_WIN32) int openmode = rb_io_mode_modenum(mode); char *exename = NULL; #endif volatile int doexec; char *cmd; FILE *fp = 0; int fd = -1; prog = rb_check_argv(argc, argv); if (!prog) { if (argc == 1) argc = 0; prog = argv[0]; } cmd = StringValueCStr(prog); doexec = (strcmp("-", cmd) != 0); #if !defined(HAVE_FORK) if (!doexec) { rb_raise(rb_eNotImpError, "The fork(2) function is unimplemented on this machine"); } #endif #if defined(HAVE_FORK) if (!doexec) { fflush(stdin); /* is it really needed? */ rb_io_flush(rb_stdout); rb_io_flush(rb_stderr); } arg.modef = modef; arg.pair[0] = arg.pair[1] = -1; switch (modef & (FMODE_READABLE|FMODE_WRITABLE)) { #if defined(HAVE_SOCKETPAIR) case FMODE_READABLE|FMODE_WRITABLE: if (socketpair(AF_UNIX, SOCK_STREAM, 0, arg.pair) < 0) rb_sys_fail(cmd); break; #endif case FMODE_READABLE: if (pipe(arg.pair) < 0) rb_sys_fail(cmd); break; case FMODE_WRITABLE: if (pipe(arg.pair) < 0) rb_sys_fail(cmd); break; default: rb_sys_fail(cmd); } if (doexec) { arg.exec.argc = argc; arg.exec.argv = argv; arg.exec.prog = cmd; pid = rb_fork(&status, popen_exec, &arg); } else { pid = rb_fork(&status, 0, 0); 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]); errno = e; rb_sys_fail(cmd); } if ((modef & FMODE_READABLE) && (modef & FMODE_WRITABLE)) { close(arg.pair[1]); fd = arg.pair[0]; } else if (modef & FMODE_READABLE) { close(arg.pair[1]); fd = arg.pair[0]; } else { close(arg.pair[0]); fd = arg.pair[1]; } #elif defined(_WIN32) if (argc) { char **args = ALLOCA_N(char *, argc+1); int i; for (i = 0; i < argc; ++i) { args[i] = RSTRING_PTR(argv[i]); } args[i] = NULL; cmd = ALLOCA_N(char, rb_w32_argv_size(args)); rb_w32_join_argv(cmd, args); exename = RSTRING_PTR(prog); } while ((pid = rb_w32_pipe_exec(cmd, exename, openmode, &fd)) == -1) { /* exec failed */ switch (errno) { case EAGAIN: #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN case EWOULDBLOCK: #endif rb_thread_sleep(1); break; default: rb_sys_fail(RSTRING_PTR(prog)); break; } } #else if (argc) { prog = rb_ary_join(rb_ary_new4(argc, argv), rb_str_new2(" ")); cmd = StringValueCStr(prog); } fp = popen(cmd, mode); 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 = modef | FMODE_SYNC|FMODE_DUPLEX; fptr->pid = pid; #if defined (__CYGWIN__) || !defined(HAVE_FORK) fptr->finalize = pipe_finalize; pipe_add_fptr(fptr); #endif return port; } /* * call-seq: * IO.popen(cmd, mode="r") => io * IO.popen(cmd, mode="r") {|io| block } => obj * * Runs the specified command as a subprocess; the subprocess's * standard input and output will be connected to the returned * IO object. If _cmd_ is a +String+ * ``-'', then a new instance of Ruby is started as the * subprocess. If cmd is an +Array+ of +String+, then it will * be used as the subprocess's +argv+ bypassing a shell. The default * mode for the new file object is ``r'', but mode may be set * to any of the modes listed in the description for class IO. * * Raises exceptions which IO::pipe and * Kernel::system 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 $?. * In this case IO::popen returns * the value of the block. * * If a block is given with a _cmd_ of ``-'', * 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 nil, and the child's standard in and * standard out will be connected to the parent through the pipe. Not * available on all platforms. * * f = IO.popen("uname") * p f.readlines * puts "Parent is #{Process.pid}" * IO.popen("date") { |f| puts f.gets } * IO.popen("-") {|f| $stderr.puts "#{Process.pid} is here, f is #{f}"} * p $? * IO.popen(%w"sed -e s|^|| -e s&$&;zot;&", "r+") {|f| * f.puts "bar"; f.close_write; puts f.gets * } * * produces: * * ["Linux\n"] * Parent is 26166 * Wed Apr 9 08:53:52 CDT 2003 * 26169 is here, f is * 26166 is here, f is # * # * bar;zot; */ static VALUE rb_io_s_popen(int argc, VALUE *argv, VALUE klass) { const char *mode; VALUE pname, pmode, port, tmp; if (rb_scan_args(argc, argv, "11", &pname, &pmode) == 1) { mode = "r"; } else if (FIXNUM_P(pmode)) { mode = rb_io_modenum_mode(FIX2INT(pmode)); } else { mode = rb_io_flags_mode(rb_io_mode_flags(StringValuePtr(pmode))); } tmp = rb_check_array_type(pname); if (!NIL_P(tmp)) { VALUE *argv = ALLOCA_N(VALUE, RARRAY_LEN(tmp)); MEMCPY(argv, RARRAY_PTR(tmp), VALUE, RARRAY_LEN(tmp)); port = pipe_open(RARRAY_LEN(tmp), argv, mode); pname = tmp; } else { SafeStringValue(pname); port = pipe_open(1, &pname, mode); } 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 VALUE rb_open_file(int argc, VALUE *argv, VALUE io) { VALUE fname, vmode, perm; const char *mode; int flags, fmode; rb_scan_args(argc, argv, "12", &fname, &vmode, &perm); FilePathValue(fname); if (FIXNUM_P(vmode) || !NIL_P(perm)) { if (FIXNUM_P(vmode)) { flags = FIX2INT(vmode); } else { SafeStringValue(vmode); flags = rb_io_mode_modenum(RSTRING_PTR(vmode)); } fmode = NIL_P(perm) ? 0666 : NUM2INT(perm); rb_file_sysopen_internal(io, RSTRING_PTR(fname), flags, fmode); } else { mode = NIL_P(vmode) ? "r" : StringValuePtr(vmode); rb_file_open_internal(io, RSTRING_PTR(fname), mode); } return io; } /* * call-seq: * IO.open(fd, mode_string="r" ) => io * IO.open(fd, mode_string="r" ) {|io| block } => obj * * With no associated block, open is a synonym for * IO::new. If the optional code block is given, it will * be passed io as an argument, and the IO object will * automatically be closed when the block terminates. In this instance, * IO::open 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 * Fixnum. * * IO.sysopen("testfile") #=> 3 * */ static VALUE rb_io_s_sysopen(int argc, VALUE *argv) { VALUE fname, vmode, perm; int flags, fmode, fd; char *path; rb_scan_args(argc, argv, "12", &fname, &vmode, &perm); FilePathValue(fname); if (NIL_P(vmode)) flags = O_RDONLY; else if (FIXNUM_P(vmode)) flags = FIX2INT(vmode); else { SafeStringValue(vmode); flags = rb_io_mode_modenum(RSTRING_PTR(vmode)); } if (NIL_P(perm)) fmode = 0666; else fmode = NUM2INT(perm); path = ALLOCA_N(char, strlen(RSTRING_PTR(fname))+1); strcpy(path, RSTRING_PTR(fname)); fd = rb_sysopen(path, flags, fmode); return INT2NUM(fd); } /* * call-seq: * open(path [, mode [, perm]] ) => io or nil * open(path [, mode [, perm]] ) {|io| block } => obj * * Creates an IO object connected to the given stream, * file, or subprocess. * * If path does not start with a pipe character * (``|''), treat it as the name of a file to open using * the specified mode (defaulting to ``r''). (See the table * of valid modes on page 331.) 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 * File object as a parameter, and the file will be * automatically closed when the block terminates. The call * returns the value of the block. * * If path starts with a pipe character, a subprocess is * created, connected to the caller by a pair of pipes. The returned * IO object may be used to write to the standard input * and read from the standard output of this subprocess. If the command * following the ``|'' is a single minus sign, Ruby forks, * and this subprocess is connected to the parent. In the subprocess, * the open call returns nil. If the command * is not ``-'', the subprocess runs the command. If a * block is associated with an open("|-") call, that block * will be run twice---once in the parent and once in the child. The * block parameter will be an IO object in the parent and * nil in the child. The parent's IO object * will be connected to the child's $stdin and * $stdout. The subprocess will be terminated at the end * of the block. * * open("testfile") do |f| * print f.gets * end * * produces: * * This is line one * * Open a subprocess and read its output: * * cmd = open("|date") * print cmd.gets * cmd.close * * produces: * * 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 * * produces: * * 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 * * produces: * * Got: in Child */ static VALUE rb_f_open(int argc, VALUE *argv) { if (argc >= 1) { ID to_open = rb_intern("to_open"); if (rb_respond_to(argv[0], to_open)) { 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; } else { VALUE tmp = rb_check_string_type(argv[0]); if (!NIL_P(tmp)) { char *str = StringValuePtr(tmp); if (str && str[0] == '|') { argv[0] = rb_str_new(str+1, RSTRING_LEN(tmp)-1); OBJ_INFECT(argv[0], tmp); return rb_io_s_popen(argc, argv, rb_cIO); } } } } return rb_io_s_open(argc, argv, rb_cFile); } static VALUE rb_io_open(const char *fname, const char *mode) { if (fname[0] == '|') { VALUE cmd = rb_str_new2(fname+1); return pipe_open(1, &cmd, mode); } else { return rb_file_open(fname, mode); } } 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_TAINTED(io) || !OBJ_TAINTED(nfile))) { rb_raise(rb_eSecurityError, "Insecure: can't reopen"); } GetOpenFile(io, fptr); GetOpenFile(nfile, orig); if (fptr == orig) return io; #if !defined __CYGWIN__ if (IS_PREP_STDIO(fptr)) { if (((fptr->mode & FMODE_READWRITE) & (orig->mode & FMODE_READWRITE)) != (fptr->mode & FMODE_READWRITE)) { rb_raise(rb_eArgError, "%s can't change access mode from \"%s\" to \"%s\"", PREP_STDIO_NAME(fptr), rb_io_flags_mode(fptr->mode), rb_io_flags_mode(orig->mode)); } } #endif if (orig->mode & FMODE_READABLE) { pos = io_tell(orig); } if (orig->mode & FMODE_WRITABLE) { io_fflush(orig); } if (fptr->mode & FMODE_WRITABLE) { io_fflush(fptr); } /* copy rb_io_t structure */ fptr->mode = orig->mode | (fptr->mode & FMODE_PREP); fptr->pid = orig->pid; fptr->lineno = orig->lineno; if (fptr->path) free(fptr->path); if (orig->path) fptr->path = strdup(orig->path); else fptr->path = 0; fptr->finalize = orig->finalize; fd = fptr->fd; fd2 = orig->fd; if (fd != fd2) { #if !defined __CYGWIN__ if (IS_PREP_STDIO(fptr)) { /* need to keep stdio objects */ if (dup2(fd2, fd) < 0) rb_sys_fail(orig->path); } else { #endif if (fptr->stdio_file) fclose(fptr->stdio_file); else close(fptr->fd); fptr->stdio_file = 0; fptr->fd = -1; if (dup2(fd2, fd) < 0) rb_sys_fail(orig->path); fptr->fd = fd; #if !defined __CYGWIN__ } #endif rb_thread_fd_close(fd); if ((orig->mode & FMODE_READABLE) && pos >= 0) { if (io_seek(fptr, pos, SEEK_SET) < 0) { rb_sys_fail(fptr->path); } if (io_seek(orig, pos, SEEK_SET) < 0) { rb_sys_fail(orig->path); } } } if (fptr->mode & FMODE_BINMODE) { rb_io_binmode(io); } RBASIC(io)->klass = RBASIC(nfile)->klass; return io; } /* * call-seq: * ios.reopen(other_IO) => ios * ios.reopen(path, mode_str) => ios * * Reassociates ios with the I/O stream given in * other_IO or to a new stream opened on path. 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) #=> # * f2.readlines[0] #=> "This is line one\n" */ static VALUE rb_io_reopen(int argc, VALUE *argv, VALUE file) { VALUE fname, nmode; const char *mode; rb_io_t *fptr; rb_secure(4); if (rb_scan_args(argc, argv, "11", &fname, &nmode) == 1) { VALUE tmp = rb_io_check_io(fname); if (!NIL_P(tmp)) { return io_reopen(file, tmp); } } FilePathValue(fname); rb_io_taint_check(file); fptr = RFILE(file)->fptr; if (!fptr) { fptr = RFILE(file)->fptr = ALLOC(rb_io_t); MEMZERO(fptr, rb_io_t, 1); } if (!NIL_P(nmode)) { int flags = rb_io_mode_flags(StringValuePtr(nmode)); if (IS_PREP_STDIO(fptr) && ((fptr->mode & FMODE_READWRITE) & (flags & FMODE_READWRITE)) != (fptr->mode & FMODE_READWRITE)) { rb_raise(rb_eArgError, "%s can't change access mode from \"%s\" to \"%s\"", PREP_STDIO_NAME(fptr), rb_io_flags_mode(fptr->mode), rb_io_flags_mode(flags)); } fptr->mode = flags; } if (fptr->path) { free(fptr->path); fptr->path = 0; } fptr->path = strdup(RSTRING_PTR(fname)); mode = rb_io_flags_mode(fptr->mode); if (fptr->fd < 0) { fptr->fd = rb_sysopen(fptr->path, rb_io_mode_modenum(mode), 0666); fptr->stdio_file = 0; return file; } if (fptr->mode & FMODE_WRITABLE) { io_fflush(fptr); } if (fptr->stdio_file) { if (freopen(RSTRING_PTR(fname), mode, fptr->stdio_file) == 0) { rb_sys_fail(fptr->path); } 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(fname)); #endif } else { if (close(fptr->fd) < 0) rb_sys_fail(fptr->path); fptr->fd = -1; fptr->fd = rb_sysopen(fptr->path, rb_io_mode_modenum(mode), 0666); } return file; } /* :nodoc: */ static VALUE rb_io_init_copy(VALUE dest, VALUE io) { rb_io_t *fptr, *orig; int fd; 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->pid = orig->pid; fptr->lineno = orig->lineno; if (orig->path) fptr->path = strdup(orig->path); fptr->finalize = orig->finalize; fd = ruby_dup(orig->fd); fptr->fd = fd; io_seek(fptr, io_tell(orig), SEEK_SET); if (fptr->mode & FMODE_BINMODE) { rb_io_binmode(dest); } return dest; } /* * call-seq: * ios.printf(format_string [, obj, ...] ) => nil * * Formats and writes to ios, converting parameters under * control of the format string. See Kernel#sprintf * 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 ios. The stream must be * opened for writing. If the output record separator ($\\) * is not nil, it will be appended to the output. If no * arguments are given, prints $_. Objects that aren't * strings will be converted by calling their to_s method. * With no argument, prints the contents of the variable $_. * Returns nil. * * $stdout.print("This is ", 100, " percent.\n") * * produces: * * 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 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 $stdout. If the output * field separator ($,) is not +nil+, its * contents will appear between each field. If the output record * separator ($\\) is not +nil+, it will be * appended to the output. If no arguments are given, prints * $_. Objects that aren't strings will be converted by * calling their to_s method. * * print "cat", [1,2,3], 99, "\n" * $, = ", " * $\ = "\n" * print "cat", [1,2,3], 99 * * produces: * * 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 obj is Numeric, write the character whose * code is obj, otherwise write the first character of the * string representation of obj to ios. * * $stdout.putc "A" * $stdout.putc 65 * * produces: * * 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) { return rb_io_putc(rb_stdout, ch); } static VALUE io_puts_ary(VALUE ary, VALUE out, int recur) { VALUE tmp; long i; for (i=0; i nil * * Writes the given objects to ios as with * IO#print. 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") * * produces: * * 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 nil * * Equivalent to * * $stdout.puts(obj, ...) */ static VALUE rb_f_puts(int argc, VALUE *argv) { rb_io_puts(argc, argv, rb_stdout); return Qnil; } void rb_p(VALUE obj) /* for debug print within C code */ { rb_io_write(rb_stdout, rb_obj_as_string(rb_inspect(obj))); rb_io_write(rb_stdout, rb_default_rs); } /* * call-seq: * p(obj, ...) => 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 * * produces: * * # */ static VALUE rb_f_p(int argc, VALUE *argv) { int i; for (i=0; i) => nil * * Prints obj on the given port (default $>). * Equivalent to: * * def display(port=$>) * port.write self * end * * For example: * * 1.display * "cat".display * [ 4, 5, 6 ].display * puts * * produces: * * 1cat456 */ static VALUE rb_obj_display(int argc, VALUE *argv, VALUE self) { VALUE out; if (rb_scan_args(argc, argv, "01", &out) == 0) { out = rb_stdout; } rb_io_write(out, self); return Qnil; } void rb_write_error2(const char *mesg, long len) { if (rb_stderr == orig_stderr || RFILE(orig_stderr)->fptr->fd < 0) { fwrite(mesg, sizeof(char), len, stderr); } else { rb_io_write(rb_stderr, rb_str_new(mesg, len)); } } void rb_write_error(const char *mesg) { rb_write_error2(mesg, strlen(mesg)); } static void must_respond_to(ID mid, VALUE val, ID id) { if (!rb_respond_to(val, mid)) { rb_raise(rb_eTypeError, "%s must have %s method, %s given", rb_id2name(id), rb_id2name(mid), rb_obj_classname(val)); } } static void stdout_setter(VALUE val, ID id, VALUE *variable) { must_respond_to(id_write, val, id); *variable = val; } static void defout_setter(VALUE val, ID id, VALUE *variable) { stdout_setter(val, id, variable); rb_warn("$defout is obsolete; use $stdout instead"); } static void deferr_setter(VALUE val, ID id, VALUE *variable) { stdout_setter(val, id, variable); rb_warn("$deferr is obsolete; use $stderr instead"); } static VALUE prep_io(int fd, int mode, 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)) { mode |= O_BINARY; setmode(fd, O_BINARY); } #endif fp->mode = mode; io_check_tty(fp); if (path) fp->path = strdup(path); return io; } static VALUE prep_stdio(FILE *f, int mode, VALUE klass, const char *path) { rb_io_t *fptr; VALUE io = prep_io(fileno(f), mode|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) { fptr->stdio_file = rb_fdopen(fptr->fd, rb_io_flags_mode(fptr->mode)); } return fptr->stdio_file; } /* * call-seq: * IO.new(fd, mode) => io * * Returns a new IO object (a stream) for the given * IO object or integer file descriptor and mode * string. See also IO#fileno and * IO::for_fd. * * puts IO.new($stdout).fileno # => 1 * * a = IO.new(2,"w") # '2' is standard error * $stderr.puts "Hello" * a.puts "World" * * produces: * * Hello * World */ static VALUE rb_io_initialize(int argc, VALUE *argv, VALUE io) { VALUE fnum, mode, orig; rb_io_t *fp, *ofp = NULL; int fd, flags, fmode; rb_secure(4); rb_scan_args(argc, argv, "11", &fnum, &mode); if (argc == 2) { if (FIXNUM_P(mode)) { flags = FIX2LONG(mode); } else { SafeStringValue(mode); flags = rb_io_mode_modenum(RSTRING_PTR(mode)); } } orig = rb_io_check_io(fnum); if (NIL_P(orig)) { fd = NUM2INT(fnum); if (argc != 2) { #if defined(HAVE_FCNTL) && defined(F_GETFL) flags = fcntl(fd, F_GETFL); if (flags == -1) rb_sys_fail(0); #else flags = O_RDONLY; #endif } MakeOpenFile(io, fp); fp->fd = fd; fp->mode = rb_io_modenum_flags(flags); io_check_tty(fp); } else if (RFILE(io)->fptr) { rb_raise(rb_eRuntimeError, "reinitializing IO"); } else { GetOpenFile(orig, ofp); if (ofp->refcnt == LONG_MAX) { VALUE s = rb_inspect(orig); rb_raise(rb_eIOError, "too many shared IO for %s", StringValuePtr(s)); } if (argc == 2) { fmode = rb_io_modenum_flags(flags); if ((ofp->mode ^ fmode) & (FMODE_READWRITE|FMODE_BINMODE)) { if (FIXNUM_P(mode)) { rb_raise(rb_eArgError, "incompatible mode 0%o", flags); } else { rb_raise(rb_eArgError, "incompatible mode \"%s\"", RSTRING_PTR(mode)); } } } ofp->refcnt++; RFILE(io)->fptr = ofp; } return io; } /* * call-seq: * File.new(filename, mode="r") => file * File.new(filename [, mode [, perm]]) => file * * Opens the file named by _filename_ according to * _mode_ (default is ``r'') and returns a new * File object. See the description of class +IO+ for * a description of _mode_. The file mode may optionally be * specified as a +Fixnum+ by _or_-ing together the * flags (O_RDONLY etc, again described under +IO+). Optional * permission bits may be given in _perm_. These mode and permission * bits are platform dependent; on Unix systems, see * open(2) for details. * * f = File.new("testfile", "r") * f = File.new("newfile", "w+") * f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644) */ static VALUE rb_file_initialize(int argc, VALUE *argv, VALUE io) { if (RFILE(io)->fptr) { rb_raise(rb_eRuntimeError, "reinitializing File"); } if (0 < argc && argc < 3) { VALUE fd = rb_check_convert_type(argv[0], T_FIXNUM, "Fixnum", "to_int"); if (!NIL_P(fd)) { argv[0] = fd; return rb_io_initialize(argc, argv, io); } } rb_open_file(argc, argv, io); return io; } /* * call-seq: * IO.new(fd, mode_string) => io * * Returns a new IO object (a stream) for the given * integer file descriptor and mode string. See also * IO#fileno and IO::for_fd. * * a = IO.new(2,"w") # '2' is standard error * $stderr.puts "Hello" * a.puts "World" * * produces: * * Hello * World */ static VALUE rb_io_s_new(int argc, VALUE *argv, VALUE klass) { if (rb_block_given_p()) { 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) => io * * Synonym for IO::new. * */ static VALUE rb_io_s_for_fd(int argc, VALUE *argv, VALUE klass) { VALUE io = rb_obj_alloc(klass); rb_io_initialize(argc, argv, io); return io; } static int binmode = 0; static VALUE argf_forward(int argc, VALUE *argv) { return rb_funcall3(current_file, rb_frame_this_func(), argc, argv); } #define ARGF_FORWARD(argc, argv) do {\ if (TYPE(current_file) != T_FILE)\ return argf_forward(argc, argv);\ } 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) { if (TYPE(file) == T_FILE) rb_io_close(file); else rb_funcall3(file, rb_intern("close"), 0, 0); } static int next_argv(void) { extern VALUE rb_argv; char *fn; rb_io_t *fptr; int stdout_binmode = 0; if (TYPE(rb_stdout) == T_FILE) { GetOpenFile(rb_stdout, fptr); if (fptr->mode & FMODE_BINMODE) stdout_binmode = 1; } if (init_p == 0) { if (RARRAY_LEN(rb_argv) > 0) { next_p = 1; } else { next_p = -1; } init_p = 1; gets_lineno = 0; } if (next_p == 1) { next_p = 0; retry: if (RARRAY_LEN(rb_argv) > 0) { filename = rb_ary_shift(rb_argv); fn = StringValuePtr(filename); if (strlen(fn) == 1 && fn[0] == '-') { current_file = rb_stdin; if (ruby_inplace_mode) { rb_warn("Can't do inplace edit for stdio; skipping"); goto retry; } } else { int fr = rb_sysopen(fn, O_RDONLY, 0); if (ruby_inplace_mode) { struct stat st, st2; VALUE str; int fw; if (TYPE(rb_stdout) == T_FILE && rb_stdout != orig_stdout) { rb_io_close(rb_stdout); } fstat(fr, &st); if (*ruby_inplace_mode) { str = rb_str_new2(fn); #ifdef NO_LONG_FNAME ruby_add_suffix(str, ruby_inplace_mode); #else rb_str_cat2(str, ruby_inplace_mode); #endif #ifdef NO_SAFE_RENAME (void)close(fr); (void)unlink(RSTRING_PTR(str)); (void)rename(fn, RSTRING_PTR(str)); fr = rb_sysopen(RSTRING_PTR(str), O_RDONLY, 0); #else if (rename(fn, RSTRING_PTR(str)) < 0) { rb_warn("Can't rename %s to %s: %s, skipping file", fn, RSTRING_PTR(str), strerror(errno)); close(fr); goto retry; } #endif } else { #ifdef NO_SAFE_RENAME rb_fatal("Can't do inplace edit without backup"); #else if (unlink(fn) < 0) { rb_warn("Can't remove %s: %s, skipping file", fn, strerror(errno)); close(fr); goto retry; } #endif } fw = rb_sysopen(fn, O_WRONLY|O_CREAT|O_TRUNC, 0666); #ifndef NO_SAFE_RENAME fstat(fw, &st2); #ifdef HAVE_FCHMOD fchmod(fw, st.st_mode); #else chmod(fn, st.st_mode); #endif if (st.st_uid!=st2.st_uid || st.st_gid!=st2.st_gid) { fchown(fw, st.st_uid, st.st_gid); } #endif rb_stdout = prep_io(fw, FMODE_WRITABLE, rb_cFile, fn); if (stdout_binmode) rb_io_binmode(rb_stdout); } current_file = prep_io(fr, FMODE_READABLE, rb_cFile, fn); } if (binmode) rb_io_binmode(current_file); } else { next_p = 1; return Qfalse; } } else if (next_p == -1) { current_file = rb_stdin; filename = rb_str_new2("-"); if (ruby_inplace_mode) { rb_warn("Can't do inplace edit for stdio"); rb_stdout = orig_stdout; } } return Qtrue; } static VALUE argf_getline(int argc, VALUE *argv) { VALUE line; retry: if (!next_argv()) return Qnil; if (argc == 0 && rb_rs == rb_default_rs) { line = rb_io_gets(current_file); } else { line = rb_io_getline(argc, argv, current_file); } if (NIL_P(line) && next_p != -1) { argf_close(current_file); next_p = 1; goto retry; } if (!NIL_P(line)) { gets_lineno++; lineno = INT2FIX(gets_lineno); } return line; } /* * call-seq: * gets(sep=$/) => string or nil * gets(limit) => string or nil * gets(sep,limit) => string or nil * * Returns (and assigns to $_) the next line from the list * of files in +ARGV+ (or $*), or from standard input if * no files are present on the command line. Returns +nil+ at end of * file. The optional argument specifies the record separator. The * separator is included with the contents of each record. A separator * of +nil+ reads the entire contents, and a zero-length separator * reads the input one paragraph at a time, where paragraphs are * divided by two consecutive newlines. If the first argument is an * integer, or optional second argument is given, the returning string * would not be longer than the given value. If multiple filenames are * present in +ARGV+, +gets(nil)+ will read the contents one file at a * time. * * ARGV << "testfile" * print while gets * * produces: * * This is line one * This is line two * This is line three * And so on... * * The style of programming using $_ as an implicit * parameter is gradually losing favor in the Ruby community. */ static VALUE rb_f_gets(int argc, VALUE *argv) { VALUE line; if (!next_argv()) return Qnil; if (TYPE(current_file) != T_FILE) { line = rb_funcall3(current_file, rb_intern("gets"), argc, argv); } else { line = argf_getline(argc, argv); } rb_lastline_set(line); return line; } VALUE rb_gets(void) { VALUE line; if (rb_rs != rb_default_rs) { return rb_f_gets(0, 0); } retry: if (!next_argv()) return Qnil; line = rb_io_gets(current_file); if (NIL_P(line) && next_p != -1) { argf_close(current_file); next_p = 1; goto retry; } rb_lastline_set(line); if (!NIL_P(line)) { gets_lineno++; lineno = INT2FIX(gets_lineno); } return line; } /* * call-seq: * readline(sep=$/) => string * readline(limit) => string * readline(sep, limit) => string * * Equivalent to Kernel::gets, except * +readline+ raises +EOFError+ at end of file. */ static VALUE rb_f_readline(int argc, VALUE *argv) { VALUE line; if (!next_argv()) rb_eof_error(); ARGF_FORWARD(argc, argv); line = rb_f_gets(argc, argv); if (NIL_P(line)) { rb_eof_error(); } return line; } /* * obsolete */ static VALUE rb_f_getc(void) { rb_warn("getc is obsolete; use STDIN.getc instead"); if (TYPE(rb_stdin) != T_FILE) { return rb_funcall3(rb_stdin, rb_intern("getc"), 0, 0); } return rb_io_getc(rb_stdin); } /* * call-seq: * readlines(sep=$/) => array * readlines(limit) => array * readlines(sep,limit) => array * * Returns an array containing the lines returned by calling * Kernel.gets(sep) until the end of file. */ static VALUE rb_f_readlines(int argc, VALUE *argv) { VALUE line, ary; NEXT_ARGF_FORWARD(argc, argv); ary = rb_ary_new(); while (!NIL_P(line = argf_getline(argc, argv))) { 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 %x{...} uses * this method. Sets $? 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(1, &str, "r"); 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 #endif static VALUE select_internal(VALUE read, VALUE write, VALUE except, struct timeval *tp, rb_fdset_t *fds) { VALUE res, list; fd_set *rp, *wp, *ep; rb_io_t *fptr; long i; int max = 0, n; int interrupt_flag = 0; int pending = 0; struct timeval timerec; if (!NIL_P(read)) { Check_Type(read, T_ARRAY); for (i=0; ifd, &fds[0]); if (READ_DATA_PENDING(fptr)) { /* check for buffered data */ pending++; rb_fd_set(fptr->fd, &fds[3]); } if (max < fptr->fd) max = fptr->fd; } if (pending) { /* no blocking if there's buffered data */ timerec.tv_sec = timerec.tv_usec = 0; tp = &timerec; } rp = rb_fd_ptr(&fds[0]); } else rp = 0; if (!NIL_P(write)) { Check_Type(write, T_ARRAY); for (i=0; ifd, &fds[1]); if (max < fptr->fd) max = fptr->fd; } wp = rb_fd_ptr(&fds[1]); } else wp = 0; if (!NIL_P(except)) { Check_Type(except, T_ARRAY); for (i=0; ifd, &fds[2]); if (max < fptr->fd) max = fptr->fd; } ep = rb_fd_ptr(&fds[2]); } else { ep = 0; } max++; n = rb_thread_select(max, rp, wp, ep, tp); if (n < 0) { rb_sys_fail(0); } if (!pending && n == 0) return Qnil; /* returns nil on timeout */ res = rb_ary_new2(3); rb_ary_push(res, rp?rb_ary_new():rb_ary_new2(0)); rb_ary_push(res, wp?rb_ary_new():rb_ary_new2(0)); rb_ary_push(res, ep?rb_ary_new():rb_ary_new2(0)); if (interrupt_flag == 0) { if (rp) { list = RARRAY_PTR(res)[0]; for (i=0; i< RARRAY_LEN(read); i++) { GetOpenFile(rb_io_get_io(RARRAY_PTR(read)[i]), fptr); if (rb_fd_isset(fptr->fd, &fds[0]) || rb_fd_isset(fptr->fd, &fds[3])) { rb_ary_push(list, rb_ary_entry(read, i)); } } } if (wp) { list = RARRAY_PTR(res)[1]; for (i=0; i< RARRAY_LEN(write); i++) { GetOpenFile(rb_io_get_io(RARRAY_PTR(write)[i]), fptr); if (rb_fd_isset(fptr->fd, &fds[1])) { rb_ary_push(list, rb_ary_entry(write, i)); } } } if (ep) { list = RARRAY_PTR(res)[2]; for (i=0; i< RARRAY_LEN(except); i++) { GetOpenFile(rb_io_get_io(RARRAY_PTR(except)[i]), fptr); if (rb_fd_isset(fptr->fd, &fds[2])) { rb_ary_push(list, rb_ary_entry(except, i)); } } } } return res; /* returns an empty array on interrupt */ } struct select_args { VALUE read, write, except; struct timeval *timeout; rb_fdset_t fdsets[4]; }; #ifdef HAVE_RB_FD_INIT static VALUE select_call(VALUE arg) { struct select_args *p = (struct select_args *)arg; return select_internal(p->read, p->write, p->except, p->timeout, p->fdsets); } static VALUE select_end(VALUE arg) { struct select_args *p = (struct select_args *)arg; int i; for (i = 0; i < sizeof(p->fdsets) / sizeof(p->fdsets[0]); ++i) rb_fd_term(&p->fdsets[i]); return Qnil; } #endif /* * call-seq: * IO.select(read_array * [, write_array * [, error_array * [, timeout]]] ) => array or nil * * See Kernel#select. */ static VALUE rb_f_select(int argc, VALUE *argv, VALUE obj) { VALUE timeout; struct select_args args; struct timeval timerec; int i; rb_scan_args(argc, argv, "13", &args.read, &args.write, &args.except, &timeout); if (NIL_P(timeout)) { args.timeout = 0; } else { timerec = rb_time_interval(timeout); args.timeout = &timerec; } for (i = 0; i < sizeof(args.fdsets) / sizeof(args.fdsets[0]); ++i) rb_fd_init(&args.fdsets[i]); #ifdef HAVE_RB_FD_INIT return rb_ensure(select_call, (VALUE)&args, select_end, (VALUE)&args); #else return select_internal(args.read, args.write, args.except, args.timeout, args.fdsets); #endif } #if !defined(MSDOS) && !defined(__human68k__) static int io_cntl(int fd, int cmd, long narg, int io_p) { int retval; #ifdef HAVE_FCNTL TRAP_BEG; # if defined(__CYGWIN__) retval = io_p?ioctl(fd, cmd, (void*)narg):fcntl(fd, cmd, narg); # else retval = io_p?ioctl(fd, cmd, narg):fcntl(fd, cmd, narg); # endif TRAP_END; #else if (!io_p) { rb_notimplement(); } TRAP_BEG; retval = ioctl(fd, cmd, narg); TRAP_END; #endif return retval; } #endif static VALUE rb_io_ctl(VALUE io, VALUE req, VALUE arg, int io_p) { #if !defined(MSDOS) && !defined(__human68k__) int cmd = NUM2ULONG(req); rb_io_t *fptr; long len = 0; long narg = 0; int retval; rb_secure(2); if (NIL_P(arg) || arg == Qfalse) { narg = 0; } else if (FIXNUM_P(arg)) { narg = FIX2LONG(arg); } else if (arg == Qtrue) { narg = 1; } else { VALUE tmp = rb_check_string_type(arg); if (NIL_P(tmp)) { narg = NUM2LONG(arg); } else { arg = tmp; #ifdef IOCPARM_MASK #ifndef IOCPARM_LEN #define IOCPARM_LEN(x) (((x) >> 16) & IOCPARM_MASK) #endif #endif #ifdef IOCPARM_LEN len = IOCPARM_LEN(cmd); /* on BSDish systems we're safe */ #else len = 256; /* otherwise guess at what's safe */ #endif rb_str_modify(arg); if (len <= RSTRING_LEN(arg)) { len = RSTRING_LEN(arg); } if (RSTRING_LEN(arg) < len) { rb_str_resize(arg, len+1); } RSTRING_PTR(arg)[len] = 17; /* a little sanity check here */ narg = (long)RSTRING_PTR(arg); } } GetOpenFile(io, fptr); retval = io_cntl(fptr->fd, cmd, narg, io_p); if (retval < 0) rb_sys_fail(fptr->path); if (TYPE(arg) == T_STRING && RSTRING_PTR(arg)[len] != 17) { rb_raise(rb_eArgError, "return value overflowed string"); } if (!io_p && cmd == F_SETFL) { if (narg & O_NONBLOCK) { fptr->mode |= FMODE_WSPLIT_INITIALIZED; fptr->mode &= ~FMODE_WSPLIT; } else { fptr->mode &= ~(FMODE_WSPLIT_INITIALIZED|FMODE_WSPLIT); } } return INT2NUM(retval); #else rb_notimplement(); return Qnil; /* not reached */ #endif } /* * call-seq: * ios.ioctl(integer_cmd, arg) => integer * * Provides a mechanism for issuing low-level commands to control or * query I/O devices. Arguments and results are platform dependent. If * arg 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 ioctl(2) for details. Not implemented on * all platforms. */ static VALUE rb_io_ioctl(int argc, VALUE *argv, VALUE io) { VALUE req, arg; rb_scan_args(argc, argv, "11", &req, &arg); return rb_io_ctl(io, req, arg, 1); } /* * call-seq: * ios.fcntl(integer_cmd, arg) => integer * * Provides a mechanism for issuing low-level commands to control or * query file-oriented I/O streams. Arguments and results are platform * dependent. If arg is a number, its value is passed * directly. If it is a string, it is interpreted as a binary sequence * of bytes (Array#pack might be a useful way to build this * string). On Unix platforms, see fcntl(2) for details. * Not implemented on all platforms. */ static VALUE rb_io_fcntl(int argc, VALUE *argv, VALUE io) { #ifdef HAVE_FCNTL VALUE req, arg; rb_scan_args(argc, argv, "11", &req, &arg); return rb_io_ctl(io, req, arg, 0); #else rb_notimplement(); return Qnil; /* not reached */ #endif } /* * call-seq: * syscall(fixnum [, args...]) => integer * * Calls the operating system function identified by _fixnum_, * passing in the arguments, which must be either +String+ * objects, or +Integer+ objects that ultimately fit within * a native +long+. Up to nine parameters may be passed (14 * on the Atari-ST). The function identified by _fixnum_ is system * dependent. On some Unix systems, the numbers may be obtained from a * header file called syscall.h. * * syscall 4, 1, "hello\n", 6 # '4' is write(2) on our box * * produces: * * hello */ static VALUE rb_f_syscall(int argc, VALUE *argv) { #if defined(HAVE_SYSCALL) && !defined(__CHECKER__) #ifdef atarist unsigned long arg[14]; /* yes, we really need that many ! */ #else unsigned long arg[8]; #endif int retval = -1; int i = 1; int items = argc - 1; /* This probably won't work on machines where sizeof(long) != sizeof(int) * or where sizeof(long) != sizeof(char*). But such machines will * not likely have syscall implemented either, so who cares? */ rb_secure(2); if (argc == 0) rb_raise(rb_eArgError, "too few arguments for syscall"); if (argc > sizeof(arg) / sizeof(arg[0])) rb_raise(rb_eArgError, "too many arguments for syscall"); arg[0] = NUM2LONG(argv[0]); argv++; while (items--) { VALUE v = rb_check_string_type(*argv); if (!NIL_P(v)) { StringValue(v); rb_str_modify(v); arg[i] = (unsigned long)RSTRING_PTR(v); } else { arg[i] = (unsigned long)NUM2LONG(*argv); } argv++; i++; } TRAP_BEG; switch (argc) { case 1: retval = syscall(arg[0]); break; case 2: retval = syscall(arg[0],arg[1]); break; case 3: retval = syscall(arg[0],arg[1],arg[2]); break; case 4: retval = syscall(arg[0],arg[1],arg[2],arg[3]); break; case 5: retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4]); break; case 6: retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5]); break; case 7: retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6]); break; case 8: retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], arg[7]); break; #ifdef atarist case 9: retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], arg[7], arg[8]); break; case 10: retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], arg[7], arg[8], arg[9]); break; case 11: retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], arg[7], arg[8], arg[9], arg[10]); break; case 12: retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], arg[7], arg[8], arg[9], arg[10], arg[11]); break; case 13: retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], arg[7], arg[8], arg[9], arg[10], arg[11], arg[12]); break; case 14: retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6], arg[7], arg[8], arg[9], arg[10], arg[11], arg[12], arg[13]); break; #endif /* atarist */ } TRAP_END; if (retval < 0) rb_sys_fail(0); return INT2NUM(retval); #else rb_notimplement(); return Qnil; /* not reached */ #endif } static VALUE io_new_instance(VALUE args) { return rb_class_new_instance(2, (VALUE*)args+1, *(VALUE*)args); } /* * call-seq: * IO.pipe -> array * * Creates a pair of pipe endpoints (connected to each other) and * returns them as a two-element array of IO objects: * [ read_file, write_file ]. Not * available on all platforms. * * 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 rd.read will never return if it * does not first issue a wr.close. * * 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 * * produces: * * Sending message to parent * Parent got: */ static VALUE rb_io_s_pipe(VALUE klass) { #ifndef __human68k__ int pipes[2], state; VALUE r, w, args[3]; if (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); } args[1] = INT2NUM(pipes[1]); args[2] = INT2FIX(O_WRONLY); w = rb_protect(io_new_instance, (VALUE)args, &state); if (state) { close(pipes[1]); if (!NIL_P(r)) rb_io_close(r); rb_jump_tag(state); } rb_io_synchronized(RFILE(w)->fptr); return rb_assoc_new(r, w); #else rb_notimplement(); return Qnil; /* not reached */ #endif } struct foreach_arg { int argc; VALUE *argv; VALUE io; }; 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=$/) {|line| block } => nil * IO.foreach(name, limit) {|line| block } => nil * IO.foreach(name, sep, limit) {|line| block } => nil * * Executes the block for every line in the named I/O port, where lines * are separated by sep. * * IO.foreach("testfile") {|x| print "GOT ", x } * * produces: * * GOT This is line one * GOT This is line two * GOT This is line three * GOT And so on... */ static VALUE rb_io_s_foreach(int argc, VALUE *argv, VALUE self) { VALUE fname; struct foreach_arg arg; RETURN_ENUMERATOR(self, argc, argv); rb_scan_args(argc, argv, "12", &fname, NULL, NULL); FilePathValue(fname); arg.io = rb_io_open(RSTRING_PTR(fname), "r"); if (NIL_P(arg.io)) return Qnil; arg.argc = argc - 1; arg.argv = argv + 1; 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=$/) => array * IO.readlines(name, limit) => array * IO.readlines(name, sep, limit) => array * * Reads the entire file specified by name as individual * lines, and returns those lines in an array. Lines are separated by * sep. * * a = IO.readlines("testfile") * a[0] #=> "This is line one\n" * */ static VALUE rb_io_s_readlines(int argc, VALUE *argv, VALUE io) { VALUE fname; struct foreach_arg arg; rb_scan_args(argc, argv, "12", &fname, NULL, NULL); FilePathValue(fname); arg.io = rb_io_open(RSTRING_PTR(fname), "r"); if (NIL_P(arg.io)) return Qnil; arg.argc = argc - 1; arg.argv = argv + 1; return rb_ensure(io_s_readlines, (VALUE)&arg, rb_io_close, arg.io); } static VALUE io_s_read(struct foreach_arg *arg) { return io_read(arg->argc, arg->argv, arg->io); } /* * call-seq: * IO.read(name, [length [, offset]] ) => string * * Opens the file, optionally seeks to the given offset, then returns * length bytes (defaulting to the rest of the file). * read ensures the file is closed before returning. * * 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 fname, offset; struct foreach_arg arg; rb_scan_args(argc, argv, "12", &fname, NULL, &offset); FilePathValue(fname); arg.argc = argc > 1 ? 1 : 0; arg.argv = argv + 1; arg.io = rb_io_open(RSTRING_PTR(fname), "r"); if (NIL_P(arg.io)) return Qnil; 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); } static VALUE argf_tell(void) { if (!next_argv()) { rb_raise(rb_eArgError, "no stream to tell"); } ARGF_FORWARD(0, 0); return rb_io_tell(current_file); } static VALUE argf_seek_m(int argc, VALUE *argv, VALUE self) { if (!next_argv()) { rb_raise(rb_eArgError, "no stream to seek"); } ARGF_FORWARD(argc, argv); return rb_io_seek_m(argc, argv, current_file); } static VALUE argf_set_pos(VALUE self, VALUE offset) { if (!next_argv()) { rb_raise(rb_eArgError, "no stream to set position"); } ARGF_FORWARD(1, &offset); return rb_io_set_pos(current_file, offset); } static VALUE argf_rewind(void) { if (!next_argv()) { rb_raise(rb_eArgError, "no stream to rewind"); } ARGF_FORWARD(0, 0); return rb_io_rewind(current_file); } static VALUE argf_fileno(void) { if (!next_argv()) { rb_raise(rb_eArgError, "no stream"); } ARGF_FORWARD(0, 0); return rb_io_fileno(current_file); } static VALUE argf_to_io(void) { next_argv(); ARGF_FORWARD(0, 0); return current_file; } static VALUE argf_eof(void) { if (current_file) { if (init_p == 0) return Qtrue; ARGF_FORWARD(0, 0); if (rb_io_eof(current_file)) { return Qtrue; } } return Qfalse; } static VALUE argf_read(int argc, VALUE *argv) { VALUE 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 (TYPE(current_file) != T_FILE) { tmp = argf_forward(argc, argv); } else { tmp = io_read(argc, argv, current_file); } if (NIL_P(str)) str = tmp; else if (!NIL_P(tmp)) rb_str_append(str, tmp); if (NIL_P(tmp) || NIL_P(length)) { if (next_p != -1) { argf_close(current_file); next_p = 1; goto retry; } } else if (argc >= 1) { if (RSTRING_LEN(str) < len) { len -= RSTRING_LEN(str); argv[0] = INT2NUM(len); goto retry; } } return str; } static VALUE argf_readpartial_rescue(VALUE dummy) { return Qnil; } static VALUE argf_readpartial(int argc, VALUE *argv) { 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 (TYPE(current_file) != T_FILE) { tmp = rb_rescue2(argf_forward, (VALUE)argv, argf_readpartial_rescue, (VALUE)Qnil, rb_eEOFError, (VALUE)0); } else { tmp = io_getpartial(argc, argv, current_file, 0); } if (NIL_P(tmp)) { if (next_p == -1) { rb_eof_error(); } argf_close(current_file); next_p = 1; if (RARRAY_LEN(rb_argv) == 0) rb_eof_error(); if (NIL_P(str)) str = rb_str_new(NULL, 0); return str; } return tmp; } static VALUE argf_getc(void) { VALUE ch; retry: if (!next_argv()) return Qnil; if (TYPE(current_file) != T_FILE) { ch = rb_funcall3(current_file, rb_intern("getc"), 0, 0); } else { ch = rb_io_getc_m(current_file); } if (NIL_P(ch) && next_p != -1) { argf_close(current_file); next_p = 1; goto retry; } return ch; } static VALUE argf_readchar(void) { VALUE c; NEXT_ARGF_FORWARD(0, 0); c = argf_getc(); if (NIL_P(c)) { rb_eof_error(); } return c; } static VALUE argf_each_line(int argc, VALUE *argv, VALUE self) { VALUE str; RETURN_ENUMERATOR(self, argc, argv); if (!next_argv()) return Qnil; if (TYPE(current_file) != T_FILE) { for (;;) { if (!next_argv()) return argf; rb_block_call(current_file, rb_intern("each"), 0, 0, rb_yield, 0); next_p = 1; } } while (!NIL_P(str = argf_getline(argc, argv))) { rb_yield(str); } return argf; } static VALUE argf_each_byte(VALUE self) { VALUE byte; RETURN_ENUMERATOR(self, 0, 0); while (!NIL_P(byte = argf_getc())) { rb_yield(byte); } return argf; } static VALUE argf_filename(void) { next_argv(); return filename; } static VALUE argf_file(void) { next_argv(); return current_file; } static VALUE argf_binmode(void) { binmode = 1; next_argv(); ARGF_FORWARD(0, 0); rb_io_binmode(current_file); return argf; } static VALUE argf_skip(void) { if (next_p != -1) { argf_close(current_file); next_p = 1; } return argf; } static VALUE argf_close_m(void) { next_argv(); argf_close(current_file); if (next_p != -1) { next_p = 1; } gets_lineno = 0; return argf; } static VALUE argf_closed(void) { next_argv(); ARGF_FORWARD(0, 0); return rb_io_closed(current_file); } static VALUE argf_to_s(void) { return rb_str_new2("ARGF"); } static VALUE opt_i_get(void) { if (!ruby_inplace_mode) return Qnil; return rb_str_new2(ruby_inplace_mode); } static void opt_i_set(VALUE val) { if (!RTEST(val)) { if (ruby_inplace_mode) free(ruby_inplace_mode); ruby_inplace_mode = 0; return; } StringValue(val); if (ruby_inplace_mode) free(ruby_inplace_mode); ruby_inplace_mode = 0; ruby_inplace_mode = strdup(RSTRING_PTR(val)); } /* * Class IO is the basis for all input and output in Ruby. * An I/O stream may be duplexed (that is, bidirectional), and * so may use more than one native operating system stream. * * Many of the examples in this section use class File, * the only standard subclass of IO. The two classes are * closely associated. * * As used in this section, portname may take any of the * following forms. * * * A plain string represents a filename suitable for the underlying * operating system. * * * A string starting with ``|'' indicates a subprocess. * The remainder of the string following the ``|'' is * invoked as a process with appropriate input/output channels * connected to it. * * * A string equal to ``|-'' 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 ``/gumby/ruby/test.rb'' will be opened as * ``\gumby\ruby\test.rb''. 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; * File::SEPARATOR 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 mode. The mode may * either be a Fixnum or a String. If numeric, it should be * one of the operating system specific constants (O_RDONLY, * O_WRONLY, O_RDWR, O_APPEND and so on). See man open(2) for * more information. * * If the mode is given as a String, it must be one of the * values listed in the following table. * * Mode | Meaning * -----+-------------------------------------------------------- * "r" | Read-only, starts at beginning of file (default mode). * -----+-------------------------------------------------------- * "r+" | Read-write, starts at beginning of file. * -----+-------------------------------------------------------- * "w" | Write-only, truncates existing file * | to zero length or creates a new file for writing. * -----+-------------------------------------------------------- * "w+" | Read-write, truncates existing file to zero length * | or creates a new file for reading and writing. * -----+-------------------------------------------------------- * "a" | Write-only, starts at end of file if file exists, * | otherwise creates a new file for writing. * -----+-------------------------------------------------------- * "a+" | Read-write, starts at end of file if file exists, * | otherwise creates a new file for reading and * | writing. * -----+-------------------------------------------------------- * "b" | (DOS/Windows only) Binary file mode (may appear with * | any of the key letters listed above). * * * 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 #path and #filename to access * the name of the file currently being read. */ void Init_IO(void) { #ifdef __CYGWIN__ #include 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"); 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("getc", rb_f_getc, 0); rb_define_global_function("select", rb_f_select, -1); rb_define_global_function("readlines", rb_f_readlines, -1); rb_define_global_function("`", rb_f_backquote, 1); rb_define_global_function("p", rb_f_p, -1); rb_define_method(rb_mKernel, "display", rb_obj_display, -1); rb_cIO = rb_define_class("IO", rb_cObject); rb_include_module(rb_cIO, rb_mEnumerable); rb_define_alloc_func(rb_cIO, io_alloc); rb_define_singleton_method(rb_cIO, "new", rb_io_s_new, -1); rb_define_singleton_method(rb_cIO, "open", rb_io_s_open, -1); rb_define_singleton_method(rb_cIO, "sysopen", rb_io_s_sysopen, -1); rb_define_singleton_method(rb_cIO, "for_fd", rb_io_s_for_fd, -1); rb_define_singleton_method(rb_cIO, "popen", rb_io_s_popen, -1); rb_define_singleton_method(rb_cIO, "foreach", rb_io_s_foreach, -1); rb_define_singleton_method(rb_cIO, "readlines", rb_io_s_readlines, -1); rb_define_singleton_method(rb_cIO, "read", rb_io_s_read, -1); rb_define_singleton_method(rb_cIO, "select", rb_f_select, -1); rb_define_singleton_method(rb_cIO, "pipe", rb_io_s_pipe, 0); rb_define_method(rb_cIO, "initialize", rb_io_initialize, -1); rb_output_fs = Qnil; rb_define_hooked_variable("$,", &rb_output_fs, 0, rb_str_setter); rb_global_variable(&rb_default_rs); rb_rs = rb_default_rs = rb_str_new2("\n"); rb_output_rs = Qnil; OBJ_FREEZE(rb_default_rs); /* avoid modifying RS_default */ rb_define_hooked_variable("$/", &rb_rs, 0, rb_str_setter); rb_define_hooked_variable("$-0", &rb_rs, 0, rb_str_setter); rb_define_hooked_variable("$\\", &rb_output_rs, 0, rb_str_setter); rb_define_hooked_variable("$.", &lineno, 0, lineno_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, "lines", rb_io_lines, -1); rb_define_method(rb_cIO, "bytes", rb_io_bytes, 0); rb_define_method(rb_cIO, "syswrite", rb_io_syswrite, 1); rb_define_method(rb_cIO, "sysread", rb_io_sysread, -1); rb_define_method(rb_cIO, "fileno", rb_io_fileno, 0); rb_define_alias(rb_cIO, "to_i", "fileno"); rb_define_method(rb_cIO, "to_io", rb_io_to_io, 0); rb_define_method(rb_cIO, "fsync", rb_io_fsync, 0); rb_define_method(rb_cIO, "sync", rb_io_sync, 0); rb_define_method(rb_cIO, "sync=", rb_io_set_sync, 1); rb_define_method(rb_cIO, "lineno", rb_io_lineno, 0); rb_define_method(rb_cIO, "lineno=", rb_io_set_lineno, 1); rb_define_method(rb_cIO, "readlines", rb_io_readlines, -1); rb_define_method(rb_cIO, "read_nonblock", io_read_nonblock, -1); rb_define_method(rb_cIO, "write_nonblock", rb_io_write_nonblock, 1); rb_define_method(rb_cIO, "readpartial", io_readpartial, -1); rb_define_method(rb_cIO, "read", io_read, -1); rb_define_method(rb_cIO, "write", io_write, 1); rb_define_method(rb_cIO, "gets", rb_io_gets_m, -1); rb_define_method(rb_cIO, "readline", rb_io_readline, -1); rb_define_method(rb_cIO, "getc", rb_io_getc_m, 0); rb_define_method(rb_cIO, "readchar", rb_io_readchar, 0); 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", 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, 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_variable("$stdin", &rb_stdin); rb_stdin = prep_stdio(stdin, FMODE_READABLE, rb_cIO, ""); rb_define_hooked_variable("$stdout", &rb_stdout, 0, stdout_setter); rb_stdout = prep_stdio(stdout, FMODE_WRITABLE, rb_cIO, ""); rb_define_hooked_variable("$stderr", &rb_stderr, 0, stdout_setter); rb_stderr = prep_stdio(stderr, FMODE_WRITABLE|FMODE_SYNC, rb_cIO, ""); rb_define_hooked_variable("$>", &rb_stdout, 0, stdout_setter); orig_stdout = rb_stdout; rb_deferr = orig_stderr = rb_stderr; /* variables to be removed in 1.8.1 */ rb_define_hooked_variable("$defout", &rb_stdout, 0, defout_setter); rb_define_hooked_variable("$deferr", &rb_stderr, 0, deferr_setter); /* constants to hold original stdin/stdout/stderr */ rb_define_global_const("STDIN", rb_stdin); rb_define_global_const("STDOUT", rb_stdout); rb_define_global_const("STDERR", rb_stderr); rb_define_readonly_variable("$<", &argf); argf = rb_obj_alloc(rb_cObject); rb_extend_object(argf, rb_mEnumerable); rb_define_global_const("ARGF", argf); rb_define_singleton_method(argf, "to_s", argf_to_s, 0); rb_define_singleton_method(argf, "fileno", argf_fileno, 0); rb_define_singleton_method(argf, "to_i", argf_fileno, 0); rb_define_singleton_method(argf, "to_io", argf_to_io, 0); rb_define_singleton_method(argf, "each", argf_each_line, -1); rb_define_singleton_method(argf, "each_line", argf_each_line, -1); rb_define_singleton_method(argf, "each_byte", argf_each_byte, 0); rb_define_singleton_method(argf, "read", argf_read, -1); rb_define_singleton_method(argf, "readpartial", argf_readpartial, -1); rb_define_singleton_method(argf, "readlines", rb_f_readlines, -1); rb_define_singleton_method(argf, "to_a", rb_f_readlines, -1); rb_define_singleton_method(argf, "gets", rb_f_gets, -1); rb_define_singleton_method(argf, "readline", rb_f_readline, -1); rb_define_singleton_method(argf, "getc", argf_getc, 0); rb_define_singleton_method(argf, "readchar", argf_readchar, 0); rb_define_singleton_method(argf, "tell", argf_tell, 0); rb_define_singleton_method(argf, "seek", argf_seek_m, -1); rb_define_singleton_method(argf, "rewind", argf_rewind, 0); rb_define_singleton_method(argf, "pos", argf_tell, 0); rb_define_singleton_method(argf, "pos=", argf_set_pos, 1); rb_define_singleton_method(argf, "eof", argf_eof, 0); rb_define_singleton_method(argf, "eof?", argf_eof, 0); rb_define_singleton_method(argf, "binmode", argf_binmode, 0); rb_define_singleton_method(argf, "filename", argf_filename, 0); rb_define_singleton_method(argf, "path", argf_filename, 0); rb_define_singleton_method(argf, "file", argf_file, 0); rb_define_singleton_method(argf, "skip", argf_skip, 0); rb_define_singleton_method(argf, "close", argf_close_m, 0); rb_define_singleton_method(argf, "closed?", argf_closed, 0); rb_define_singleton_method(argf, "lineno", argf_lineno, 0); rb_define_singleton_method(argf, "lineno=", argf_set_lineno, 1); rb_global_variable(¤t_file); rb_define_readonly_variable("$FILENAME", &filename); filename = rb_str_new2("-"); rb_define_virtual_variable("$-i", opt_i_get, opt_i_set); #if defined (_WIN32) || defined(DJGPP) || defined(__CYGWIN__) || defined(__human68k__) atexit(pipe_atexit); #endif Init_File(); rb_define_method(rb_cFile, "initialize", rb_file_initialize, -1); rb_file_const("RDONLY", INT2FIX(O_RDONLY)); rb_file_const("WRONLY", INT2FIX(O_WRONLY)); rb_file_const("RDWR", INT2FIX(O_RDWR)); rb_file_const("APPEND", INT2FIX(O_APPEND)); rb_file_const("CREAT", INT2FIX(O_CREAT)); rb_file_const("EXCL", INT2FIX(O_EXCL)); #if defined(O_NDELAY) || defined(O_NONBLOCK) # ifdef O_NONBLOCK rb_file_const("NONBLOCK", INT2FIX(O_NONBLOCK)); # else rb_file_const("NONBLOCK", INT2FIX(O_NDELAY)); # endif #endif rb_file_const("TRUNC", INT2FIX(O_TRUNC)); #ifdef O_NOCTTY rb_file_const("NOCTTY", INT2FIX(O_NOCTTY)); #endif #ifdef O_BINARY rb_file_const("BINARY", INT2FIX(O_BINARY)); #endif #ifdef O_SYNC rb_file_const("SYNC", INT2FIX(O_SYNC)); #endif }