14#include "ruby/internal/config.h"
25# if defined(__linux__)
28# if defined(__FreeBSD_version) && __FreeBSD_version >= 1100000
38#define free(x) xfree(x)
40#if defined(DOSISH) || defined(__CYGWIN__)
45#if defined HAVE_NET_SOCKET_H
46# include <net/socket.h>
47#elif defined HAVE_SYS_SOCKET_H
48# include <sys/socket.h>
51#if defined(__BOW__) || defined(__CYGWIN__) || defined(_WIN32)
52# define NO_SAFE_RENAME
55#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__sun) || defined(_nec_ews)
64#if defined(HAVE_SYS_IOCTL_H) && !defined(_WIN32)
67#if defined(HAVE_FCNTL_H) || defined(_WIN32)
69#elif defined(HAVE_SYS_FCNTL_H)
79#if defined(HAVE_SYS_PARAM_H) || defined(__HIUX_MPP__)
80# include <sys/param.h>
93#elif defined HAVE_SYS_SYSCALL_H
94#include <sys/syscall.h>
101#ifdef HAVE_SYS_WAIT_H
102# include <sys/wait.h>
105#ifdef HAVE_COPYFILE_H
106# include <copyfile.h>
108# ifndef COPYFILE_STATE_COPIED
114# undef HAVE_FCOPYFILE
120#include "ccan/list/list.h"
125#include "internal/class.h"
126#include "internal/encoding.h"
127#include "internal/error.h"
128#include "internal/inits.h"
129#include "internal/io.h"
130#include "internal/numeric.h"
131#include "internal/object.h"
132#include "internal/process.h"
133#include "internal/thread.h"
134#include "internal/transcode.h"
135#include "internal/variable.h"
138#include "ruby/missing.h"
141#include "ruby_atomic.h"
151#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
155# ifdef _POSIX_PIPE_BUF
156# define PIPE_BUF _POSIX_PIPE_BUF
163# define EWOULDBLOCK EAGAIN
166#if defined(HAVE___SYSCALL) && (defined(__APPLE__) || defined(__OpenBSD__))
168off_t __syscall(quad_t number, ...);
171#define IO_RBUF_CAPA_MIN 8192
172#define IO_CBUF_CAPA_MIN (128*1024)
173#define IO_RBUF_CAPA_FOR(fptr) (NEED_READCONV(fptr) ? IO_CBUF_CAPA_MIN : IO_RBUF_CAPA_MIN)
174#define IO_WBUF_CAPA_MIN 8192
176#define IO_MAX_BUFFER_GROWTH 8 * 1024 * 1024
181#define open rb_w32_uopen
183#define rename(f, t) rb_w32_urename((f), (t))
184#include "win32/file.h"
194static VALUE rb_eEAGAINWaitReadable;
195static VALUE rb_eEAGAINWaitWritable;
196static VALUE rb_eEWOULDBLOCKWaitReadable;
197static VALUE rb_eEWOULDBLOCKWaitWritable;
198static VALUE rb_eEINPROGRESSWaitWritable;
199static VALUE rb_eEINPROGRESSWaitReadable;
202static VALUE orig_stdout, orig_stderr;
211static ID id_write, id_read, id_getc, id_flush, id_readpartial, id_set_encoding, id_fileno;
212static VALUE sym_mode, sym_perm, sym_flags, sym_extenc, sym_intenc, sym_encoding, sym_open_args;
213static VALUE sym_textmode, sym_binmode, sym_autoclose;
214static VALUE sym_SET, sym_CUR, sym_END;
215static VALUE sym_wait_readable, sym_wait_writable;
217static VALUE sym_DATA;
220static VALUE sym_HOLE;
223static VALUE prep_io(
int fd,
enum rb_io_mode fmode,
VALUE klass,
const char *path);
226rb_io_blocking_region_wait(
struct rb_io *io, rb_blocking_function_t *function,
void *argument,
enum rb_io_event events)
228 return rb_thread_io_blocking_call(io, function, argument, events);
231VALUE rb_io_blocking_region(
struct rb_io *io, rb_blocking_function_t *function,
void *argument)
233 return rb_io_blocking_region_wait(io, function, argument, 0);
237 VALUE filename, current_file;
243 int8_t init_p, next_p, binmode;
254 if (fd < 0 || afd <= max_fd)
257#if defined(HAVE_FCNTL) && defined(F_GETFL)
258 err = fcntl(fd, F_GETFL) == -1;
262 err = fstat(fd, &buf) != 0;
265 if (err &&
errno == EBADF) {
266 rb_bug(
"rb_update_max_fd: invalid fd (%d) given.", fd);
269 while (max_fd < afd) {
270 max_fd = ATOMIC_CAS(max_file_descriptor, max_fd, afd);
275rb_maygvl_fd_fix_cloexec(
int fd)
278#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
279 int flags, flags2, ret;
280 flags = fcntl(fd, F_GETFD);
282 rb_bug(
"rb_maygvl_fd_fix_cloexec: fcntl(%d, F_GETFD) failed: %s", fd, strerror(
errno));
285 flags2 = flags & ~FD_CLOEXEC;
287 flags2 = flags | FD_CLOEXEC;
288 if (flags != flags2) {
289 ret = fcntl(fd, F_SETFD, flags2);
291 rb_bug(
"rb_maygvl_fd_fix_cloexec: fcntl(%d, F_SETFD, %d) failed: %s", fd, flags2, strerror(
errno));
300 rb_maygvl_fd_fix_cloexec(fd);
306rb_fix_detect_o_cloexec(
int fd)
308#if defined(O_CLOEXEC) && defined(F_GETFD)
309 int flags = fcntl(fd, F_GETFD);
312 rb_bug(
"rb_fix_detect_o_cloexec: fcntl(%d, F_GETFD) failed: %s", fd, strerror(
errno));
314 if (flags & FD_CLOEXEC)
317 rb_maygvl_fd_fix_cloexec(fd);
324 return (e == EWOULDBLOCK) || (e == EAGAIN);
331 static int o_cloexec_state = -1;
333 static const int retry_interval = 0;
334 static const int retry_max_count = 10000;
341#elif defined O_NOINHERIT
342 flags |= O_NOINHERIT;
345 while ((ret = open(pathname, flags, mode)) == -1) {
347 if (!io_again_p(e))
break;
348 if (retry_count++ >= retry_max_count)
break;
350 sleep(retry_interval);
353 if (ret < 0)
return ret;
354 if (ret <= 2 || o_cloexec_state == 0) {
355 rb_maygvl_fd_fix_cloexec(ret);
357 else if (o_cloexec_state > 0) {
361 o_cloexec_state = rb_fix_detect_o_cloexec(ret);
380 if (oldfd == newfd) {
384#if defined(HAVE_DUP3) && defined(O_CLOEXEC)
385 static int try_dup3 = 1;
386 if (2 < newfd && try_dup3) {
387 ret = dup3(oldfd, newfd, O_CLOEXEC);
391 if (
errno == ENOSYS) {
393 ret = dup2(oldfd, newfd);
397 ret = dup2(oldfd, newfd);
400 ret = dup2(oldfd, newfd);
402 if (ret < 0)
return ret;
404 rb_maygvl_fd_fix_cloexec(ret);
409rb_fd_set_nonblock(
int fd)
412 return rb_w32_set_nonblock(fd);
413#elif defined(F_GETFL)
414 int oflags = fcntl(fd, F_GETFL);
418 if (oflags & O_NONBLOCK)
420 oflags |= O_NONBLOCK;
421 return fcntl(fd, F_SETFL, oflags);
430 int result = pipe2(descriptors, O_CLOEXEC | O_NONBLOCK);
432 int result = pipe(descriptors);
439 if (result == 0 && descriptors[1] == -1) {
440 close(descriptors[0]);
448 rb_maygvl_fd_fix_cloexec(descriptors[0]);
449 rb_maygvl_fd_fix_cloexec(descriptors[1]);
452 rb_fd_set_nonblock(descriptors[0]);
453 rb_fd_set_nonblock(descriptors[1]);
465#if defined(HAVE_FCNTL) && defined(F_DUPFD_CLOEXEC) && defined(F_DUPFD)
466 static int try_dupfd_cloexec = 1;
467 if (try_dupfd_cloexec) {
468 ret = fcntl(fd, F_DUPFD_CLOEXEC, minfd);
471 rb_maygvl_fd_fix_cloexec(ret);
475 if (
errno == EINVAL) {
476 ret = fcntl(fd, F_DUPFD, minfd);
478 try_dupfd_cloexec = 0;
483 ret = fcntl(fd, F_DUPFD, minfd);
485#elif defined(HAVE_FCNTL) && defined(F_DUPFD)
486 ret = fcntl(fd, F_DUPFD, minfd);
489 if (ret >= 0 && ret < minfd) {
490 const int prev_fd = ret;
496 if (ret < 0)
return ret;
497 rb_maygvl_fd_fix_cloexec(ret);
501#define argf_of(obj) (*(struct argf *)DATA_PTR(obj))
502#define ARGF argf_of(argf)
504#define GetWriteIO(io) rb_io_get_write_io(io)
506#define READ_DATA_PENDING(fptr) ((fptr)->rbuf.len)
507#define READ_DATA_PENDING_COUNT(fptr) ((fptr)->rbuf.len)
508#define READ_DATA_PENDING_PTR(fptr) ((fptr)->rbuf.ptr+(fptr)->rbuf.off)
509#define READ_DATA_BUFFERED(fptr) READ_DATA_PENDING(fptr)
511#define READ_CHAR_PENDING(fptr) ((fptr)->cbuf.len)
512#define READ_CHAR_PENDING_COUNT(fptr) ((fptr)->cbuf.len)
513#define READ_CHAR_PENDING_PTR(fptr) ((fptr)->cbuf.ptr+(fptr)->cbuf.off)
516#define WAIT_FD_IN_WIN32(fptr) \
517 (rb_w32_io_cancelable_p((fptr)->fd) ? Qnil : rb_io_wait(fptr->self, RB_INT2NUM(RUBY_IO_READABLE), RUBY_IO_TIMEOUT_DEFAULT))
519#define WAIT_FD_IN_WIN32(fptr)
522#define READ_CHECK(fptr) do {\
523 if (!READ_DATA_PENDING(fptr)) {\
524 WAIT_FD_IN_WIN32(fptr);\
525 rb_io_check_closed(fptr);\
531# define S_ISSOCK(m) _S_ISSOCK(m)
534# define S_ISSOCK(m) (((m) & S_IFMT) == _S_IFSOCK)
537# define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
543static int io_fflush(
rb_io_t *);
544static rb_io_t *flush_before_seek(
rb_io_t *fptr,
bool discard_rbuf);
545static void clear_codeconv(
rb_io_t *fptr);
547#define FMODE_SIGNAL_ON_EPIPE (1<<17)
549#define fptr_signal_on_epipe(fptr) \
550 (((fptr)->mode & FMODE_SIGNAL_ON_EPIPE) != 0)
552#define fptr_set_signal_on_epipe(fptr, flag) \
554 (fptr)->mode |= FMODE_SIGNAL_ON_EPIPE : \
555 (fptr)->mode &= ~FMODE_SIGNAL_ON_EPIPE)
557extern ID ruby_static_id_signo;
559NORETURN(
static void rb_sys_fail_on_write(
rb_io_t *fptr));
561rb_sys_fail_on_write(
rb_io_t *fptr)
564 VALUE errinfo = rb_syserr_new_path(e, (fptr)->pathv);
566 if (fptr_signal_on_epipe(fptr) && (e == EPIPE)) {
578#define NEED_NEWLINE_DECORATOR_ON_READ(fptr) ((fptr)->mode & FMODE_TEXTMODE)
579#define NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) ((fptr)->mode & FMODE_TEXTMODE)
580#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
581# define RUBY_CRLF_ENVIRONMENT 1
583# define RUBY_CRLF_ENVIRONMENT 0
586#if RUBY_CRLF_ENVIRONMENT
588# define DEFAULT_TEXTMODE FMODE_TEXTMODE
589# define TEXTMODE_NEWLINE_DECORATOR_ON_WRITE ECONV_CRLF_NEWLINE_DECORATOR
597#define NEED_READCONV(fptr) ((fptr)->encs.enc2 != NULL || (fptr)->encs.ecflags & ~ECONV_CRLF_NEWLINE_DECORATOR)
598#define WRITECONV_MASK ( \
599 (ECONV_DECORATOR_MASK & ~ECONV_CRLF_NEWLINE_DECORATOR)|\
600 ECONV_STATEFUL_DECORATOR_MASK|\
602#define NEED_WRITECONV(fptr) ( \
603 ((fptr)->encs.enc != NULL && (fptr)->encs.enc != rb_ascii8bit_encoding()) || \
604 ((fptr)->encs.ecflags & WRITECONV_MASK) || \
606#define SET_BINARY_MODE(fptr) setmode((fptr)->fd, O_BINARY)
608#define NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr) do {\
609 if (NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {\
610 if (((fptr)->mode & FMODE_READABLE) &&\
611 !((fptr)->encs.ecflags & ECONV_NEWLINE_DECORATOR_MASK)) {\
612 setmode((fptr)->fd, O_BINARY);\
615 setmode((fptr)->fd, O_TEXT);\
620#define SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags) do {\
621 if ((enc2) && ((ecflags) & ECONV_DEFAULT_NEWLINE_DECORATOR)) {\
622 (ecflags) |= ECONV_UNIVERSAL_NEWLINE_DECORATOR;\
630io_unread(
rb_io_t *fptr,
bool discard_rbuf)
646 if (!rb_w32_fd_is_text(fptr->
fd)) {
647 r = lseek(fptr->
fd, -fptr->
rbuf.
len, SEEK_CUR);
648 if (r < 0 &&
errno) {
651 if (!discard_rbuf)
return;
657 pos = lseek(fptr->
fd, 0, SEEK_CUR);
658 if (pos < 0 &&
errno) {
661 if (!discard_rbuf)
goto end;
665 extra_max = (long)(pos - fptr->
rbuf.
len);
673 for (i = 0; i < fptr->
rbuf.
len; i++) {
674 if (*p ==
'\n') newlines++;
675 if (extra_max == newlines)
break;
680 while (newlines >= 0) {
681 r = lseek(fptr->
fd, pos - fptr->
rbuf.
len - newlines, SEEK_SET);
682 if (newlines == 0)
break;
687 read_size = _read(fptr->
fd, buf, fptr->
rbuf.
len + newlines);
691 rb_syserr_fail_path(e, fptr->
pathv);
693 if (read_size == fptr->
rbuf.
len) {
694 lseek(fptr->
fd, r, SEEK_SET);
705 clear_codeconv(fptr);
717set_binary_mode_with_seek_cur(
rb_io_t *fptr)
719 if (!rb_w32_fd_is_text(fptr->
fd))
return O_BINARY;
722 return setmode(fptr->
fd, O_BINARY);
724 flush_before_seek(fptr,
false);
725 return setmode(fptr->
fd, O_BINARY);
727#define SET_BINARY_MODE_WITH_SEEK_CUR(fptr) set_binary_mode_with_seek_cur(fptr)
731# define DEFAULT_TEXTMODE 0
732#define NEED_READCONV(fptr) ((fptr)->encs.enc2 != NULL || NEED_NEWLINE_DECORATOR_ON_READ(fptr))
733#define NEED_WRITECONV(fptr) ( \
734 ((fptr)->encs.enc != NULL && (fptr)->encs.enc != rb_ascii8bit_encoding()) || \
735 NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) || \
736 ((fptr)->encs.ecflags & (ECONV_DECORATOR_MASK|ECONV_STATEFUL_DECORATOR_MASK)) || \
738#define SET_BINARY_MODE(fptr) (void)(fptr)
739#define NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr) (void)(fptr)
740#define SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags) ((void)(enc2), (void)(ecflags))
741#define SET_BINARY_MODE_WITH_SEEK_CUR(fptr) (void)(fptr)
744#if !defined HAVE_SHUTDOWN && !defined shutdown
745#define shutdown(a,b) 0
749#define is_socket(fd, path) rb_w32_is_socket(fd)
750#elif !defined(S_ISSOCK)
751#define is_socket(fd, path) 0
754is_socket(
int fd,
VALUE path)
757 if (fstat(fd, &sbuf) < 0)
758 rb_sys_fail_path(path);
759 return S_ISSOCK(sbuf.st_mode);
763static const char closed_stream[] =
"closed stream";
766io_fd_check_closed(
int fd)
799 io_fd_check_closed(fptr->
fd);
803rb_io_get_fptr(
VALUE io)
813 return rb_convert_type_with_id(io,
T_FILE,
"IO", idTo_io);
819 return rb_check_convert_type_with_id(io,
T_FILE,
"IO", idTo_io);
837 rb_io_t *fptr = rb_io_get_fptr(io);
846 return write_io ? write_io :
Qnil;
859 rb_io_t *fptr = rb_io_get_fptr(self);
889 if (
RTEST(timeout)) {
893 rb_io_t *fptr = rb_io_get_fptr(self);
918#if !RUBY_CRLF_ENVIRONMENT
920io_unread(
rb_io_t *fptr,
bool discard_rbuf)
928 r = lseek(fptr->
fd, -fptr->
rbuf.
len, SEEK_CUR);
929 if (r < 0 &&
errno) {
932 if (!discard_rbuf)
return;
936 clear_codeconv(fptr);
946 long len = RSTRING_LEN(str);
949 const int min_capa = IO_RBUF_CAPA_FOR(fptr);
952#if SIZEOF_LONG > SIZEOF_INT
977flush_before_seek(
rb_io_t *fptr,
bool discard_rbuf)
979 if (io_fflush(fptr) < 0)
980 rb_sys_fail_on_write(fptr);
981 io_unread(fptr, discard_rbuf);
986#define io_seek(fptr, ofs, whence) (errno = 0, lseek(flush_before_seek(fptr, true)->fd, (ofs), (whence)))
987#define io_tell(fptr) lseek(flush_before_seek(fptr, false)->fd, 0, SEEK_CUR)
1003 if (io_fflush(fptr) < 0)
1004 rb_sys_fail_on_write(fptr);
1009 if (io_fflush(wfptr) < 0)
1010 rb_sys_fail_on_write(wfptr);
1018 if (READ_CHAR_PENDING(fptr)) {
1019 rb_raise(
rb_eIOError,
"byte oriented read for character buffered IO");
1030io_read_encoding(
rb_io_t *fptr)
1035 return rb_default_external_encoding();
1039io_input_encoding(
rb_io_t *fptr)
1044 return io_read_encoding(fptr);
1055 io_unread(fptr,
true);
1060rb_io_read_pending(
rb_io_t *fptr)
1063 if (READ_CHAR_PENDING(fptr))
1065 return READ_DATA_PENDING(fptr);
1071 if (!READ_DATA_PENDING(fptr)) {
1078rb_gc_for_fd(
int err)
1080 if (err == EMFILE || err == ENFILE || err == ENOMEM) {
1090#define TRY_WITH_GC(expr) \
1091 for (int first_errno, retried_errno = 0, retried = 0; \
1094 (!rb_gc_for_fd(first_errno = errno) || !(expr)) && \
1095 (retried_errno = errno, 1)); \
1096 (void)retried_errno, retried = 1)
1111io_alloc(
VALUE klass)
1121# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
1147struct io_internal_writev_struct {
1154 const struct iovec *iov;
1167io_internal_wait(
VALUE thread,
rb_io_t *fptr,
int error,
int events,
struct timeval *timeout)
1169 if (!timeout && rb_thread_mn_schedulable(thread)) {
1174 int ready = nogvl_wait_for(thread, fptr, events, timeout);
1179 else if (ready == 0) {
1196internal_read_func(
void *ptr)
1201 if (iis->timeout && !iis->nonblock) {
1202 if (io_internal_wait(iis->th, iis->fptr, 0, RB_WAITFD_IN, iis->timeout) == -1) {
1208 result = read(iis->fd, iis->buf, iis->capa);
1210 if (result < 0 && !iis->nonblock) {
1211 if (io_again_p(
errno)) {
1212 if (io_internal_wait(iis->th, iis->fptr,
errno, RB_WAITFD_IN, iis->timeout) == -1) {
1224#if defined __APPLE__
1225# define do_write_retry(code) do {result = code;} while (result == -1 && errno == EPROTOTYPE)
1227# define do_write_retry(code) result = code
1231internal_write_func(
void *ptr)
1236 if (iis->timeout && !iis->nonblock) {
1237 if (io_internal_wait(iis->th, iis->fptr, 0, RB_WAITFD_OUT, iis->timeout) == -1) {
1243 do_write_retry(write(iis->fd, iis->buf, iis->capa));
1245 if (result < 0 && !iis->nonblock) {
1247 if (io_again_p(e)) {
1248 if (io_internal_wait(iis->th, iis->fptr,
errno, RB_WAITFD_OUT, iis->timeout) == -1) {
1262internal_writev_func(
void *ptr)
1264 struct io_internal_writev_struct *iis = ptr;
1267 if (iis->timeout && !iis->nonblock) {
1268 if (io_internal_wait(iis->th, iis->fptr, 0, RB_WAITFD_OUT, iis->timeout) == -1) {
1274 do_write_retry(writev(iis->fd, iis->iov, iis->iovcnt));
1276 if (result < 0 && !iis->nonblock) {
1277 if (io_again_p(
errno)) {
1278 if (io_internal_wait(iis->th, iis->fptr,
errno, RB_WAITFD_OUT, iis->timeout) == -1) {
1292rb_io_read_memory(
rb_io_t *fptr,
void *buf,
size_t count)
1295 if (scheduler !=
Qnil) {
1298 if (!UNDEF_P(result)) {
1314 struct timeval timeout_storage;
1318 iis.timeout = &timeout_storage;
1321 return (ssize_t)rb_io_blocking_region_wait(fptr, internal_read_func, &iis,
RUBY_IO_READABLE);
1325rb_io_write_memory(
rb_io_t *fptr,
const void *buf,
size_t count)
1328 if (scheduler !=
Qnil) {
1331 if (!UNDEF_P(result)) {
1347 struct timeval timeout_storage;
1351 iis.timeout = &timeout_storage;
1354 return (ssize_t)rb_io_blocking_region_wait(fptr, internal_write_func, &iis,
RUBY_IO_WRITABLE);
1359rb_writev_internal(
rb_io_t *fptr,
const struct iovec *iov,
int iovcnt)
1361 if (!iovcnt)
return 0;
1364 if (scheduler !=
Qnil) {
1368 if (!UNDEF_P(result)) {
1373 struct io_internal_writev_struct iis = {
1384 struct timeval timeout_storage;
1388 iis.timeout = &timeout_storage;
1391 return (ssize_t)rb_io_blocking_region_wait(fptr, internal_writev_func, &iis,
RUBY_IO_WRITABLE);
1396io_flush_buffer_sync(
void *arg)
1418io_flush_buffer_async(
VALUE arg)
1421 return rb_io_blocking_region_wait(fptr, io_flush_buffer_sync, fptr,
RUBY_IO_WRITABLE);
1428 return (
int)io_flush_buffer_async((
VALUE)fptr);
1443 while (fptr->
wbuf.
len > 0 && io_flush_buffer(fptr) != 0) {
1458 if (scheduler !=
Qnil) {
1468 if (NIL_OR_UNDEF_P(timeout)) {
1472 if (timeout !=
Qnil) {
1477 int ready = rb_thread_io_wait(fptr,
RB_NUM2INT(events), tv);
1501io_wait_for_single_fd(
int fd,
int events,
struct timeval *timeout)
1505 if (scheduler !=
Qnil) {
1511 return rb_thread_wait_for_single_fd(fd, events, timeout);
1517 io_fd_check_closed(f);
1523#if defined(ERESTART)
1530#if EWOULDBLOCK != EAGAIN
1533 if (scheduler !=
Qnil) {
1551 io_fd_check_closed(f);
1557#if defined(ERESTART)
1573#if EWOULDBLOCK != EAGAIN
1576 if (scheduler !=
Qnil) {
1594 return io_wait_for_single_fd(fd, events, timeout);
1628#if defined(ERESTART)
1638#if EWOULDBLOCK != EAGAIN
1655 if (
RTEST(result)) {
1670 if (
RTEST(result)) {
1684 const char *senc, *denc;
1691 ecflags = fptr->
encs.
ecflags & ~ECONV_NEWLINE_DECORATOR_READ_MASK;
1718 denc = rb_enc_name(enc);
1750io_binwrite_string_internal(
rb_io_t *fptr,
const char *ptr,
long length)
1753 struct iovec iov[2];
1756 iov[0].iov_len = fptr->
wbuf.
len;
1757 iov[1].iov_base = (
void*)ptr;
1758 iov[1].iov_len = length;
1760 ssize_t result = rb_writev_internal(fptr, iov, 2);
1765 if (result >= fptr->
wbuf.
len) {
1773 fptr->
wbuf.
off += (int)result;
1774 fptr->
wbuf.
len -= (int)result;
1782 return rb_io_write_memory(fptr, ptr, length);
1787io_binwrite_string_internal(
rb_io_t *fptr,
const char *ptr,
long length)
1789 long remaining = length;
1792 if (fptr->
wbuf.
len+length <= fptr->wbuf.capa) {
1799 fptr->
wbuf.
len += (int)length;
1806 if (io_fflush(fptr) < 0) {
1811 if (remaining == 0) {
1817 return rb_io_write_memory(fptr, ptr, length);
1822io_binwrite_string(
VALUE arg)
1826 const char *ptr = p->ptr;
1827 size_t remaining = p->length;
1831 ssize_t result = io_binwrite_string_internal(p->fptr, ptr, remaining);
1837 else if (result > 0) {
1838 if ((
size_t)result == remaining)
break;
1840 remaining -= result;
1856io_allocate_write_buffer(
rb_io_t *fptr,
int sync)
1861 fptr->
wbuf.
capa = IO_WBUF_CAPA_MIN;
1872io_binwrite_requires_flush_write(
rb_io_t *fptr,
long len,
int nosync)
1887io_binwrite(
const char *ptr,
long len,
rb_io_t *fptr,
int nosync)
1889 if (
len <= 0)
return len;
1894 io_allocate_write_buffer(fptr, !nosync);
1896 if (io_binwrite_requires_flush_write(fptr,
len, nosync)) {
1907 return io_binwrite_string((
VALUE)&arg);
1924# define MODE_BTMODE(a,b,c) ((fmode & FMODE_BINMODE) ? (b) : \
1925 (fmode & FMODE_TEXTMODE) ? (c) : (a))
1927#define MODE_BTXMODE(a, b, c, d, e, f) ((fmode & FMODE_EXCL) ? \
1928 MODE_BTMODE(d, e, f) : \
1929 MODE_BTMODE(a, b, c))
1934 if (NEED_WRITECONV(fptr)) {
1936 SET_BINARY_MODE(fptr);
1938 make_writeconv(fptr);
1941#define fmode (fptr->mode)
1944 else if (MODE_BTMODE(DEFAULT_TEXTMODE,0,1) && !rb_enc_asciicompat(rb_enc_get(str))) {
1945 rb_raise(rb_eArgError,
"ASCII incompatible string written for text mode IO without encoding conversion: %s",
1946 rb_enc_name(rb_enc_get(str)));
1952 common_encoding = rb_enc_from_encoding(fptr->
encs.
enc2);
1953 else if (fptr->
encs.
enc != rb_ascii8bit_encoding())
1954 common_encoding = rb_enc_from_encoding(fptr->
encs.
enc);
1957 if (!
NIL_P(common_encoding)) {
1968#if RUBY_CRLF_ENVIRONMENT
1969#define fmode (fptr->mode)
1970 else if (MODE_BTMODE(DEFAULT_TEXTMODE,0,1)) {
1973 setmode(fptr->
fd, O_BINARY);
1976 setmode(fptr->
fd, O_TEXT);
1978 if (!rb_enc_asciicompat(rb_enc_get(str))) {
1979 rb_raise(rb_eArgError,
"ASCII incompatible string written for text mode IO without encoding conversion: %s",
1980 rb_enc_name(rb_enc_get(str)));
1998 long len = rb_w32_write_console(str, fptr->
fd);
2003 str = do_writeconv(str, fptr, &converted);
2007 tmp = rb_str_tmp_frozen_no_embed_acquire(str);
2009 n = io_binwrite(ptr,
len, fptr, nosync);
2010 rb_str_tmp_frozen_release(str, tmp);
2022 return (ssize_t)io_binwrite(buf, (
long)size, fptr, 0);
2032 io = GetWriteIO(io);
2042 if (RSTRING_LEN(str) == 0)
return INT2FIX(0);
2047 n = io_fwrite(str, fptr, nosync);
2048 if (n < 0L) rb_sys_fail_on_write(fptr);
2054struct binwritev_arg {
2062io_binwritev_internal(
VALUE arg)
2064 struct binwritev_arg *p = (
struct binwritev_arg *)arg;
2066 size_t remaining = p->total;
2070 struct iovec *iov = p->iov;
2071 int iovcnt = p->iovcnt;
2074 long result = rb_writev_internal(fptr, iov, iovcnt);
2079 if (offset < (
size_t)fptr->
wbuf.
len) {
2084 offset -= (size_t)fptr->
wbuf.
len;
2090 if (offset == p->total) {
2094 while (result >= (ssize_t)iov->iov_len) {
2096 result -= iov->iov_len;
2106 iov->iov_base = (
char *)iov->iov_base + result;
2107 iov->iov_len -= result;
2121io_binwritev(
struct iovec *iov,
int iovcnt,
rb_io_t *fptr)
2126 if (iovcnt == 0)
return 0;
2129 for (
int i = 1; i < iovcnt; i++) total += iov[i].iov_len;
2131 io_allocate_write_buffer(fptr, 1);
2137 if (offset + total <= (
size_t)fptr->
wbuf.
capa) {
2138 for (
int i = 1; i < iovcnt; i++) {
2139 memcpy(fptr->
wbuf.
ptr+offset, iov[i].iov_base, iov[i].iov_len);
2140 offset += iov[i].iov_len;
2149 iov[0].iov_len = fptr->
wbuf.
len;
2162 struct binwritev_arg arg;
2165 arg.iovcnt = iovcnt;
2172 return io_binwritev_internal((
VALUE)&arg);
2179 int i, converted, iovcnt = argc + 1;
2181 VALUE v1, v2, str, tmp, *tmp_array;
2187 for (i = 0; i < argc; i++) {
2190 str = do_writeconv(str, fptr, &converted);
2195 tmp = rb_str_tmp_frozen_acquire(str);
2199 iov[i+1].iov_base = RSTRING_PTR(tmp);
2200 iov[i+1].iov_len = RSTRING_LEN(tmp);
2203 n = io_binwritev(iov, iovcnt, fptr);
2206 for (i = 0; i < argc; i++) {
2207 rb_str_tmp_frozen_release(argv[i], tmp_array[i]);
2216iovcnt_ok(
int iovcnt)
2219 return iovcnt < IOV_MAX;
2227io_writev(
int argc,
const VALUE *argv,
VALUE io)
2234 io = GetWriteIO(io);
2239 return rb_funcallv(io, id_write, argc, argv);
2247 for (i = 0; i < argc; i += cnt) {
2250 n = io_fwritev(cnt, &argv[i], fptr);
2261 rb_sys_fail_on_write(fptr);
2263 total = rb_fix_plus(
LONG2FIX(n), total);
2294 return io_writev(argc, argv, io);
2297 VALUE str = argv[0];
2298 return io_write(io, str, 0);
2305 return rb_funcallv(io, id_write, 1, &str);
2309rb_io_writev(
VALUE io,
int argc,
const VALUE *argv)
2314 char sep = RCLASS_SINGLETON_P(klass) ? (klass = io,
'.') :
'#';
2317 " which accepts just one argument",
2322 do rb_io_write(io, *argv++);
while (--argc);
2327 return rb_funcallv(io, id_write, argc, argv);
2353 rb_io_write(io, str);
2359nogvl_fsync(
void *ptr)
2364 if (GetFileType((HANDLE)rb_w32_get_osfhandle(fptr->
fd)) != FILE_TYPE_DISK)
2367 return (
VALUE)fsync(fptr->
fd);
2372rb_io_flush_raw(
VALUE io,
int sync)
2380 io = GetWriteIO(io);
2384 if (io_fflush(fptr) < 0)
2385 rb_sys_fail_on_write(fptr);
2388 io_unread(fptr,
true);
2409 return rb_io_flush_raw(io, 1);
2435 pos = io_tell(fptr);
2436 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2442rb_io_seek(
VALUE io,
VALUE offset,
int whence)
2449 pos = io_seek(fptr, pos, whence);
2450 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2456interpret_seek_whence(
VALUE vwhence)
2458 if (vwhence == sym_SET)
2460 if (vwhence == sym_CUR)
2462 if (vwhence == sym_END)
2465 if (vwhence == sym_DATA)
2469 if (vwhence == sym_HOLE)
2525 VALUE offset, ptrname;
2526 int whence = SEEK_SET;
2528 if (
rb_scan_args(argc, argv,
"11", &offset, &ptrname) == 2) {
2529 whence = interpret_seek_whence(ptrname);
2532 return rb_io_seek(io, offset, whence);
2560 pos = io_seek(fptr, pos, SEEK_SET);
2561 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2566static void clear_readconv(
rb_io_t *fptr);
2593rb_io_rewind(
VALUE io)
2598 if (io_seek(fptr, 0L, 0) < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2599 if (io == ARGF.current_file) {
2600 ARGF.lineno -= fptr->
lineno;
2604 clear_readconv(fptr);
2611fptr_wait_readable(
rb_io_t *fptr)
2629 fptr->
rbuf.
capa = IO_RBUF_CAPA_FOR(fptr);
2640 if (fptr_wait_readable(fptr))
2644 VALUE path = rb_sprintf(
"fd:%d ", fptr->
fd);
2649 rb_syserr_fail_path(e, path);
2703 if (READ_CHAR_PENDING(fptr))
return Qfalse;
2704 if (READ_DATA_PENDING(fptr))
return Qfalse;
2706#if RUBY_CRLF_ENVIRONMENT
2707 if (!NEED_READCONV(fptr) && NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {
2708 return RBOOL(eof(fptr->
fd));
2711 return RBOOL(io_fillbuf(fptr) < 0);
2735 io = GetWriteIO(io);
2772 io = GetWriteIO(io);
2778 fptr->
mode &= ~FMODE_SYNC;
2802rb_io_fsync(
VALUE io)
2806 io = GetWriteIO(io);
2809 if (io_fflush(fptr) < 0)
2810 rb_sys_fail_on_write(fptr);
2812 if ((
int)rb_io_blocking_region(fptr, nogvl_fsync, fptr))
2813 rb_sys_fail_path(fptr->
pathv);
2818# define rb_io_fsync rb_f_notimplement
2819# define rb_io_sync rb_f_notimplement
2828#ifdef HAVE_FDATASYNC
2830nogvl_fdatasync(
void *ptr)
2835 if (GetFileType((HANDLE)rb_w32_get_osfhandle(fptr->
fd)) != FILE_TYPE_DISK)
2838 return (
VALUE)fdatasync(fptr->
fd);
2853rb_io_fdatasync(
VALUE io)
2857 io = GetWriteIO(io);
2860 if (io_fflush(fptr) < 0)
2861 rb_sys_fail_on_write(fptr);
2863 if ((
int)rb_io_blocking_region(fptr, nogvl_fdatasync, fptr) == 0)
2867 return rb_io_fsync(io);
2870#define rb_io_fdatasync rb_io_fsync
2888rb_io_fileno(
VALUE io)
2908 if (!UNDEF_P(fileno)) {
2996rb_io_inspect(
VALUE obj)
3000 static const char closed[] =
" (closed)";
3002 fptr =
RFILE(obj)->fptr;
3009 rb_str_cat(result, closed+1, strlen(closed)-1);
3012 rb_str_catf(result,
"fd %d", fptr->
fd);
3033rb_io_to_io(
VALUE io)
3040read_buffered_data(
char *ptr,
long len,
rb_io_t *fptr)
3044 n = READ_DATA_PENDING_COUNT(fptr);
3045 if (n <= 0)
return 0;
3046 if (n >
len) n = (int)
len;
3054io_bufread(
char *ptr,
long len,
rb_io_t *fptr)
3060 if (READ_DATA_PENDING(fptr) == 0) {
3064 c = rb_io_read_memory(fptr, ptr+offset, n);
3067 if (fptr_wait_readable(fptr))
3072 if ((n -= c) <= 0)
break;
3078 c = read_buffered_data(ptr+offset, n, fptr);
3081 if ((n -= c) <= 0)
break;
3084 if (io_fillbuf(fptr) < 0) {
3091static int io_setstrbuf(
VALUE *str,
long len);
3100bufread_call(
VALUE arg)
3103 p->len = io_bufread(p->str_ptr, p->len, p->fptr);
3108io_fread(
VALUE str,
long offset,
long size,
rb_io_t *fptr)
3113 io_setstrbuf(&str, offset + size);
3114 arg.str_ptr = RSTRING_PTR(str) + offset;
3117 rb_str_locktmp_ensure(str, bufread_call, (
VALUE)&arg);
3119 if (
len < 0) rb_sys_fail_path(fptr->
pathv);
3127 rb_off_t siz = READ_DATA_PENDING_COUNT(fptr);
3130 if (fstat(fptr->
fd, &st) == 0 && S_ISREG(st.st_mode)
3131#
if defined(__HAIKU__)
3136 if (io_fflush(fptr) < 0)
3137 rb_sys_fail_on_write(fptr);
3138 pos = lseek(fptr->
fd, 0, SEEK_CUR);
3139 if (st.st_size >= pos && pos >= 0) {
3140 siz += st.st_size - pos;
3141 if (siz > LONG_MAX) {
3142 rb_raise(
rb_eIOError,
"file too big for single read");
3155 rb_enc_associate(str, io_read_encoding(fptr));
3162make_readconv(
rb_io_t *fptr,
int size)
3167 const char *sname, *dname;
3168 ecflags = fptr->
encs.
ecflags & ~ECONV_NEWLINE_DECORATOR_WRITE_MASK;
3171 sname = rb_enc_name(fptr->
encs.
enc2);
3172 dname = rb_enc_name(io_read_encoding(fptr));
3182 if (size < IO_CBUF_CAPA_MIN) size = IO_CBUF_CAPA_MIN;
3188#define MORE_CHAR_SUSPENDED Qtrue
3189#define MORE_CHAR_FINISHED Qnil
3191fill_cbuf(
rb_io_t *fptr,
int ec_flags)
3193 const unsigned char *ss, *sp, *se;
3194 unsigned char *ds, *dp, *de;
3203 return MORE_CHAR_SUSPENDED;
3214 ss = sp = (
const unsigned char *)fptr->
rbuf.
ptr + fptr->
rbuf.
off;
3219 fptr->
rbuf.
off += (int)(sp - ss);
3220 fptr->
rbuf.
len -= (int)(sp - ss);
3221 fptr->
cbuf.
len += (int)(dp - ds);
3226 fptr->
rbuf.
off -= putbackable;
3227 fptr->
rbuf.
len += putbackable;
3234 if (cbuf_len0 != fptr->
cbuf.
len)
3235 return MORE_CHAR_SUSPENDED;
3238 return MORE_CHAR_FINISHED;
3244 if (io_fillbuf(fptr) < 0) {
3246 return MORE_CHAR_FINISHED;
3251 fptr->
cbuf.
len += (int)(dp - ds);
3258 if (cbuf_len0 != fptr->
cbuf.
len)
3259 return MORE_CHAR_SUSPENDED;
3261 return MORE_CHAR_FINISHED;
3269 if (v != MORE_CHAR_SUSPENDED && v != MORE_CHAR_FINISHED)
3286 rb_enc_associate(str, fptr->
encs.
enc);
3315 long clen = RSTRING_LEN(s);
3327#define MAX_REALLOC_GAP 4096
3329io_shrink_read_string(
VALUE str,
long n)
3332 rb_str_resize(str, n);
3337io_set_read_length(
VALUE str,
long n,
int shrinkable)
3339 if (RSTRING_LEN(str) != n) {
3342 if (shrinkable) io_shrink_read_string(str, n);
3356 if (NEED_READCONV(fptr)) {
3357 int first = !
NIL_P(str);
3358 SET_BINARY_MODE(fptr);
3359 shrinkable = io_setstrbuf(&str,0);
3360 make_readconv(fptr, 0);
3365 io_shift_cbuf(fptr, fptr->
cbuf.
len, &str);
3367 v = fill_cbuf(fptr, 0);
3368 if (v != MORE_CHAR_SUSPENDED && v != MORE_CHAR_FINISHED) {
3371 io_shift_cbuf(fptr, fptr->
cbuf.
len, &str);
3375 if (v == MORE_CHAR_FINISHED) {
3376 clear_readconv(fptr);
3378 if (shrinkable) io_shrink_read_string(str, RSTRING_LEN(str));
3379 return io_enc_str(str, fptr);
3384 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
3388 enc = io_read_encoding(fptr);
3391 if (siz == 0) siz = BUFSIZ;
3392 shrinkable = io_setstrbuf(&str, siz);
3395 n = io_fread(str, bytes, siz - bytes, fptr);
3396 if (n == 0 && bytes == 0) {
3404 if (bytes < siz)
break;
3408 if (
capa < (
size_t)RSTRING_LEN(str) + BUFSIZ) {
3409 if (
capa < BUFSIZ) {
3412 else if (
capa > IO_MAX_BUFFER_GROWTH) {
3413 capa = IO_MAX_BUFFER_GROWTH;
3418 if (shrinkable) io_shrink_read_string(str, RSTRING_LEN(str));
3419 str = io_enc_str(str, fptr);
3427 if (rb_fd_set_nonblock(fptr->
fd) != 0) {
3428 rb_sys_fail_path(fptr->
pathv);
3433io_read_memory_call(
VALUE arg)
3438 if (scheduler !=
Qnil) {
3441 if (!UNDEF_P(result)) {
3447 if (iis->nonblock) {
3448 return rb_io_blocking_region(iis->fptr, internal_read_func, iis);
3451 return rb_io_blocking_region_wait(iis->fptr, internal_read_func, iis,
RUBY_IO_READABLE);
3458 return (
long)rb_str_locktmp_ensure(str, io_read_memory_call, (
VALUE)iis);
3461#define no_exception_p(opts) !rb_opts_exception_p((opts), TRUE)
3464io_getpartial(
int argc,
VALUE *argv,
VALUE io,
int no_exception,
int nonblock)
3475 rb_raise(rb_eArgError,
"negative length %ld given",
len);
3478 shrinkable = io_setstrbuf(&str,
len);
3484 io_set_read_length(str, 0, shrinkable);
3490 n = read_buffered_data(RSTRING_PTR(str),
len, fptr);
3496 io_setstrbuf(&str,
len);
3499 iis.nonblock = nonblock;
3501 iis.buf = RSTRING_PTR(str);
3504 n = io_read_memory_locktmp(str, &iis);
3507 if (!nonblock && fptr_wait_readable(fptr))
3509 if (nonblock && (io_again_p(e))) {
3511 return sym_wait_readable;
3514 e,
"read would block");
3516 rb_syserr_fail_path(e, fptr->
pathv);
3519 io_set_read_length(str, n, shrinkable);
3620io_readpartial(
int argc,
VALUE *argv,
VALUE io)
3624 ret = io_getpartial(argc, argv, io,
Qnil, 0);
3631io_nonblock_eof(
int no_exception)
3633 if (!no_exception) {
3649 rb_raise(rb_eArgError,
"negative length %ld given",
len);
3652 shrinkable = io_setstrbuf(&str,
len);
3653 rb_bool_expected(ex,
"exception", TRUE);
3659 io_set_read_length(str, 0, shrinkable);
3663 n = read_buffered_data(RSTRING_PTR(str),
len, fptr);
3665 rb_fd_set_nonblock(fptr->
fd);
3666 shrinkable |= io_setstrbuf(&str,
len);
3670 iis.buf = RSTRING_PTR(str);
3673 n = io_read_memory_locktmp(str, &iis);
3676 if (io_again_p(e)) {
3677 if (!ex)
return sym_wait_readable;
3679 e,
"read would block");
3681 rb_syserr_fail_path(e, fptr->
pathv);
3684 io_set_read_length(str, n, shrinkable);
3687 if (!ex)
return Qnil;
3703 rb_bool_expected(ex,
"exception", TRUE);
3705 io = GetWriteIO(io);
3709 if (io_fflush(fptr) < 0)
3710 rb_sys_fail_on_write(fptr);
3712 rb_fd_set_nonblock(fptr->
fd);
3713 n = write(fptr->
fd, RSTRING_PTR(str), RSTRING_LEN(str));
3718 if (io_again_p(e)) {
3720 return sym_wait_writable;
3726 rb_syserr_fail_path(e, fptr->
pathv);
3810#if RUBY_CRLF_ENVIRONMENT
3816 if (
NIL_P(length)) {
3819 return read_all(fptr, remain_size(fptr), str);
3823 rb_raise(rb_eArgError,
"negative length %ld given",
len);
3826 shrinkable = io_setstrbuf(&str,
len);
3831 io_set_read_length(str, 0, shrinkable);
3836#if RUBY_CRLF_ENVIRONMENT
3837 previous_mode = set_binary_mode_with_seek_cur(fptr);
3839 n = io_fread(str, 0,
len, fptr);
3840 io_set_read_length(str, n, shrinkable);
3841#if RUBY_CRLF_ENVIRONMENT
3842 if (previous_mode == O_TEXT) {
3843 setmode(fptr->
fd, O_TEXT);
3846 if (n == 0)
return Qnil;
3852rscheck(
const char *rsptr,
long rslen,
VALUE rs)
3855 if (RSTRING_PTR(rs) != rsptr && RSTRING_LEN(rs) != rslen)
3860search_delim(
const char *p,
long len,
int delim,
rb_encoding *enc)
3862 if (rb_enc_mbminlen(enc) == 1) {
3863 p = memchr(p, delim,
len);
3864 if (p)
return p + 1;
3867 const char *end = p +
len;
3869 int r = rb_enc_precise_mbclen(p, end, enc);
3871 p += rb_enc_mbminlen(enc);
3875 if (rb_enc_mbc_to_codepoint(p, end, enc) == (
unsigned int)delim) {
3890 if (NEED_READCONV(fptr)) {
3891 SET_BINARY_MODE(fptr);
3892 make_readconv(fptr, 0);
3895 int searchlen = READ_CHAR_PENDING_COUNT(fptr);
3897 p = READ_CHAR_PENDING_PTR(fptr);
3898 if (0 < limit && limit < searchlen)
3899 searchlen = (int)limit;
3900 e = search_delim(p, searchlen, delim, enc);
3902 int len = (int)(e-p);
3924 return (
unsigned char)RSTRING_PTR(str)[RSTRING_LEN(str)-1];
3927 }
while (more_char(fptr) != MORE_CHAR_FINISHED);
3928 clear_readconv(fptr);
3933 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
3935 long pending = READ_DATA_PENDING_COUNT(fptr);
3937 const char *p = READ_DATA_PENDING_PTR(fptr);
3941 if (limit > 0 && pending > limit) pending = limit;
3942 e = search_delim(p, pending, delim, enc);
3943 if (e) pending = e - p;
3945 last = RSTRING_LEN(str);
3946 rb_str_resize(str, last + pending);
3953 read_buffered_data(RSTRING_PTR(str) + last, pending, fptr);
3956 if (e)
return delim;
3958 return (
unsigned char)RSTRING_PTR(str)[RSTRING_LEN(str)-1];
3961 }
while (io_fillbuf(fptr) >= 0);
3967swallow(
rb_io_t *fptr,
int term)
3969 if (NEED_READCONV(fptr)) {
3971 int needconv = rb_enc_mbminlen(enc) != 1;
3972 SET_BINARY_MODE(fptr);
3973 make_readconv(fptr, 0);
3976 while ((cnt = READ_CHAR_PENDING_COUNT(fptr)) > 0) {
3977 const char *p = READ_CHAR_PENDING_PTR(fptr);
3980 if (*p != term)
return TRUE;
3982 while (--i && *++p == term);
3985 const char *e = p + cnt;
3986 if (rb_enc_ascget(p, e, &i, enc) != term)
return TRUE;
3987 while ((p += i) < e && rb_enc_ascget(p, e, &i, enc) == term);
3990 io_shift_cbuf(fptr, (
int)cnt - i, NULL);
3992 }
while (more_char(fptr) != MORE_CHAR_FINISHED);
3996 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
3999 while ((cnt = READ_DATA_PENDING_COUNT(fptr)) > 0) {
4001 const char *p = READ_DATA_PENDING_PTR(fptr);
4003 if (cnt >
sizeof buf) cnt =
sizeof buf;
4004 if (*p != term)
return TRUE;
4006 while (--i && *++p == term);
4007 if (!read_buffered_data(buf, cnt - i, fptr))
4008 rb_sys_fail_path(fptr->
pathv);
4011 }
while (io_fillbuf(fptr) == 0);
4024 int pending = READ_DATA_PENDING_COUNT(fptr);
4027 const char *p = READ_DATA_PENDING_PTR(fptr);
4031 e = memchr(p,
'\n', pending);
4033 pending = (int)(e - p + 1);
4035 chomplen = (pending > 1 && *(e-1) ==
'\r') + 1;
4044 rb_str_resize(str,
len + pending - chomplen);
4045 read_buffered_data(RSTRING_PTR(str)+
len, pending - chomplen, fptr);
4048 if (pending == 1 && chomplen == 1 &&
len > 0) {
4049 if (RSTRING_PTR(str)[
len-1] ==
'\r') {
4050 rb_str_resize(str, --
len);
4055 len += pending - chomplen;
4061 }
while (io_fillbuf(fptr) >= 0);
4064 str = io_enc_str(str, fptr);
4075 unsigned int chomp: 1;
4089 chomp = (!UNDEF_P(vchomp)) &&
RTEST(vchomp);
4091 args->chomp = chomp;
4109 else if (2 <= argc) {
4110 rs = argv[0], lim = argv[1];
4119check_getline_args(
VALUE *rsp,
long *limit,
VALUE io)
4128 enc_rs = rb_enc_get(rs);
4129 enc_io = io_read_encoding(fptr);
4130 if (enc_io != enc_rs &&
4131 (!is_ascii_string(rs) ||
4132 (RSTRING_LEN(rs) > 0 && !rb_enc_asciicompat(enc_io)))) {
4133 if (rs == rb_default_rs) {
4134 rs = rb_enc_str_new(0, 0, enc_io);
4139 rb_raise(rb_eArgError,
"encoding mismatch: %s IO with %s RS",
4140 rb_enc_name(enc_io),
4141 rb_enc_name(enc_rs));
4151 argc =
rb_scan_args(argc, argv,
"02:", NULL, NULL, &opts);
4152 extract_getline_args(argc, argv, args);
4153 extract_getline_opts(opts, args);
4154 check_getline_args(&args->rs, &args->limit, io);
4158rb_io_getline_0(
VALUE rs,
long limit,
int chomp,
rb_io_t *fptr)
4165 if (
NIL_P(rs) && limit < 0) {
4166 str = read_all(fptr, 0,
Qnil);
4167 if (RSTRING_LEN(str) == 0)
return Qnil;
4169 else if (limit == 0) {
4170 return rb_enc_str_new(0, 0, io_read_encoding(fptr));
4172 else if (rs == rb_default_rs && limit < 0 && !NEED_READCONV(fptr) &&
4173 rb_enc_asciicompat(enc = io_read_encoding(fptr))) {
4174 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
4175 return rb_io_getline_fast(fptr, enc, chomp);
4178 int c, newline = -1;
4179 const char *rsptr = 0;
4182 int extra_limit = 16;
4183 int chomp_cr = chomp;
4185 SET_BINARY_MODE(fptr);
4186 enc = io_read_encoding(fptr);
4189 rslen = RSTRING_LEN(rs);
4194 swallow(fptr,
'\n');
4196 if (!rb_enc_asciicompat(enc)) {
4200 rsptr = RSTRING_PTR(rs);
4201 rslen = RSTRING_LEN(rs);
4205 else if (rb_enc_mbminlen(enc) == 1) {
4206 rsptr = RSTRING_PTR(rs);
4207 newline = (
unsigned char)rsptr[rslen - 1];
4211 rsptr = RSTRING_PTR(rs);
4212 const char *e = rsptr + rslen;
4213 const char *last = rb_enc_prev_char(rsptr, e, e, enc);
4215 newline = rb_enc_codepoint_len(last, e, &n, enc);
4216 if (last + n != e) rb_raise(rb_eArgError,
"broken separator");
4218 chomp_cr = chomp && newline ==
'\n' && rslen == rb_enc_mbminlen(enc);
4222 while ((c = appendline(fptr, newline, &str, &limit, enc)) != EOF) {
4223 const char *s, *p, *pp, *e;
4226 if (RSTRING_LEN(str) < rslen)
continue;
4227 s = RSTRING_PTR(str);
4230 if (!at_char_boundary(s, p, e, enc))
continue;
4231 if (!rspara) rscheck(rsptr, rslen, rs);
4232 if (memcmp(p, rsptr, rslen) == 0) {
4234 if (chomp_cr && p > s && *(p-1) ==
'\r') --p;
4241 s = RSTRING_PTR(str);
4243 pp = rb_enc_prev_char(s, p, p, enc);
4244 if (extra_limit && pp &&
4258 if (rspara && c != EOF)
4259 swallow(fptr,
'\n');
4261 str = io_enc_str(str, fptr);
4264 if (!
NIL_P(str) && !nolimit) {
4272rb_io_getline_1(
VALUE rs,
long limit,
int chomp,
VALUE io)
4275 int old_lineno, new_lineno;
4279 old_lineno = fptr->
lineno;
4280 str = rb_io_getline_0(rs, limit, chomp, fptr);
4281 if (!
NIL_P(str) && (new_lineno = fptr->
lineno) != old_lineno) {
4282 if (io == ARGF.current_file) {
4283 ARGF.lineno += new_lineno - old_lineno;
4284 ARGF.last_lineno = ARGF.lineno;
4287 ARGF.last_lineno = new_lineno;
4295rb_io_getline(
int argc,
VALUE *argv,
VALUE io)
4299 prepare_getline_args(argc, argv, &args, io);
4300 return rb_io_getline_1(args.rs, args.limit, args.chomp, io);
4310rb_io_gets_internal(
VALUE io)
4314 return rb_io_getline_0(rb_default_rs, -1, FALSE, fptr);
4394 str = rb_io_getline(argc, argv, io);
4410rb_io_lineno(
VALUE io)
4465 check_getline_args(&sep, &limit, io);
4467 VALUE line = rb_io_getline_1(sep, limit,
RTEST(chomp), io);
4468 rb_lastline_set_up(line, 1);
4543rb_io_readlines(
int argc,
VALUE *argv,
VALUE io)
4547 prepare_getline_args(argc, argv, &args, io);
4548 return io_readlines(&args, io);
4556 if (arg->limit == 0)
4557 rb_raise(rb_eArgError,
"invalid limit: 0 for readlines");
4559 while (!
NIL_P(line = rb_io_getline_1(arg->rs, arg->limit, arg->chomp, io))) {
4560 rb_ary_push(ary, line);
4672rb_io_each_line(
int argc,
VALUE *argv,
VALUE io)
4678 prepare_getline_args(argc, argv, &args, io);
4679 if (args.limit == 0)
4680 rb_raise(rb_eArgError,
"invalid limit: 0 for each_line");
4681 while (!
NIL_P(str = rb_io_getline_1(args.rs, args.limit, args.chomp, io))) {
4708rb_io_each_byte(
VALUE io)
4724 }
while (io_fillbuf(fptr) >= 0);
4734 if (NEED_READCONV(fptr)) {
4738 SET_BINARY_MODE(fptr);
4739 make_readconv(fptr, 0);
4753 if (more_char(fptr) == MORE_CHAR_FINISHED) {
4755 clear_readconv(fptr);
4759 str = rb_enc_str_new(fptr->
cbuf.
ptr+fptr->
cbuf.
off, 1, read_enc);
4762 if (fptr->
cbuf.
len == 0) clear_readconv(fptr);
4771 io_shift_cbuf(fptr, r, &str);
4778 ISASCII(RSTRING_PTR(str)[0])) {
4782 str = io_enc_str(str, fptr);
4787 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
4788 if (io_fillbuf(fptr) < 0) {
4810 if (io_fillbuf(fptr) != -1) {
4814 r = rb_enc_precise_mbclen(RSTRING_PTR(str), RSTRING_PTR(str)+RSTRING_LEN(str), enc);
4830 str = io_enc_str(str, fptr);
4856rb_io_each_char(
VALUE io)
4866 enc = io_input_encoding(fptr);
4868 while (!
NIL_P(c = io_getc(fptr, enc))) {
4894rb_io_each_codepoint(
VALUE io)
4906 if (NEED_READCONV(fptr)) {
4907 SET_BINARY_MODE(fptr);
4910 make_readconv(fptr, 0);
4918 r = ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(1);
4925 if (more_char(fptr) == MORE_CHAR_FINISHED) {
4926 clear_readconv(fptr);
4953 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
4954 enc = io_input_encoding(fptr);
4955 while (io_fillbuf(fptr) >= 0) {
4970 char cbuf[8], *p = cbuf;
4972 if (more > numberof(cbuf))
goto invalid;
4974 if (more > numberof(cbuf))
goto invalid;
4975 while ((n = (
int)read_buffered_data(p, more, fptr)) > 0 &&
4976 (p += n, (more -= n) > 0)) {
4977 if (io_fillbuf(fptr) < 0)
goto invalid;
4978 if ((n = fptr->
rbuf.
len) > more) n = more;
4980 r = rb_enc_precise_mbclen(cbuf, p, enc);
4993 rb_raise(rb_eArgError,
"invalid byte sequence in %s", rb_enc_name(enc));
5025 enc = io_input_encoding(fptr);
5027 return io_getc(fptr, enc);
5050rb_io_readchar(
VALUE io)
5052 VALUE c = rb_io_getc(io);
5087 VALUE r_stdout = rb_ractor_stdout();
5092 rb_io_flush(r_stdout);
5095 if (io_fillbuf(fptr) < 0) {
5124rb_io_readbyte(
VALUE io)
5185 unsigned char c =
NUM2INT(v) & 0xFF;
5191 io_ungetbyte(b, fptr);
5247 else if (RB_BIGNUM_TYPE_P(c)) {
5253 if (NEED_READCONV(fptr)) {
5254 SET_BINARY_MODE(fptr);
5255 len = RSTRING_LEN(c);
5256#if SIZEOF_LONG > SIZEOF_INT
5260 make_readconv(fptr, (
int)
len);
5274 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
5275 io_ungetbyte(c, fptr);
5295rb_io_isatty(
VALUE io)
5300 return RBOOL(isatty(fptr->
fd) != 0);
5303#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
5319rb_io_close_on_exec_p(
VALUE io)
5325 write_io = GetWriteIO(io);
5326 if (io != write_io) {
5328 if (fptr && 0 <= (fd = fptr->
fd)) {
5329 if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5330 if (!(ret & FD_CLOEXEC))
return Qfalse;
5335 if (fptr && 0 <= (fd = fptr->
fd)) {
5336 if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5337 if (!(ret & FD_CLOEXEC))
return Qfalse;
5342#define rb_io_close_on_exec_p rb_f_notimplement
5345#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
5369 int flag =
RTEST(arg) ? FD_CLOEXEC : 0;
5374 write_io = GetWriteIO(io);
5375 if (io != write_io) {
5377 if (fptr && 0 <= (fd = fptr->
fd)) {
5378 if ((ret = fcntl(fptr->
fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5379 if ((ret & FD_CLOEXEC) != flag) {
5380 ret = (ret & ~FD_CLOEXEC) | flag;
5381 ret = fcntl(fd, F_SETFD, ret);
5382 if (ret != 0) rb_sys_fail_path(fptr->
pathv);
5389 if (fptr && 0 <= (fd = fptr->
fd)) {
5390 if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5391 if ((ret & FD_CLOEXEC) != flag) {
5392 ret = (ret & ~FD_CLOEXEC) | flag;
5393 ret = fcntl(fd, F_SETFD, ret);
5394 if (ret != 0) rb_sys_fail_path(fptr->
pathv);
5400#define rb_io_set_close_on_exec rb_f_notimplement
5403#define RUBY_IO_EXTERNAL_P(f) ((f)->mode & FMODE_EXTERNAL)
5404#define PREP_STDIO_NAME(f) (RSTRING_PTR((f)->pathv))
5407finish_writeconv(
rb_io_t *fptr,
int noalloc)
5409 unsigned char *ds, *dp, *de;
5413 unsigned char buf[1024];
5418 de = buf +
sizeof(buf);
5421 size_t remaining = dp-ds;
5422 long result = rb_io_write_memory(fptr, ds, remaining);
5426 if ((
size_t)result == remaining)
break;
5449 if (io_fflush(fptr) < 0) {
5457 fptr->
wbuf.
len += (int)(dp - ds);
5473finish_writeconv_sync(
VALUE arg)
5476 return finish_writeconv(p->fptr, p->noalloc);
5480nogvl_close(
void *ptr)
5484 return (
void*)(intptr_t)close(*fd);
5488maygvl_close(
int fd,
int keepgvl)
5497 return IO_WITHOUT_GVL_INT(nogvl_close, &fd);
5501nogvl_fclose(
void *ptr)
5505 return (
void*)(intptr_t)fclose(file);
5509maygvl_fclose(
FILE *file,
int keepgvl)
5512 return fclose(file);
5514 return IO_WITHOUT_GVL_INT(nogvl_fclose, file);
5520fptr_finalize_flush(
rb_io_t *fptr,
int noraise,
int keepgvl,
5526 int mode = fptr->
mode;
5532 arg.noalloc = noraise;
5536 error = finish_writeconv(fptr, noraise);
5541 io_flush_buffer_sync(fptr);
5544 if (io_fflush(fptr) < 0 &&
NIL_P(error)) {
5552 if (RUBY_IO_EXTERNAL_P(fptr) || fd <= 2) {
5564 rb_notify_fd_close_wait(busy);
5576 if (!done && stdio_file) {
5578 if ((maygvl_fclose(stdio_file, noraise) < 0) &&
NIL_P(error)) {
5587 if (!done && fd >= 0) {
5593 if ((maygvl_close(fd, keepgvl) < 0) &&
NIL_P(error)) {
5602 if (!
NIL_P(error) && !noraise) {
5611fptr_finalize(
rb_io_t *fptr,
int noraise)
5613 fptr_finalize_flush(fptr, noraise, FALSE, 0);
5614 free_io_buffer(&fptr->
rbuf);
5615 free_io_buffer(&fptr->
wbuf);
5616 clear_codeconv(fptr);
5620rb_io_fptr_cleanup(
rb_io_t *fptr,
int noraise)
5626 fptr_finalize(fptr, noraise);
5634 ruby_sized_xfree(buf->
ptr, (
size_t)buf->
capa);
5646 free_io_buffer(&fptr->
cbuf);
5662 clear_readconv(fptr);
5663 clear_writeconv(fptr);
5667rb_io_fptr_cleanup_all(
rb_io_t *fptr)
5671 rb_io_fptr_cleanup(fptr, TRUE);
5673 free_io_buffer(&fptr->
rbuf);
5674 free_io_buffer(&fptr->
wbuf);
5675 clear_codeconv(fptr);
5682 rb_io_fptr_cleanup_all(io);
5689rb_io_memsize(
const rb_io_t *fptr)
5691 size_t size =
sizeof(
rb_io_t);
5702# define KEEPGVL TRUE
5704# define KEEPGVL FALSE
5708io_close_fptr(
VALUE io)
5715 write_io = GetWriteIO(io);
5716 if (io != write_io) {
5717 write_fptr =
RFILE(write_io)->fptr;
5718 if (write_fptr && 0 <= write_fptr->
fd) {
5719 rb_io_fptr_cleanup(write_fptr, TRUE);
5723 fptr =
RFILE(io)->fptr;
5724 if (!fptr)
return 0;
5725 if (fptr->
fd < 0)
return 0;
5727 if (rb_notify_fd_close(fptr->
fd, &busy)) {
5729 fptr_finalize_flush(fptr, FALSE, KEEPGVL, &busy);
5731 rb_io_fptr_cleanup(fptr, FALSE);
5736fptr_waitpid(
rb_io_t *fptr,
int nohang)
5740 rb_last_status_clear();
5749 rb_io_t *fptr = io_close_fptr(io);
5750 if (fptr) fptr_waitpid(fptr, 0);
5790rb_io_close_m(
VALUE io)
5792 rb_io_t *fptr = rb_io_get_fptr(io);
5801io_call_close(
VALUE io)
5810 enum {mesg_len =
sizeof(closed_stream)-1};
5811 VALUE mesg = rb_attr_get(exc, idMesg);
5813 RSTRING_LEN(mesg) != mesg_len ||
5814 memcmp(RSTRING_PTR(mesg), closed_stream, mesg_len)) {
5824 if (!UNDEF_P(closed) &&
RTEST(closed))
return io;
5825 rb_rescue2(io_call_close, io, ignore_closed_stream, io,
5861 write_io = GetWriteIO(io);
5862 if (io != write_io) {
5863 write_fptr =
RFILE(write_io)->fptr;
5864 if (write_fptr && 0 <= write_fptr->
fd) {
5869 fptr = rb_io_get_fptr(io);
5870 return RBOOL(0 > fptr->
fd);
5906rb_io_close_read(
VALUE io)
5912 if (fptr->
fd < 0)
return Qnil;
5913 if (is_socket(fptr->
fd, fptr->
pathv)) {
5917 if (shutdown(fptr->
fd, SHUT_RD) < 0)
5918 rb_sys_fail_path(fptr->
pathv);
5919 fptr->
mode &= ~FMODE_READABLE;
5925 write_io = GetWriteIO(io);
5926 if (io != write_io) {
5931 RFILE(io)->fptr = wfptr;
5934 RFILE(write_io)->fptr = fptr;
5935 rb_io_fptr_cleanup(fptr, FALSE);
5941 rb_raise(
rb_eIOError,
"closing non-duplex IO for reading");
5979rb_io_close_write(
VALUE io)
5984 write_io = GetWriteIO(io);
5986 if (fptr->
fd < 0)
return Qnil;
5987 if (is_socket(fptr->
fd, fptr->
pathv)) {
5991 if (shutdown(fptr->
fd, SHUT_WR) < 0)
5992 rb_sys_fail_path(fptr->
pathv);
5993 fptr->
mode &= ~FMODE_WRITABLE;
6000 rb_raise(
rb_eIOError,
"closing non-duplex IO for writing");
6003 if (io != write_io) {
6023rb_io_sysseek(
int argc,
VALUE *argv,
VALUE io)
6025 VALUE offset, ptrname;
6026 int whence = SEEK_SET;
6030 if (
rb_scan_args(argc, argv,
"11", &offset, &ptrname) == 2) {
6031 whence = interpret_seek_whence(ptrname);
6036 (READ_DATA_BUFFERED(fptr) || READ_CHAR_PENDING(fptr))) {
6040 rb_warn(
"sysseek for buffered IO");
6043 pos = lseek(fptr->
fd, pos, whence);
6044 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
6078 io = GetWriteIO(io);
6083 rb_warn(
"syswrite for buffered IO");
6086 tmp = rb_str_tmp_frozen_acquire(str);
6088 n = rb_io_write_memory(fptr, ptr,
len);
6089 if (n < 0) rb_sys_fail_path(fptr->
pathv);
6090 rb_str_tmp_frozen_release(str, tmp);
6107rb_io_sysread(
int argc,
VALUE *argv,
VALUE io)
6118 shrinkable = io_setstrbuf(&str, ilen);
6119 if (ilen == 0)
return str;
6124 if (READ_DATA_BUFFERED(fptr)) {
6130 io_setstrbuf(&str, ilen);
6135 iis.buf = RSTRING_PTR(str);
6138 n = io_read_memory_locktmp(str, &iis);
6141 rb_sys_fail_path(fptr->
pathv);
6144 io_set_read_length(str, n, shrinkable);
6146 if (n == 0 && ilen > 0) {
6162internal_pread_func(
void *_arg)
6166 return (
VALUE)pread(arg->fd, arg->buf, arg->count, arg->offset);
6170pread_internal_call(
VALUE _arg)
6175 if (scheduler !=
Qnil) {
6178 if (!UNDEF_P(result)) {
6183 return rb_io_blocking_region_wait(arg->io, internal_pread_func, arg,
RUBY_IO_READABLE);
6227 shrinkable = io_setstrbuf(&str, (
long)arg.count);
6228 if (arg.count == 0)
return str;
6229 arg.buf = RSTRING_PTR(str);
6242 rb_sys_fail_path(fptr->
pathv);
6244 io_set_read_length(str, n, shrinkable);
6245 if (n == 0 && arg.count > 0) {
6253internal_pwrite_func(
void *_arg)
6258 if (scheduler !=
Qnil) {
6261 if (!UNDEF_P(result)) {
6267 return (
VALUE)pwrite(arg->fd, arg->buf, arg->count, arg->offset);
6308 io = GetWriteIO(io);
6315 tmp = rb_str_tmp_frozen_acquire(str);
6316 arg.buf = RSTRING_PTR(tmp);
6317 arg.count = (size_t)RSTRING_LEN(tmp);
6319 n = (ssize_t)rb_io_blocking_region_wait(fptr, internal_pwrite_func, &arg,
RUBY_IO_WRITABLE);
6320 if (n < 0) rb_sys_fail_path(fptr->
pathv);
6321 rb_str_tmp_frozen_release(str, tmp);
6337 fptr->
mode &= ~FMODE_TEXTMODE;
6341 SET_BINARY_MODE_WITH_SEEK_CUR(fptr);
6344 setmode(fptr->
fd, O_BINARY);
6351io_ascii8bit_binmode(
rb_io_t *fptr)
6362 fptr->
mode &= ~FMODE_TEXTMODE;
6363 SET_BINARY_MODE_WITH_SEEK_CUR(fptr);
6365 fptr->
encs.
enc = rb_ascii8bit_encoding();
6369 clear_codeconv(fptr);
6378 io_ascii8bit_binmode(fptr);
6395rb_io_binmode_m(
VALUE io)
6401 write_io = GetWriteIO(io);
6416rb_io_binmode_p(
VALUE io)
6424rb_io_fmode_modestr(
enum rb_io_mode fmode)
6428 return MODE_BTMODE(
"a+",
"ab+",
"at+");
6430 return MODE_BTMODE(
"a",
"ab",
"at");
6434 rb_raise(rb_eArgError,
"invalid access fmode 0x%x", fmode);
6436 return MODE_BTMODE(
"r",
"rb",
"rt");
6438 return MODE_BTXMODE(
"w",
"wb",
"wt",
"wx",
"wbx",
"wtx");
6441 return MODE_BTXMODE(
"w+",
"wb+",
"wt+",
"w+x",
"wb+x",
"wt+x");
6443 return MODE_BTMODE(
"r+",
"rb+",
"rt+");
6447static const char bom_prefix[] =
"bom|";
6448static const char utf_prefix[] =
"utf-";
6449enum {bom_prefix_len = (int)
sizeof(bom_prefix) - 1};
6450enum {utf_prefix_len = (int)
sizeof(utf_prefix) - 1};
6453io_encname_bom_p(
const char *name,
long len)
6455 return len > bom_prefix_len &&
STRNCASECMP(name, bom_prefix, bom_prefix_len) == 0;
6461 enum rb_io_mode fmode = 0;
6462 const char *m = modestr, *p = NULL;
6490 if (modestr[0] !=
'w')
6498 if (io_encname_bom_p(m, p ? (
long)(p - m) : (long)strlen(m)))
6511 rb_raise(rb_eArgError,
"invalid access mode %s", modestr);
6516rb_io_oflags_fmode(
int oflags)
6518 enum rb_io_mode fmode = 0;
6520 switch (oflags & O_ACCMODE) {
6532 if (oflags & O_APPEND) {
6535 if (oflags & O_TRUNC) {
6538 if (oflags & O_CREAT) {
6541 if (oflags & O_EXCL) {
6545 if (oflags & O_BINARY) {
6554rb_io_fmode_oflags(
enum rb_io_mode fmode)
6598rb_io_oflags_modestr(
int oflags)
6601# define MODE_BINARY(a,b) ((oflags & O_BINARY) ? (b) : (a))
6603# define MODE_BINARY(a,b) (a)
6606 if (oflags & O_EXCL) {
6607 rb_raise(rb_eArgError,
"exclusive access mode is not supported");
6609 accmode = oflags & (O_RDONLY|O_WRONLY|O_RDWR);
6610 if (oflags & O_APPEND) {
6611 if (accmode == O_WRONLY) {
6612 return MODE_BINARY(
"a",
"ab");
6614 if (accmode == O_RDWR) {
6615 return MODE_BINARY(
"a+",
"ab+");
6620 rb_raise(rb_eArgError,
"invalid access oflags 0x%x", oflags);
6622 return MODE_BINARY(
"r",
"rb");
6624 return MODE_BINARY(
"w",
"wb");
6626 if (oflags & O_TRUNC) {
6627 return MODE_BINARY(
"w+",
"wb+");
6629 return MODE_BINARY(
"r+",
"rb+");
6641 int default_ext = 0;
6644 ext = rb_default_external_encoding();
6647 if (rb_is_ascii8bit_enc(ext)) {
6651 else if (intern == NULL) {
6652 intern = rb_default_internal_encoding();
6657 *enc = (default_ext && intern != ext) ? NULL : ext;
6667unsupported_encoding(
const char *name,
rb_encoding *enc)
6669 rb_enc_warn(enc,
"Unsupported encoding %s ignored", name);
6673parse_mode_enc(
const char *estr,
rb_encoding *estr_enc,
6679 enum rb_io_mode fmode = fmode_p ? *fmode_p : 0;
6685 p = strrchr(estr,
':');
6686 len = p ? (p++ - estr) : (long)strlen(estr);
6688 estr += bom_prefix_len;
6689 len -= bom_prefix_len;
6690 if (!
STRNCASECMP(estr, utf_prefix, utf_prefix_len)) {
6694 rb_enc_warn(estr_enc,
"BOM with non-UTF encoding %s is nonsense", estr);
6695 fmode &= ~FMODE_SETENC_BY_BOM;
6703 memcpy(encname, estr,
len);
6704 encname[
len] =
'\0';
6707 idx = rb_enc_find_index(estr);
6709 if (fmode_p) *fmode_p = fmode;
6712 ext_enc = rb_enc_from_index(idx);
6715 unsupported_encoding(estr, estr_enc);
6721 if (*p ==
'-' && *(p+1) ==
'\0') {
6726 idx2 = rb_enc_find_index(p);
6728 unsupported_encoding(p, estr_enc);
6733 int_enc = rb_enc_from_index(idx2);
6737 rb_io_ext_int_to_encs(ext_enc, int_enc, enc_p, enc2_p, fmode);
6750 v = rb_hash_lookup2(opt, sym_encoding,
Qnil);
6751 if (v !=
Qnil) encoding = v;
6752 v = rb_hash_lookup2(opt, sym_extenc,
Qundef);
6753 if (v !=
Qnil) extenc = v;
6754 v = rb_hash_lookup2(opt, sym_intenc,
Qundef);
6755 if (!UNDEF_P(v)) intenc = v;
6757 if ((!UNDEF_P(extenc) || !UNDEF_P(intenc)) && !
NIL_P(encoding)) {
6759 int idx = rb_to_encoding_index(encoding);
6760 if (idx >= 0) encoding = rb_enc_from_encoding(rb_enc_from_index(idx));
6761 rb_warn(
"Ignoring encoding parameter '%"PRIsVALUE
"': %s_encoding is used",
6762 encoding, UNDEF_P(extenc) ?
"internal" :
"external");
6766 if (!UNDEF_P(extenc) && !
NIL_P(extenc)) {
6767 extencoding = rb_to_encoding(extenc);
6769 if (!UNDEF_P(intenc)) {
6770 if (
NIL_P(intenc)) {
6777 if (*p ==
'-' && *(p+1) ==
'\0') {
6782 intencoding = rb_to_encoding(intenc);
6786 intencoding = rb_to_encoding(intenc);
6788 if (extencoding == intencoding) {
6792 if (!
NIL_P(encoding)) {
6796 enc_p, enc2_p, fmode_p);
6799 rb_io_ext_int_to_encs(rb_to_encoding(encoding), NULL, enc_p, enc2_p, 0);
6802 else if (!UNDEF_P(extenc) || !UNDEF_P(intenc)) {
6804 rb_io_ext_int_to_encs(extencoding, intencoding, enc_p, enc2_p, 0);
6812 enum rb_io_mode fmode = *fmode_p;
6817 !rb_enc_asciicompat(enc ? enc : rb_default_external_encoding()))
6818 rb_raise(rb_eArgError,
"ASCII incompatible encoding needs binmode");
6821 rb_raise(rb_eArgError,
"newline decorator with binary mode");
6828#if !DEFAULT_TEXTMODE
6830 fmode &= ~FMODE_TEXTMODE;
6837extract_binmode(
VALUE opthash,
enum rb_io_mode *fmode)
6839 if (!
NIL_P(opthash)) {
6841 v = rb_hash_aref(opthash, sym_textmode);
6844 rb_raise(rb_eArgError,
"textmode specified twice");
6846 rb_raise(rb_eArgError,
"both textmode and binmode specified");
6850 v = rb_hash_aref(opthash, sym_binmode);
6853 rb_raise(rb_eArgError,
"binmode specified twice");
6855 rb_raise(rb_eArgError,
"both textmode and binmode specified");
6861 rb_raise(rb_eArgError,
"both textmode and binmode specified");
6867 int *oflags_p,
enum rb_io_mode *fmode_p,
struct rb_io_encoding *convconfig_p)
6871 enum rb_io_mode fmode;
6875 int has_enc = 0, has_vmode = 0;
6881 rb_io_ext_int_to_encs(NULL, NULL, &enc, &enc2, 0);
6891 fmode = rb_io_oflags_fmode(oflags);
6899 oflags = rb_io_fmode_oflags(fmode);
6903 parse_mode_enc(p+1, rb_enc_get(vmode), &enc, &enc2, &fmode);
6908 e = (fmode &
FMODE_BINMODE) ? rb_ascii8bit_encoding() : NULL;
6909 rb_io_ext_int_to_encs(e, NULL, &enc, &enc2, fmode);
6913 if (
NIL_P(opthash)) {
6917#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
6919 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
6920 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
6922 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
6929 rb_io_ext_int_to_encs(rb_ascii8bit_encoding(), NULL, &enc, &enc2, fmode);
6932 else if (
NIL_P(vmode)) {
6933 fmode |= DEFAULT_TEXTMODE;
6940 v = rb_hash_aref(opthash, sym_mode);
6942 if (!
NIL_P(vmode)) {
6943 rb_raise(rb_eArgError,
"mode specified twice");
6950 v = rb_hash_aref(opthash, sym_flags);
6955 fmode = rb_io_oflags_fmode(oflags);
6957 extract_binmode(opthash, &fmode);
6963 rb_io_ext_int_to_encs(rb_ascii8bit_encoding(), NULL, &enc, &enc2, fmode);
6966 else if (
NIL_P(vmode)) {
6967 fmode |= DEFAULT_TEXTMODE;
6970 v = rb_hash_aref(opthash, sym_perm);
6973 if (!
NIL_P(*vperm_p)) {
6974 rb_raise(rb_eArgError,
"perm specified twice");
6985#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
6987 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
6988 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
6993 rb_raise(rb_eArgError,
"encoding specified twice");
6996 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
7000 validate_enc_binmode(&fmode, ecflags, enc, enc2);
7006 convconfig_p->
enc = enc;
7007 convconfig_p->
enc2 = enc2;
7008 convconfig_p->
ecflags = ecflags;
7009 convconfig_p->
ecopts = ecopts;
7019sysopen_func(
void *ptr)
7022 const char *fname = RSTRING_PTR(data->fname);
7031 fd = IO_WITHOUT_GVL_INT(sysopen_func, data);
7032 }
while (fd < 0 &&
errno == EINTR);
7039rb_sysopen(
VALUE fname,
int oflags, mode_t perm)
7044 data.fname = rb_str_encode_ospath(fname);
7046 data.oflags = oflags;
7049 TRY_WITH_GC((fd = rb_sysopen_internal(&data)) >= 0) {
7050 rb_syserr_fail_path(first_errno, fname);
7056fdopen_internal(
int fd,
const char *modestr)
7063 file = fdopen(fd, modestr);
7079 TRY_WITH_GC((file = fdopen_internal(fd, modestr)) != 0) {
7085 if (setvbuf(file, NULL, _IOFBF, 0) != 0)
7086 rb_warn(
"setvbuf() can't be honoured (fd=%d)", fd);
7094 int t = isatty(fptr->
fd);
7104io_strip_bom(
VALUE io)
7106 VALUE b1, b2, b3, b4;
7117 return rb_utf8_encindex();
7127 return ENCINDEX_UTF_16BE;
7138 return ENCINDEX_UTF_32LE;
7143 return ENCINDEX_UTF_16LE;
7153 return ENCINDEX_UTF_32BE;
7167io_set_encoding_by_bom(
VALUE io)
7169 int idx = io_strip_bom(io);
7175 extenc = rb_enc_from_index(idx);
7176 io_encoding_set(fptr, rb_enc_from_encoding(extenc),
7177 rb_io_internal_encoding(io),
Qnil);
7186rb_file_open_generic(
VALUE io,
VALUE filename,
int oflags,
enum rb_io_mode fmode,
7194 rb_io_ext_int_to_encs(NULL, NULL, &cc.enc, &cc.enc2, fmode);
7199 validate_enc_binmode(&fmode, convconfig->
ecflags,
7200 convconfig->
enc, convconfig->
enc2);
7204 fptr->
encs = *convconfig;
7207 if (!(oflags & O_TMPFILE)) {
7208 fptr->
pathv = pathv;
7211 fptr->
pathv = pathv;
7213 fptr->
fd = rb_sysopen(pathv, oflags, perm);
7221rb_file_open_internal(
VALUE io,
VALUE filename,
const char *modestr)
7224 const char *p = strchr(modestr,
':');
7228 parse_mode_enc(p+1, rb_usascii_encoding(),
7229 &convconfig.
enc, &convconfig.
enc2, &fmode);
7235 e = (fmode &
FMODE_BINMODE) ? rb_ascii8bit_encoding() : NULL;
7236 rb_io_ext_int_to_encs(e, NULL, &convconfig.
enc, &convconfig.
enc2, fmode);
7242#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
7244 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
7245 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
7247 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(convconfig.
enc2, convconfig.
ecflags);
7250 return rb_file_open_generic(io, filename,
7251 rb_io_fmode_oflags(fmode),
7261 return rb_file_open_internal(io_alloc(
rb_cFile), fname, modestr);
7270#if defined(__CYGWIN__) || !defined(HAVE_WORKING_FORK)
7293 while ((tmp = *prev) != 0) {
7294 if (tmp->fptr == fptr) {
7303#if defined (_WIN32) || defined(__CYGWIN__)
7319pipe_finalize(
rb_io_t *fptr,
int noraise)
7321#if !defined(HAVE_WORKING_FORK) && !defined(_WIN32)
7330 fptr_finalize(fptr, noraise);
7332 pipe_del_fptr(fptr);
7339#if defined(__CYGWIN__) || !defined(HAVE_WORKING_FORK)
7340 void (*
const old_finalize)(
struct rb_io*,int) = fptr->
finalize;
7342 if (old_finalize == orig->finalize)
return;
7347#if defined(__CYGWIN__) || !defined(HAVE_WORKING_FORK)
7348 if (old_finalize != pipe_finalize) {
7350 for (list =
pipe_list; list; list = list->next) {
7351 if (list->fptr == fptr)
break;
7353 if (!list) pipe_add_fptr(fptr);
7356 pipe_del_fptr(fptr);
7369rb_io_unbuffered(
rb_io_t *fptr)
7387#define HAVE_SPAWNV 1
7388#define spawnv(mode, cmd, args) rb_w32_uaspawn((mode), (cmd), (args))
7389#define spawn(mode, cmd) rb_w32_uspawn((mode), (cmd), 0)
7392#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
7402#ifdef HAVE_WORKING_FORK
7403# ifndef __EMSCRIPTEN__
7405popen_redirect(
struct popen_arg *p)
7408 close(p->write_pair[1]);
7409 if (p->write_pair[0] != 0) {
7410 dup2(p->write_pair[0], 0);
7411 close(p->write_pair[0]);
7414 if (p->pair[1] != 1) {
7415 dup2(p->pair[1], 1);
7421 if (p->pair[1] != 1) {
7422 dup2(p->pair[1], 1);
7428 if (p->pair[0] != 0) {
7429 dup2(p->pair[0], 0);
7436#if defined(__linux__)
7447linux_get_maxfd(
void)
7450 char buf[4096], *p, *np, *e;
7453 if (fd < 0)
return fd;
7454 ss = read(fd, buf,
sizeof(buf));
7455 if (ss < 0)
goto err;
7458 while ((
int)
sizeof(
"FDSize:\t0\n")-1 <= e-p &&
7459 (np = memchr(p,
'\n', e-p)) != NULL) {
7460 if (memcmp(p,
"FDSize:",
sizeof(
"FDSize:")-1) == 0) {
7462 p +=
sizeof(
"FDSize:")-1;
7482#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
7484 int max = (int)max_file_descriptor;
7487 ret = fcntl(0, F_MAXFD);
7489 maxhint = max = ret;
7490# elif defined(__linux__)
7491 ret = linux_get_maxfd();
7498 for (fd = lowfd; fd <= max; fd++) {
7499 if (!
NIL_P(noclose_fds) &&
7502 ret = fcntl(fd, F_GETFD);
7503 if (ret != -1 && !(ret & FD_CLOEXEC)) {
7504 fcntl(fd, F_SETFD, ret|FD_CLOEXEC);
7506# define CONTIGUOUS_CLOSED_FDS 20
7508 if (max < fd + CONTIGUOUS_CLOSED_FDS)
7509 max = fd + CONTIGUOUS_CLOSED_FDS;
7515# ifndef __EMSCRIPTEN__
7517popen_exec(
void *pp,
char *errmsg,
size_t errmsg_len)
7519 struct popen_arg *p = (
struct popen_arg*)pp;
7521 return rb_exec_async_signal_safe(p->eargp, errmsg, errmsg_len);
7526#if (defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)) && !defined __EMSCRIPTEN__
7528rb_execarg_fixup_v(
VALUE execarg_obj)
7530 rb_execarg_parent_start(execarg_obj);
7534char *rb_execarg_commandline(
const struct rb_execarg *eargp,
VALUE *prog);
7537#ifndef __EMSCRIPTEN__
7539pipe_open(
VALUE execarg_obj,
const char *modestr,
enum rb_io_mode fmode,
7542 struct rb_execarg *eargp =
NIL_P(execarg_obj) ? NULL : rb_execarg_get(execarg_obj);
7543 VALUE prog = eargp ? (eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name) :
Qfalse ;
7549#if defined(HAVE_WORKING_FORK)
7551 char errmsg[80] = {
'\0' };
7553#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
7555 struct popen_arg arg;
7558#if defined(HAVE_SPAWNV)
7559# if defined(HAVE_SPAWNVE)
7560# define DO_SPAWN(cmd, args, envp) ((args) ? \
7561 spawnve(P_NOWAIT, (cmd), (args), (envp)) : \
7562 spawne(P_NOWAIT, (cmd), (envp)))
7564# define DO_SPAWN(cmd, args, envp) ((args) ? \
7565 spawnv(P_NOWAIT, (cmd), (args)) : \
7566 spawn(P_NOWAIT, (cmd)))
7568# if !defined(HAVE_WORKING_FORK)
7570# if defined(HAVE_SPAWNVE)
7575#if !defined(HAVE_WORKING_FORK)
7581#if !defined(HAVE_WORKING_FORK)
7582 const char *cmd = 0;
7588#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
7589 arg.execarg_obj = execarg_obj;
7592 arg.pair[0] = arg.pair[1] = -1;
7593 arg.write_pair[0] = arg.write_pair[1] = -1;
7594# if !defined(HAVE_WORKING_FORK)
7595 if (eargp && !eargp->use_shell) {
7596 args = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str);
7601 if (
rb_pipe(arg.write_pair) < 0)
7602 rb_sys_fail_str(prog);
7605 close(arg.write_pair[0]);
7606 close(arg.write_pair[1]);
7610 rb_execarg_addopt(execarg_obj,
INT2FIX(0),
INT2FIX(arg.write_pair[0]));
7611 rb_execarg_addopt(execarg_obj,
INT2FIX(1),
INT2FIX(arg.pair[1]));
7616 rb_sys_fail_str(prog);
7618 rb_execarg_addopt(execarg_obj,
INT2FIX(1),
INT2FIX(arg.pair[1]));
7622 rb_sys_fail_str(prog);
7624 rb_execarg_addopt(execarg_obj,
INT2FIX(0),
INT2FIX(arg.pair[0]));
7627 rb_sys_fail_str(prog);
7629 if (!
NIL_P(execarg_obj)) {
7630 rb_protect(rb_execarg_fixup_v, execarg_obj, &state);
7632 if (0 <= arg.write_pair[0]) close(arg.write_pair[0]);
7633 if (0 <= arg.write_pair[1]) close(arg.write_pair[1]);
7634 if (0 <= arg.pair[0]) close(arg.pair[0]);
7635 if (0 <= arg.pair[1]) close(arg.pair[1]);
7636 rb_execarg_parent_end(execarg_obj);
7640# if defined(HAVE_WORKING_FORK)
7641 pid = rb_fork_async_signal_safe(&status, popen_exec, &arg, arg.eargp->redirect_fds, errmsg,
sizeof(errmsg));
7643 rb_execarg_run_options(eargp, sargp, NULL, 0);
7644# if defined(HAVE_SPAWNVE)
7645 if (eargp->envp_str) envp = (
char **)RSTRING_PTR(eargp->envp_str);
7647 while ((pid = DO_SPAWN(cmd, args, envp)) < 0) {
7649 switch (e =
errno) {
7651# if EWOULDBLOCK != EAGAIN
7660 rb_execarg_run_options(sargp, NULL, NULL, 0);
7662 rb_execarg_parent_end(execarg_obj);
7665# if defined(HAVE_WORKING_FORK)
7666 pid = rb_call_proc__fork();
7668 popen_redirect(&arg);
7680# if defined(HAVE_WORKING_FORK)
7686 close(arg.write_pair[0]);
7687 close(arg.write_pair[1]);
7689# if defined(HAVE_WORKING_FORK)
7698 close(arg.write_pair[0]);
7699 write_fd = arg.write_pair[1];
7710 cmd = rb_execarg_commandline(eargp, &prog);
7711 if (!
NIL_P(execarg_obj)) {
7712 rb_execarg_parent_start(execarg_obj);
7713 rb_execarg_run_options(eargp, sargp, NULL, 0);
7715 fp = popen(cmd, modestr);
7718 rb_execarg_parent_end(execarg_obj);
7719 rb_execarg_run_options(sargp, NULL, NULL, 0);
7721 if (!fp) rb_syserr_fail_path(e, prog);
7731 fptr->
encs = *convconfig;
7732#if RUBY_CRLF_ENVIRONMENT
7739 if (NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {
7742#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
7743 if (NEED_NEWLINE_DECORATOR_ON_WRITE(fptr)) {
7744 fptr->
encs.
ecflags |= TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;
7750 if (0 <= write_fd) {
7751 write_port = io_alloc(
rb_cIO);
7753 write_fptr->
fd = write_fd;
7755 fptr->
mode &= ~FMODE_WRITABLE;
7757 rb_ivar_set(port, rb_intern(
"@tied_io_for_writing"), write_port);
7760#if defined (__CYGWIN__) || !defined(HAVE_WORKING_FORK)
7762 pipe_add_fptr(fptr);
7768pipe_open(
VALUE execarg_obj,
const char *modestr,
enum rb_io_mode fmode,
7776is_popen_fork(
VALUE prog)
7778 if (RSTRING_LEN(prog) == 1 && RSTRING_PTR(prog)[0] ==
'-') {
7779#if !defined(HAVE_WORKING_FORK)
7781 "fork() function is unimplemented on this machine");
7790pipe_open_s(
VALUE prog,
const char *modestr,
enum rb_io_mode fmode,
7794 VALUE *argv = &prog;
7797 if (!is_popen_fork(prog))
7798 execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE);
7799 return pipe_open(execarg_obj, modestr, fmode, convconfig);
7805 rb_io_t *fptr = io_close_fptr(io);
7973rb_io_s_popen(
int argc,
VALUE *argv,
VALUE klass)
7977 if (argc > 1 && !
NIL_P(opt = rb_check_hash_type(argv[argc-1]))) --argc;
7978 if (argc > 1 && !
NIL_P(env = rb_check_hash_type(argv[0]))) --argc, ++argv;
7987 int ex = !
NIL_P(opt);
7988 rb_error_arity(argc + ex, 1 + ex, 2 + ex);
7991 return popen_finish(rb_io_popen(pname, pmode, env, opt), klass);
7997 const char *modestr;
8000 enum rb_io_mode fmode;
8003 tmp = rb_check_array_type(pname);
8006#if SIZEOF_LONG > SIZEOF_INT
8007 if (
len > INT_MAX) {
8008 rb_raise(rb_eArgError,
"too many arguments");
8017 if (!is_popen_fork(pname))
8018 execarg_obj = rb_execarg_new(1, &pname, TRUE, FALSE);
8020 if (!
NIL_P(execarg_obj)) {
8022 opt = rb_execarg_extract_options(execarg_obj, opt);
8024 rb_execarg_setenv(execarg_obj, env);
8027 modestr = rb_io_oflags_modestr(oflags);
8029 return pipe_open(execarg_obj, modestr, fmode, &convconfig);
8039 rb_io_flush(rb_ractor_stdout());
8040 rb_io_flush(rb_ractor_stderr());
8045 RBASIC_SET_CLASS(port, klass);
8052#if defined(HAVE_WORKING_FORK) && !defined(__EMSCRIPTEN__)
8053struct popen_writer_arg {
8055 struct popen_arg popen;
8059exec_popen_writer(
void *arg,
char *errmsg,
size_t buflen)
8061 struct popen_writer_arg *pw = arg;
8063 popen_redirect(&pw->popen);
8064 execv(pw->argv[0], pw->argv);
8065 strlcpy(errmsg, strerror(
errno), buflen);
8071ruby_popen_writer(
char *
const *argv, rb_pid_t *pid)
8073#if (defined(HAVE_WORKING_FORK) && !defined(__EMSCRIPTEN__)) || defined(_WIN32)
8074# ifdef HAVE_WORKING_FORK
8075 struct popen_writer_arg pw;
8076 int *
const write_pair = pw.popen.pair;
8084# ifdef HAVE_WORKING_FORK
8087 char errmsg[80] = {
'\0'};
8088 *pid = rb_fork_async_signal_safe(&status, exec_popen_writer, &pw,
Qnil, errmsg,
sizeof(errmsg));
8090 *pid = rb_w32_uspawn_process(P_NOWAIT, argv[0], argv, write_pair[0], -1, -1, 0);
8091 const char *errmsg = (*pid < 0) ? strerror(
errno) : NULL;
8093 close(write_pair[0]);
8095 close(write_pair[1]);
8096 fprintf(stderr,
"ruby_popen_writer(%s): %s\n", argv[0], errmsg);
8099 return fdopen(write_pair[1],
"w");
8110 enum rb_io_mode fmode;
8119 rb_file_open_generic(io, fname, oflags, fmode, &convconfig, perm);
8157rb_io_s_open(
int argc,
VALUE *argv,
VALUE klass)
8189 VALUE fname, vmode, vperm;
8194 rb_scan_args(argc, argv,
"12", &fname, &vmode, &vperm);
8205 if (
NIL_P(vperm)) perm = 0666;
8209 fd = rb_sysopen(fname, oflags, perm);
8214check_pipe_command(
VALUE filename_or_command)
8216 char *s = RSTRING_PTR(filename_or_command);
8217 long l = RSTRING_LEN(filename_or_command);
8221 if (rb_enc_ascget(s, e, &chlen, rb_enc_get(filename_or_command)) ==
'|') {
8259 int redirect = FALSE;
8267 VALUE tmp = argv[0];
8273 VALUE cmd = check_pipe_command(tmp);
8276 rb_warn_deprecated_to_remove_at(4.0,
"Calling Kernel#open with a leading '|'",
"IO.popen");
8278 return rb_io_s_popen(argc, argv,
rb_cIO);
8291 return rb_io_s_open(argc, argv,
rb_cFile);
8295rb_io_open_generic(
VALUE klass,
VALUE filename,
int oflags,
enum rb_io_mode fmode,
8299 if (klass ==
rb_cIO && !
NIL_P(cmd = check_pipe_command(filename))) {
8301 rb_warn_deprecated_to_remove_at(4.0,
"IO process creation with a leading '|'",
"IO.popen");
8302 return pipe_open_s(cmd, rb_io_oflags_modestr(oflags), fmode, convconfig);
8305 return rb_file_open_generic(io_alloc(klass), filename,
8306 oflags, fmode, convconfig, perm);
8314 enum rb_io_mode fmode;
8320 return rb_io_open_generic(io, filename, oflags, fmode, &convconfig, perm);
8334 if (fptr == orig)
return io;
8335 if (RUBY_IO_EXTERNAL_P(fptr)) {
8339 rb_raise(rb_eArgError,
8340 "%s can't change access mode from \"%s\" to \"%s\"",
8341 PREP_STDIO_NAME(fptr), rb_io_fmode_modestr(fptr->
mode),
8342 rb_io_fmode_modestr(orig->
mode));
8346 if (io_fflush(fptr) < 0)
8347 rb_sys_fail_on_write(fptr);
8350 flush_before_seek(fptr,
true);
8353 pos = io_tell(orig);
8356 if (io_fflush(orig) < 0)
8357 rb_sys_fail_on_write(fptr);
8366 else if (!RUBY_IO_EXTERNAL_P(fptr)) fptr->
pathv =
Qnil;
8367 fptr_copy_finalizer(fptr, orig);
8372 if (RUBY_IO_EXTERNAL_P(fptr) || fd <= 2 || !fptr->stdio_file) {
8375 rb_sys_fail_path(orig->
pathv);
8383 rb_sys_fail_path(orig->
pathv);
8389 if (io_seek(fptr, pos, SEEK_SET) < 0 &&
errno) {
8390 rb_sys_fail_path(fptr->
pathv);
8392 if (io_seek(orig, pos, SEEK_SET) < 0 &&
errno) {
8393 rb_sys_fail_path(orig->
pathv);
8407int rb_freopen(
VALUE fname,
const char *mode,
FILE *fp);
8410rb_freopen(
VALUE fname,
const char *mode,
FILE *fp)
8412 if (!freopen(RSTRING_PTR(fname), mode, fp)) {
8455rb_io_reopen(
int argc,
VALUE *argv,
VALUE file)
8457 VALUE fname, nmode, opt;
8461 if (
rb_scan_args(argc, argv,
"11:", &fname, &nmode, &opt) == 1) {
8464 return io_reopen(file, tmp);
8470 fptr =
RFILE(file)->fptr;
8476 enum rb_io_mode fmode;
8480 if (RUBY_IO_EXTERNAL_P(fptr) &&
8483 rb_raise(rb_eArgError,
8484 "%s can't change access mode from \"%s\" to \"%s\"",
8485 PREP_STDIO_NAME(fptr), rb_io_fmode_modestr(fptr->
mode),
8486 rb_io_fmode_modestr(fmode));
8489 fptr->
encs = convconfig;
8492 oflags = rb_io_fmode_oflags(fptr->
mode);
8495 fptr->
pathv = fname;
8497 fptr->
fd = rb_sysopen(fptr->
pathv, oflags, 0666);
8503 if (io_fflush(fptr) < 0)
8504 rb_sys_fail_on_write(fptr);
8509 int e = rb_freopen(rb_str_encode_ospath(fptr->
pathv),
8510 rb_io_oflags_modestr(oflags),
8512 if (e) rb_syserr_fail_path(e, fptr->
pathv);
8516 if (setvbuf(fptr->
stdio_file, NULL, _IOFBF, 0) != 0)
8517 rb_warn(
"setvbuf() can't be honoured for %"PRIsVALUE, fptr->
pathv);
8520 if (setvbuf(fptr->
stdio_file, NULL, _IONBF, BUFSIZ) != 0)
8521 rb_warn(
"setvbuf() can't be honoured for %"PRIsVALUE, fptr->
pathv);
8523 else if (fptr->
stdio_file == stdout && isatty(fptr->
fd)) {
8524 if (setvbuf(fptr->
stdio_file, NULL, _IOLBF, BUFSIZ) != 0)
8525 rb_warn(
"setvbuf() can't be honoured for %"PRIsVALUE, fptr->
pathv);
8529 int tmpfd = rb_sysopen(fptr->
pathv, oflags, 0666);
8535 rb_syserr_fail_path(err, fptr->
pathv);
8559 fptr->
mode = orig->
mode & ~FMODE_EXTERNAL;
8565 fptr_copy_finalizer(fptr, orig);
8567 fd = ruby_dup(orig->
fd);
8569 pos = io_tell(orig);
8571 io_seek(fptr, pos, SEEK_SET);
8576 write_io = GetWriteIO(io);
8577 if (io != write_io) {
8580 rb_ivar_set(dest, rb_intern(
"@tied_io_for_writing"), write_io);
8643 if (argc == 0)
return Qnil;
8645 out = rb_ractor_stdout();
8662 rb_warn_deprecated(
"'%s'", NULL, rb_id2name(
id));
8672 rb_raise(
rb_eTypeError,
"value of %"PRIsVALUE
" must be String", rb_id2str(
id));
8678 val = rb_str_frozen_bare_string(val);
8681 rb_warn_deprecated(
"'%s'", NULL, rb_id2name(
id));
8754 if (argc > 1 && !
NIL_P(rb_output_fs)) {
8757 for (i=0; i<argc; i++) {
8758 if (!
NIL_P(rb_output_fs) && i>0) {
8759 rb_io_write(out, rb_output_fs);
8761 rb_io_write(out, argv[i]);
8858 rb_io_write(io, str);
8862#define forward(obj, id, argc, argv) \
8863 rb_funcallv_kw(obj, id, argc, argv, RB_PASS_CALLED_KEYWORDS)
8864#define forward_public(obj, id, argc, argv) \
8865 rb_funcallv_public_kw(obj, id, argc, argv, RB_PASS_CALLED_KEYWORDS)
8866#define forward_current(id, argc, argv) \
8867 forward_public(ARGF.current_file, id, argc, argv)
8884 VALUE r_stdout = rb_ractor_stdout();
8885 if (recv == r_stdout) {
8886 return rb_io_putc(recv, ch);
8888 return forward(r_stdout, rb_intern(
"putc"), 1, &ch);
8893rb_str_end_with_asciichar(
VALUE str,
int c)
8895 long len = RSTRING_LEN(str);
8896 const char *
ptr = RSTRING_PTR(str);
8900 if (
len == 0)
return 0;
8901 if ((n = rb_enc_mbminlen(
enc)) == 1) {
8902 return ptr[
len - 1] == c;
8904 return rb_enc_ascget(
ptr + ((
len - 1) / n) * n,
ptr +
len, &n,
enc) == c;
8915 rb_io_puts(1, &tmp, out);
8918 ary = rb_check_array_type(ary);
8922 rb_io_puts(1, &tmp, out);
8977 VALUE line, args[2];
8984 for (
int i = 0; i < argc; i++) {
8998 if (RSTRING_LEN(line) == 0) {
9003 if (!rb_str_end_with_asciichar(line,
'\n')) {
9008 rb_io_writev(out, n, args);
9026 VALUE r_stdout = rb_ractor_stdout();
9027 if (recv == r_stdout) {
9028 return rb_io_puts(argc, argv, recv);
9030 return forward(r_stdout, rb_intern(
"puts"), argc, argv);
9034rb_p_write(
VALUE str)
9039 VALUE r_stdout = rb_ractor_stdout();
9041 rb_method_basic_definition_p(
CLASS_OF(r_stdout), id_write)) {
9042 io_writev(2, args, r_stdout);
9045 rb_io_writev(r_stdout, 2, args);
9057rb_p_result(
int argc,
const VALUE *argv)
9064 else if (argc > 1) {
9067 VALUE r_stdout = rb_ractor_stdout();
9069 rb_uninterruptible(rb_io_flush, r_stdout);
9110 for (i=0; i<argc; i++) {
9112 rb_uninterruptible(rb_p_write, inspected);
9114 return rb_p_result(argc, argv);
9135rb_obj_display(
int argc,
VALUE *argv,
VALUE self)
9139 out = (!
rb_check_arity(argc, 0, 1) ? rb_ractor_stdout() : argv[0]);
9140 rb_io_write(out, self);
9146rb_stderr_to_original_p(
VALUE err)
9148 return (err == orig_stderr ||
RFILE(orig_stderr)->fptr->
fd < 0);
9154 VALUE out = rb_ractor_stderr();
9155 if (rb_stderr_to_original_p(out)) {
9157 if (isatty(fileno(stderr))) {
9158 if (rb_w32_write_console(
rb_str_new(mesg,
len), fileno(stderr)) > 0)
return;
9161 if (fwrite(mesg,
sizeof(
char), (
size_t)
len, stderr) < (
size_t)
len) {
9178rb_write_error_str(
VALUE mesg)
9180 VALUE out = rb_ractor_stderr();
9182 if (rb_stderr_to_original_p(out)) {
9183 size_t len = (size_t)RSTRING_LEN(mesg);
9185 if (isatty(fileno(stderr))) {
9186 if (rb_w32_write_console(mesg, fileno(stderr)) > 0)
return;
9189 if (fwrite(RSTRING_PTR(mesg),
sizeof(
char),
len, stderr) <
len) {
9196 rb_io_write(out, mesg);
9201rb_stderr_tty_p(
void)
9203 if (rb_stderr_to_original_p(rb_ractor_stderr()))
9204 return isatty(fileno(stderr));
9209must_respond_to(
ID mid,
VALUE val,
ID id)
9212 rb_raise(
rb_eTypeError,
"%"PRIsVALUE
" must have %"PRIsVALUE
" method, %"PRIsVALUE
" given",
9213 rb_id2str(
id), rb_id2str(mid),
9233 must_respond_to(id_write, val,
id);
9240 return rb_ractor_stdout();
9246 must_respond_to(id_write, val,
id);
9253 return rb_ractor_stderr();
9257allocate_and_open_new_file(
VALUE klass)
9259 VALUE self = io_alloc(klass);
9260 rb_io_make_open_file(self);
9268 VALUE self = rb_protect(allocate_and_open_new_file, klass, &state);
9276 maygvl_close(descriptor, 0);
9284 io->
fd = descriptor;
9302 io->
encs = *encoding;
9311prep_io(
int fd,
enum rb_io_mode fmode,
VALUE klass,
const char *path)
9321 e = (fmode &
FMODE_BINMODE) ? rb_ascii8bit_encoding() : NULL;
9322 rb_io_ext_int_to_encs(e, NULL, &convconfig.
enc, &convconfig.
enc2, fmode);
9326#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
9328 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
9329 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
9331 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(convconfig.
enc2, convconfig.
ecflags);
9337 if (!io_check_tty(io)) {
9340 setmode(fd, O_BINARY);
9352 if (path && strcmp(path,
"-")) klass =
rb_cFile;
9353 return prep_io(fd, rb_io_oflags_fmode(oflags), klass, path);
9357prep_stdio(
FILE *f,
enum rb_io_mode fmode,
VALUE klass,
const char *path)
9364#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
9365 fptr->
encs.
ecflags |= TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;
9376rb_io_prep_stdin(
void)
9382rb_io_prep_stdout(
void)
9388rb_io_prep_stderr(
void)
9397 int oflags = rb_io_fmode_oflags(fptr->
mode) & ~O_EXCL;
9424 rb_io_buffer_init(&fp->
wbuf);
9425 rb_io_buffer_init(&fp->
rbuf);
9426 rb_io_buffer_init(&fp->
cbuf);
9444rb_io_make_open_file(
VALUE obj)
9449 if (
RFILE(obj)->fptr) {
9452 RFILE(obj)->fptr = 0;
9454 fp = rb_io_fptr_new();
9456 RFILE(obj)->fptr = fp;
9504rb_io_initialize(
int argc,
VALUE *argv,
VALUE io)
9510 return io_initialize(io, fnum, vmode, opt);
9517 int fd, oflags = O_RDONLY;
9518 enum rb_io_mode fmode;
9520#if defined(HAVE_FCNTL) && defined(F_GETFL)
9530 rb_raise(rb_eArgError,
"The given fd is not accessible because RubyVM reserves it");
9532#if defined(HAVE_FCNTL) && defined(F_GETFL)
9533 oflags = fcntl(fd, F_GETFL);
9534 if (oflags == -1) rb_sys_fail(0);
9536 if (fstat(fd, &st) < 0) rb_sys_fail(0);
9539#if defined(HAVE_FCNTL) && defined(F_GETFL)
9540 ofmode = rb_io_oflags_fmode(oflags);
9552 if (rb_hash_aref(opt, sym_autoclose) ==
Qfalse) {
9556 path = rb_hash_aref(opt,
RB_ID2SYM(idPath));
9567 fp->
encs = convconfig;
9572 if (fileno(stdin) == fd)
9574 else if (fileno(stdout) == fd)
9576 else if (fileno(stderr) == fd)
9608rb_io_set_encoding_by_bom(
VALUE io)
9614 rb_raise(rb_eArgError,
"ASCII incompatible encoding needs binmode");
9617 rb_raise(rb_eArgError,
"encoding conversion is set");
9619 else if (fptr->
encs.
enc && fptr->
encs.
enc != rb_ascii8bit_encoding()) {
9620 rb_raise(rb_eArgError,
"encoding is set to %s already",
9623 if (!io_set_encoding_by_bom(io))
return Qnil;
9624 return rb_enc_from_encoding(fptr->
encs.
enc);
9669rb_file_initialize(
int argc,
VALUE *argv,
VALUE io)
9671 if (
RFILE(io)->fptr) {
9674 VALUE fname, vmode, vperm, opt;
9675 int posargc =
rb_scan_args(argc, argv,
"12:", &fname, &vmode, &vperm, &opt);
9680 return io_initialize(io, fd, vmode, opt);
9683 return rb_open_file(io, fname, vmode, vperm, opt);
9688rb_io_s_new(
int argc,
VALUE *argv,
VALUE klass)
9693 rb_warn(
"%"PRIsVALUE
"::new() does not take block; use %"PRIsVALUE
"::open() instead",
9709rb_io_s_for_fd(
int argc,
VALUE *argv,
VALUE klass)
9712 rb_io_initialize(argc, argv, io);
9725rb_io_autoclose_p(
VALUE io)
9750rb_io_set_autoclose(
VALUE io,
VALUE autoclose)
9754 if (!
RTEST(autoclose))
9757 fptr->
mode &= ~FMODE_EXTERNAL;
9762io_wait_event(
VALUE io,
int event,
VALUE timeout,
int return_io)
9794io_wait_readable(
int argc,
VALUE *argv,
VALUE io)
9801 if (rb_io_read_pending(fptr))
return Qtrue;
9804 VALUE timeout = (argc == 1 ? argv[0] :
Qnil);
9818io_wait_writable(
int argc,
VALUE *argv,
VALUE io)
9826 VALUE timeout = (argc == 1 ? argv[0] :
Qnil);
9841io_wait_priority(
int argc,
VALUE *argv,
VALUE io)
9848 if (rb_io_read_pending(fptr))
return Qtrue;
9851 VALUE timeout = argc == 1 ? argv[0] :
Qnil;
9857wait_mode_sym(
VALUE mode)
9859 if (mode ==
ID2SYM(rb_intern(
"r"))) {
9860 return RB_WAITFD_IN;
9862 if (mode ==
ID2SYM(rb_intern(
"read"))) {
9863 return RB_WAITFD_IN;
9865 if (mode ==
ID2SYM(rb_intern(
"readable"))) {
9866 return RB_WAITFD_IN;
9868 if (mode ==
ID2SYM(rb_intern(
"w"))) {
9869 return RB_WAITFD_OUT;
9871 if (mode ==
ID2SYM(rb_intern(
"write"))) {
9872 return RB_WAITFD_OUT;
9874 if (mode ==
ID2SYM(rb_intern(
"writable"))) {
9875 return RB_WAITFD_OUT;
9877 if (mode ==
ID2SYM(rb_intern(
"rw"))) {
9878 return RB_WAITFD_IN|RB_WAITFD_OUT;
9880 if (mode ==
ID2SYM(rb_intern(
"read_write"))) {
9881 return RB_WAITFD_IN|RB_WAITFD_OUT;
9883 if (mode ==
ID2SYM(rb_intern(
"readable_writable"))) {
9884 return RB_WAITFD_IN|RB_WAITFD_OUT;
9887 rb_raise(rb_eArgError,
"unsupported mode: %"PRIsVALUE, mode);
9891io_event_from_value(
VALUE value)
9895 if (events <= 0) rb_raise(rb_eArgError,
"Events must be positive integer!");
9933 for (
int i = 0; i < argc; i += 1) {
9935 events |= wait_mode_sym(argv[i]);
9937 else if (UNDEF_P(timeout)) {
9941 rb_raise(rb_eArgError,
"timeout given more than once");
9945 if (UNDEF_P(timeout)) timeout =
Qnil;
9953 events = io_event_from_value(argv[0]);
9961 if (rb_io_read_pending(fptr)) {
9963 if (return_io)
return Qtrue;
9969 return io_wait_event(io, events, timeout, return_io);
9975 struct argf *p = ptr;
9976 rb_gc_mark(p->filename);
9977 rb_gc_mark(p->current_file);
9978 rb_gc_mark(p->argv);
9979 rb_gc_mark(p->inplace);
9980 rb_gc_mark(p->encs.
ecopts);
9984argf_memsize(
const void *ptr)
9986 const struct argf *p = ptr;
9987 size_t size =
sizeof(*p);
9992argf_compact(
void *ptr)
9994 struct argf *p = ptr;
9995 p->filename = rb_gc_location(p->filename);
9996 p->current_file = rb_gc_location(p->current_file);
9997 p->argv = rb_gc_location(p->argv);
9998 p->inplace = rb_gc_location(p->inplace);
10005 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
10011 p->filename =
Qnil;
10012 p->current_file =
Qnil;
10018argf_alloc(
VALUE klass)
10023 argf_init(p,
Qnil);
10033 memset(&ARGF, 0,
sizeof(ARGF));
10034 argf_init(&ARGF, argv);
10044 ARGF = argf_of(orig);
10071 ARGF.last_lineno = ARGF.lineno;
10097 return forward_current(rb_frame_this_func(), argc, argv);
10100#define next_argv() argf_next_argv(argf)
10101#define ARGF_GENERIC_INPUT_P() \
10102 (ARGF.current_file == rb_stdin && !RB_TYPE_P(ARGF.current_file, T_FILE))
10103#define ARGF_FORWARD(argc, argv) do {\
10104 if (ARGF_GENERIC_INPUT_P())\
10105 return argf_forward((argc), (argv), argf);\
10107#define NEXT_ARGF_FORWARD(argc, argv) do {\
10108 if (!next_argv()) return Qnil;\
10109 ARGF_FORWARD((argc), (argv));\
10115 VALUE file = ARGF.current_file;
10129 int stdout_binmode = 0;
10130 enum rb_io_mode fmode;
10132 VALUE r_stdout = rb_ractor_stdout();
10137 stdout_binmode = 1;
10140 if (ARGF.init_p == 0) {
10150 if (
NIL_P(ARGF.argv)) {
10153 else if (ARGF.next_p == -1 &&
RARRAY_LEN(ARGF.argv) > 0) {
10158 if (ARGF.next_p == 1) {
10159 if (ARGF.init_p == 1) argf_close(
argf);
10162 VALUE filename = rb_ary_shift(ARGF.argv);
10164 ARGF.filename = filename;
10165 filename = rb_str_encode_ospath(filename);
10167 if (RSTRING_LEN(filename) == 1 && fn[0] ==
'-') {
10169 if (ARGF.inplace) {
10170 rb_warn(
"Can't do inplace edit for stdio; skipping");
10176 int fr = rb_sysopen(filename, O_RDONLY, 0);
10178 if (ARGF.inplace) {
10180#ifndef NO_SAFE_RENAME
10191 if (!
NIL_P(ARGF.inplace)) {
10192 VALUE suffix = ARGF.inplace;
10194 if (
NIL_P(rb_str_cat_conv_enc_opts(str, RSTRING_LEN(str),
10195 RSTRING_PTR(suffix), RSTRING_LEN(suffix),
10196 rb_enc_get(suffix), 0,
Qnil))) {
10199#ifdef NO_SAFE_RENAME
10201 (void)unlink(RSTRING_PTR(str));
10202 if (rename(fn, RSTRING_PTR(str)) < 0) {
10203 rb_warn(
"Can't rename %"PRIsVALUE
" to %"PRIsVALUE
": %s, skipping file",
10204 filename, str, strerror(
errno));
10207 fr = rb_sysopen(str, O_RDONLY, 0);
10209 if (rename(fn, RSTRING_PTR(str)) < 0) {
10210 rb_warn(
"Can't rename %"PRIsVALUE
" to %"PRIsVALUE
": %s, skipping file",
10211 filename, str, strerror(
errno));
10218#ifdef NO_SAFE_RENAME
10219 rb_fatal(
"Can't do inplace edit without backup");
10221 if (unlink(fn) < 0) {
10222 rb_warn(
"Can't remove %"PRIsVALUE
": %s, skipping file",
10223 filename, strerror(
errno));
10229 fw = rb_sysopen(filename, O_WRONLY|O_CREAT|O_TRUNC, 0666);
10230#ifndef NO_SAFE_RENAME
10233 fchmod(fw, st.st_mode);
10235 chmod(fn, st.st_mode);
10237 if (st.st_uid!=st2.st_uid || st.st_gid!=st2.st_gid) {
10240 err = fchown(fw, st.st_uid, st.st_gid);
10242 err = chown(fn, st.st_uid, st.st_gid);
10244 if (err && getuid() == 0 && st2.st_uid == 0) {
10245 const char *wkfn = RSTRING_PTR(filename);
10246 rb_warn(
"Can't set owner/group of %"PRIsVALUE
" to same as %"PRIsVALUE
": %s, skipping file",
10247 filename, str, strerror(
errno));
10250 (void)unlink(wkfn);
10260 if (!ARGF.binmode) {
10261 fmode |= DEFAULT_TEXTMODE;
10263 ARGF.current_file = prep_io(fr, fmode,
rb_cFile, fn);
10264 if (!
NIL_P(write_io)) {
10271 if (ARGF.encs.enc) {
10272 fptr->
encs = ARGF.encs;
10273 clear_codeconv(fptr);
10276 fptr->
encs.
ecflags &= ~ECONV_NEWLINE_DECORATOR_MASK;
10277 if (!ARGF.binmode) {
10279#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
10280 fptr->
encs.
ecflags |= TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;
10291 else if (ARGF.next_p == -1) {
10294 if (ARGF.inplace) {
10295 rb_warn(
"Can't do inplace edit for stdio");
10299 if (ARGF.init_p == -1) ARGF.init_p = 1;
10307 long lineno = ARGF.lineno;
10310 if (!next_argv())
return Qnil;
10311 if (ARGF_GENERIC_INPUT_P()) {
10312 line = forward_current(idGets, argc, argv);
10319 line = rb_io_getline(argc, argv, ARGF.current_file);
10321 if (
NIL_P(line) && ARGF.next_p != -1) {
10327 if (!
NIL_P(line)) {
10328 ARGF.lineno = ++lineno;
10329 ARGF.last_lineno = ARGF.lineno;
10335argf_lineno_getter(
ID id,
VALUE *var)
10338 return INT2FIX(ARGF.last_lineno);
10346 ARGF.last_lineno = ARGF.lineno = n;
10350rb_reset_argf_lineno(
long n)
10352 ARGF.last_lineno = ARGF.lineno = n;
10393 if (recv ==
argf) {
10394 return argf_gets(argc, argv,
argf);
10396 return forward(
argf, idGets, argc, argv);
10422 line = argf_getline(argc, argv,
argf);
10434 return rb_f_gets(0, 0,
argf);
10438 if (!next_argv())
return Qnil;
10440 if (
NIL_P(line) && ARGF.next_p != -1) {
10446 if (!
NIL_P(line)) {
10448 ARGF.last_lineno = ARGF.lineno;
10474rb_f_readline(
int argc,
VALUE *argv,
VALUE recv)
10476 if (recv ==
argf) {
10477 return argf_readline(argc, argv,
argf);
10479 return forward(
argf, rb_intern(
"readline"), argc, argv);
10505 if (!next_argv()) rb_eof_error();
10506 ARGF_FORWARD(argc, argv);
10507 line = argf_gets(argc, argv,
argf);
10577rb_f_readlines(
int argc,
VALUE *argv,
VALUE recv)
10579 if (recv ==
argf) {
10580 return argf_readlines(argc, argv,
argf);
10582 return forward(
argf, rb_intern(
"readlines"), argc, argv);
10606 long lineno = ARGF.lineno;
10609 ary = rb_ary_new();
10610 while (next_argv()) {
10611 if (ARGF_GENERIC_INPUT_P()) {
10612 lines = forward_current(rb_intern(
"readlines"), argc, argv);
10615 lines = rb_io_readlines(argc, argv, ARGF.current_file);
10619 rb_ary_concat(ary, lines);
10621 ARGF.last_lineno = ARGF.lineno;
10656 rb_last_status_clear();
10657 port = pipe_open_s(str,
"r",
FMODE_READABLE|DEFAULT_TEXTMODE, NULL);
10661 result = read_all(fptr, remain_size(fptr),
Qnil);
10663 rb_io_fptr_cleanup_all(fptr);
10669#ifdef HAVE_SYS_SELECT_H
10670#include <sys/select.h>
10684 if (!
NIL_P(read)) {
10689 if (READ_DATA_PENDING(fptr) || READ_CHAR_PENDING(fptr)) {
10693 if (max < fptr->fd) max = fptr->
fd;
10696 timerec.tv_sec = timerec.tv_usec = 0;
10704 if (!
NIL_P(write)) {
10710 if (max < fptr->fd) max = fptr->
fd;
10717 if (!
NIL_P(except)) {
10721 VALUE write_io = GetWriteIO(io);
10724 if (max < fptr->fd) max = fptr->
fd;
10725 if (io != write_io) {
10728 if (max < fptr->fd) max = fptr->
fd;
10743 if (!pending && n == 0)
return Qnil;
10746 rb_ary_push(res, rp?rb_ary_new():
rb_ary_new2(0));
10747 rb_ary_push(res, wp?rb_ary_new():
rb_ary_new2(0));
10748 rb_ary_push(res, ep?rb_ary_new():
rb_ary_new2(0));
10753 VALUE obj = rb_ary_entry(read, i);
10758 rb_ary_push(list, obj);
10766 VALUE obj = rb_ary_entry(write, i);
10768 VALUE write_io = GetWriteIO(io);
10771 rb_ary_push(list, obj);
10779 VALUE obj = rb_ary_entry(except, i);
10781 VALUE write_io = GetWriteIO(io);
10784 rb_ary_push(list, obj);
10786 else if (io != write_io) {
10789 rb_ary_push(list, obj);
10799 VALUE read, write, except;
10805select_call(
VALUE arg)
10809 return select_internal(p->read, p->write, p->except, p->timeout, p->fdsets);
10813select_end(
VALUE arg)
10818 for (i = 0; i < numberof(p->fdsets); ++i)
10823static VALUE sym_normal, sym_sequential, sym_random,
10824 sym_willneed, sym_dontneed, sym_noreuse;
10826#ifdef HAVE_POSIX_FADVISE
10827struct io_advise_struct {
10835io_advise_internal(
void *arg)
10837 struct io_advise_struct *ptr = arg;
10838 return posix_fadvise(ptr->fd, ptr->offset, ptr->len, ptr->advice);
10842io_advise_sym_to_const(
VALUE sym)
10844#ifdef POSIX_FADV_NORMAL
10845 if (sym == sym_normal)
10846 return INT2NUM(POSIX_FADV_NORMAL);
10849#ifdef POSIX_FADV_RANDOM
10850 if (sym == sym_random)
10851 return INT2NUM(POSIX_FADV_RANDOM);
10854#ifdef POSIX_FADV_SEQUENTIAL
10855 if (sym == sym_sequential)
10856 return INT2NUM(POSIX_FADV_SEQUENTIAL);
10859#ifdef POSIX_FADV_WILLNEED
10860 if (sym == sym_willneed)
10861 return INT2NUM(POSIX_FADV_WILLNEED);
10864#ifdef POSIX_FADV_DONTNEED
10865 if (sym == sym_dontneed)
10866 return INT2NUM(POSIX_FADV_DONTNEED);
10869#ifdef POSIX_FADV_NOREUSE
10870 if (sym == sym_noreuse)
10871 return INT2NUM(POSIX_FADV_NOREUSE);
10878do_io_advise(
rb_io_t *fptr,
VALUE advice, rb_off_t offset, rb_off_t
len)
10881 struct io_advise_struct ias;
10884 num_adv = io_advise_sym_to_const(advice);
10890 if (
NIL_P(num_adv))
10894 ias.advice =
NUM2INT(num_adv);
10895 ias.offset = offset;
10898 rv = (int)rb_io_blocking_region(fptr, io_advise_internal, &ias);
10899 if (rv && rv != ENOSYS) {
10902 VALUE message = rb_sprintf(
"%"PRIsVALUE
" "
10906 fptr->
pathv, offset,
len, advice);
10916advice_arg_check(
VALUE advice)
10921 if (advice != sym_normal &&
10922 advice != sym_sequential &&
10923 advice != sym_random &&
10924 advice != sym_willneed &&
10925 advice != sym_dontneed &&
10926 advice != sym_noreuse) {
10927 rb_raise(
rb_eNotImpError,
"Unsupported advice: %+"PRIsVALUE, advice);
10965rb_io_advise(
int argc,
VALUE *argv,
VALUE io)
10972 advice_arg_check(advice);
10974 io = GetWriteIO(io);
10980#ifdef HAVE_POSIX_FADVISE
10981 return do_io_advise(fptr, advice,
off, l);
10983 ((void)
off, (
void)l);
10995 return isinf(f) && 0 < f;
11151rb_f_select(
int argc,
VALUE *argv,
VALUE obj)
11154 if (scheduler !=
Qnil) {
11157 if (!UNDEF_P(result))
return result;
11165 rb_scan_args(argc, argv,
"13", &args.read, &args.write, &args.except, &timeout);
11166 if (
NIL_P(timeout) || is_pos_inf(timeout)) {
11171 args.timeout = &timerec;
11174 for (i = 0; i < numberof(args.fdsets); ++i)
11180#ifdef IOCTL_REQ_TYPE
11181 typedef IOCTL_REQ_TYPE ioctl_req_t;
11183 typedef int ioctl_req_t;
11184# define NUM2IOCTLREQ(num) ((int)NUM2LONG(num))
11195nogvl_ioctl(
void *ptr)
11197 struct ioctl_arg *arg = ptr;
11199 return (
VALUE)ioctl(arg->fd, arg->cmd, arg->narg);
11203do_ioctl(
struct rb_io *io, ioctl_req_t cmd,
long narg)
11206 struct ioctl_arg arg;
11212 retval = (int)rb_io_blocking_region(io, nogvl_ioctl, &arg);
11218#define DEFAULT_IOCTL_NARG_LEN (256)
11220#if defined(__linux__) && defined(_IOC_SIZE)
11222linux_iocparm_len(ioctl_req_t cmd)
11226 if ((cmd & 0xFFFF0000) == 0) {
11228 return DEFAULT_IOCTL_NARG_LEN;
11231 len = _IOC_SIZE(cmd);
11234 if (
len < DEFAULT_IOCTL_NARG_LEN)
11235 len = DEFAULT_IOCTL_NARG_LEN;
11243ioctl_narg_len(ioctl_req_t cmd)
11249#define IOCPARM_LEN(x) (((x) >> 16) & IOCPARM_MASK)
11253 len = IOCPARM_LEN(cmd);
11254#elif defined(__linux__) && defined(_IOC_SIZE)
11255 len = linux_iocparm_len(cmd);
11258 len = DEFAULT_IOCTL_NARG_LEN;
11267typedef long fcntl_arg_t;
11270typedef int fcntl_arg_t;
11274fcntl_narg_len(ioctl_req_t cmd)
11281 len =
sizeof(fcntl_arg_t);
11289#ifdef F_DUPFD_CLOEXEC
11290 case F_DUPFD_CLOEXEC:
11291 len =
sizeof(fcntl_arg_t);
11301 len =
sizeof(fcntl_arg_t);
11311 len =
sizeof(fcntl_arg_t);
11321 len =
sizeof(fcntl_arg_t);
11326 len =
sizeof(
struct f_owner_ex);
11331 len =
sizeof(
struct f_owner_ex);
11336 len =
sizeof(
struct flock);
11341 len =
sizeof(
struct flock);
11346 len =
sizeof(
struct flock);
11366 len =
sizeof(fcntl_arg_t);
11376 len =
sizeof(fcntl_arg_t);
11381 len =
sizeof(fcntl_arg_t);
11394fcntl_narg_len(ioctl_req_t cmd)
11400#define NARG_SENTINEL 17
11403setup_narg(ioctl_req_t cmd,
VALUE *argp,
long (*narg_len)(ioctl_req_t))
11414 else if (arg ==
Qtrue) {
11428 len = narg_len(cmd);
11429 rb_str_modify(arg);
11431 slen = RSTRING_LEN(arg);
11433 if (slen <
len+1) {
11434 rb_str_resize(arg,
len+1);
11435 MEMZERO(RSTRING_PTR(arg)+slen,
char,
len-slen);
11439 ptr = RSTRING_PTR(arg);
11440 ptr[slen - 1] = NARG_SENTINEL;
11449finish_narg(
int retval,
VALUE arg,
const rb_io_t *fptr)
11451 if (retval < 0) rb_sys_fail_path(fptr->
pathv);
11456 if (ptr[slen-1] != NARG_SENTINEL)
11457 rb_raise(rb_eArgError,
"return value overflowed string");
11458 ptr[slen-1] =
'\0';
11468 ioctl_req_t cmd = NUM2IOCTLREQ(req);
11473 narg = setup_narg(cmd, &arg, ioctl_narg_len);
11475 retval = do_ioctl(fptr, cmd, narg);
11476 return finish_narg(retval, arg, fptr);
11503 return rb_ioctl(io, req, arg);
11506#define rb_io_ioctl rb_f_notimplement
11517nogvl_fcntl(
void *ptr)
11519 struct fcntl_arg *arg = ptr;
11521#if defined(F_DUPFD)
11522 if (arg->cmd == F_DUPFD)
11525 return (
VALUE)fcntl(arg->fd, arg->cmd, arg->narg);
11529do_fcntl(
struct rb_io *io,
int cmd,
long narg)
11532 struct fcntl_arg arg;
11538 retval = (int)rb_io_blocking_region(io, nogvl_fcntl, &arg);
11539 if (retval != -1) {
11541#if defined(F_DUPFD)
11544#if defined(F_DUPFD_CLOEXEC)
11545 case F_DUPFD_CLOEXEC:
11562 narg = setup_narg(cmd, &arg, fcntl_narg_len);
11564 retval = do_fcntl(fptr, cmd, narg);
11565 return finish_narg(retval, arg, fptr);
11591 return rb_fcntl(io, req, arg);
11594#define rb_io_fcntl rb_f_notimplement
11597#if defined(HAVE_SYSCALL) || defined(HAVE___SYSCALL)
11629#if SIZEOF_VOIDP == 8 && defined(HAVE___SYSCALL) && SIZEOF_INT != 8
11630# define SYSCALL __syscall
11631# define NUM2SYSCALLID(x) NUM2LONG(x)
11632# define RETVAL2NUM(x) LONG2NUM(x)
11633# if SIZEOF_LONG == 8
11634 long num, retval = -1;
11635# elif SIZEOF_LONG_LONG == 8
11636 long long num, retval = -1;
11638# error ---->> it is asserted that __syscall takes the first argument and returns retval in 64bit signed integer. <<----
11640#elif defined(__linux__)
11641# define SYSCALL syscall
11642# define NUM2SYSCALLID(x) NUM2LONG(x)
11643# define RETVAL2NUM(x) LONG2NUM(x)
11651 long num, retval = -1;
11653# define SYSCALL syscall
11654# define NUM2SYSCALLID(x) NUM2INT(x)
11655# define RETVAL2NUM(x) INT2NUM(x)
11656 int num, retval = -1;
11662 "We plan to remove a syscall function at future release. DL(Fiddle) provides safer alternative.");
11666 rb_raise(rb_eArgError,
"too few arguments for syscall");
11667 if (argc > numberof(arg))
11668 rb_raise(rb_eArgError,
"too many arguments for syscall");
11669 num = NUM2SYSCALLID(argv[0]); ++argv;
11670 for (i = argc - 1; i--; ) {
11685 retval = SYSCALL(num);
11688 retval = SYSCALL(num, arg[0]);
11691 retval = SYSCALL(num, arg[0],arg[1]);
11694 retval = SYSCALL(num, arg[0],arg[1],arg[2]);
11697 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3]);
11700 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4]);
11703 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5]);
11706 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6]);
11712 return RETVAL2NUM(retval);
11714#undef NUM2SYSCALLID
11718#define rb_f_syscall rb_f_notimplement
11722io_new_instance(
VALUE args)
11728find_encoding(
VALUE v)
11731 if (!enc)
rb_warn(
"Unsupported encoding %"PRIsVALUE
" ignored", v);
11743 enc2 = find_encoding(v1);
11746 if (RSTRING_LEN(tmp) == 1 && RSTRING_PTR(tmp)[0] ==
'-') {
11752 enc = find_encoding(v2);
11759 enc = find_encoding(v2);
11765 if (enc2 == rb_ascii8bit_encoding()) {
11770 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
11776 rb_io_ext_int_to_encs(NULL, NULL, &enc, &enc2, 0);
11777 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
11782 if (!
NIL_P(tmp) && rb_enc_asciicompat(enc = rb_enc_get(tmp))) {
11783 parse_mode_enc(RSTRING_PTR(tmp), enc, &enc, &enc2, NULL);
11784 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
11788 rb_io_ext_int_to_encs(find_encoding(v1), NULL, &enc, &enc2, 0);
11789 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
11794 validate_enc_binmode(&fptr->
mode, ecflags, enc, enc2);
11799 clear_codeconv(fptr);
11811io_encoding_set_v(
VALUE v)
11814 io_encoding_set(arg->fptr, arg->v1, arg->v2, arg->opt);
11819pipe_pair_close(
VALUE rw)
11822 return rb_ensure(io_close, rwp[0], io_close, rwp[1]);
11905rb_io_s_pipe(
int argc,
VALUE *argv,
VALUE klass)
11907 int pipes[2], state;
11908 VALUE r, w, args[3], v1, v2;
11912 enum rb_io_mode fmode = 0;
11915 argc =
rb_scan_args(argc, argv,
"02:", &v1, &v2, &opt);
11922 r = rb_protect(io_new_instance, (
VALUE)args, &state);
11926 rb_jump_tag(state);
11930 ies_args.fptr = fptr;
11933 ies_args.opt = opt;
11934 rb_protect(io_encoding_set_v, (
VALUE)&ies_args, &state);
11938 rb_jump_tag(state);
11943 w = rb_protect(io_new_instance, (
VALUE)args, &state);
11947 rb_jump_tag(state);
11952 extract_binmode(opt, &fmode);
11959#if DEFAULT_TEXTMODE
11961 fptr->
mode &= ~FMODE_TEXTMODE;
11962 setmode(fptr->
fd, O_BINARY);
11964#if RUBY_CRLF_ENVIRONMENT
11970 fptr->
mode |= fmode;
11971#if DEFAULT_TEXTMODE
11973 fptr2->
mode &= ~FMODE_TEXTMODE;
11974 setmode(fptr2->
fd, O_BINARY);
11977 fptr2->
mode |= fmode;
11979 ret = rb_assoc_new(r, w);
12011 else if (!
NIL_P(v = rb_hash_aref(opt, sym_open_args))) {
12014 v = rb_to_array_type(v);
12019 arg->io = rb_io_open(klass, path, vmode, vperm, opt);
12023io_s_foreach(
VALUE v)
12028 if (arg->limit == 0)
12029 rb_raise(rb_eArgError,
"invalid limit: 0 for foreach");
12030 while (!
NIL_P(str = rb_io_getline_1(arg->rs, arg->limit, arg->chomp, arg->io))) {
12118rb_io_s_foreach(
int argc,
VALUE *argv,
VALUE self)
12121 int orig_argc = argc;
12125 argc =
rb_scan_args(argc, argv,
"12:", NULL, NULL, NULL, &opt);
12127 extract_getline_args(argc-1, argv+1, &garg);
12128 open_key_args(self, argc, argv, opt, &arg);
12130 extract_getline_opts(opt, &garg);
12131 check_getline_args(&garg.rs, &garg.limit, garg.io = arg.io);
12132 return rb_ensure(io_s_foreach, (
VALUE)&garg, rb_io_close, arg.io);
12136io_s_readlines(
VALUE v)
12139 return io_readlines(arg, arg->io);
12196rb_io_s_readlines(
int argc,
VALUE *argv,
VALUE io)
12202 argc =
rb_scan_args(argc, argv,
"12:", NULL, NULL, NULL, &opt);
12203 extract_getline_args(argc-1, argv+1, &garg);
12204 open_key_args(io, argc, argv, opt, &arg);
12206 extract_getline_opts(opt, &garg);
12207 check_getline_args(&garg.rs, &garg.limit, garg.io = arg.io);
12208 return rb_ensure(io_s_readlines, (
VALUE)&garg, rb_io_close, arg.io);
12215 return io_read(arg->argc, arg->argv, arg->io);
12225seek_before_access(
VALUE argp)
12229 return rb_io_seek(arg->io, arg->offset, arg->mode);
12275rb_io_s_read(
int argc,
VALUE *argv,
VALUE io)
12281 argc =
rb_scan_args(argc, argv,
"13:", NULL, NULL, &offset, NULL, &opt);
12283 rb_raise(rb_eArgError,
"negative offset %ld given",
off);
12285 open_key_args(io, argc, argv, opt, &arg);
12287 if (!
NIL_P(offset)) {
12291 sarg.offset = offset;
12292 sarg.mode = SEEK_SET;
12293 rb_protect(seek_before_access, (
VALUE)&sarg, &state);
12296 rb_jump_tag(state);
12298 if (arg.argc == 2) arg.argc = 1;
12317rb_io_s_binread(
int argc,
VALUE *argv,
VALUE io)
12332 convconfig.
enc = rb_ascii8bit_encoding();
12333 arg.io = rb_io_open_generic(io, argv[0], oflags, fmode, &convconfig, 0);
12336 arg.argc = (argc > 1) ? 1 : 0;
12337 if (!
NIL_P(offset)) {
12341 sarg.offset = offset;
12342 sarg.mode = SEEK_SET;
12343 rb_protect(seek_before_access, (
VALUE)&sarg, &state);
12346 rb_jump_tag(state);
12353io_s_write0(
VALUE v)
12356 return io_write(arg->io,arg->str,arg->nosync);
12360io_s_write(
int argc,
VALUE *argv,
VALUE klass,
int binary)
12362 VALUE string, offset, opt;
12366 rb_scan_args(argc, argv,
"21:", NULL, &
string, &offset, &opt);
12368 if (
NIL_P(opt)) opt = rb_hash_new();
12369 else opt = rb_hash_dup(opt);
12372 if (
NIL_P(rb_hash_aref(opt,sym_mode))) {
12373 int mode = O_WRONLY|O_CREAT;
12375 if (binary) mode |= O_BINARY;
12377 if (
NIL_P(offset)) mode |= O_TRUNC;
12378 rb_hash_aset(opt,sym_mode,
INT2NUM(mode));
12380 open_key_args(klass, argc, argv, opt, &arg);
12383 if (binary) rb_io_binmode_m(arg.io);
12387 if (!
NIL_P(offset)) {
12391 sarg.offset = offset;
12392 sarg.mode = SEEK_SET;
12393 rb_protect(seek_before_access, (
VALUE)&sarg, &state);
12396 rb_jump_tag(state);
12404 return rb_ensure(io_s_write0, (
VALUE)&warg, rb_io_close, arg.io);
12452rb_io_s_write(
int argc,
VALUE *argv,
VALUE io)
12454 return io_s_write(argc, argv, io, 0);
12471rb_io_s_binwrite(
int argc,
VALUE *argv,
VALUE io)
12473 return io_s_write(argc, argv, io, 1);
12479 rb_off_t copy_length;
12480 rb_off_t src_offset;
12484 unsigned close_src : 1;
12485 unsigned close_dst : 1;
12488 const char *syserr;
12489 const char *notimp;
12491 struct stat src_stat;
12492 struct stat dst_stat;
12493#ifdef HAVE_FCOPYFILE
12494 copyfile_state_t copyfile_state;
12499exec_interrupts(
void *arg)
12502 rb_thread_execute_interrupts(th);
12516#if defined(ERESTART)
12521 rb_thread_execute_interrupts(stp->th);
12540fiber_scheduler_wait_for(
void * _arguments)
12550# define IOWAIT_SYSCALL "poll"
12551STATIC_ASSERT(pollin_expected, POLLIN == RB_WAITFD_IN);
12552STATIC_ASSERT(pollout_expected, POLLOUT == RB_WAITFD_OUT);
12557 if (scheduler !=
Qnil) {
12560 return RTEST(args.result);
12564 if (fd == -1)
return 0;
12569 fds.events = events;
12571 int timeout_milliseconds = -1;
12574 timeout_milliseconds = (int)(timeout->tv_sec * 1000) + (int)(timeout->tv_usec / 1000);
12577 return poll(&fds, 1, timeout_milliseconds);
12580# define IOWAIT_SYSCALL "select"
12585 if (scheduler !=
Qnil) {
12588 return RTEST(args.result);
12608 case RB_WAITFD_OUT:
12612 VM_UNREACHABLE(nogvl_wait_for);
12632 ret = nogvl_wait_for(stp->th, stp->src_fptr, RB_WAITFD_IN, NULL);
12634 }
while (ret < 0 && maygvl_copy_stream_continue_p(has_gvl, stp));
12637 stp->syserr = IOWAIT_SYSCALL;
12638 stp->error_no =
errno;
12650 ret = nogvl_wait_for(stp->th, stp->dst_fptr, RB_WAITFD_OUT, NULL);
12651 }
while (ret < 0 && maygvl_copy_stream_continue_p(0, stp));
12654 stp->syserr = IOWAIT_SYSCALL;
12655 stp->error_no =
errno;
12661#ifdef USE_COPY_FILE_RANGE
12664simple_copy_file_range(
int in_fd, rb_off_t *in_offset,
int out_fd, rb_off_t *out_offset,
size_t count,
unsigned int flags)
12666#ifdef HAVE_COPY_FILE_RANGE
12667 return copy_file_range(in_fd, in_offset, out_fd, out_offset, count, flags);
12669 return syscall(__NR_copy_file_range, in_fd, in_offset, out_fd, out_offset, count, flags);
12678 rb_off_t copy_length, src_offset, *src_offset_ptr;
12680 if (!S_ISREG(stp->src_stat.st_mode))
12683 src_size = stp->src_stat.st_size;
12684 src_offset = stp->src_offset;
12685 if (src_offset >= (rb_off_t)0) {
12686 src_offset_ptr = &src_offset;
12689 src_offset_ptr = NULL;
12692 copy_length = stp->copy_length;
12693 if (copy_length < (rb_off_t)0) {
12694 if (src_offset < (rb_off_t)0) {
12695 rb_off_t current_offset;
12697 current_offset = lseek(stp->src_fptr->
fd, 0, SEEK_CUR);
12698 if (current_offset < (rb_off_t)0 &&
errno) {
12699 stp->syserr =
"lseek";
12700 stp->error_no =
errno;
12701 return (
int)current_offset;
12703 copy_length = src_size - current_offset;
12706 copy_length = src_size - src_offset;
12710 retry_copy_file_range:
12711# if SIZEOF_OFF_T > SIZEOF_SIZE_T
12713 ss = (copy_length > (rb_off_t)SSIZE_MAX) ? SSIZE_MAX : (ssize_t)copy_length;
12715 ss = (ssize_t)copy_length;
12717 ss = simple_copy_file_range(stp->src_fptr->
fd, src_offset_ptr, stp->dst_fptr->
fd, NULL, ss, 0);
12721 if (0 < copy_length) {
12722 goto retry_copy_file_range;
12726 if (maygvl_copy_stream_continue_p(0, stp)) {
12727 goto retry_copy_file_range;
12741#if EWOULDBLOCK != EAGAIN
12745 int ret = nogvl_copy_stream_wait_write(stp);
12746 if (ret < 0)
return ret;
12748 goto retry_copy_file_range;
12752 int flags = fcntl(stp->dst_fptr->
fd, F_GETFL);
12754 if (flags != -1 && flags & O_APPEND) {
12760 stp->syserr =
"copy_file_range";
12761 stp->error_no =
errno;
12768#ifdef HAVE_FCOPYFILE
12772 rb_off_t cur, ss = 0;
12773 const rb_off_t src_offset = stp->src_offset;
12776 if (stp->copy_length >= (rb_off_t)0) {
12781 if (!S_ISREG(stp->src_stat.st_mode))
12784 if (!S_ISREG(stp->dst_stat.st_mode))
12786 if (lseek(stp->dst_fptr->
fd, 0, SEEK_CUR) > (rb_off_t)0)
12788 if (fcntl(stp->dst_fptr->
fd, F_GETFL) & O_APPEND) {
12791 rb_off_t end = lseek(stp->dst_fptr->
fd, 0, SEEK_END);
12792 lseek(stp->dst_fptr->
fd, 0, SEEK_SET);
12793 if (end > (rb_off_t)0)
return 0;
12796 if (src_offset > (rb_off_t)0) {
12801 cur = lseek(stp->src_fptr->
fd, 0, SEEK_CUR);
12802 if (cur < (rb_off_t)0 &&
errno) {
12803 stp->error_no =
errno;
12808 r = lseek(stp->src_fptr->
fd, src_offset, SEEK_SET);
12809 if (r < (rb_off_t)0 &&
errno) {
12810 stp->error_no =
errno;
12815 stp->copyfile_state = copyfile_state_alloc();
12816 ret = fcopyfile(stp->src_fptr->
fd, stp->dst_fptr->
fd, stp->copyfile_state, COPYFILE_DATA);
12817 copyfile_state_get(stp->copyfile_state, COPYFILE_STATE_COPIED, &ss);
12821 if (src_offset > (rb_off_t)0) {
12825 r = lseek(stp->src_fptr->
fd, cur, SEEK_SET);
12826 if (r < (rb_off_t)0 &&
errno) {
12827 stp->error_no =
errno;
12839 stp->syserr =
"fcopyfile";
12840 stp->error_no =
errno;
12847#ifdef HAVE_SENDFILE
12850# define USE_SENDFILE
12852# ifdef HAVE_SYS_SENDFILE_H
12853# include <sys/sendfile.h>
12857simple_sendfile(
int out_fd,
int in_fd, rb_off_t *offset, rb_off_t count)
12859 return sendfile(out_fd, in_fd, offset, (
size_t)count);
12862# elif 0 || defined(__APPLE__)
12866# define USE_SENDFILE
12869simple_sendfile(
int out_fd,
int in_fd, rb_off_t *offset, rb_off_t count)
12872 rb_off_t pos = offset ? *offset : lseek(in_fd, 0, SEEK_CUR);
12875 r = sendfile(in_fd, out_fd, pos, &count, NULL, 0);
12878 r = sendfile(in_fd, out_fd, pos, (
size_t)count, NULL, &sbytes, 0);
12880 if (r != 0 && sbytes == 0)
return r;
12885 lseek(in_fd, sbytes, SEEK_CUR);
12887 return (ssize_t)sbytes;
12900 rb_off_t copy_length;
12901 rb_off_t src_offset;
12904 if (!S_ISREG(stp->src_stat.st_mode))
12907 src_size = stp->src_stat.st_size;
12909 if ((stp->dst_stat.st_mode & S_IFMT) != S_IFSOCK)
12913 src_offset = stp->src_offset;
12914 use_pread = src_offset >= (rb_off_t)0;
12916 copy_length = stp->copy_length;
12917 if (copy_length < (rb_off_t)0) {
12919 copy_length = src_size - src_offset;
12923 cur = lseek(stp->src_fptr->
fd, 0, SEEK_CUR);
12924 if (cur < (rb_off_t)0 &&
errno) {
12925 stp->syserr =
"lseek";
12926 stp->error_no =
errno;
12929 copy_length = src_size - cur;
12934# if SIZEOF_OFF_T > SIZEOF_SIZE_T
12936 ss = (copy_length > (rb_off_t)SSIZE_MAX) ? SSIZE_MAX : (ssize_t)copy_length;
12938 ss = (ssize_t)copy_length;
12941 ss = simple_sendfile(stp->dst_fptr->
fd, stp->src_fptr->
fd, &src_offset, ss);
12944 ss = simple_sendfile(stp->dst_fptr->
fd, stp->src_fptr->
fd, NULL, ss);
12949 if (0 < copy_length) {
12950 goto retry_sendfile;
12954 if (maygvl_copy_stream_continue_p(0, stp))
12955 goto retry_sendfile;
12968#if EWOULDBLOCK != EAGAIN
12981 ret = maygvl_copy_stream_wait_read(0, stp);
12982 if (ret < 0)
return ret;
12984 ret = nogvl_copy_stream_wait_write(stp);
12985 if (ret < 0)
return ret;
12987 goto retry_sendfile;
12989 stp->syserr =
"sendfile";
12990 stp->error_no =
errno;
12998maygvl_read(
int has_gvl,
rb_io_t *fptr,
void *buf,
size_t count)
13001 return rb_io_read_memory(fptr, buf, count);
13003 return read(fptr->
fd, buf, count);
13007maygvl_copy_stream_read(
int has_gvl,
struct copy_stream_struct *stp,
char *buf,
size_t len, rb_off_t offset)
13011 if (offset < (rb_off_t)0) {
13012 ss = maygvl_read(has_gvl, stp->src_fptr, buf,
len);
13015 ss = pread(stp->src_fptr->
fd, buf,
len, offset);
13021 if (maygvl_copy_stream_continue_p(has_gvl, stp))
13025#if EWOULDBLOCK != EAGAIN
13029 int ret = maygvl_copy_stream_wait_read(has_gvl, stp);
13030 if (ret < 0)
return ret;
13035 stp->notimp =
"pread";
13039 stp->syserr = offset < (rb_off_t)0 ?
"read" :
"pread";
13040 stp->error_no =
errno;
13051 ss = write(stp->dst_fptr->
fd, buf+
off,
len);
13053 if (maygvl_copy_stream_continue_p(0, stp))
13055 if (io_again_p(
errno)) {
13056 int ret = nogvl_copy_stream_wait_write(stp);
13057 if (ret < 0)
return ret;
13060 stp->syserr =
"write";
13061 stp->error_no =
errno;
13078 rb_off_t copy_length;
13079 rb_off_t src_offset;
13083 copy_length = stp->copy_length;
13084 use_eof = copy_length < (rb_off_t)0;
13085 src_offset = stp->src_offset;
13086 use_pread = src_offset >= (rb_off_t)0;
13088 if (use_pread && stp->close_src) {
13091 r = lseek(stp->src_fptr->
fd, src_offset, SEEK_SET);
13092 if (r < (rb_off_t)0 &&
errno) {
13093 stp->syserr =
"lseek";
13094 stp->error_no =
errno;
13097 src_offset = (rb_off_t)-1;
13101 while (use_eof || 0 < copy_length) {
13102 if (!use_eof && copy_length < (rb_off_t)
sizeof(buf)) {
13103 len = (size_t)copy_length;
13109 ss = maygvl_copy_stream_read(0, stp, buf,
len, src_offset);
13114 ss = maygvl_copy_stream_read(0, stp, buf,
len, (rb_off_t)-1);
13119 ret = nogvl_copy_stream_write(stp, buf, ss);
13129nogvl_copy_stream_func(
void *arg)
13132#if defined(USE_SENDFILE) || defined(USE_COPY_FILE_RANGE) || defined(HAVE_FCOPYFILE)
13136#ifdef USE_COPY_FILE_RANGE
13137 ret = nogvl_copy_file_range(stp);
13142#ifdef HAVE_FCOPYFILE
13143 ret = nogvl_fcopyfile(stp);
13149 ret = nogvl_copy_stream_sendfile(stp);
13154 nogvl_copy_stream_read_write(stp);
13156#if defined(USE_SENDFILE) || defined(USE_COPY_FILE_RANGE) || defined(HAVE_FCOPYFILE)
13163copy_stream_fallback_body(
VALUE arg)
13166 const int buflen = 16*1024;
13169 rb_off_t rest = stp->copy_length;
13170 rb_off_t
off = stp->src_offset;
13171 ID read_method = id_readpartial;
13173 if (!stp->src_fptr) {
13175 read_method = id_read;
13182 rb_str_make_independent(buf);
13183 if (stp->copy_length < (rb_off_t)0) {
13188 rb_str_resize(buf, 0);
13191 l = buflen < rest ? buflen : (long)rest;
13193 if (!stp->src_fptr) {
13196 if (read_method == id_read &&
NIL_P(rc))
13201 rb_str_resize(buf, buflen);
13202 ss = maygvl_copy_stream_read(1, stp, RSTRING_PTR(buf), l,
off);
13203 rb_str_resize(buf, ss > 0 ? ss : 0);
13208 if (
off >= (rb_off_t)0)
13211 n = rb_io_write(stp->dst, buf);
13213 stp->total += numwrote;
13215 if (read_method == id_read && RSTRING_LEN(buf) == 0) {
13226 if (!stp->src_fptr && stp->src_offset >= (rb_off_t)0) {
13227 rb_raise(rb_eArgError,
"cannot specify src_offset for non-IO");
13236copy_stream_body(
VALUE arg)
13239 VALUE src_io = stp->src, dst_io = stp->dst;
13240 const int common_oflags = 0
13250 if (src_io ==
argf ||
13254 stp->src_fptr = NULL;
13259 if (!
NIL_P(tmp_io)) {
13266 args[1] =
INT2NUM(O_RDONLY|common_oflags);
13269 stp->close_src = 1;
13274 stat_ret = fstat(stp->src_fptr->
fd, &stp->src_stat);
13275 if (stat_ret < 0) {
13276 stp->syserr =
"fstat";
13277 stp->error_no =
errno;
13282 if (dst_io ==
argf ||
13286 stp->dst_fptr = NULL;
13291 if (!
NIL_P(tmp_io)) {
13292 dst_io = GetWriteIO(tmp_io);
13298 args[1] =
INT2NUM(O_WRONLY|O_CREAT|O_TRUNC|common_oflags);
13302 stp->close_dst = 1;
13305 dst_io = GetWriteIO(dst_io);
13311 stat_ret = fstat(stp->dst_fptr->
fd, &stp->dst_stat);
13312 if (stat_ret < 0) {
13313 stp->syserr =
"fstat";
13314 stp->error_no =
errno;
13321 SET_BINARY_MODE_WITH_SEEK_CUR(stp->src_fptr);
13324 io_ascii8bit_binmode(stp->dst_fptr);
13326 if (stp->src_offset < (rb_off_t)0 && stp->src_fptr && stp->src_fptr->
rbuf.
len) {
13329 if (stp->copy_length >= (rb_off_t)0 && stp->copy_length < (rb_off_t)
len) {
13330 len = (size_t)stp->copy_length;
13333 rb_str_resize(str,
len);
13334 read_buffered_data(RSTRING_PTR(str),
len, stp->src_fptr);
13335 if (stp->dst_fptr) {
13336 if (io_binwrite(RSTRING_PTR(str), RSTRING_LEN(str), stp->dst_fptr, 0) < 0)
13337 rb_sys_fail_on_write(stp->dst_fptr);
13340 rb_io_write(dst_io, str);
13341 rb_str_resize(str, 0);
13343 if (stp->copy_length >= (rb_off_t)0)
13344 stp->copy_length -=
len;
13347 if (stp->dst_fptr && io_fflush(stp->dst_fptr) < 0) {
13351 if (stp->copy_length == 0)
13354 if (stp->src_fptr == NULL || stp->dst_fptr == NULL) {
13355 return copy_stream_fallback(stp);
13358 IO_WITHOUT_GVL(nogvl_copy_stream_func, stp);
13363copy_stream_finalize(
VALUE arg)
13367#ifdef HAVE_FCOPYFILE
13368 if (stp->copyfile_state) {
13369 copyfile_state_free(stp->copyfile_state);
13373 if (stp->close_src) {
13374 rb_io_close_m(stp->src);
13376 if (stp->close_dst) {
13377 rb_io_close_m(stp->dst);
13440rb_io_s_copy_stream(
int argc,
VALUE *argv,
VALUE io)
13442 VALUE src, dst, length, src_offset;
13447 rb_scan_args(argc, argv,
"22", &src, &dst, &length, &src_offset);
13452 st.src_fptr = NULL;
13453 st.dst_fptr = NULL;
13456 st.copy_length = (rb_off_t)-1;
13458 st.copy_length =
NUM2OFFT(length);
13460 if (
NIL_P(src_offset))
13461 st.src_offset = (rb_off_t)-1;
13463 st.src_offset =
NUM2OFFT(src_offset);
13482rb_io_external_encoding(
VALUE io)
13487 return rb_enc_from_encoding(fptr->
encs.
enc2);
13491 return rb_enc_from_encoding(fptr->
encs.
enc);
13494 return rb_enc_from_encoding(io_read_encoding(fptr));
13510rb_io_internal_encoding(
VALUE io)
13515 return rb_enc_from_encoding(io_read_encoding(fptr));
13549rb_io_set_encoding(
int argc,
VALUE *argv,
VALUE io)
13555 return forward(io, id_set_encoding, argc, argv);
13558 argc =
rb_scan_args(argc, argv,
"11:", &v1, &v2, &opt);
13560 io_encoding_set(fptr, v1, v2, opt);
13565rb_stdio_set_default_encoding(
void)
13570 if (isatty(fileno(stdin))) {
13572 rb_encoding *internal = rb_default_internal_encoding();
13573 if (!internal) internal = rb_default_external_encoding();
13575 rb_enc_from_encoding(external),
13576 rb_enc_from_encoding(internal),
13581 rb_io_set_encoding(1, &val,
rb_stdin);
13582 rb_io_set_encoding(1, &val,
rb_stdout);
13583 rb_io_set_encoding(1, &val,
rb_stderr);
13587global_argf_p(
VALUE arg)
13589 return arg ==
argf;
13592typedef VALUE (*argf_encoding_func)(
VALUE io);
13595argf_encoding(
VALUE argf, argf_encoding_func func)
13597 if (!
RTEST(ARGF.current_file)) {
13598 return rb_enc_default_external();
13622 return argf_encoding(
argf, rb_io_external_encoding);
13641 return argf_encoding(
argf, rb_io_internal_encoding);
13680 if (!next_argv()) {
13681 rb_raise(rb_eArgError,
"no stream to set encoding");
13683 rb_io_set_encoding(argc, argv, ARGF.current_file);
13685 ARGF.encs = fptr->
encs;
13704 if (!next_argv()) {
13705 rb_raise(rb_eArgError,
"no stream to tell");
13707 ARGF_FORWARD(0, 0);
13708 return rb_io_tell(ARGF.current_file);
13721 if (!next_argv()) {
13722 rb_raise(rb_eArgError,
"no stream to seek");
13724 ARGF_FORWARD(argc, argv);
13725 return rb_io_seek_m(argc, argv, ARGF.current_file);
13742 if (!next_argv()) {
13743 rb_raise(rb_eArgError,
"no stream to set position");
13745 ARGF_FORWARD(1, &offset);
13746 return rb_io_set_pos(ARGF.current_file, offset);
13767 if (!next_argv()) {
13768 rb_raise(rb_eArgError,
"no stream to rewind");
13770 ARGF_FORWARD(0, 0);
13771 old_lineno =
RFILE(ARGF.current_file)->fptr->lineno;
13772 ret = rb_io_rewind(ARGF.current_file);
13773 if (!global_argf_p(
argf)) {
13774 ARGF.last_lineno = ARGF.lineno -= old_lineno;
13792 if (!next_argv()) {
13793 rb_raise(rb_eArgError,
"no stream");
13795 ARGF_FORWARD(0, 0);
13796 return rb_io_fileno(ARGF.current_file);
13815 ARGF_FORWARD(0, 0);
13816 return ARGF.current_file;
13841 if (
RTEST(ARGF.current_file)) {
13842 if (ARGF.init_p == 0)
return Qtrue;
13844 ARGF_FORWARD(0, 0);
13903 VALUE tmp, str, length;
13907 if (!
NIL_P(length)) {
13912 rb_str_resize(str,0);
13917 if (!next_argv()) {
13920 if (ARGF_GENERIC_INPUT_P()) {
13921 tmp = argf_forward(argc, argv,
argf);
13924 tmp = io_read(argc, argv, ARGF.current_file);
13926 if (
NIL_P(str)) str = tmp;
13929 if (ARGF.next_p != -1) {
13935 else if (argc >= 1) {
13936 long slen = RSTRING_LEN(str);
13952argf_forward_call(
VALUE arg)
13955 argf_forward(p->argc, p->argv, p->argf);
13985 return argf_getpartial(argc, argv,
argf,
Qnil, 0);
14006 return argf_getpartial(argc, argv,
argf, opts, 1);
14012 VALUE tmp, str, length;
14020 no_exception = no_exception_p(opts);
14022 if (!next_argv()) {
14024 rb_str_resize(str, 0);
14028 if (ARGF_GENERIC_INPUT_P()) {
14038 tmp = io_getpartial(argc, argv, ARGF.current_file, no_exception, nonblock);
14041 if (ARGF.next_p == -1) {
14042 return io_nonblock_eof(no_exception);
14047 return io_nonblock_eof(no_exception);
14085 if (!next_argv())
return Qnil;
14086 if (ARGF_GENERIC_INPUT_P()) {
14087 ch = forward_current(rb_intern(
"getc"), 0, 0);
14090 ch = rb_io_getc(ARGF.current_file);
14092 if (
NIL_P(ch) && ARGF.next_p != -1) {
14125 if (!next_argv())
return Qnil;
14127 ch = forward_current(rb_intern(
"getbyte"), 0, 0);
14132 if (
NIL_P(ch) && ARGF.next_p != -1) {
14165 if (!next_argv()) rb_eof_error();
14167 ch = forward_current(rb_intern(
"getc"), 0, 0);
14170 ch = rb_io_getc(ARGF.current_file);
14172 if (
NIL_P(ch) && ARGF.next_p != -1) {
14204 NEXT_ARGF_FORWARD(0, 0);
14205 c = argf_getbyte(
argf);
14212#define FOREACH_ARGF() while (next_argv())
14217 const VALUE current = ARGF.current_file;
14219 if (ARGF.init_p == -1 || current != ARGF.current_file) {
14225#define ARGF_block_call(mid, argc, argv, func, argf) \
14226 rb_block_call_kw(ARGF.current_file, mid, argc, argv, \
14227 func, argf, rb_keyword_given_p())
14232 VALUE ret = ARGF_block_call(mid, argc, argv, argf_block_call_i,
argf);
14233 if (!UNDEF_P(ret)) ARGF.next_p = 1;
14239 if (!global_argf_p(
argf)) {
14240 ARGF.last_lineno = ++ARGF.lineno;
14242 return argf_block_call_i(i,
argf, argc, argv, blockarg);
14248 VALUE ret = ARGF_block_call(mid, argc, argv, argf_block_call_line_i,
argf);
14249 if (!UNDEF_P(ret)) ARGF.next_p = 1;
14297 argf_block_call_line(rb_intern(
"each_line"), argc, argv,
argf);
14328 argf_block_call(rb_intern(
"each_byte"), 0, 0,
argf);
14354 argf_block_call(rb_intern(
"each_char"), 0, 0,
argf);
14380 argf_block_call(rb_intern(
"each_codepoint"), 0, 0,
argf);
14411 return ARGF.filename;
14415argf_filename_getter(
ID id,
VALUE *var)
14417 return argf_filename(*var);
14442 return ARGF.current_file;
14461 ARGF_FORWARD(0, 0);
14482 return RBOOL(ARGF.binmode);
14502 if (ARGF.init_p && ARGF.next_p == 0) {
14531 if (ARGF.next_p != -1) {
14549 ARGF_FORWARD(0, 0);
14576 if (!ARGF.inplace)
return Qnil;
14584 return argf_inplace_mode_get(*var);
14615 ARGF.inplace =
Qnil;
14626 argf_inplace_mode_set(*var, val);
14630ruby_set_inplace_mode(
const char *suffix)
14656argf_argv_getter(
ID id,
VALUE *var)
14658 return argf_argv(*var);
14677 if (!
RTEST(ARGF.current_file)) {
14680 return GetWriteIO(ARGF.current_file);
14692 return rb_io_writev(argf_write_io(
argf), argc, argv);
14707 case RB_IO_WAIT_WRITABLE:
14710 c = rb_eEAGAINWaitWritable;
14712#if EAGAIN != EWOULDBLOCK
14714 c = rb_eEWOULDBLOCKWaitWritable;
14718 c = rb_eEINPROGRESSWaitWritable;
14724 case RB_IO_WAIT_READABLE:
14727 c = rb_eEAGAINWaitReadable;
14729#if EAGAIN != EWOULDBLOCK
14731 c = rb_eEWOULDBLOCKWaitReadable;
14735 c = rb_eEINPROGRESSWaitReadable;
14742 rb_bug(
"invalid read/write type passed to rb_readwrite_sys_fail: %d", waiting);
14748get_LAST_READ_LINE(
ID _x,
VALUE *_y)
15633#include <sys/cygwin.h>
15634 static struct __cygwin_perfile pf[] =
15636 {
"", O_RDONLY | O_BINARY},
15637 {
"", O_WRONLY | O_BINARY},
15638 {
"", O_RDWR | O_BINARY},
15639 {
"", O_APPEND | O_BINARY},
15642 cygwin_internal(CW_PERFILE, pf);
15697#if EAGAIN == EWOULDBLOCK
15698 rb_eEWOULDBLOCKWaitReadable = rb_eEAGAINWaitReadable;
15700 rb_define_const(
rb_cIO,
"EWOULDBLOCKWaitReadable", rb_eEAGAINWaitReadable);
15701 rb_eEWOULDBLOCKWaitWritable = rb_eEAGAINWaitWritable;
15703 rb_define_const(
rb_cIO,
"EWOULDBLOCKWaitWritable", rb_eEAGAINWaitWritable);
15743 rb_output_fs =
Qnil;
15751 rb_gvar_ractor_local(
"$/");
15753 rb_gvar_ractor_local(
"$-0");
15757 rb_gvar_ractor_local(
"$_");
15873 rb_gvar_ractor_local(
"$stdin");
15874 rb_gvar_ractor_local(
"$stdout");
15875 rb_gvar_ractor_local(
"$>");
15876 rb_gvar_ractor_local(
"$stderr");
15962 rb_define_method(rb_cARGF,
"external_encoding", argf_external_encoding, 0);
15963 rb_define_method(rb_cARGF,
"internal_encoding", argf_internal_encoding, 0);
15982 rb_gvar_ractor_local(
"$-i");
15986#if defined (_WIN32) || defined(__CYGWIN__)
15987 atexit(pipe_atexit);
15999 sym_encoding =
ID2SYM(rb_id_encoding());
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
std::atomic< unsigned > rb_atomic_t
Type that is eligible for atomic operations.
unsigned long ruby_strtoul(const char *str, char **endptr, int base)
Our own locale-insensitive version of strtoul(3).
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
#define rb_define_global_function(mid, func, arity)
Defines rb_mKernel #mid.
void rb_include_module(VALUE klass, VALUE module)
Includes a module to a class.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
VALUE rb_class_new(VALUE super)
Creates a new, anonymous class.
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
VALUE rb_define_module_under(VALUE outer, const char *name)
Defines a module under the namespace of outer.
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
int rb_scan_args_kw(int kw_flag, int argc, const VALUE *argv, const char *fmt,...)
Identical to rb_scan_args(), except it also accepts kw_splat.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
int rb_block_given_p(void)
Determines if the current method is given a block.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
#define ECONV_AFTER_OUTPUT
Old name of RUBY_ECONV_AFTER_OUTPUT.
#define rb_str_new2
Old name of rb_str_new_cstr.
#define TYPE(_)
Old name of rb_type.
#define RB_INTEGER_TYPE_P
Old name of rb_integer_type_p.
#define ENC_CODERANGE_7BIT
Old name of RUBY_ENC_CODERANGE_7BIT.
#define T_FILE
Old name of RUBY_T_FILE.
#define ENC_CODERANGE_VALID
Old name of RUBY_ENC_CODERANGE_VALID.
#define ECONV_UNIVERSAL_NEWLINE_DECORATOR
Old name of RUBY_ECONV_UNIVERSAL_NEWLINE_DECORATOR.
#define OBJ_INIT_COPY(obj, orig)
Old name of RB_OBJ_INIT_COPY.
#define ALLOC
Old name of RB_ALLOC.
#define RFLOAT_VALUE
Old name of rb_float_value.
#define T_STRING
Old name of RUBY_T_STRING.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define rb_str_cat2
Old name of rb_str_cat_cstr.
#define T_NIL
Old name of RUBY_T_NIL.
#define UNREACHABLE
Old name of RBIMPL_UNREACHABLE.
#define ID2SYM
Old name of RB_ID2SYM.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define FIX2UINT
Old name of RB_FIX2UINT.
#define SSIZET2NUM
Old name of RB_SSIZE2NUM.
#define ZALLOC
Old name of RB_ZALLOC.
#define CLASS_OF
Old name of rb_class_of.
#define rb_ary_new4
Old name of rb_ary_new_from_values.
#define ENCODING_MAXNAMELEN
Old name of RUBY_ENCODING_MAXNAMELEN.
#define MBCLEN_NEEDMORE_LEN(ret)
Old name of ONIGENC_MBCLEN_NEEDMORE_LEN.
#define ENCODING_GET(obj)
Old name of RB_ENCODING_GET.
#define LONG2FIX
Old name of RB_INT2FIX.
#define NUM2UINT
Old name of RB_NUM2UINT.
#define ALLOC_N
Old name of RB_ALLOC_N.
#define MBCLEN_CHARFOUND_LEN(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_LEN.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define rb_exc_new3
Old name of rb_exc_new_str.
#define STRNCASECMP
Old name of st_locale_insensitive_strncasecmp.
#define MBCLEN_INVALID_P(ret)
Old name of ONIGENC_MBCLEN_INVALID_P.
#define ISASCII
Old name of rb_isascii.
#define ECONV_STATEFUL_DECORATOR_MASK
Old name of RUBY_ECONV_STATEFUL_DECORATOR_MASK.
#define Qtrue
Old name of RUBY_Qtrue.
#define MBCLEN_NEEDMORE_P(ret)
Old name of ONIGENC_MBCLEN_NEEDMORE_P.
#define ECONV_PARTIAL_INPUT
Old name of RUBY_ECONV_PARTIAL_INPUT.
#define NUM2INT
Old name of RB_NUM2INT.
#define ECONV_ERROR_HANDLER_MASK
Old name of RUBY_ECONV_ERROR_HANDLER_MASK.
#define INT2NUM
Old name of RB_INT2NUM.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
#define ENC_CODERANGE_BROKEN
Old name of RUBY_ENC_CODERANGE_BROKEN.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define NIL_P
Old name of RB_NIL_P.
#define ALLOCV_N
Old name of RB_ALLOCV_N.
#define MBCLEN_CHARFOUND_P(ret)
Old name of ONIGENC_MBCLEN_CHARFOUND_P.
#define NUM2CHR
Old name of RB_NUM2CHR.
#define NUM2LONG
Old name of RB_NUM2LONG.
#define UINT2NUM
Old name of RB_UINT2NUM.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define ECONV_NEWLINE_DECORATOR_MASK
Old name of RUBY_ECONV_NEWLINE_DECORATOR_MASK.
#define CONST_ID
Old name of RUBY_CONST_ID.
#define rb_ary_new2
Old name of rb_ary_new_capa.
#define NUM2SIZET
Old name of RB_NUM2SIZE.
#define ENC_CODERANGE_SET(obj, cr)
Old name of RB_ENC_CODERANGE_SET.
#define rb_str_new4
Old name of rb_str_new_frozen.
#define ALLOCV_END
Old name of RB_ALLOCV_END.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
#define ECONV_DEFAULT_NEWLINE_DECORATOR
Old name of RUBY_ECONV_DEFAULT_NEWLINE_DECORATOR.
void rb_notimplement(void)
void rb_category_warn(rb_warning_category_t category, const char *fmt,...)
Identical to rb_category_warning(), except it reports unless $VERBOSE is nil.
void rb_category_warning(rb_warning_category_t category, const char *fmt,...)
Identical to rb_warning(), except it takes additional "category" parameter.
VALUE rb_eNotImpError
NotImplementedError exception.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
void rb_syserr_fail(int e, const char *mesg)
Raises appropriate exception that represents a C errno.
void rb_readwrite_syserr_fail(enum rb_io_wait_readwrite waiting, int n, const char *mesg)
Identical to rb_readwrite_sys_fail(), except it does not depend on C global variable errno.
VALUE rb_eIOError
IOError exception.
VALUE rb_eStandardError
StandardError exception.
void rb_mod_syserr_fail_str(VALUE mod, int e, VALUE mesg)
Identical to rb_mod_syserr_fail(), except it takes the message in Ruby's String instead of C's.
void rb_syserr_fail_str(int e, VALUE mesg)
Identical to rb_syserr_fail(), except it takes the message in Ruby's String instead of C's.
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eEOFError
EOFError exception.
void rb_readwrite_sys_fail(enum rb_io_wait_readwrite waiting, const char *mesg)
Raises appropriate exception using the parameters.
void rb_iter_break_value(VALUE val)
Identical to rb_iter_break(), except it additionally takes the "value" of this breakage.
rb_io_wait_readwrite
for rb_readwrite_sys_fail first argument
VALUE rb_eRuntimeError
RuntimeError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
VALUE rb_eSystemCallError
SystemCallError exception.
@ RB_WARN_CATEGORY_DEPRECATED
Warning is for deprecated features.
VALUE rb_mKernel
Kernel module.
VALUE rb_check_to_int(VALUE val)
Identical to rb_check_to_integer(), except it uses #to_int for conversion.
VALUE rb_any_to_s(VALUE obj)
Generates a textual representation of the given object.
VALUE rb_obj_alloc(VALUE klass)
Allocates an instance of the given class.
VALUE rb_class_new_instance(int argc, const VALUE *argv, VALUE klass)
Allocates, then initialises an instance of the given class.
VALUE rb_class_new_instance_kw(int argc, const VALUE *argv, VALUE klass, int kw_splat)
Identical to rb_class_new_instance(), except you can specify how to handle the last element of the gi...
VALUE rb_mEnumerable
Enumerable module.
VALUE rb_stdin
STDIN constant.
VALUE rb_stderr
STDERR constant.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_obj_dup(VALUE obj)
Duplicates the given object.
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
VALUE rb_mWaitReadable
IO::WaitReadable module.
VALUE rb_mWaitWritable
IO::WaitReadable module.
VALUE rb_obj_freeze(VALUE obj)
Just calls rb_obj_freeze_inline() inside.
VALUE rb_check_to_integer(VALUE val, const char *mid)
Identical to rb_check_convert_type(), except the return value type is fixed to rb_cInteger.
VALUE rb_cFile
File class.
VALUE rb_stdout
STDOUT constant.
VALUE rb_to_int(VALUE val)
Identical to rb_check_to_int(), except it raises in case of conversion mismatch.
static unsigned int rb_enc_codepoint(const char *p, const char *e, rb_encoding *enc)
Queries the code point of character pointed by the passed pointer.
VALUE rb_str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to)
Encoding conversion main routine.
int rb_enc_str_coderange(VALUE str)
Scans the passed string to collect its code range.
VALUE rb_enc_uint_chr(unsigned int code, rb_encoding *enc)
Encodes the passed code point into a series of bytes.
long rb_str_coderange_scan_restartable(const char *str, const char *end, rb_encoding *enc, int *cr)
Scans the passed string until it finds something odd.
int rb_econv_prepare_options(VALUE opthash, VALUE *ecopts, int ecflags)
Identical to rb_econv_prepare_opts(), except it additionally takes the initial value of flags.
VALUE rb_econv_open_exc(const char *senc, const char *denc, int ecflags)
Creates a rb_eConverterNotFoundError exception object (but does not raise).
rb_econv_result_t rb_econv_convert(rb_econv_t *ec, const unsigned char **source_buffer_ptr, const unsigned char *source_buffer_end, unsigned char **destination_buffer_ptr, unsigned char *destination_buffer_end, int flags)
Converts a string from an encoding to another.
rb_econv_result_t
return value of rb_econv_convert()
@ econv_incomplete_input
The conversion stopped in middle of reading a character, possibly due to a partial read of a socket e...
@ econv_finished
The conversion stopped after converting everything.
@ econv_undefined_conversion
The conversion stopped when it found a character in the input which cannot be representable in the ou...
@ econv_source_buffer_empty
The conversion stopped because there is no input.
@ econv_destination_buffer_full
The conversion stopped because there is no destination.
@ econv_invalid_byte_sequence
The conversion stopped when it found an invalid sequence.
int rb_econv_putbackable(rb_econv_t *ec)
Queries if rb_econv_putback() makes sense, i.e.
const char * rb_econv_asciicompat_encoding(const char *encname)
Queries the passed encoding's corresponding ASCII compatible encoding.
VALUE rb_econv_str_convert(rb_econv_t *ec, VALUE src, int flags)
Identical to rb_econv_convert(), except it takes Ruby's string instead of C's pointer.
rb_econv_t * rb_econv_open_opts(const char *source_encoding, const char *destination_encoding, int ecflags, VALUE ecopts)
Identical to rb_econv_open(), except it additionally takes a hash of optional strings.
void rb_econv_binmode(rb_econv_t *ec)
This badly named function does not set the destination encoding to binary, but instead just nullifies...
VALUE rb_str_encode(VALUE str, VALUE to, int ecflags, VALUE ecopts)
Converts the contents of the passed string from its encoding to the passed one.
VALUE rb_econv_make_exception(rb_econv_t *ec)
This function makes sense right after rb_econv_convert() returns.
void rb_econv_check_error(rb_econv_t *ec)
This is a rb_econv_make_exception() + rb_exc_raise() combo.
void rb_econv_close(rb_econv_t *ec)
Destructs a converter.
void rb_econv_putback(rb_econv_t *ec, unsigned char *p, int n)
Puts back the bytes.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
VALUE rb_funcallv_kw(VALUE recv, ID mid, int argc, const VALUE *argv, int kw_splat)
Identical to rb_funcallv(), except you can specify how to handle the last element of the given array.
Defines RBIMPL_HAS_BUILTIN.
#define RETURN_ENUMERATOR(obj, argc, argv)
Identical to RETURN_SIZED_ENUMERATOR(), except its size is unknown.
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
VALUE rb_io_printf(int argc, const VALUE *argv, VALUE io)
This is a rb_f_sprintf() + rb_io_write() combo.
VALUE rb_io_gets(VALUE io)
Reads a "line" from the given IO.
int rb_cloexec_pipe(int fildes[2])
Opens a pipe with closing on exec.
VALUE rb_io_print(int argc, const VALUE *argv, VALUE io)
Iterates over the passed array to apply rb_io_write() individually.
VALUE rb_io_addstr(VALUE io, VALUE str)
Identical to rb_io_write(), except it always returns the passed IO.
void rb_write_error(const char *str)
Writes the given error message to somewhere applicable.
VALUE rb_io_ungetbyte(VALUE io, VALUE b)
Identical to rb_io_ungetc(), except it doesn't take the encoding of the passed IO into account.
VALUE rb_io_getbyte(VALUE io)
Reads a byte from the given IO.
int rb_cloexec_dup2(int oldfd, int newfd)
Identical to rb_cloexec_dup(), except you can specify the destination file descriptor.
VALUE rb_io_fdopen(int fd, int flags, const char *path)
Creates an IO instance whose backend is the given file descriptor.
void rb_update_max_fd(int fd)
Informs the interpreter that the passed fd can be the max.
int rb_cloexec_open(const char *pathname, int flags, mode_t mode)
Opens a file that closes on exec.
VALUE rb_output_rs
The record separator character for outputs, or the $\.
VALUE rb_io_eof(VALUE io)
Queries if the passed IO is at the end of file.
void rb_write_error2(const char *str, long len)
Identical to rb_write_error(), except it additionally takes the message's length.
void rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds)
Closes everything.
int rb_reserved_fd_p(int fd)
Queries if the given FD is reserved or not.
void rb_fd_fix_cloexec(int fd)
Sets or clears the close-on-exec flag of the passed file descriptor to the desired state.
VALUE rb_io_ascii8bit_binmode(VALUE io)
Forces no conversions be applied to the passed IO.
VALUE rb_io_binmode(VALUE io)
Sets the binmode.
VALUE rb_io_ungetc(VALUE io, VALUE c)
"Unget"s a string.
int rb_pipe(int *pipes)
This is an rb_cloexec_pipe() + rb_update_max_fd() combo.
VALUE rb_gets(void)
Much like rb_io_gets(), but it reads from the mysterious ARGF object.
int rb_cloexec_fcntl_dupfd(int fd, int minfd)
Duplicates a file descriptor with closing on exec.
VALUE rb_file_open_str(VALUE fname, const char *fmode)
Identical to rb_file_open(), except it takes the pathname as a Ruby's string instead of C's.
int rb_cloexec_dup(int oldfd)
Identical to rb_cloexec_fcntl_dupfd(), except it implies minfd is 3.
VALUE rb_file_open(const char *fname, const char *fmode)
Opens a file located at the given path.
VALUE rb_io_close(VALUE io)
Closes the IO.
VALUE rb_default_rs
This is the default value of rb_rs, i.e.
void rb_lastline_set(VALUE str)
Updates $_.
VALUE rb_lastline_get(void)
Queries the last line, or the $_.
int rb_obj_method_arity(VALUE obj, ID mid)
Identical to rb_mod_method_arity(), except it searches for singleton methods rather than instance met...
rb_pid_t rb_waitpid(rb_pid_t pid, int *status, int flags)
Waits for a process, with releasing GVL.
void rb_last_status_set(int status, rb_pid_t pid)
Sets the "last status", or the $?.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
#define rb_str_buf_cat
Just another name of rb_str_cat.
#define rb_usascii_str_new(str, len)
Identical to rb_str_new, except it generates a string of "US ASCII" encoding.
size_t rb_str_capacity(VALUE str)
Queries the capacity of the given string.
VALUE rb_str_new_frozen(VALUE str)
Creates a frozen copy of the string, if necessary.
VALUE rb_str_dup(VALUE str)
Duplicates a string.
VALUE rb_str_cat(VALUE dst, const char *src, long srclen)
Destructively appends the passed contents to the string.
VALUE rb_str_locktmp(VALUE str)
Obtains a "temporary lock" of the string.
rb_gvar_setter_t rb_str_setter
This is a rb_gvar_setter_t that refutes non-string assignments.
VALUE rb_str_equal(VALUE str1, VALUE str2)
Equality of two strings.
void rb_str_set_len(VALUE str, long len)
Overwrites the length of the string.
VALUE rb_str_buf_cat_ascii(VALUE dst, const char *src)
Identical to rb_str_cat_cstr(), except it additionally assumes the source string be a NUL terminated ...
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
VALUE rb_str_substr(VALUE str, long beg, long len)
This is the implementation of two-argumented String#slice.
VALUE rb_str_unlocktmp(VALUE str)
Releases a lock formerly obtained by rb_str_locktmp().
void rb_str_modify_expand(VALUE str, long capa)
Identical to rb_str_modify(), except it additionally expands the capacity of the receiver.
VALUE rb_str_buf_new(long capa)
Allocates a "string buffer".
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
VALUE rb_obj_as_string(VALUE obj)
Try converting an object to its stringised representation using its to_s method, if any.
int rb_thread_interrupted(VALUE thval)
Checks if the thread's execution was recently interrupted.
VALUE rb_mutex_new(void)
Creates a mutex.
int rb_thread_fd_writable(int fd)
Identical to rb_thread_wait_fd(), except it blocks the current thread until the given file descriptor...
VALUE rb_exec_recursive(VALUE(*f)(VALUE g, VALUE h, int r), VALUE g, VALUE h)
"Recursion" API entry point.
void rb_thread_fd_close(int fd)
Notifies a closing of a file descriptor to other threads.
VALUE rb_mutex_synchronize(VALUE mutex, VALUE(*func)(VALUE arg), VALUE arg)
Obtains the lock, runs the passed function, and releases the lock when it completes.
void rb_thread_check_ints(void)
Checks for interrupts.
VALUE rb_thread_current(void)
Obtains the "current" thread.
int rb_thread_wait_fd(int fd)
Blocks the current thread until the given file descriptor is ready to be read.
void rb_thread_sleep(int sec)
Blocks for the given period of time.
struct timeval rb_time_interval(VALUE num)
Creates a "time interval".
void rb_set_class_path(VALUE klass, VALUE space, const char *name)
Names a class.
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
VALUE rb_class_name(VALUE obj)
Queries the name of the given object's class.
int rb_respond_to(VALUE obj, ID mid)
Queries if the object responds to the method.
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it returns RUBY_Qundef instead of raising rb_eNoMethodError.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
#define RB_ID2SYM
Just another name of rb_id2sym.
void rb_define_global_const(const char *name, VALUE val)
Identical to rb_define_const(), except it defines that of "global", i.e.
void rb_define_readonly_variable(const char *name, const VALUE *var)
Identical to rb_define_variable(), except it does not allow Ruby programs to assign values to such gl...
rb_gvar_setter_t rb_gvar_readonly_setter
This function just raises rb_eNameError.
#define FMODE_READABLE
The IO is opened for reading.
enum rb_io_mode rb_io_modestr_fmode(const char *modestr)
Maps a file mode string (that rb_file_open() takes) into a mixture of FMODE_ flags.
VALUE rb_io_get_io(VALUE io)
Identical to rb_io_check_io(), except it raises exceptions on conversion failures.
VALUE rb_io_timeout(VALUE io)
Get the timeout associated with the specified io object.
VALUE rb_io_taint_check(VALUE obj)
void rb_io_read_check(rb_io_t *fptr)
Blocks until there is a pending read in the passed IO.
int rb_io_modestr_oflags(const char *modestr)
Identical to rb_io_modestr_fmode(), except it returns a mixture of O_ flags.
#define FMODE_SETENC_BY_BOM
This flag amends the encoding of the IO so that the BOM of the contents of the IO takes effect.
rb_io_event
Type of events that an IO can wait.
@ RUBY_IO_READABLE
IO::READABLE
@ RUBY_IO_PRIORITY
IO::PRIORITY
@ RUBY_IO_WRITABLE
IO::WRITABLE
#define FMODE_READWRITE
The IO is opened for both read/write.
#define FMODE_EXTERNAL
This flag means that an IO object is wrapping an "external" file descriptor, which is owned by someth...
#define GetOpenFile
This is an old name of RB_IO_POINTER.
void rb_io_check_byte_readable(rb_io_t *fptr)
Asserts that an IO is opened for byte-based reading.
#define FMODE_TTY
The IO is a TTY.
#define FMODE_CREATE
The IO is opened for creating.
void rb_io_check_readable(rb_io_t *fptr)
Just another name of rb_io_check_byte_readable.
int rb_wait_for_single_fd(int fd, int events, struct timeval *tv)
Blocks until the passed file descriptor is ready for the passed events.
FILE * rb_fdopen(int fd, const char *modestr)
Identical to rb_io_stdio_file(), except it takes file descriptors instead of Ruby's IO.
int rb_io_extract_encoding_option(VALUE opt, rb_encoding **enc_p, rb_encoding **enc2_p, enum rb_io_mode *fmode_p)
This function breaks down the option hash that IO#initialize takes into components.
int rb_io_descriptor(VALUE io)
Returns an integer representing the numeric file descriptor for io.
#define FMODE_WRITABLE
The IO is opened for writing.
FILE * rb_io_stdio_file(rb_io_t *fptr)
Finds or creates a stdio's file structure from a Ruby's one.
#define FMODE_APPEND
The IO is opened for appending.
#define MakeOpenFile
This is an old name of RB_IO_OPEN.
#define FMODE_DUPLEX
Ruby eventually detects that the IO is bidirectional.
#define FMODE_BINMODE
The IO is in "binary mode".
int rb_io_maybe_wait_readable(int error, VALUE io, VALUE timeout)
Blocks until the passed IO is ready for reading, if that makes sense for the passed errno.
int capa
Designed capacity of the buffer.
#define RB_IO_POINTER(obj, fp)
Queries the underlying IO pointer.
VALUE rb_io_maybe_wait(int error, VALUE io, VALUE events, VALUE timeout)
Identical to rb_io_wait() except it additionally takes previous errno.
VALUE rb_eIOTimeoutError
Indicates that a timeout has occurred while performing an IO operation.
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
#define FMODE_SYNC
The IO is in "sync mode".
int off
Offset inside of ptr.
VALUE rb_io_path(VALUE io)
Returns the path for the given IO.
void rb_io_extract_modeenc(VALUE *vmode_p, VALUE *vperm_p, VALUE opthash, int *oflags_p, enum rb_io_mode *fmode_p, rb_io_enc_t *convconfig_p)
This function can be seen as an extended version of rb_io_extract_encoding_option() that not only con...
void rb_io_check_initialized(rb_io_t *fptr)
Asserts that the passed IO is initialised.
#define FMODE_EXCL
This flag amends the effect of FMODE_CREATE, so that if there already is a file at the given path the...
#define FMODE_TEXTMODE
The IO is in "text mode".
int rb_io_fptr_finalize(rb_io_t *fptr)
Destroys the given IO.
VALUE rb_io_check_io(VALUE io)
Try converting an object to its IO representation using its to_io method, if any.
VALUE rb_io_closed_p(VALUE io)
Returns whether or not the underlying IO is closed.
VALUE rb_io_set_timeout(VALUE io, VALUE timeout)
Set the timeout associated with the specified io object.
ssize_t rb_io_bufwrite(VALUE io, const void *buf, size_t size)
Buffered write to the passed IO.
void rb_io_check_char_readable(rb_io_t *fptr)
Asserts that an IO is opened for character-based reading.
#define FMODE_TRUNC
This flag amends the effect of FMODE_CREATE, so that if there already is a file at the given path it ...
VALUE rb_io_get_write_io(VALUE io)
Queries the tied IO for writing.
void rb_io_set_nonblock(rb_io_t *fptr)
Instructs the OS to put its internal file structure into "nonblocking mode".
int rb_io_wait_writable(int fd)
Blocks until the passed file descriptor gets writable.
VALUE rb_io_open_descriptor(VALUE klass, int descriptor, int mode, VALUE path, VALUE timeout, struct rb_io_encoding *encoding)
Allocate a new IO object, with the given file descriptor.
VALUE rb_io_set_write_io(VALUE io, VALUE w)
Assigns the tied IO for writing.
void rb_io_check_writable(rb_io_t *fptr)
Asserts that an IO is opened for writing.
int rb_io_maybe_wait_writable(int error, VALUE io, VALUE timeout)
Blocks until the passed IO is ready for writing, if that makes sense for the passed errno.
void rb_io_check_closed(rb_io_t *fptr)
This badly named function asserts that the passed IO is open.
int rb_io_wait_readable(int fd)
Blocks until the passed file descriptor gets readable.
void rb_io_synchronized(rb_io_t *fptr)
Sets FMODE_SYNC.
VALUE rb_io_wait(VALUE io, VALUE events, VALUE timeout)
Blocks until the passed IO is ready for the passed events.
int len
Length of the buffer.
VALUE rb_ractor_stdin(void)
Queries the standard input of the current Ractor that is calling this function.
void rb_ractor_stderr_set(VALUE io)
Assigns an IO to the standard error of the Ractor that is calling this function.
void rb_ractor_stdout_set(VALUE io)
Assigns an IO to the standard output of the Ractor that is calling this function.
void rb_ractor_stdin_set(VALUE io)
Assigns an IO to the standard input of the Ractor that is calling this function.
void * rb_thread_call_with_gvl(void *(*func)(void *), void *data1)
(Re-)acquires the GVL.
#define RB_NUM2INT
Just another name of rb_num2int_inline.
#define RB_INT2NUM
Just another name of rb_int2num_inline.
VALUE rb_f_sprintf(int argc, const VALUE *argv)
Identical to rb_str_format(), except how the arguments are arranged.
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
Shim for block function parameters.
VALUE rb_yield_values2(int n, const VALUE *argv)
Identical to rb_yield_values(), except it takes the parameters as a C array instead of variadic argum...
VALUE rb_yield(VALUE val)
Yields the block.
void rb_fd_term(rb_fdset_t *f)
Destroys the rb_fdset_t, releasing any memory and resources it used.
#define MEMZERO(p, type, n)
Handy macro to erase a region of memory.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
#define MEMMOVE(p1, p2, type, n)
Handy macro to call memmove.
#define NUM2MODET
Converts a C's mode_t into an instance of rb_cInteger.
void rb_define_hooked_variable(const char *q, VALUE *w, type *e, void_type *r)
Define a function-backended global variable.
void rb_define_virtual_variable(const char *q, type *w, void_type *e)
Define a function-backended global variable.
VALUE rb_rescue2(type *q, VALUE w, type *e, VALUE r,...)
An equivalent of rescue clause.
VALUE rb_ensure(type *q, VALUE w, type *e, VALUE r)
An equivalent of ensure clause.
#define PRI_OFFT_PREFIX
A rb_sprintf() format prefix to be used for an off_t parameter.
#define OFFT2NUM
Converts a C's off_t into an instance of rb_cInteger.
#define NUM2OFFT
Converts an instance of rb_cNumeric into C's off_t.
#define PIDT2NUM
Converts a C's pid_t into an instance of rb_cInteger.
#define rb_fd_isset
Queries if the given fd is in the rb_fdset_t.
#define rb_fd_select
Waits for multiple file descriptors at once.
#define rb_fd_init
Initialises the :given :rb_fdset_t.
#define rb_fd_set
Sets the given fd to the rb_fdset_t.
#define RARRAY_LEN
Just another name of rb_array_len.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
#define RARRAY_AREF(a, i)
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
#define RFILE(obj)
Convenient casting macro.
#define StringValue(v)
Ensures that the parameter object is a String.
static char * RSTRING_END(VALUE str)
Queries the end of the contents pointer of the string.
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Convenient macro to obtain the contents and length at once.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
#define RUBY_TYPED_DEFAULT_FREE
This is a value you can set to rb_data_type_struct::dfree.
#define TypedData_Make_Struct(klass, type, data_type, sval)
Identical to TypedData_Wrap_Struct, except it allocates a new data region internally instead of takin...
VALUE rb_get_argv(void)
Queries the arguments passed to the current process that you can access from Ruby as ARGV.
void rb_p(VALUE obj)
Inspects an object.
#define FilePathValue(v)
Ensures that the parameter object is a path.
#define errno
Ractor-aware version of errno.
#define RB_SCAN_ARGS_LAST_HASH_KEYWORDS
Treat a final argument as keywords if it is a hash, and not as keywords otherwise.
#define RB_PASS_CALLED_KEYWORDS
Pass keywords if current method is called with keywords, useful for argument delegation.
VALUE rb_fiber_scheduler_current(void)
Identical to rb_fiber_scheduler_get(), except it also returns RUBY_Qnil in case of a blocking fiber.
VALUE rb_fiber_scheduler_io_pread_memory(VALUE scheduler, VALUE io, rb_off_t from, void *base, size_t size, size_t length)
Non-blocking pread from the passed IO using a native buffer.
VALUE rb_fiber_scheduler_make_timeout(struct timeval *timeout)
Converts the passed timeout to an expression that rb_fiber_scheduler_block() etc.
VALUE rb_fiber_scheduler_io_wait_readable(VALUE scheduler, VALUE io)
Non-blocking wait until the passed IO is ready for reading.
VALUE rb_fiber_scheduler_io_read_memory(VALUE scheduler, VALUE io, void *base, size_t size, size_t length)
Non-blocking read from the passed IO using a native buffer.
VALUE rb_fiber_scheduler_io_wait(VALUE scheduler, VALUE io, VALUE events, VALUE timeout)
Non-blocking version of rb_io_wait().
static ssize_t rb_fiber_scheduler_io_result_apply(VALUE result)
Apply an io result to the local thread, returning the value of the original system call that created ...
VALUE rb_fiber_scheduler_io_selectv(VALUE scheduler, int argc, VALUE *argv)
Non-blocking version of IO.select, argv variant.
VALUE rb_fiber_scheduler_io_pwrite_memory(VALUE scheduler, VALUE io, rb_off_t from, const void *base, size_t size, size_t length)
Non-blocking pwrite to the passed IO using a native buffer.
VALUE rb_fiber_scheduler_current_for_thread(VALUE thread)
Identical to rb_fiber_scheduler_current(), except it queries for that of the passed thread instead of...
VALUE rb_fiber_scheduler_io_write_memory(VALUE scheduler, VALUE io, const void *base, size_t size, size_t length)
Non-blocking write to the passed IO using a native buffer.
VALUE rb_fiber_scheduler_io_wait_writable(VALUE scheduler, VALUE io)
Non-blocking wait until the passed IO is ready for writing.
int rb_thread_fd_select(int nfds, rb_fdset_t *rfds, rb_fdset_t *wfds, rb_fdset_t *efds, struct timeval *timeout)
Waits for multiple file descriptors at once.
static bool RB_TEST(VALUE obj)
Emulates Ruby's "if" statement.
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
This is the struct that holds necessary info for a struct.
The data structure which wraps the fd_set bitmap used by select(2).
Decomposed encoding flags (e.g.
VALUE ecopts
Flags as Ruby hash.
rb_encoding * enc2
External encoding.
rb_encoding * enc
Internal encoding.
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
int off
Offset inside of ptr.
int len
Length of the buffer.
int capa
Designed capacity of the buffer.
Ruby's IO, metadata and buffers.
rb_io_buffer_t wbuf
Write buffer.
enum rb_io_mode mode
mode flags: FMODE_XXXs
void(* finalize)(struct rb_io *, int)
finalize proc
rb_econv_t * readconv
Encoding converter used when reading from this IO.
rb_econv_t * writeconv
Encoding converter used when writing to this IO.
struct rb_io_encoding encs
Decomposed encoding flags.
VALUE self
The IO's Ruby level counterpart.
VALUE write_lock
This is a Ruby level mutex.
VALUE timeout
The timeout associated with this IO when performing blocking operations.
FILE * stdio_file
stdio ptr for read/write, if available.
VALUE writeconv_pre_ecopts
Value of ::rb_io_t::rb_io_enc_t::ecopts stored right before initialising rb_io_t::writeconv.
VALUE tied_io_for_writing
Duplex IO object, if set.
int writeconv_initialized
Whether rb_io_t::writeconv is already set up.
rb_io_buffer_t rbuf
(Byte) read buffer.
int lineno
number of lines read
VALUE writeconv_asciicompat
This is, when set, an instance of rb_cString which holds the "common" encoding.
rb_io_buffer_t cbuf
rb_io_ungetc() destination.
rb_pid_t pid
child's pid (for pipes)
int writeconv_pre_ecflags
Value of ::rb_io_t::rb_io_enc_t::ecflags stored right before initialising rb_io_t::writeconv.
VALUE pathv
pathname for file
intptr_t SIGNED_VALUE
A signed integer type that has the same width with VALUE.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static bool RB_FLOAT_TYPE_P(VALUE obj)
Queries if the object is an instance of rb_cFloat.
static bool RB_SYMBOL_P(VALUE obj)
Queries if the object is an instance of rb_cSymbol.
static void Check_Type(VALUE v, enum ruby_value_type t)
Identical to RB_TYPE_P(), except it raises exceptions on predication failure.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.