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 <AvailabilityMacros.h>
124#include "ccan/list/list.h"
129#include "internal/class.h"
130#include "internal/encoding.h"
131#include "internal/error.h"
132#include "internal/inits.h"
133#include "internal/io.h"
134#include "internal/numeric.h"
135#include "internal/object.h"
136#include "internal/process.h"
137#include "internal/string.h"
138#include "internal/thread.h"
139#include "internal/transcode.h"
140#include "internal/variable.h"
143#include "ruby/missing.h"
146#include "ruby_atomic.h"
156#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
160# ifdef _POSIX_PIPE_BUF
161# define PIPE_BUF _POSIX_PIPE_BUF
168# define EWOULDBLOCK EAGAIN
171#if defined(HAVE___SYSCALL) && (defined(__APPLE__) || defined(__OpenBSD__))
173off_t __syscall(quad_t number, ...);
176#define IO_RBUF_CAPA_MIN 8192
177#define IO_CBUF_CAPA_MIN (128*1024)
178#define IO_RBUF_CAPA_FOR(fptr) (NEED_READCONV(fptr) ? IO_CBUF_CAPA_MIN : IO_RBUF_CAPA_MIN)
179#define IO_WBUF_CAPA_MIN 8192
181#define IO_MAX_BUFFER_GROWTH 8 * 1024 * 1024
186#define open rb_w32_uopen
188#define rename(f, t) rb_w32_urename((f), (t))
189#include "win32/file.h"
199static VALUE rb_eEAGAINWaitReadable;
200static VALUE rb_eEAGAINWaitWritable;
201static VALUE rb_eEWOULDBLOCKWaitReadable;
202static VALUE rb_eEWOULDBLOCKWaitWritable;
203static VALUE rb_eEINPROGRESSWaitWritable;
204static VALUE rb_eEINPROGRESSWaitReadable;
207static VALUE orig_stdout, orig_stderr;
216static ID id_write, id_read, id_getc, id_flush, id_readpartial, id_set_encoding, id_fileno;
217static VALUE sym_mode, sym_perm, sym_flags, sym_extenc, sym_intenc, sym_encoding, sym_open_args;
218static VALUE sym_textmode, sym_binmode, sym_autoclose;
219static VALUE sym_SET, sym_CUR, sym_END;
220static VALUE sym_wait_readable, sym_wait_writable;
222static VALUE sym_DATA;
225static VALUE sym_HOLE;
228static VALUE prep_io(
int fd,
enum rb_io_mode fmode,
VALUE klass,
const char *path);
231rb_io_blocking_region_wait(
struct rb_io *io, rb_blocking_function_t *function,
void *argument,
enum rb_io_event events)
233 return rb_thread_io_blocking_call(io, function, argument, events);
236VALUE rb_io_blocking_region(
struct rb_io *io, rb_blocking_function_t *function,
void *argument)
238 return rb_io_blocking_region_wait(io, function, argument, 0);
242 VALUE filename, current_file;
248 int8_t init_p, next_p, binmode;
252#if defined(__APPLE__) && \
253 (!defined(MAC_OS_VERSION_27_0) || (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_VERSION_27_0))
255# if __has_attribute(availability) && __has_warning("-Wunguarded-availability-new")
261static inline int (*rb_dup3(
void))(int, int, int) {
return &dup3;}
262# define dup3 rb_dup3()
266static inline int (*rb_pipe2(
void))(
int [2], int) {
return &pipe2;}
267# define pipe2 rb_pipe2()
292 if (fd < 0 || afd <= max_fd)
295#if defined(HAVE_FCNTL) && defined(F_GETFL)
296 err = fcntl(fd, F_GETFL) == -1;
300 err = fstat(fd, &buf) != 0;
303 if (err &&
errno == EBADF) {
304 rb_bug(
"rb_update_max_fd: invalid fd (%d) given.", fd);
307 while (max_fd < afd) {
308 max_fd = ATOMIC_CAS(max_file_descriptor, max_fd, afd);
313rb_maygvl_fd_fix_cloexec(
int fd)
316#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
317 int flags, flags2, ret;
318 flags = fcntl(fd, F_GETFD);
320 rb_bug(
"rb_maygvl_fd_fix_cloexec: fcntl(%d, F_GETFD) failed: %s", fd, strerror(
errno));
323 flags2 = flags & ~FD_CLOEXEC;
325 flags2 = flags | FD_CLOEXEC;
326 if (flags != flags2) {
327 ret = fcntl(fd, F_SETFD, flags2);
329 rb_bug(
"rb_maygvl_fd_fix_cloexec: fcntl(%d, F_SETFD, %d) failed: %s", fd, flags2, strerror(
errno));
338 rb_maygvl_fd_fix_cloexec(fd);
344rb_fix_detect_o_cloexec(
int fd)
346#if defined(O_CLOEXEC) && defined(F_GETFD)
347 int flags = fcntl(fd, F_GETFD);
350 rb_bug(
"rb_fix_detect_o_cloexec: fcntl(%d, F_GETFD) failed: %s", fd, strerror(
errno));
352 if (flags & FD_CLOEXEC)
355 rb_maygvl_fd_fix_cloexec(fd);
362 return (e == EWOULDBLOCK) || (e == EAGAIN);
369 static int o_cloexec_state = -1;
371 static const int retry_interval = 0;
372 static const int retry_max_count = 10000;
379#elif defined O_NOINHERIT
380 flags |= O_NOINHERIT;
383 while ((ret = open(pathname, flags, mode)) == -1) {
385 if (!io_again_p(e))
break;
386 if (retry_count++ >= retry_max_count)
break;
388 sleep(retry_interval);
391 if (ret < 0)
return ret;
392 if (ret <= 2 || o_cloexec_state == 0) {
393 rb_maygvl_fd_fix_cloexec(ret);
395 else if (o_cloexec_state > 0) {
399 o_cloexec_state = rb_fix_detect_o_cloexec(ret);
418 if (oldfd == newfd) {
422#if defined(HAVE_DUP3) && defined(O_CLOEXEC)
423# if defined(__APPLE__)
424# define try_dup3 (dup3 != NULL)
425# define abandon_dup3() true
427 static bool try_dup3 =
true;
428# define abandon_dup3() (errno != ENOSYS || !!(try_dup3 = false))
434 ret = dup3(oldfd, newfd, O_CLOEXEC);
441 if (abandon_dup3())
return ret;
444 ret = dup2(oldfd, newfd);
445 if (ret < 0)
return ret;
447 rb_maygvl_fd_fix_cloexec(ret);
452rb_fd_set_nonblock(
int fd)
455 return rb_w32_set_nonblock(fd);
456#elif defined(F_GETFL)
457 int oflags = fcntl(fd, F_GETFL);
461 if (oflags & O_NONBLOCK)
463 oflags |= O_NONBLOCK;
464 return fcntl(fd, F_SETFL, oflags);
470cloexec_pipe(
int descriptors[2],
int flags,
bool force_cloexec)
474# if defined(__APPLE__)
475# define try_pipe2 (pipe2 != NULL)
476# define abandon_pipe2() true
478 static bool try_pipe2 =
true;
479# define abandon_pipe2() (errno != ENOSYS || !!(try_pipe2 = false))
482 result = pipe2(descriptors, O_CLOEXEC | flags);
483 if (result == 0)
return result;
484 if (abandon_pipe2())
return result;
487 if (result < 0 && (result = pipe(descriptors)) < 0)
491 if (result == 0 && descriptors[1] == -1) {
492 close(descriptors[0]);
499 if (!force_cloexec)
return result;
502 rb_maygvl_fd_fix_cloexec(descriptors[0]);
503 rb_maygvl_fd_fix_cloexec(descriptors[1]);
506 rb_fd_set_nonblock(descriptors[0]);
507 rb_fd_set_nonblock(descriptors[1]);
516 return cloexec_pipe(descriptors, O_NONBLOCK,
true);
524#if defined(HAVE_FCNTL) && defined(F_DUPFD_CLOEXEC) && defined(F_DUPFD)
525 static int try_dupfd_cloexec = 1;
526 if (try_dupfd_cloexec) {
527 ret = fcntl(fd, F_DUPFD_CLOEXEC, minfd);
530 rb_maygvl_fd_fix_cloexec(ret);
534 if (
errno == EINVAL) {
535 ret = fcntl(fd, F_DUPFD, minfd);
537 try_dupfd_cloexec = 0;
542 ret = fcntl(fd, F_DUPFD, minfd);
544#elif defined(HAVE_FCNTL) && defined(F_DUPFD)
545 ret = fcntl(fd, F_DUPFD, minfd);
548 if (ret >= 0 && ret < minfd) {
549 const int prev_fd = ret;
555 if (ret < 0)
return ret;
556 rb_maygvl_fd_fix_cloexec(ret);
560#define argf_of(obj) (*(struct argf *)DATA_PTR(obj))
561#define ARGF argf_of(argf)
563#define GetWriteIO(io) rb_io_get_write_io(io)
565#define READ_DATA_PENDING(fptr) ((fptr)->rbuf.len)
566#define READ_DATA_PENDING_COUNT(fptr) ((fptr)->rbuf.len)
567#define READ_DATA_PENDING_PTR(fptr) ((fptr)->rbuf.ptr+(fptr)->rbuf.off)
568#define READ_DATA_BUFFERED(fptr) READ_DATA_PENDING(fptr)
570#define READ_CHAR_PENDING(fptr) ((fptr)->cbuf.len)
571#define READ_CHAR_PENDING_COUNT(fptr) ((fptr)->cbuf.len)
572#define READ_CHAR_PENDING_PTR(fptr) ((fptr)->cbuf.ptr+(fptr)->cbuf.off)
575#define WAIT_FD_IN_WIN32(fptr) \
576 (rb_w32_io_cancelable_p((fptr)->fd) ? Qnil : rb_io_wait(fptr->self, RB_INT2NUM(RUBY_IO_READABLE), RUBY_IO_TIMEOUT_DEFAULT))
578#define WAIT_FD_IN_WIN32(fptr)
581#define READ_CHECK(fptr) do {\
582 if (!READ_DATA_PENDING(fptr)) {\
583 WAIT_FD_IN_WIN32(fptr);\
584 rb_io_check_closed(fptr);\
590# define S_ISSOCK(m) _S_ISSOCK(m)
593# define S_ISSOCK(m) (((m) & S_IFMT) == _S_IFSOCK)
596# define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
602static int io_fflush(rb_io_t *);
603static rb_io_t *flush_before_seek(rb_io_t *fptr,
bool discard_rbuf);
604static void clear_codeconv(rb_io_t *fptr);
606#define FMODE_SIGNAL_ON_EPIPE (1<<17)
608#define fptr_signal_on_epipe(fptr) \
609 (((fptr)->mode & FMODE_SIGNAL_ON_EPIPE) != 0)
611#define fptr_set_signal_on_epipe(fptr, flag) \
613 (fptr)->mode |= FMODE_SIGNAL_ON_EPIPE : \
614 (fptr)->mode &= ~FMODE_SIGNAL_ON_EPIPE)
616extern ID ruby_static_id_signo;
618NORETURN(
static void rb_sys_fail_on_write(rb_io_t *fptr));
620rb_sys_fail_on_write(rb_io_t *fptr)
623 VALUE errinfo = rb_syserr_new_path(e, (fptr)->pathv);
625 if (fptr_signal_on_epipe(fptr) && (e == EPIPE)) {
637#define NEED_NEWLINE_DECORATOR_ON_READ(fptr) ((fptr)->mode & FMODE_TEXTMODE)
638#define NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) ((fptr)->mode & FMODE_TEXTMODE)
639#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
640# define RUBY_CRLF_ENVIRONMENT 1
642# define RUBY_CRLF_ENVIRONMENT 0
645#if RUBY_CRLF_ENVIRONMENT
647# define DEFAULT_TEXTMODE FMODE_TEXTMODE
648# define TEXTMODE_NEWLINE_DECORATOR_ON_WRITE ECONV_CRLF_NEWLINE_DECORATOR
656#define NEED_READCONV(fptr) ((fptr)->encs.enc2 != NULL || (fptr)->encs.ecflags & ~ECONV_CRLF_NEWLINE_DECORATOR)
657#define WRITECONV_MASK ( \
658 (ECONV_DECORATOR_MASK & ~ECONV_CRLF_NEWLINE_DECORATOR)|\
659 ECONV_STATEFUL_DECORATOR_MASK|\
661#define NEED_WRITECONV(fptr) ( \
662 ((fptr)->encs.enc != NULL && (fptr)->encs.enc != rb_ascii8bit_encoding()) || \
663 ((fptr)->encs.ecflags & WRITECONV_MASK) || \
665#define SET_BINARY_MODE(fptr) setmode((fptr)->fd, O_BINARY)
667#define NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr) do {\
668 if (NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {\
669 if (((fptr)->mode & FMODE_READABLE) &&\
670 !((fptr)->encs.ecflags & ECONV_NEWLINE_DECORATOR_MASK)) {\
671 setmode((fptr)->fd, O_BINARY);\
674 setmode((fptr)->fd, O_TEXT);\
679#define SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags) do {\
680 if ((enc2) && ((ecflags) & ECONV_DEFAULT_NEWLINE_DECORATOR)) {\
681 (ecflags) |= ECONV_UNIVERSAL_NEWLINE_DECORATOR;\
689io_unread(rb_io_t *fptr,
bool discard_rbuf)
705 if (!rb_w32_fd_is_text(fptr->
fd)) {
706 r = lseek(fptr->
fd, -fptr->
rbuf.
len, SEEK_CUR);
707 if (r < 0 &&
errno) {
710 if (!discard_rbuf)
return;
716 pos = lseek(fptr->
fd, 0, SEEK_CUR);
717 if (pos < 0 &&
errno) {
720 if (!discard_rbuf)
goto end;
724 extra_max = (long)(pos - fptr->
rbuf.
len);
732 for (i = 0; i < fptr->
rbuf.
len; i++) {
733 if (*p ==
'\n') newlines++;
734 if (extra_max == newlines)
break;
739 while (newlines >= 0) {
740 r = lseek(fptr->
fd, pos - fptr->
rbuf.
len - newlines, SEEK_SET);
741 if (newlines == 0)
break;
746 read_size = _read(fptr->
fd, buf, fptr->
rbuf.
len + newlines);
750 rb_syserr_fail_path(e, fptr->
pathv);
752 if (read_size == fptr->
rbuf.
len) {
753 lseek(fptr->
fd, r, SEEK_SET);
764 clear_codeconv(fptr);
776set_binary_mode_with_seek_cur(rb_io_t *fptr)
778 if (!rb_w32_fd_is_text(fptr->
fd))
return O_BINARY;
781 return setmode(fptr->
fd, O_BINARY);
783 flush_before_seek(fptr,
false);
784 return setmode(fptr->
fd, O_BINARY);
786#define SET_BINARY_MODE_WITH_SEEK_CUR(fptr) set_binary_mode_with_seek_cur(fptr)
790# define DEFAULT_TEXTMODE 0
791#define NEED_READCONV(fptr) ((fptr)->encs.enc2 != NULL || NEED_NEWLINE_DECORATOR_ON_READ(fptr))
792#define NEED_WRITECONV(fptr) ( \
793 ((fptr)->encs.enc != NULL && (fptr)->encs.enc != rb_ascii8bit_encoding()) || \
794 NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) || \
795 ((fptr)->encs.ecflags & (ECONV_DECORATOR_MASK|ECONV_STATEFUL_DECORATOR_MASK)) || \
797#define SET_BINARY_MODE(fptr) (void)(fptr)
798#define NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr) (void)(fptr)
799#define SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags) ((void)(enc2), (void)(ecflags))
800#define SET_BINARY_MODE_WITH_SEEK_CUR(fptr) (void)(fptr)
803#if !defined HAVE_SHUTDOWN && !defined shutdown
804#define shutdown(a,b) 0
808#define is_socket(fd, path) rb_w32_is_socket(fd)
809#elif !defined(S_ISSOCK)
810#define is_socket(fd, path) 0
813is_socket(
int fd,
VALUE path)
816 if (fstat(fd, &sbuf) < 0)
817 rb_sys_fail_path(path);
818 return S_ISSOCK(sbuf.st_mode);
822static const char closed_stream[] =
"closed stream";
825io_fd_check_closed(
int fd)
858 io_fd_check_closed(fptr->
fd);
862rb_io_get_fptr(
VALUE io)
864 rb_io_t *fptr =
RFILE(io)->fptr;
872 return rb_convert_type_with_id(io,
T_FILE,
"IO", idTo_io);
878 return rb_check_convert_type_with_id(io,
T_FILE,
"IO", idTo_io);
885 write_io = rb_io_get_fptr(io)->tied_io_for_writing;
896 rb_io_t *fptr = rb_io_get_fptr(io);
905 return write_io ? write_io :
Qnil;
918 rb_io_t *fptr = rb_io_get_fptr(self);
948 if (
RTEST(timeout)) {
952 rb_io_t *fptr = rb_io_get_fptr(self);
977#if !RUBY_CRLF_ENVIRONMENT
979io_unread(rb_io_t *fptr,
bool discard_rbuf)
987 r = lseek(fptr->
fd, -fptr->
rbuf.
len, SEEK_CUR);
988 if (r < 0 &&
errno) {
991 if (!discard_rbuf)
return;
995 clear_codeconv(fptr);
1000static rb_encoding *io_input_encoding(rb_io_t *fptr);
1003io_ungetbyte(
VALUE str, rb_io_t *fptr)
1005 long len = RSTRING_LEN(str);
1008 const int min_capa = IO_RBUF_CAPA_FOR(fptr);
1011#if SIZEOF_LONG > SIZEOF_INT
1036flush_before_seek(rb_io_t *fptr,
bool discard_rbuf)
1038 if (io_fflush(fptr) < 0)
1039 rb_sys_fail_on_write(fptr);
1040 io_unread(fptr, discard_rbuf);
1045#define io_seek(fptr, ofs, whence) (errno = 0, lseek(flush_before_seek(fptr, true)->fd, (ofs), (whence)))
1046#define io_tell(fptr) lseek(flush_before_seek(fptr, false)->fd, 0, SEEK_CUR)
1062 if (io_fflush(fptr) < 0)
1063 rb_sys_fail_on_write(fptr);
1068 if (io_fflush(wfptr) < 0)
1069 rb_sys_fail_on_write(wfptr);
1077 if (READ_CHAR_PENDING(fptr)) {
1078 rb_raise(
rb_eIOError,
"byte oriented read for character buffered IO");
1089io_read_encoding(rb_io_t *fptr)
1094 return rb_default_external_encoding();
1098io_input_encoding(rb_io_t *fptr)
1103 return io_read_encoding(fptr);
1114 io_unread(fptr,
true);
1122 if (READ_CHAR_PENDING(fptr))
1124 return READ_DATA_PENDING(fptr);
1130 if (!READ_DATA_PENDING(fptr)) {
1137rb_gc_for_fd(
int err)
1139 if (err == EMFILE || err == ENFILE || err == ENOMEM) {
1149#define TRY_WITH_GC(expr) \
1150 for (int first_errno, retried_errno = 0, retried = 0; \
1153 (!rb_gc_for_fd(first_errno = errno) || !(expr)) && \
1154 (retried_errno = errno, 1)); \
1155 (void)retried_errno, retried = 1)
1170io_alloc(
VALUE klass)
1180# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
1206struct io_internal_writev_struct {
1213 const struct iovec *iov;
1218static int nogvl_wait_for(
VALUE th, rb_io_t *fptr,
short events,
struct timeval *timeout);
1226io_internal_wait(
VALUE thread, rb_io_t *fptr,
int error,
int events,
struct timeval *timeout)
1228 if (!timeout && rb_thread_mn_schedulable(thread)) {
1233 int ready = nogvl_wait_for(thread, fptr, events, timeout);
1238 else if (ready == 0) {
1255internal_read_func(
void *
ptr)
1260 if (iis->timeout && !iis->nonblock) {
1261 if (io_internal_wait(iis->th, iis->fptr, 0, RB_WAITFD_IN, iis->timeout) == -1) {
1267 result = read(iis->fd, iis->buf, iis->capa);
1269 if (result < 0 && !iis->nonblock) {
1270 if (io_again_p(
errno)) {
1271 if (io_internal_wait(iis->th, iis->fptr,
errno, RB_WAITFD_IN, iis->timeout) == -1) {
1283#if defined __APPLE__
1284# define do_write_retry(code) do {result = code;} while (result == -1 && errno == EPROTOTYPE)
1286# define do_write_retry(code) result = code
1290internal_write_func(
void *
ptr)
1295 if (iis->timeout && !iis->nonblock) {
1296 if (io_internal_wait(iis->th, iis->fptr, 0, RB_WAITFD_OUT, iis->timeout) == -1) {
1302 do_write_retry(write(iis->fd, iis->buf, iis->capa));
1304 if (result < 0 && !iis->nonblock) {
1306 if (io_again_p(e)) {
1307 if (io_internal_wait(iis->th, iis->fptr,
errno, RB_WAITFD_OUT, iis->timeout) == -1) {
1321internal_writev_func(
void *
ptr)
1323 struct io_internal_writev_struct *iis =
ptr;
1326 if (iis->timeout && !iis->nonblock) {
1327 if (io_internal_wait(iis->th, iis->fptr, 0, RB_WAITFD_OUT, iis->timeout) == -1) {
1333 do_write_retry(writev(iis->fd, iis->iov, iis->iovcnt));
1335 if (result < 0 && !iis->nonblock) {
1336 if (io_again_p(
errno)) {
1337 if (io_internal_wait(iis->th, iis->fptr,
errno, RB_WAITFD_OUT, iis->timeout) == -1) {
1351rb_io_read_memory(rb_io_t *fptr,
void *buf,
size_t count)
1353 rb_thread_t *th = GET_THREAD();
1355 if (scheduler !=
Qnil) {
1358 if (!UNDEF_P(result)) {
1359 return rb_fiber_scheduler_io_result_apply(result);
1374 struct timeval timeout_storage;
1378 iis.timeout = &timeout_storage;
1381 return (ssize_t)rb_io_blocking_region_wait(fptr, internal_read_func, &iis,
RUBY_IO_READABLE);
1385rb_io_write_memory(rb_io_t *fptr,
const void *buf,
size_t count)
1387 rb_thread_t *th = GET_THREAD();
1389 if (scheduler !=
Qnil) {
1392 if (!UNDEF_P(result)) {
1393 return rb_fiber_scheduler_io_result_apply(result);
1408 struct timeval timeout_storage;
1412 iis.timeout = &timeout_storage;
1415 return (ssize_t)rb_io_blocking_region_wait(fptr, internal_write_func, &iis,
RUBY_IO_WRITABLE);
1420rb_writev_internal(rb_io_t *fptr,
const struct iovec *iov,
int iovcnt)
1422 if (!iovcnt)
return 0;
1424 rb_thread_t *th = GET_THREAD();
1427 if (scheduler !=
Qnil) {
1431 if (!UNDEF_P(result)) {
1432 return rb_fiber_scheduler_io_result_apply(result);
1436 struct io_internal_writev_struct iis = {
1447 struct timeval timeout_storage;
1451 iis.timeout = &timeout_storage;
1454 return (ssize_t)rb_io_blocking_region_wait(fptr, internal_writev_func, &iis,
RUBY_IO_WRITABLE);
1459io_flush_buffer_sync(
void *arg)
1461 rb_io_t *fptr = arg;
1481io_flush_buffer_fiber_scheduler(
VALUE scheduler, rb_io_t *fptr)
1484 if (!UNDEF_P(ret)) {
1485 ssize_t result = rb_fiber_scheduler_io_result_apply(ret);
1496io_flush_buffer_async(
VALUE arg)
1498 rb_io_t *fptr = (rb_io_t *)arg;
1501 if (scheduler !=
Qnil) {
1502 VALUE result = io_flush_buffer_fiber_scheduler(scheduler, fptr);
1503 if (!UNDEF_P(result)) {
1508 return rb_io_blocking_region_wait(fptr, io_flush_buffer_sync, fptr,
RUBY_IO_WRITABLE);
1512io_flush_buffer(rb_io_t *fptr)
1515 return (
int)io_flush_buffer_async((
VALUE)fptr);
1523io_fflush(rb_io_t *fptr)
1530 while (fptr->
wbuf.
len > 0 && io_flush_buffer(fptr) != 0) {
1543 rb_thread_t *th = GET_THREAD();
1546 if (scheduler !=
Qnil) {
1550 rb_io_t * fptr = NULL;
1556 if (NIL_OR_UNDEF_P(timeout)) {
1560 if (timeout !=
Qnil) {
1565 int ready = rb_thread_io_wait(th, fptr,
RB_NUM2INT(events), tv);
1589io_wait_for_single_fd(
int fd,
int events,
struct timeval *timeout, rb_thread_t *th,
VALUE scheduler)
1591 if (scheduler !=
Qnil) {
1597 return rb_thread_wait_for_single_fd(th, fd, events, timeout);
1603 io_fd_check_closed(f);
1605 rb_thread_t *th = GET_THREAD();
1610#if defined(ERESTART)
1617#if EWOULDBLOCK != EAGAIN
1620 if (scheduler !=
Qnil) {
1638 io_fd_check_closed(f);
1640 rb_thread_t *th = GET_THREAD();
1645#if defined(ERESTART)
1661#if EWOULDBLOCK != EAGAIN
1664 if (scheduler !=
Qnil) {
1682 rb_thread_t *th = GET_THREAD();
1684 return io_wait_for_single_fd(fd, events, timeout, th, scheduler);
1718#if defined(ERESTART)
1728#if EWOULDBLOCK != EAGAIN
1751 if (
RTEST(result)) {
1766 if (
RTEST(result)) {
1777make_writeconv(rb_io_t *fptr)
1780 const char *senc, *denc;
1814 denc = rb_enc_name(enc);
1846io_binwrite_string_internal(rb_io_t *fptr,
const char *
ptr,
long length)
1849 struct iovec iov[2];
1852 iov[0].iov_len = fptr->
wbuf.
len;
1853 iov[1].iov_base = (
void*)
ptr;
1854 iov[1].iov_len = length;
1856 ssize_t result = rb_writev_internal(fptr, iov, 2);
1861 if (result >= fptr->
wbuf.
len) {
1869 fptr->
wbuf.
off += (int)result;
1870 fptr->
wbuf.
len -= (int)result;
1878 return rb_io_write_memory(fptr,
ptr, length);
1883io_binwrite_string_internal(rb_io_t *fptr,
const char *
ptr,
long length)
1885 long remaining = length;
1888 if (fptr->
wbuf.
len+length <= fptr->wbuf.capa) {
1895 fptr->
wbuf.
len += (int)length;
1902 if (io_fflush(fptr) < 0) {
1907 if (remaining == 0) {
1913 return rb_io_write_memory(fptr,
ptr, length);
1918io_binwrite_string(
VALUE arg)
1922 const char *
ptr = p->ptr;
1923 size_t remaining = p->length;
1927 ssize_t result = io_binwrite_string_internal(p->fptr,
ptr, remaining);
1933 else if (result > 0) {
1934 if ((
size_t)result == remaining)
break;
1936 remaining -= result;
1952io_allocate_write_buffer(rb_io_t *fptr,
int sync)
1957 fptr->
wbuf.
capa = IO_WBUF_CAPA_MIN;
1968io_binwrite_requires_flush_write(rb_io_t *fptr,
long len,
int nosync)
1983io_binwrite(
const char *
ptr,
long len, rb_io_t *fptr,
int nosync)
1985 if (
len <= 0)
return len;
1990 io_allocate_write_buffer(fptr, !nosync);
1992 if (io_binwrite_requires_flush_write(fptr,
len, nosync)) {
2003 return io_binwrite_string((
VALUE)&arg);
2020# define MODE_BTMODE(a,b,c) ((fmode & FMODE_BINMODE) ? (b) : \
2021 (fmode & FMODE_TEXTMODE) ? (c) : (a))
2023#define MODE_BTXMODE(a, b, c, d, e, f) ((fmode & FMODE_EXCL) ? \
2024 MODE_BTMODE(d, e, f) : \
2025 MODE_BTMODE(a, b, c))
2028do_writeconv(
VALUE str, rb_io_t *fptr,
int *converted)
2030 if (NEED_WRITECONV(fptr)) {
2032 SET_BINARY_MODE(fptr);
2034 make_writeconv(fptr);
2037#define fmode (fptr->mode)
2040 else if (MODE_BTMODE(DEFAULT_TEXTMODE,0,1) && !rb_enc_asciicompat(rb_enc_get(str))) {
2041 rb_raise(rb_eArgError,
"ASCII incompatible string written for text mode IO without encoding conversion: %s",
2042 rb_enc_name(rb_enc_get(str)));
2048 common_encoding = rb_enc_from_encoding(fptr->
encs.
enc2);
2049 else if (fptr->
encs.
enc != rb_ascii8bit_encoding())
2050 common_encoding = rb_enc_from_encoding(fptr->
encs.
enc);
2053 if (!
NIL_P(common_encoding)) {
2064#if RUBY_CRLF_ENVIRONMENT
2065#define fmode (fptr->mode)
2066 else if (MODE_BTMODE(DEFAULT_TEXTMODE,0,1)) {
2069 setmode(fptr->
fd, O_BINARY);
2072 setmode(fptr->
fd, O_TEXT);
2074 if (!rb_enc_asciicompat(rb_enc_get(str))) {
2075 rb_raise(rb_eArgError,
"ASCII incompatible string written for text mode IO without encoding conversion: %s",
2076 rb_enc_name(rb_enc_get(str)));
2085io_fwrite(
VALUE str, rb_io_t *fptr,
int nosync)
2094 long len = rb_w32_write_console(str, fptr->
fd);
2099 str = do_writeconv(str, fptr, &converted);
2103 tmp = rb_str_tmp_frozen_no_embed_acquire(str);
2105 n = io_binwrite(
ptr,
len, fptr, nosync);
2106 rb_str_tmp_frozen_release(str, tmp);
2118 return (ssize_t)io_binwrite(buf, (
long)size, fptr, 0);
2128 io = GetWriteIO(io);
2138 if (RSTRING_LEN(str) == 0)
return INT2FIX(0);
2143 n = io_fwrite(str, fptr, nosync);
2144 if (n < 0L) rb_sys_fail_on_write(fptr);
2150struct binwritev_arg {
2158io_binwritev_internal(
VALUE arg)
2160 struct binwritev_arg *p = (
struct binwritev_arg *)arg;
2162 size_t remaining = p->total;
2165 rb_io_t *fptr = p->fptr;
2166 struct iovec *iov = p->iov;
2167 int iovcnt = p->iovcnt;
2170 long result = rb_writev_internal(fptr, iov, iovcnt);
2175 if (offset < (
size_t)fptr->
wbuf.
len) {
2180 offset -= (size_t)fptr->
wbuf.
len;
2186 if (offset == p->total) {
2190 while (result >= (ssize_t)iov->iov_len) {
2192 result -= iov->iov_len;
2202 iov->iov_base = (
char *)iov->iov_base + result;
2203 iov->iov_len -= result;
2217io_binwritev(
struct iovec *iov,
int iovcnt, rb_io_t *fptr)
2222 if (iovcnt == 0)
return 0;
2225 for (
int i = 1; i < iovcnt; i++) total += iov[i].iov_len;
2227 io_allocate_write_buffer(fptr, 1);
2233 if (offset + total <= (
size_t)fptr->
wbuf.
capa) {
2234 for (
int i = 1; i < iovcnt; i++) {
2235 memcpy(fptr->
wbuf.
ptr+offset, iov[i].iov_base, iov[i].iov_len);
2236 offset += iov[i].iov_len;
2245 iov[0].iov_len = fptr->
wbuf.
len;
2258 struct binwritev_arg arg;
2261 arg.iovcnt = iovcnt;
2268 return io_binwritev_internal((
VALUE)&arg);
2273io_fwritev(
int argc,
const VALUE *argv, rb_io_t *fptr)
2275 int i, converted, iovcnt = argc + 1;
2277 VALUE v1, v2, str, tmp, *tmp_array;
2283 for (i = 0; i < argc; i++) {
2286 str = do_writeconv(str, fptr, &converted);
2291 tmp = rb_str_tmp_frozen_acquire(str);
2295 iov[i+1].iov_base = RSTRING_PTR(tmp);
2296 iov[i+1].iov_len = RSTRING_LEN(tmp);
2299 n = io_binwritev(iov, iovcnt, fptr);
2302 for (i = 0; i < argc; i++) {
2303 rb_str_tmp_frozen_release(argv[i], tmp_array[i]);
2312iovcnt_ok(
int iovcnt)
2315 return iovcnt < IOV_MAX;
2323io_writev(
int argc,
const VALUE *argv,
VALUE io)
2330 io = GetWriteIO(io);
2335 return rb_funcallv(io, id_write, argc, argv);
2343 for (i = 0; i < argc; i += cnt) {
2346 n = io_fwritev(cnt, &argv[i], fptr);
2357 rb_sys_fail_on_write(fptr);
2359 total = rb_fix_plus(
LONG2FIX(n), total);
2390 return io_writev(argc, argv, io);
2393 VALUE str = argv[0];
2394 return io_write(io, str, 0);
2401 return rb_funcallv(io, id_write, 1, &str);
2405rb_io_writev(
VALUE io,
int argc,
const VALUE *argv)
2410 char sep = RCLASS_SINGLETON_P(klass) ? (klass = io,
'.') :
'#';
2413 " which accepts just one argument",
2418 do rb_io_write(io, *argv++);
while (--argc);
2423 return rb_funcallv(io, id_write, argc, argv);
2449 rb_io_write(io, str);
2455nogvl_fsync(
void *
ptr)
2457 rb_io_t *fptr =
ptr;
2460 if (GetFileType((HANDLE)rb_w32_get_osfhandle(fptr->
fd)) != FILE_TYPE_DISK)
2463 return (
VALUE)fsync(fptr->
fd);
2468rb_io_flush_raw(
VALUE io,
int sync)
2472 if (!RB_TYPE_P(io,
T_FILE)) {
2476 io = GetWriteIO(io);
2480 if (io_fflush(fptr) < 0)
2481 rb_sys_fail_on_write(fptr);
2484 io_unread(fptr,
true);
2505 return rb_io_flush_raw(io, 1);
2531 pos = io_tell(fptr);
2532 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2538rb_io_seek(
VALUE io,
VALUE offset,
int whence)
2545 pos = io_seek(fptr, pos, whence);
2546 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2552interpret_seek_whence(
VALUE vwhence)
2554 if (vwhence == sym_SET)
2556 if (vwhence == sym_CUR)
2558 if (vwhence == sym_END)
2561 if (vwhence == sym_DATA)
2565 if (vwhence == sym_HOLE)
2621 VALUE offset, ptrname;
2622 int whence = SEEK_SET;
2624 if (
rb_scan_args(argc, argv,
"11", &offset, &ptrname) == 2) {
2625 whence = interpret_seek_whence(ptrname);
2628 return rb_io_seek(io, offset, whence);
2656 pos = io_seek(fptr, pos, SEEK_SET);
2657 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2662static void clear_readconv(rb_io_t *fptr);
2689rb_io_rewind(
VALUE io)
2694 if (io_seek(fptr, 0L, 0) < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2695 if (io == ARGF.current_file) {
2696 ARGF.lineno -= fptr->
lineno;
2700 clear_readconv(fptr);
2707fptr_wait_readable(rb_io_t *fptr)
2718io_fillbuf(rb_io_t *fptr)
2725 fptr->
rbuf.
capa = IO_RBUF_CAPA_FOR(fptr);
2733 if (fptr_wait_readable(fptr))
2737 VALUE path = rb_sprintf(
"fd:%d ", fptr->
fd);
2742 rb_syserr_fail_path(e, path);
2796 if (READ_CHAR_PENDING(fptr))
return Qfalse;
2797 if (READ_DATA_PENDING(fptr))
return Qfalse;
2799#if RUBY_CRLF_ENVIRONMENT
2800 if (!NEED_READCONV(fptr) && NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {
2801 return RBOOL(eof(fptr->
fd));
2804 return RBOOL(io_fillbuf(fptr) < 0);
2828 io = GetWriteIO(io);
2865 io = GetWriteIO(io);
2895rb_io_fsync(
VALUE io)
2899 io = GetWriteIO(io);
2902 if (io_fflush(fptr) < 0)
2903 rb_sys_fail_on_write(fptr);
2905 if ((
int)rb_io_blocking_region(fptr, nogvl_fsync, fptr))
2906 rb_sys_fail_path(fptr->
pathv);
2911# define rb_io_fsync rb_f_notimplement
2912# define rb_io_sync rb_f_notimplement
2921#ifdef HAVE_FDATASYNC
2923nogvl_fdatasync(
void *
ptr)
2925 rb_io_t *fptr =
ptr;
2928 if (GetFileType((HANDLE)rb_w32_get_osfhandle(fptr->
fd)) != FILE_TYPE_DISK)
2931 return (
VALUE)fdatasync(fptr->
fd);
2946rb_io_fdatasync(
VALUE io)
2950 io = GetWriteIO(io);
2953 if (io_fflush(fptr) < 0)
2954 rb_sys_fail_on_write(fptr);
2956 if ((
int)rb_io_blocking_region(fptr, nogvl_fdatasync, fptr) == 0)
2960 return rb_io_fsync(io);
2963#define rb_io_fdatasync rb_io_fsync
2981rb_io_fileno(
VALUE io)
2983 rb_io_t *fptr =
RFILE(io)->fptr;
2994 if (RB_TYPE_P(io,
T_FILE)) {
2995 rb_io_t *fptr =
RFILE(io)->fptr;
3001 if (!UNDEF_P(fileno)) {
3068 rb_io_t *fptr =
RFILE(io)->fptr;
3089rb_io_inspect(
VALUE obj)
3093 static const char closed[] =
" (closed)";
3095 fptr =
RFILE(obj)->fptr;
3102 rb_str_cat(result, closed+1, strlen(closed)-1);
3105 rb_str_catf(result,
"fd %d", fptr->
fd);
3126rb_io_to_io(
VALUE io)
3133read_buffered_data(
char *
ptr,
long len, rb_io_t *fptr)
3137 n = READ_DATA_PENDING_COUNT(fptr);
3138 if (n <= 0)
return 0;
3139 if (n >
len) n = (int)
len;
3147io_bufread(
char *
ptr,
long len, rb_io_t *fptr)
3153 if (READ_DATA_PENDING(fptr) == 0) {
3157 c = rb_io_read_memory(fptr,
ptr+offset, n);
3160 if (fptr_wait_readable(fptr))
3165 if ((n -= c) <= 0)
break;
3171 c = read_buffered_data(
ptr+offset, n, fptr);
3174 if ((n -= c) <= 0)
break;
3177 if (io_fillbuf(fptr) < 0) {
3184static int io_setstrbuf(
VALUE *str,
long len);
3193bufread_call(
VALUE arg)
3196 p->len = io_bufread(p->str_ptr, p->len, p->fptr);
3201io_fread(
VALUE str,
long offset,
long size, rb_io_t *fptr)
3206 io_setstrbuf(&str, offset + size);
3207 if (!READ_DATA_PENDING(fptr))
3208 rb_str_make_heap(str);
3209 arg.str_ptr = RSTRING_PTR(str) + offset;
3212 rb_str_locktmp_ensure(str, bufread_call, (
VALUE)&arg);
3214 if (
len < 0) rb_sys_fail_path(fptr->
pathv);
3219remain_size(rb_io_t *fptr)
3222 rb_off_t siz = READ_DATA_PENDING_COUNT(fptr);
3225 if (fstat(fptr->
fd, &st) == 0 && S_ISREG(st.st_mode)
3226#
if defined(__HAIKU__)
3231 if (io_fflush(fptr) < 0)
3232 rb_sys_fail_on_write(fptr);
3233 pos = lseek(fptr->
fd, 0, SEEK_CUR);
3234 if (st.st_size >= pos && pos >= 0) {
3235 siz += st.st_size - pos;
3236 if (siz > LONG_MAX) {
3237 rb_raise(
rb_eIOError,
"file too big for single read");
3248io_enc_str(
VALUE str, rb_io_t *fptr)
3250 rb_enc_associate(str, io_read_encoding(fptr));
3255make_readconv(rb_io_t *fptr,
int size)
3260 const char *sname, *dname;
3264 sname = rb_enc_name(fptr->
encs.
enc2);
3265 dname = rb_enc_name(io_read_encoding(fptr));
3275 if (size < IO_CBUF_CAPA_MIN) size = IO_CBUF_CAPA_MIN;
3281#define MORE_CHAR_SUSPENDED Qtrue
3282#define MORE_CHAR_FINISHED Qnil
3284fill_cbuf(rb_io_t *fptr,
int ec_flags)
3286 const unsigned char *ss, *sp, *se;
3287 unsigned char *ds, *dp, *de;
3296 return MORE_CHAR_SUSPENDED;
3307 ss = sp = (
const unsigned char *)fptr->
rbuf.
ptr + fptr->
rbuf.
off;
3312 fptr->
rbuf.
off += (int)(sp - ss);
3313 fptr->
rbuf.
len -= (int)(sp - ss);
3314 fptr->
cbuf.
len += (int)(dp - ds);
3320 if (putbackable > fptr->
rbuf.
off)
3324 fptr->
rbuf.
off -= putbackable;
3325 fptr->
rbuf.
len += putbackable;
3332 if (cbuf_len0 != fptr->
cbuf.
len)
3333 return MORE_CHAR_SUSPENDED;
3336 return MORE_CHAR_FINISHED;
3342 if (io_fillbuf(fptr) < 0) {
3344 return MORE_CHAR_FINISHED;
3349 fptr->
cbuf.
len += (int)(dp - ds);
3356 if (cbuf_len0 != fptr->
cbuf.
len)
3357 return MORE_CHAR_SUSPENDED;
3359 return MORE_CHAR_FINISHED;
3363more_char(rb_io_t *fptr)
3367 if (v != MORE_CHAR_SUSPENDED && v != MORE_CHAR_FINISHED)
3373io_shift_cbuf(rb_io_t *fptr,
int len,
VALUE *strp)
3384 rb_enc_associate(str, fptr->
encs.
enc);
3409 long clen = RSTRING_LEN(s);
3421#define MAX_REALLOC_GAP 4096
3423io_shrink_read_string(
VALUE str,
long n)
3426 rb_str_resize(str, n);
3431io_set_read_length(
VALUE str,
long n,
int shrinkable)
3433 if (RSTRING_LEN(str) != n) {
3436 if (shrinkable) io_shrink_read_string(str, n);
3441read_all(rb_io_t *fptr,
long siz,
VALUE str)
3450 if (NEED_READCONV(fptr)) {
3451 int first = !
NIL_P(str);
3452 SET_BINARY_MODE(fptr);
3453 shrinkable = io_setstrbuf(&str,0);
3454 make_readconv(fptr, 0);
3459 io_shift_cbuf(fptr, fptr->
cbuf.
len, &str);
3461 v = fill_cbuf(fptr, 0);
3462 if (v != MORE_CHAR_SUSPENDED && v != MORE_CHAR_FINISHED) {
3465 io_shift_cbuf(fptr, fptr->
cbuf.
len, &str);
3469 if (v == MORE_CHAR_FINISHED) {
3470 clear_readconv(fptr);
3472 if (shrinkable) io_shrink_read_string(str, RSTRING_LEN(str));
3473 return io_enc_str(str, fptr);
3478 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
3482 enc = io_read_encoding(fptr);
3485 if (siz == 0) siz = BUFSIZ;
3486 shrinkable = io_setstrbuf(&str, siz);
3489 n = io_fread(str, bytes, siz - bytes, fptr);
3490 if (n == 0 && bytes == 0) {
3497 pos += rb_str_coderange_scan_restartable(RSTRING_PTR(str) + pos, RSTRING_PTR(str) + bytes, enc, &cr);
3498 if (bytes < siz)
break;
3502 if (
capa < (
size_t)RSTRING_LEN(str) + BUFSIZ) {
3503 if (
capa < BUFSIZ) {
3506 else if (
capa > IO_MAX_BUFFER_GROWTH) {
3507 capa = IO_MAX_BUFFER_GROWTH;
3512 if (shrinkable) io_shrink_read_string(str, RSTRING_LEN(str));
3513 str = io_enc_str(str, fptr);
3521 if (rb_fd_set_nonblock(fptr->
fd) != 0) {
3522 rb_sys_fail_path(fptr->
pathv);
3527io_read_memory_call(
VALUE arg)
3532 if (scheduler !=
Qnil) {
3535 if (!UNDEF_P(result)) {
3537 return (
VALUE)rb_fiber_scheduler_io_result_apply(result);
3541 if (iis->nonblock) {
3542 return rb_io_blocking_region(iis->fptr, internal_read_func, iis);
3545 return rb_io_blocking_region_wait(iis->fptr, internal_read_func, iis,
RUBY_IO_READABLE);
3552 return (
long)rb_str_locktmp_ensure(str, io_read_memory_call, (
VALUE)iis);
3555#define no_exception_p(opts) !rb_opts_exception_p((opts), TRUE)
3558io_getpartial(
int argc,
VALUE *argv,
VALUE io,
int no_exception,
int nonblock)
3569 rb_raise(rb_eArgError,
"negative length %ld given",
len);
3572 shrinkable = io_setstrbuf(&str,
len);
3578 io_set_read_length(str, 0, shrinkable);
3584 n = read_buffered_data(RSTRING_PTR(str),
len, fptr);
3590 io_setstrbuf(&str,
len);
3591 rb_str_make_heap(str);
3594 iis.nonblock = nonblock;
3596 iis.buf = RSTRING_PTR(str);
3599 n = io_read_memory_locktmp(str, &iis);
3602 if (!nonblock && fptr_wait_readable(fptr))
3604 if (nonblock && (io_again_p(e))) {
3606 return sym_wait_readable;
3609 e,
"read would block");
3611 rb_syserr_fail_path(e, fptr->
pathv);
3614 io_set_read_length(str, n, shrinkable);
3715io_readpartial(
int argc,
VALUE *argv,
VALUE io)
3719 ret = io_getpartial(argc, argv, io,
Qnil, 0);
3726io_nonblock_eof(
int no_exception)
3728 if (!no_exception) {
3744 rb_raise(rb_eArgError,
"negative length %ld given",
len);
3747 shrinkable = io_setstrbuf(&str,
len);
3748 rb_bool_expected(ex,
"exception", TRUE);
3754 io_set_read_length(str, 0, shrinkable);
3758 n = read_buffered_data(RSTRING_PTR(str),
len, fptr);
3760 rb_fd_set_nonblock(fptr->
fd);
3761 shrinkable |= io_setstrbuf(&str,
len);
3765 iis.buf = RSTRING_PTR(str);
3768 n = io_read_memory_locktmp(str, &iis);
3771 if (io_again_p(e)) {
3772 if (!ex)
return sym_wait_readable;
3774 e,
"read would block");
3776 rb_syserr_fail_path(e, fptr->
pathv);
3779 io_set_read_length(str, n, shrinkable);
3782 if (!ex)
return Qnil;
3791io_write_nonblock(rb_execution_context_t *ec,
VALUE io,
VALUE str,
VALUE ex)
3798 rb_bool_expected(ex,
"exception", TRUE);
3800 io = GetWriteIO(io);
3804 if (io_fflush(fptr) < 0)
3805 rb_sys_fail_on_write(fptr);
3807 rb_fd_set_nonblock(fptr->
fd);
3808 n = write(fptr->
fd, RSTRING_PTR(str), RSTRING_LEN(str));
3813 if (io_again_p(e)) {
3815 return sym_wait_writable;
3821 rb_syserr_fail_path(e, fptr->
pathv);
3905#if RUBY_CRLF_ENVIRONMENT
3911 if (
NIL_P(length)) {
3914 return read_all(fptr, remain_size(fptr), str);
3918 rb_raise(rb_eArgError,
"negative length %ld given",
len);
3921 shrinkable = io_setstrbuf(&str,
len);
3926 io_set_read_length(str, 0, shrinkable);
3931#if RUBY_CRLF_ENVIRONMENT
3932 previous_mode = set_binary_mode_with_seek_cur(fptr);
3934 n = io_fread(str, 0,
len, fptr);
3935 io_set_read_length(str, n, shrinkable);
3936#if RUBY_CRLF_ENVIRONMENT
3937 if (previous_mode == O_TEXT) {
3938 setmode(fptr->
fd, O_TEXT);
3941 if (n == 0)
return Qnil;
3947rscheck(
const char *rsptr,
long rslen,
VALUE rs)
3950 if (RSTRING_PTR(rs) != rsptr && RSTRING_LEN(rs) != rslen)
3955search_delim(
const char *p,
long len,
int delim, rb_encoding *enc)
3957 if (delim < 0)
return NULL;
3958 if (rb_enc_mbminlen(enc) == 1) {
3959 p = memchr(p, delim,
len);
3960 if (p)
return p + 1;
3963 const char *end = p +
len;
3965 int r = rb_enc_precise_mbclen(p, end, enc);
3967 p += rb_enc_mbminlen(enc);
3971 if (rb_enc_mbc_to_codepoint(p, end, enc) == (
unsigned int)delim) {
3981appendline(rb_io_t *fptr,
int delim,
VALUE *strp,
long *lp, rb_encoding *enc)
3986 if (NEED_READCONV(fptr)) {
3987 SET_BINARY_MODE(fptr);
3988 make_readconv(fptr, 0);
3991 int searchlen = READ_CHAR_PENDING_COUNT(fptr);
3993 p = READ_CHAR_PENDING_PTR(fptr);
3994 if (0 < limit && limit < searchlen)
3995 searchlen = (int)limit;
3996 e = search_delim(p, searchlen, delim, enc);
3998 int len = (int)(e-p);
4020 return (
unsigned char)RSTRING_PTR(str)[RSTRING_LEN(str)-1];
4023 }
while (more_char(fptr) != MORE_CHAR_FINISHED);
4024 clear_readconv(fptr);
4029 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
4031 long pending = READ_DATA_PENDING_COUNT(fptr);
4033 const char *p = READ_DATA_PENDING_PTR(fptr);
4037 if (limit > 0 && pending > limit) pending = limit;
4038 e = search_delim(p, pending, delim, enc);
4039 if (e) pending = e - p;
4041 last = RSTRING_LEN(str);
4042 rb_str_resize(str, last + pending);
4049 read_buffered_data(RSTRING_PTR(str) + last, pending, fptr);
4052 if (e)
return delim;
4054 return (
unsigned char)RSTRING_PTR(str)[RSTRING_LEN(str)-1];
4057 }
while (io_fillbuf(fptr) >= 0);
4063swallow(rb_io_t *fptr,
int term)
4065 if (NEED_READCONV(fptr)) {
4066 rb_encoding *enc = io_read_encoding(fptr);
4067 int needconv = rb_enc_mbminlen(enc) != 1;
4068 SET_BINARY_MODE(fptr);
4069 make_readconv(fptr, 0);
4072 while ((cnt = READ_CHAR_PENDING_COUNT(fptr)) > 0) {
4073 const char *p = READ_CHAR_PENDING_PTR(fptr);
4076 if (*p != term)
return TRUE;
4078 while (--i && *++p == term);
4081 const char *e = p + cnt;
4082 if (rb_enc_ascget(p, e, &i, enc) != term)
return TRUE;
4083 while ((p += i) < e && rb_enc_ascget(p, e, &i, enc) == term);
4086 io_shift_cbuf(fptr, (
int)cnt - i, NULL);
4088 }
while (more_char(fptr) != MORE_CHAR_FINISHED);
4092 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
4095 while ((cnt = READ_DATA_PENDING_COUNT(fptr)) > 0) {
4097 const char *p = READ_DATA_PENDING_PTR(fptr);
4099 if (cnt >
sizeof buf) cnt =
sizeof buf;
4100 if (*p != term)
return TRUE;
4102 while (--i && *++p == term);
4103 if (!read_buffered_data(buf, cnt - i, fptr))
4104 rb_sys_fail_path(fptr->
pathv);
4107 }
while (io_fillbuf(fptr) == 0);
4112rb_io_getline_fast(rb_io_t *fptr, rb_encoding *enc,
int chomp)
4120 int pending = READ_DATA_PENDING_COUNT(fptr);
4123 const char *p = READ_DATA_PENDING_PTR(fptr);
4127 e = memchr(p,
'\n', pending);
4129 pending = (int)(e - p + 1);
4131 chomplen = (pending > 1 && *(e-1) ==
'\r') + 1;
4140 rb_str_resize(str,
len + pending - chomplen);
4141 read_buffered_data(RSTRING_PTR(str)+
len, pending - chomplen, fptr);
4144 if (pending == 1 && chomplen == 1 &&
len > 0) {
4145 if (RSTRING_PTR(str)[
len-1] ==
'\r') {
4146 rb_str_resize(str, --
len);
4151 len += pending - chomplen;
4153 pos += rb_str_coderange_scan_restartable(RSTRING_PTR(str) + pos, RSTRING_PTR(str) +
len, enc, &cr);
4157 }
while (io_fillbuf(fptr) >= 0);
4160 str = io_enc_str(str, fptr);
4171 unsigned int chomp: 1;
4182 kwds[0] = rb_intern_const(
"chomp");
4185 chomp = (!UNDEF_P(vchomp)) &&
RTEST(vchomp);
4187 args->chomp = chomp;
4205 else if (2 <= argc) {
4206 rs = argv[0], lim = argv[1];
4215check_getline_args(
VALUE *rsp,
long *limit,
VALUE io)
4221 rb_encoding *enc_rs, *enc_io;
4224 enc_rs = rb_enc_get(rs);
4225 enc_io = io_read_encoding(fptr);
4226 if (enc_io != enc_rs &&
4227 (!is_ascii_string(rs) ||
4228 (RSTRING_LEN(rs) > 0 && !rb_enc_asciicompat(enc_io)))) {
4230 rs = rb_enc_str_new(0, 0, enc_io);
4235 rb_raise(rb_eArgError,
"encoding mismatch: %s IO with %s RS",
4236 rb_enc_name(enc_io),
4237 rb_enc_name(enc_rs));
4247 argc =
rb_scan_args(argc, argv,
"02:", NULL, NULL, &opts);
4248 extract_getline_args(argc, argv, args);
4249 extract_getline_opts(opts, args);
4250 check_getline_args(&args->rs, &args->limit, io);
4254rb_io_getline_0(
VALUE rs,
long limit,
int chomp, rb_io_t *fptr)
4261 if (
NIL_P(rs) && limit < 0) {
4262 str = read_all(fptr, 0,
Qnil);
4263 if (RSTRING_LEN(str) == 0)
return Qnil;
4265 else if (limit == 0) {
4266 return rb_enc_str_new(0, 0, io_read_encoding(fptr));
4268 else if (rs ==
rb_default_rs && limit < 0 && !NEED_READCONV(fptr) &&
4269 rb_enc_asciicompat(enc = io_read_encoding(fptr))) {
4270 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
4271 return rb_io_getline_fast(fptr, enc, chomp);
4274 int c, newline = -1;
4275 const char *rsptr = 0;
4278 int extra_limit = 16;
4279 int chomp_cr = chomp;
4281 SET_BINARY_MODE(fptr);
4282 enc = io_read_encoding(fptr);
4285 rslen = RSTRING_LEN(rs);
4290 swallow(fptr,
'\n');
4292 if (!rb_enc_asciicompat(enc)) {
4296 rsptr = RSTRING_PTR(rs);
4297 rslen = RSTRING_LEN(rs);
4301 else if (rb_enc_mbminlen(enc) == 1) {
4302 rsptr = RSTRING_PTR(rs);
4303 newline = (
unsigned char)rsptr[rslen - 1];
4307 rsptr = RSTRING_PTR(rs);
4308 const char *e = rsptr + rslen;
4309 const char *last = rb_enc_prev_char(rsptr, e, e, enc);
4311 newline = rb_enc_codepoint_len(last, e, &n, enc);
4312 if (last + n != e) rb_raise(rb_eArgError,
"broken separator");
4314 chomp_cr = chomp && newline ==
'\n' && rslen == rb_enc_mbminlen(enc);
4318 while ((c = appendline(fptr, newline, &str, &limit, enc)) != EOF) {
4319 const char *s, *p, *pp, *e;
4321 if (c == newline && RSTRING_LEN(str) >= rslen) {
4322 s = RSTRING_PTR(str);
4323 e = RSTRING_END(str);
4325 if (at_char_boundary(s, p, e, enc)) {
4326 if (!rspara) rscheck(rsptr, rslen, rs);
4327 if (memcmp(p, rsptr, rslen) == 0) {
4329 if (chomp_cr && p > s && *(p-1) ==
'\r') --p;
4337 s = RSTRING_PTR(str);
4338 p = RSTRING_END(str);
4339 pp = rb_enc_prev_char(s, p, p, enc);
4340 if (extra_limit && pp &&
4354 if (rspara && c != EOF)
4355 swallow(fptr,
'\n');
4357 str = io_enc_str(str, fptr);
4360 if (!
NIL_P(str) && !nolimit) {
4368rb_io_getline_1(
VALUE rs,
long limit,
int chomp,
VALUE io)
4371 int old_lineno, new_lineno;
4375 old_lineno = fptr->
lineno;
4376 str = rb_io_getline_0(rs, limit, chomp, fptr);
4377 if (!
NIL_P(str) && (new_lineno = fptr->
lineno) != old_lineno) {
4378 if (io == ARGF.current_file) {
4379 ARGF.lineno += new_lineno - old_lineno;
4380 ARGF.last_lineno = ARGF.lineno;
4383 ARGF.last_lineno = new_lineno;
4391rb_io_getline(
int argc,
VALUE *argv,
VALUE io)
4395 prepare_getline_args(argc, argv, &args, io);
4396 return rb_io_getline_1(args.rs, args.limit, args.chomp, io);
4406rb_io_gets_limit_internal(
VALUE io,
long limit)
4414rb_io_gets_internal(
VALUE io)
4416 return rb_io_gets_limit_internal(io, -1);
4496 str = rb_io_getline(argc, argv, io);
4512rb_io_lineno(
VALUE io)
4567 check_getline_args(&sep, &limit, io);
4569 VALUE line = rb_io_getline_1(sep, limit,
RTEST(chomp), io);
4570 rb_lastline_set_up(line, 1);
4645rb_io_readlines(
int argc,
VALUE *argv,
VALUE io)
4649 prepare_getline_args(argc, argv, &args, io);
4650 return io_readlines(&args, io);
4658 if (arg->limit == 0)
4659 rb_raise(rb_eArgError,
"invalid limit: 0 for readlines");
4661 while (!
NIL_P(line = rb_io_getline_1(arg->rs, arg->limit, arg->chomp, io))) {
4774rb_io_each_line(
int argc,
VALUE *argv,
VALUE io)
4780 prepare_getline_args(argc, argv, &args, io);
4781 if (args.limit == 0)
4782 rb_raise(rb_eArgError,
"invalid limit: 0 for each_line");
4783 while (!
NIL_P(str = rb_io_getline_1(args.rs, args.limit, args.chomp, io))) {
4810rb_io_each_byte(
VALUE io)
4826 }
while (io_fillbuf(fptr) >= 0);
4831io_getc(rb_io_t *fptr, rb_encoding *enc)
4836 if (NEED_READCONV(fptr)) {
4837 rb_encoding *read_enc = io_read_encoding(fptr);
4840 SET_BINARY_MODE(fptr);
4841 make_readconv(fptr, 0);
4855 if (more_char(fptr) == MORE_CHAR_FINISHED) {
4857 clear_readconv(fptr);
4861 str = rb_enc_str_new(fptr->
cbuf.
ptr+fptr->
cbuf.
off, 1, read_enc);
4864 if (fptr->
cbuf.
len == 0) clear_readconv(fptr);
4873 io_shift_cbuf(fptr, r, &str);
4880 ISASCII(RSTRING_PTR(str)[0])) {
4884 str = io_enc_str(str, fptr);
4889 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
4890 if (io_fillbuf(fptr) < 0) {
4893 if (rb_enc_asciicompat(enc) && ISASCII(fptr->
rbuf.
ptr[fptr->
rbuf.
off])) {
4912 if (io_fillbuf(fptr) != -1) {
4916 r = rb_enc_precise_mbclen(RSTRING_PTR(str), RSTRING_PTR(str)+RSTRING_LEN(str), enc);
4932 str = io_enc_str(str, fptr);
4958rb_io_each_char(
VALUE io)
4968 enc = io_input_encoding(fptr);
4970 while (!
NIL_P(c = io_getc(fptr, enc))) {
4996rb_io_each_codepoint(
VALUE io)
5008 enc = io_read_encoding(fptr);
5009 if (NEED_READCONV(fptr)) {
5010 SET_BINARY_MODE(fptr);
5013 make_readconv(fptr, 0);
5025 if (more_char(fptr) == MORE_CHAR_FINISHED) {
5026 clear_readconv(fptr);
5046 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
5047 while (io_fillbuf(fptr) >= 0) {
5062 char cbuf[8], *p = cbuf;
5064 if (more > numberof(cbuf))
goto invalid;
5066 if (more > numberof(cbuf))
goto invalid;
5067 while ((n = (
int)read_buffered_data(p, more, fptr)) > 0 &&
5068 (p += n, (more -= n) > 0)) {
5069 if (io_fillbuf(fptr) < 0)
goto invalid;
5070 if ((n = fptr->
rbuf.
len) > more) n = more;
5072 r = rb_enc_precise_mbclen(cbuf, p, enc);
5074 c = rb_enc_codepoint(cbuf, p, enc);
5085 rb_raise(rb_eArgError,
"invalid byte sequence in %s", rb_enc_name(enc));
5117 enc = io_input_encoding(fptr);
5119 return io_getc(fptr, enc);
5142rb_io_readchar(
VALUE io)
5144 VALUE c = rb_io_getc(io);
5179 VALUE r_stdout = rb_ractor_stdout();
5184 rb_io_flush(r_stdout);
5187 if (io_fillbuf(fptr) < 0) {
5216rb_io_readbyte(
VALUE io)
5277 unsigned char c =
NUM2INT(v) & 0xFF;
5283 io_ungetbyte(b, fptr);
5339 else if (RB_BIGNUM_TYPE_P(c)) {
5345 if (NEED_READCONV(fptr)) {
5346 SET_BINARY_MODE(fptr);
5347 len = RSTRING_LEN(c);
5348#if SIZEOF_LONG > SIZEOF_INT
5352 make_readconv(fptr, (
int)
len);
5366 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
5367 io_ungetbyte(c, fptr);
5387rb_io_isatty(
VALUE io)
5392 return RBOOL(isatty(fptr->
fd) != 0);
5395#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
5411rb_io_close_on_exec_p(
VALUE io)
5417 write_io = GetWriteIO(io);
5418 if (io != write_io) {
5420 if (fptr && 0 <= (fd = fptr->
fd)) {
5421 if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5422 if (!(ret & FD_CLOEXEC))
return Qfalse;
5427 if (fptr && 0 <= (fd = fptr->
fd)) {
5428 if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5429 if (!(ret & FD_CLOEXEC))
return Qfalse;
5434#define rb_io_close_on_exec_p rb_f_notimplement
5437#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
5461 int flag =
RTEST(arg) ? FD_CLOEXEC : 0;
5466 write_io = GetWriteIO(io);
5467 if (io != write_io) {
5469 if (fptr && 0 <= (fd = fptr->
fd)) {
5470 if ((ret = fcntl(fptr->
fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5471 if ((ret & FD_CLOEXEC) != flag) {
5472 ret = (ret & ~FD_CLOEXEC) | flag;
5473 ret = fcntl(fd, F_SETFD, ret);
5474 if (ret != 0) rb_sys_fail_path(fptr->
pathv);
5481 if (fptr && 0 <= (fd = fptr->
fd)) {
5482 if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5483 if ((ret & FD_CLOEXEC) != flag) {
5484 ret = (ret & ~FD_CLOEXEC) | flag;
5485 ret = fcntl(fd, F_SETFD, ret);
5486 if (ret != 0) rb_sys_fail_path(fptr->
pathv);
5492#define rb_io_set_close_on_exec rb_f_notimplement
5495#define RUBY_IO_EXTERNAL_P(f) ((f)->mode & FMODE_EXTERNAL)
5496#define PREP_STDIO_NAME(f) (RSTRING_PTR((f)->pathv))
5499finish_writeconv(rb_io_t *fptr,
int noalloc)
5501 unsigned char *ds, *dp, *de;
5505 unsigned char buf[1024];
5510 de = buf +
sizeof(buf);
5513 size_t remaining = dp-ds;
5514 long result = rb_io_write_memory(fptr, ds, remaining);
5518 if ((
size_t)result == remaining)
break;
5541 if (io_fflush(fptr) < 0) {
5549 fptr->
wbuf.
len += (int)(dp - ds);
5565finish_writeconv_sync(
VALUE arg)
5568 return finish_writeconv(p->fptr, p->noalloc);
5572nogvl_close(
void *
ptr)
5576 return (
void*)(intptr_t)close(*fd);
5580maygvl_close(
int fd,
int keepgvl)
5589 return IO_WITHOUT_GVL_INT(nogvl_close, &fd);
5593nogvl_fclose(
void *
ptr)
5597 return (
void*)(intptr_t)fclose(file);
5601maygvl_fclose(FILE *file,
int keepgvl)
5604 return fclose(file);
5606 return IO_WITHOUT_GVL_INT(nogvl_fclose, file);
5612fptr_finalize_flush(rb_io_t *fptr,
int noraise,
int keepgvl)
5617 int mode = fptr->
mode;
5623 arg.noalloc = noraise;
5627 error = finish_writeconv(fptr, noraise);
5632 io_flush_buffer_sync(fptr);
5635 if (io_fflush(fptr) < 0 &&
NIL_P(error)) {
5643 if (RUBY_IO_EXTERNAL_P(fptr) || fd <= 2) {
5653 rb_thread_io_close_wait(fptr);
5655 if (!done && stdio_file) {
5657 if ((maygvl_fclose(stdio_file, noraise) < 0) &&
NIL_P(error)) {
5667 if (!done && fd >= 0 && scheduler !=
Qnil) {
5670 if (!UNDEF_P(result)) {
5671 done =
RTEST(result);
5675 if (!done && fd >= 0) {
5681 if ((maygvl_close(fd, keepgvl) < 0) &&
NIL_P(error)) {
5690 if (!
NIL_P(error) && !noraise) {
5699fptr_finalize(rb_io_t *fptr,
int noraise)
5701 fptr_finalize_flush(fptr, noraise, FALSE);
5702 free_io_buffer(&fptr->
rbuf);
5703 free_io_buffer(&fptr->
wbuf);
5704 clear_codeconv(fptr);
5708rb_io_fptr_cleanup(rb_io_t *fptr,
int noraise)
5714 fptr_finalize(fptr, noraise);
5722 ruby_sized_xfree(buf->
ptr, (
size_t)buf->
capa);
5728clear_readconv(rb_io_t *fptr)
5734 free_io_buffer(&fptr->
cbuf);
5738clear_writeconv(rb_io_t *fptr)
5748clear_codeconv(rb_io_t *fptr)
5750 clear_readconv(fptr);
5751 clear_writeconv(fptr);
5755rb_io_fptr_cleanup_all(rb_io_t *fptr)
5759 rb_io_fptr_cleanup(fptr, TRUE);
5761 free_io_buffer(&fptr->
rbuf);
5762 free_io_buffer(&fptr->
wbuf);
5763 clear_codeconv(fptr);
5770 rb_io_fptr_cleanup_all(io);
5777rb_io_memsize(
const rb_io_t *io)
5779 size_t size =
sizeof(rb_io_t);
5789 rb_serial_t fork_generation = GET_VM()->fork_gen;
5790 if (io->fork_generation == fork_generation) {
5801# define KEEPGVL TRUE
5803# define KEEPGVL FALSE
5807io_close_fptr(
VALUE io)
5811 rb_io_t *write_fptr;
5813 write_io = GetWriteIO(io);
5814 if (io != write_io) {
5815 write_fptr =
RFILE(write_io)->fptr;
5816 if (write_fptr && 0 <= write_fptr->
fd) {
5817 rb_io_fptr_cleanup(write_fptr, TRUE);
5821 fptr =
RFILE(io)->fptr;
5822 if (!fptr)
return 0;
5823 if (fptr->
fd < 0)
return 0;
5826 if (rb_thread_io_close_interrupt(fptr)) {
5828 fptr_finalize_flush(fptr, FALSE, KEEPGVL);
5831 rb_io_fptr_cleanup(fptr, FALSE);
5836fptr_waitpid(rb_io_t *fptr,
int nohang)
5840 rb_last_status_clear();
5849 rb_io_t *fptr = io_close_fptr(io);
5850 if (fptr) fptr_waitpid(fptr, 0);
5890rb_io_close_m(
VALUE io)
5892 rb_io_t *fptr = rb_io_get_fptr(io);
5901io_call_close(
VALUE io)
5910 enum {mesg_len =
sizeof(closed_stream)-1};
5911 VALUE mesg = rb_attr_get(exc, idMesg);
5913 RSTRING_LEN(mesg) != mesg_len ||
5914 memcmp(RSTRING_PTR(mesg), closed_stream, mesg_len)) {
5924 if (!UNDEF_P(closed) &&
RTEST(closed))
return io;
5925 rb_rescue2(io_call_close, io, ignore_closed_stream, io,
5959 rb_io_t *write_fptr;
5961 write_io = GetWriteIO(io);
5962 if (io != write_io) {
5963 write_fptr =
RFILE(write_io)->fptr;
5964 if (write_fptr && 0 <= write_fptr->
fd) {
5969 fptr = rb_io_get_fptr(io);
5970 return RBOOL(0 > fptr->
fd);
6006rb_io_close_read(
VALUE io)
6012 if (fptr->
fd < 0)
return Qnil;
6013 if (is_socket(fptr->
fd, fptr->
pathv)) {
6017 if (shutdown(fptr->
fd, SHUT_RD) < 0)
6018 rb_sys_fail_path(fptr->
pathv);
6025 write_io = GetWriteIO(io);
6026 if (io != write_io) {
6031 RFILE(io)->fptr = wfptr;
6034 RFILE(write_io)->fptr = fptr;
6035 rb_io_fptr_cleanup(fptr, FALSE);
6041 rb_raise(
rb_eIOError,
"closing non-duplex IO for reading");
6079rb_io_close_write(
VALUE io)
6084 write_io = GetWriteIO(io);
6086 if (fptr->
fd < 0)
return Qnil;
6087 if (is_socket(fptr->
fd, fptr->
pathv)) {
6091 if (shutdown(fptr->
fd, SHUT_WR) < 0)
6092 rb_sys_fail_path(fptr->
pathv);
6100 rb_raise(
rb_eIOError,
"closing non-duplex IO for writing");
6103 if (io != write_io) {
6123rb_io_sysseek(
int argc,
VALUE *argv,
VALUE io)
6125 VALUE offset, ptrname;
6126 int whence = SEEK_SET;
6130 if (
rb_scan_args(argc, argv,
"11", &offset, &ptrname) == 2) {
6131 whence = interpret_seek_whence(ptrname);
6136 (READ_DATA_BUFFERED(fptr) || READ_CHAR_PENDING(fptr))) {
6140 rb_warn(
"sysseek for buffered IO");
6143 pos = lseek(fptr->
fd, pos, whence);
6144 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
6178 io = GetWriteIO(io);
6183 rb_warn(
"syswrite for buffered IO");
6186 tmp = rb_str_tmp_frozen_acquire(str);
6188 n = rb_io_write_memory(fptr,
ptr,
len);
6189 if (n < 0) rb_sys_fail_path(fptr->
pathv);
6190 rb_str_tmp_frozen_release(str, tmp);
6207rb_io_sysread(
int argc,
VALUE *argv,
VALUE io)
6218 rb_raise(rb_eArgError,
"negative string size (or size too big)");
6220 shrinkable = io_setstrbuf(&str, ilen);
6221 if (ilen == 0)
return str;
6226 if (READ_DATA_BUFFERED(fptr)) {
6232 io_setstrbuf(&str, ilen);
6233 rb_str_make_heap(str);
6238 iis.buf = RSTRING_PTR(str);
6241 n = io_read_memory_locktmp(str, &iis);
6244 rb_sys_fail_path(fptr->
pathv);
6247 io_set_read_length(str, n, shrinkable);
6249 if (n == 0 && ilen > 0) {
6265internal_pread_func(
void *_arg)
6269 return (
VALUE)pread(arg->fd, arg->buf, arg->count, arg->offset);
6273pread_internal_call(
VALUE _arg)
6278 if (scheduler !=
Qnil) {
6281 if (!UNDEF_P(result)) {
6282 return rb_fiber_scheduler_io_result_apply(result);
6286 return rb_io_blocking_region_wait(arg->io, internal_pread_func, arg,
RUBY_IO_READABLE);
6330 rb_raise(rb_eArgError,
"negative string size (or size too big)");
6332 arg.count = (size_t)ilen;
6335 shrinkable = io_setstrbuf(&str, (
long)arg.count);
6336 if (arg.count == 0)
return str;
6337 rb_str_make_heap(str);
6338 arg.buf = RSTRING_PTR(str);
6351 rb_sys_fail_path(fptr->
pathv);
6353 io_set_read_length(str, n, shrinkable);
6354 if (n == 0 && arg.count > 0) {
6362internal_pwrite_func(
void *_arg)
6366 return (
VALUE)pwrite(arg->fd, arg->buf, arg->count, arg->offset);
6370pwrite_internal_call(
VALUE _arg)
6375 if (scheduler !=
Qnil) {
6378 if (!UNDEF_P(result)) {
6379 return rb_fiber_scheduler_io_result_apply(result);
6383 return rb_io_blocking_region_wait(arg->io, internal_pwrite_func, arg,
RUBY_IO_WRITABLE);
6424 io = GetWriteIO(io);
6431 tmp = rb_str_tmp_frozen_acquire(str);
6432 arg.buf = RSTRING_PTR(tmp);
6433 arg.count = (size_t)RSTRING_LEN(tmp);
6435 n = (ssize_t)pwrite_internal_call((
VALUE)&arg);
6436 if (n < 0) rb_sys_fail_path(fptr->
pathv);
6437 rb_str_tmp_frozen_release(str, tmp);
6457 SET_BINARY_MODE_WITH_SEEK_CUR(fptr);
6460 setmode(fptr->
fd, O_BINARY);
6467io_ascii8bit_binmode(rb_io_t *fptr)
6479 SET_BINARY_MODE_WITH_SEEK_CUR(fptr);
6481 fptr->
encs.
enc = rb_ascii8bit_encoding();
6485 clear_codeconv(fptr);
6494 io_ascii8bit_binmode(fptr);
6511rb_io_binmode_m(
VALUE io)
6517 write_io = GetWriteIO(io);
6532rb_io_binmode_p(
VALUE io)
6540rb_io_fmode_modestr(
enum rb_io_mode fmode)
6544 return MODE_BTMODE(
"a+",
"ab+",
"at+");
6546 return MODE_BTMODE(
"a",
"ab",
"at");
6550 rb_raise(rb_eArgError,
"invalid access fmode 0x%x", fmode);
6552 return MODE_BTMODE(
"r",
"rb",
"rt");
6554 return MODE_BTXMODE(
"w",
"wb",
"wt",
"wx",
"wbx",
"wtx");
6557 return MODE_BTXMODE(
"w+",
"wb+",
"wt+",
"w+x",
"wb+x",
"wt+x");
6559 return MODE_BTMODE(
"r+",
"rb+",
"rt+");
6563static const char bom_prefix[] =
"bom|";
6564static const char utf_prefix[] =
"utf-";
6565enum {bom_prefix_len = (int)
sizeof(bom_prefix) - 1};
6566enum {utf_prefix_len = (int)
sizeof(utf_prefix) - 1};
6569io_encname_bom_p(
const char *name,
long len)
6571 return len > bom_prefix_len &&
STRNCASECMP(name, bom_prefix, bom_prefix_len) == 0;
6577 enum rb_io_mode fmode = 0;
6578 const char *m = modestr, *p = NULL;
6606 if (modestr[0] !=
'w')
6614 if (io_encname_bom_p(m, p ? (
long)(p - m) : (
long)strlen(m)))
6627 rb_raise(rb_eArgError,
"invalid access mode %s", modestr);
6634 enum rb_io_mode fmode = 0;
6636 switch (oflags & O_ACCMODE) {
6648 if (oflags & O_APPEND) {
6651 if (oflags & O_TRUNC) {
6654 if (oflags & O_CREAT) {
6657 if (oflags & O_EXCL) {
6661 if (oflags & O_BINARY) {
6670rb_io_fmode_oflags(
enum rb_io_mode fmode)
6714rb_io_oflags_modestr(
int oflags)
6717# define MODE_BINARY(a,b) ((oflags & O_BINARY) ? (b) : (a))
6719# define MODE_BINARY(a,b) (a)
6722 if (oflags & O_EXCL) {
6723 rb_raise(rb_eArgError,
"exclusive access mode is not supported");
6725 accmode = oflags & (O_RDONLY|O_WRONLY|O_RDWR);
6726 if (oflags & O_APPEND) {
6727 if (accmode == O_WRONLY) {
6728 return MODE_BINARY(
"a",
"ab");
6730 if (accmode == O_RDWR) {
6731 return MODE_BINARY(
"a+",
"ab+");
6736 rb_raise(rb_eArgError,
"invalid access oflags 0x%x", oflags);
6738 return MODE_BINARY(
"r",
"rb");
6740 return MODE_BINARY(
"w",
"wb");
6742 if (oflags & O_TRUNC) {
6743 return MODE_BINARY(
"w+",
"wb+");
6745 return MODE_BINARY(
"r+",
"rb+");
6755rb_io_ext_int_to_encs(rb_encoding *ext, rb_encoding *intern, rb_encoding **enc, rb_encoding **enc2,
enum rb_io_mode fmode)
6757 int default_ext = 0;
6760 ext = rb_default_external_encoding();
6763 if (rb_is_ascii8bit_enc(ext)) {
6767 else if (intern == NULL) {
6768 intern = rb_default_internal_encoding();
6770 if (intern == NULL || intern == (rb_encoding *)
Qnil ||
6773 *enc = (default_ext && intern != ext) ? NULL : ext;
6783unsupported_encoding(
const char *name, rb_encoding *enc)
6785 rb_enc_warn(enc,
"Unsupported encoding %s ignored", name);
6789parse_mode_enc(
const char *estr, rb_encoding *estr_enc,
6790 rb_encoding **enc_p, rb_encoding **enc2_p,
enum rb_io_mode *fmode_p)
6795 enum rb_io_mode fmode = fmode_p ? *fmode_p : 0;
6796 rb_encoding *ext_enc, *int_enc;
6801 p = strrchr(estr,
':');
6802 len = p ? (p++ - estr) : (long)strlen(estr);
6804 estr += bom_prefix_len;
6805 len -= bom_prefix_len;
6806 if (!
STRNCASECMP(estr, utf_prefix, utf_prefix_len)) {
6810 rb_enc_warn(estr_enc,
"BOM with non-UTF encoding %s is nonsense", estr);
6819 memcpy(encname, estr,
len);
6820 encname[
len] =
'\0';
6823 idx = rb_enc_find_index(estr);
6825 if (fmode_p) *fmode_p = fmode;
6828 ext_enc = rb_enc_from_index(idx);
6831 unsupported_encoding(estr, estr_enc);
6837 if (*p ==
'-' && *(p+1) ==
'\0') {
6839 int_enc = (rb_encoding *)
Qnil;
6842 idx2 = rb_enc_find_index(p);
6844 unsupported_encoding(p, estr_enc);
6846 int_enc = (rb_encoding *)
Qnil;
6849 int_enc = rb_enc_from_index(idx2);
6853 rb_io_ext_int_to_encs(ext_enc, int_enc, enc_p, enc2_p, fmode);
6861 rb_encoding *extencoding = NULL;
6862 rb_encoding *intencoding = NULL;
6866 v = rb_hash_lookup2(opt, sym_encoding,
Qnil);
6867 if (v !=
Qnil) encoding = v;
6868 v = rb_hash_lookup2(opt, sym_extenc,
Qundef);
6869 if (v !=
Qnil) extenc = v;
6870 v = rb_hash_lookup2(opt, sym_intenc,
Qundef);
6871 if (!UNDEF_P(v)) intenc = v;
6873 if ((!UNDEF_P(extenc) || !UNDEF_P(intenc)) && !
NIL_P(encoding)) {
6875 int idx = rb_to_encoding_index(encoding);
6876 if (idx >= 0) encoding = rb_enc_from_encoding(rb_enc_from_index(idx));
6877 rb_warn(
"Ignoring encoding parameter '%"PRIsVALUE
"': %s_encoding is used",
6878 encoding, UNDEF_P(extenc) ?
"internal" :
"external");
6882 if (!UNDEF_P(extenc) && !
NIL_P(extenc)) {
6883 extencoding = rb_to_encoding(extenc);
6885 if (!UNDEF_P(intenc)) {
6886 if (
NIL_P(intenc)) {
6888 intencoding = (rb_encoding *)
Qnil;
6893 if (*p ==
'-' && *(p+1) ==
'\0') {
6895 intencoding = (rb_encoding *)
Qnil;
6898 intencoding = rb_to_encoding(intenc);
6902 intencoding = rb_to_encoding(intenc);
6904 if (extencoding == intencoding) {
6905 intencoding = (rb_encoding *)
Qnil;
6908 if (!
NIL_P(encoding)) {
6912 enc_p, enc2_p, fmode_p);
6915 rb_io_ext_int_to_encs(rb_to_encoding(encoding), NULL, enc_p, enc2_p, 0);
6918 else if (!UNDEF_P(extenc) || !UNDEF_P(intenc)) {
6920 rb_io_ext_int_to_encs(extencoding, intencoding, enc_p, enc2_p, 0);
6926validate_enc_binmode(
enum rb_io_mode *fmode_p,
int ecflags, rb_encoding *enc, rb_encoding *enc2)
6928 enum rb_io_mode fmode = *fmode_p;
6933 !rb_enc_asciicompat(enc ? enc : rb_default_external_encoding()))
6934 rb_raise(rb_eArgError,
"ASCII incompatible encoding needs binmode");
6937 rb_raise(rb_eArgError,
"newline decorator with binary mode");
6944#if !DEFAULT_TEXTMODE
6953extract_binmode(
VALUE opthash,
enum rb_io_mode *fmode)
6955 if (!
NIL_P(opthash)) {
6957 v = rb_hash_aref(opthash, sym_textmode);
6960 rb_raise(rb_eArgError,
"textmode specified twice");
6962 rb_raise(rb_eArgError,
"both textmode and binmode specified");
6966 v = rb_hash_aref(opthash, sym_binmode);
6969 rb_raise(rb_eArgError,
"binmode specified twice");
6971 rb_raise(rb_eArgError,
"both textmode and binmode specified");
6977 rb_raise(rb_eArgError,
"both textmode and binmode specified");
6983 int *oflags_p,
enum rb_io_mode *fmode_p,
struct rb_io_encoding *convconfig_p)
6987 enum rb_io_mode fmode;
6988 rb_encoding *enc, *enc2;
6991 int has_enc = 0, has_vmode = 0;
6997 rb_io_ext_int_to_encs(NULL, NULL, &enc, &enc2, 0);
7015 oflags = rb_io_fmode_oflags(fmode);
7019 parse_mode_enc(p+1, rb_enc_get(vmode), &enc, &enc2, &fmode);
7024 e = (fmode &
FMODE_BINMODE) ? rb_ascii8bit_encoding() : NULL;
7025 rb_io_ext_int_to_encs(e, NULL, &enc, &enc2, fmode);
7029 if (
NIL_P(opthash)) {
7033#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
7035 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
7036 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
7038 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
7045 rb_io_ext_int_to_encs(rb_ascii8bit_encoding(), NULL, &enc, &enc2, fmode);
7048 else if (
NIL_P(vmode)) {
7049 fmode |= DEFAULT_TEXTMODE;
7056 v = rb_hash_aref(opthash, sym_mode);
7058 if (!
NIL_P(vmode)) {
7059 rb_raise(rb_eArgError,
"mode specified twice");
7066 v = rb_hash_aref(opthash, sym_flags);
7073 extract_binmode(opthash, &fmode);
7079 rb_io_ext_int_to_encs(rb_ascii8bit_encoding(), NULL, &enc, &enc2, fmode);
7082 else if (
NIL_P(vmode)) {
7083 fmode |= DEFAULT_TEXTMODE;
7086 v = rb_hash_aref(opthash, sym_perm);
7089 if (!
NIL_P(*vperm_p)) {
7090 rb_raise(rb_eArgError,
"perm specified twice");
7101#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
7103 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
7104 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
7109 rb_raise(rb_eArgError,
"encoding specified twice");
7112 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
7116 validate_enc_binmode(&fmode, ecflags, enc, enc2);
7122 convconfig_p->
enc = enc;
7123 convconfig_p->
enc2 = enc2;
7124 convconfig_p->
ecflags = ecflags;
7125 convconfig_p->
ecopts = ecopts;
7135sysopen_func(
void *
ptr)
7138 const char *fname = RSTRING_PTR(data->fname);
7147 fd = IO_WITHOUT_GVL_INT(sysopen_func, data);
7148 }
while (fd < 0 &&
errno == EINTR);
7155rb_sysopen(
VALUE fname,
int oflags, mode_t perm)
7160 data.fname = rb_str_encode_ospath(fname);
7162 data.oflags = oflags;
7165 TRY_WITH_GC((fd = rb_sysopen_internal(&data)) >= 0) {
7166 rb_syserr_fail_path(first_errno, fname);
7172fdopen_internal(
int fd,
const char *modestr)
7179 file = fdopen(fd, modestr);
7195 TRY_WITH_GC((file = fdopen_internal(fd, modestr)) != 0) {
7201 if (setvbuf(file, NULL, _IOFBF, 0) != 0)
7202 rb_warn(
"setvbuf() can't be honoured (fd=%d)", fd);
7208io_check_tty(rb_io_t *fptr)
7210 int t = isatty(fptr->
fd);
7220io_strip_bom(
VALUE io)
7222 VALUE b1, b2, b3, b4;
7233 return rb_utf8_encindex();
7243 return ENCINDEX_UTF_16BE;
7254 return ENCINDEX_UTF_32LE;
7259 return ENCINDEX_UTF_16LE;
7269 return ENCINDEX_UTF_32BE;
7283io_set_encoding_by_bom(
VALUE io)
7285 int idx = io_strip_bom(io);
7287 rb_encoding *extenc = NULL;
7291 extenc = rb_enc_from_index(idx);
7292 io_encoding_set(fptr, rb_enc_from_encoding(extenc),
7293 rb_io_internal_encoding(io),
Qnil);
7302rb_file_open_generic(
VALUE io,
VALUE filename,
int oflags,
enum rb_io_mode fmode,
7310 rb_io_ext_int_to_encs(NULL, NULL, &cc.enc, &cc.enc2, fmode);
7315 validate_enc_binmode(&fmode, convconfig->
ecflags,
7316 convconfig->
enc, convconfig->
enc2);
7320 fptr->
encs = *convconfig;
7323 if (!(oflags & O_TMPFILE)) {
7324 fptr->
pathv = pathv;
7327 fptr->
pathv = pathv;
7329 fptr->
fd = rb_sysopen(pathv, oflags, perm);
7337rb_file_open_internal(
VALUE io,
VALUE filename,
const char *modestr)
7340 const char *p = strchr(modestr,
':');
7344 parse_mode_enc(p+1, rb_usascii_encoding(),
7345 &convconfig.
enc, &convconfig.
enc2, &fmode);
7351 e = (fmode &
FMODE_BINMODE) ? rb_ascii8bit_encoding() : NULL;
7352 rb_io_ext_int_to_encs(e, NULL, &convconfig.
enc, &convconfig.
enc2, fmode);
7358#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
7360 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
7361 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
7363 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(convconfig.
enc2, convconfig.
ecflags);
7366 return rb_file_open_generic(io, filename,
7367 rb_io_fmode_oflags(fmode),
7377 return rb_file_open_internal(io_alloc(
rb_cFile), fname, modestr);
7386#if defined(__CYGWIN__) || !defined(HAVE_WORKING_FORK)
7393pipe_add_fptr(rb_io_t *fptr)
7404pipe_del_fptr(rb_io_t *fptr)
7409 while ((tmp = *prev) != 0) {
7410 if (tmp->fptr == fptr) {
7419#if defined (_WIN32) || defined(__CYGWIN__)
7435pipe_finalize(rb_io_t *fptr,
int noraise)
7437#if !defined(HAVE_WORKING_FORK) && !defined(_WIN32)
7446 fptr_finalize(fptr, noraise);
7448 pipe_del_fptr(fptr);
7453fptr_copy_finalizer(rb_io_t *fptr,
const rb_io_t *orig)
7455#if defined(__CYGWIN__) || !defined(HAVE_WORKING_FORK)
7456 void (*
const old_finalize)(
struct rb_io*,int) = fptr->
finalize;
7458 if (old_finalize == orig->finalize)
return;
7463#if defined(__CYGWIN__) || !defined(HAVE_WORKING_FORK)
7464 if (old_finalize != pipe_finalize) {
7466 for (list =
pipe_list; list; list = list->next) {
7467 if (list->fptr == fptr)
break;
7469 if (!list) pipe_add_fptr(fptr);
7472 pipe_del_fptr(fptr);
7485rb_io_unbuffered(rb_io_t *fptr)
7503#define HAVE_SPAWNV 1
7504#define spawnv(mode, cmd, args) rb_w32_uaspawn((mode), (cmd), (args))
7505#define spawn(mode, cmd) rb_w32_uspawn((mode), (cmd), 0)
7508#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
7511 struct rb_execarg *eargp;
7518#ifdef HAVE_WORKING_FORK
7519# ifndef __EMSCRIPTEN__
7521popen_redirect(
struct popen_arg *p)
7524 close(p->write_pair[1]);
7525 if (p->write_pair[0] != 0) {
7526 dup2(p->write_pair[0], 0);
7527 close(p->write_pair[0]);
7530 if (p->pair[1] != 1) {
7531 dup2(p->pair[1], 1);
7537 if (p->pair[1] != 1) {
7538 dup2(p->pair[1], 1);
7544 if (p->pair[0] != 0) {
7545 dup2(p->pair[0], 0);
7552#if defined(__linux__)
7563linux_get_maxfd(
void)
7566 char buf[4096], *p, *np, *e;
7569 if (fd < 0)
return fd;
7570 ss = read(fd, buf,
sizeof(buf));
7571 if (ss < 0)
goto err;
7574 while ((
int)
sizeof(
"FDSize:\t0\n")-1 <= e-p &&
7575 (np = memchr(p,
'\n', e-p)) != NULL) {
7576 if (memcmp(p,
"FDSize:",
sizeof(
"FDSize:")-1) == 0) {
7578 p +=
sizeof(
"FDSize:")-1;
7598#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
7600 int max = (int)max_file_descriptor;
7603 ret = fcntl(0, F_MAXFD);
7605 maxhint = max = ret;
7606# elif defined(__linux__)
7607 ret = linux_get_maxfd();
7614 for (fd = lowfd; fd <= max; fd++) {
7615 if (!
NIL_P(noclose_fds) &&
7618 ret = fcntl(fd, F_GETFD);
7619 if (ret != -1 && !(ret & FD_CLOEXEC)) {
7620 fcntl(fd, F_SETFD, ret|FD_CLOEXEC);
7622# define CONTIGUOUS_CLOSED_FDS 20
7624 if (max < fd + CONTIGUOUS_CLOSED_FDS)
7625 max = fd + CONTIGUOUS_CLOSED_FDS;
7631# ifndef __EMSCRIPTEN__
7633popen_exec(
void *pp,
char *errmsg,
size_t errmsg_len)
7635 struct popen_arg *p = (
struct popen_arg*)pp;
7637 return rb_exec_async_signal_safe(p->eargp, errmsg, errmsg_len);
7642#if (defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)) && !defined __EMSCRIPTEN__
7644rb_execarg_fixup_v(
VALUE execarg_obj)
7646 rb_execarg_parent_start(execarg_obj);
7650char *rb_execarg_commandline(
const struct rb_execarg *eargp,
VALUE *prog);
7653#ifndef __EMSCRIPTEN__
7655pipe_open(
VALUE execarg_obj,
const char *modestr,
enum rb_io_mode fmode,
7658 struct rb_execarg *eargp =
NIL_P(execarg_obj) ? NULL : rb_execarg_get(execarg_obj);
7659 VALUE prog = eargp ? (eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name) :
Qfalse ;
7663 rb_io_t *write_fptr;
7665#if defined(HAVE_WORKING_FORK)
7667 char errmsg[80] = {
'\0' };
7669#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
7671 struct popen_arg arg;
7674#if defined(HAVE_SPAWNV)
7675# if defined(HAVE_SPAWNVE)
7676# define DO_SPAWN(cmd, args, envp) ((args) ? \
7677 spawnve(P_NOWAIT, (cmd), (args), (envp)) : \
7678 spawne(P_NOWAIT, (cmd), (envp)))
7680# define DO_SPAWN(cmd, args, envp) ((args) ? \
7681 spawnv(P_NOWAIT, (cmd), (args)) : \
7682 spawn(P_NOWAIT, (cmd)))
7684# if !defined(HAVE_WORKING_FORK)
7686# if defined(HAVE_SPAWNVE)
7691#if !defined(HAVE_WORKING_FORK)
7697#if !defined(HAVE_WORKING_FORK)
7698 const char *cmd = 0;
7704#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
7705 arg.execarg_obj = execarg_obj;
7708 arg.pair[0] = arg.pair[1] = -1;
7709 arg.write_pair[0] = arg.write_pair[1] = -1;
7710# if !defined(HAVE_WORKING_FORK)
7711 if (eargp && !eargp->use_shell) {
7712 args = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str);
7717 if (
rb_pipe(arg.write_pair) < 0)
7718 rb_sys_fail_str(prog);
7721 close(arg.write_pair[0]);
7722 close(arg.write_pair[1]);
7726 rb_execarg_addopt(execarg_obj,
INT2FIX(0),
INT2FIX(arg.write_pair[0]));
7727 rb_execarg_addopt(execarg_obj,
INT2FIX(1),
INT2FIX(arg.pair[1]));
7732 rb_sys_fail_str(prog);
7734 rb_execarg_addopt(execarg_obj,
INT2FIX(1),
INT2FIX(arg.pair[1]));
7738 rb_sys_fail_str(prog);
7740 rb_execarg_addopt(execarg_obj,
INT2FIX(0),
INT2FIX(arg.pair[0]));
7743 rb_sys_fail_str(prog);
7745 if (!
NIL_P(execarg_obj)) {
7746 rb_protect(rb_execarg_fixup_v, execarg_obj, &state);
7748 if (0 <= arg.write_pair[0]) close(arg.write_pair[0]);
7749 if (0 <= arg.write_pair[1]) close(arg.write_pair[1]);
7750 if (0 <= arg.pair[0]) close(arg.pair[0]);
7751 if (0 <= arg.pair[1]) close(arg.pair[1]);
7752 rb_execarg_parent_end(execarg_obj);
7756# if defined(HAVE_WORKING_FORK)
7757 pid = rb_fork_async_signal_safe(&status, popen_exec, &arg, arg.eargp->redirect_fds, errmsg,
sizeof(errmsg));
7759 rb_execarg_run_options(eargp, sargp, NULL, 0);
7760# if defined(HAVE_SPAWNVE)
7761 if (eargp->envp_str) envp = (
char **)RSTRING_PTR(eargp->envp_str);
7763 while ((pid = DO_SPAWN(cmd, args, envp)) < 0) {
7765 switch (e =
errno) {
7767# if EWOULDBLOCK != EAGAIN
7776 rb_execarg_run_options(sargp, NULL, NULL, 0);
7778 rb_execarg_parent_end(execarg_obj);
7781# if defined(HAVE_WORKING_FORK)
7782 pid = rb_call_proc__fork();
7784 popen_redirect(&arg);
7796# if defined(HAVE_WORKING_FORK)
7802 close(arg.write_pair[0]);
7803 close(arg.write_pair[1]);
7805# if defined(HAVE_WORKING_FORK)
7814 close(arg.write_pair[0]);
7815 write_fd = arg.write_pair[1];
7826 cmd = rb_execarg_commandline(eargp, &prog);
7827 if (!
NIL_P(execarg_obj)) {
7828 rb_execarg_parent_start(execarg_obj);
7829 rb_execarg_run_options(eargp, sargp, NULL, 0);
7831 fp = popen(cmd, modestr);
7834 rb_execarg_parent_end(execarg_obj);
7835 rb_execarg_run_options(sargp, NULL, NULL, 0);
7837 if (!fp) rb_syserr_fail_path(e, prog);
7847 fptr->
encs = *convconfig;
7848#if RUBY_CRLF_ENVIRONMENT
7855 if (NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {
7858#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
7859 if (NEED_NEWLINE_DECORATOR_ON_WRITE(fptr)) {
7860 fptr->
encs.
ecflags |= TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;
7866 if (0 <= write_fd) {
7867 write_port = io_alloc(
rb_cIO);
7869 write_fptr->
fd = write_fd;
7873 rb_ivar_set(port, rb_intern(
"@tied_io_for_writing"), write_port);
7876#if defined (__CYGWIN__) || !defined(HAVE_WORKING_FORK)
7878 pipe_add_fptr(fptr);
7884pipe_open(
VALUE execarg_obj,
const char *modestr,
enum rb_io_mode fmode,
7892is_popen_fork(
VALUE prog)
7894 if (RSTRING_LEN(prog) == 1 && RSTRING_PTR(prog)[0] ==
'-') {
7895#if !defined(HAVE_WORKING_FORK)
7897 "fork() function is unimplemented on this machine");
7906pipe_open_s(
VALUE prog,
const char *modestr,
enum rb_io_mode fmode,
7910 VALUE *argv = &prog;
7913 if (!is_popen_fork(prog))
7914 execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE);
7915 return pipe_open(execarg_obj, modestr, fmode, convconfig);
7921 rb_io_t *fptr = io_close_fptr(io);
8090rb_io_s_popen(
int argc,
VALUE *argv,
VALUE klass)
8094 if (argc > 1 && !
NIL_P(opt = rb_check_hash_type(argv[argc-1]))) --argc;
8095 if (argc > 1 && !
NIL_P(env = rb_check_hash_type(argv[0]))) --argc, ++argv;
8104 int ex = !
NIL_P(opt);
8105 rb_error_arity(argc + ex, 1 + ex, 2 + ex);
8108 return popen_finish(rb_io_popen(pname, pmode, env, opt), klass);
8114 const char *modestr;
8117 enum rb_io_mode fmode;
8123#if SIZEOF_LONG > SIZEOF_INT
8124 if (
len > INT_MAX) {
8125 rb_raise(rb_eArgError,
"too many arguments");
8134 if (!is_popen_fork(pname))
8135 execarg_obj = rb_execarg_new(1, &pname, TRUE, FALSE);
8137 if (!
NIL_P(execarg_obj)) {
8139 opt = rb_execarg_extract_options(execarg_obj, opt);
8141 rb_execarg_setenv(execarg_obj, env);
8144 modestr = rb_io_oflags_modestr(oflags);
8146 return pipe_open(execarg_obj, modestr, fmode, &convconfig);
8156 rb_io_flush(rb_ractor_stdout());
8157 rb_io_flush(rb_ractor_stderr());
8162 RBASIC_SET_CLASS(port, klass);
8169#if defined(HAVE_WORKING_FORK) && !defined(__EMSCRIPTEN__)
8170struct popen_writer_arg {
8172 struct popen_arg popen;
8176exec_popen_writer(
void *arg,
char *errmsg,
size_t buflen)
8178 struct popen_writer_arg *pw = arg;
8180 popen_redirect(&pw->popen);
8181 execv(pw->argv[0], pw->argv);
8182 strlcpy(errmsg, strerror(
errno), buflen);
8188ruby_popen_writer(
char *
const *argv, rb_pid_t *pid)
8190#if (defined(HAVE_WORKING_FORK) && !defined(__EMSCRIPTEN__)) || defined(_WIN32)
8191# ifdef HAVE_WORKING_FORK
8192 struct popen_writer_arg pw;
8193 int *
const write_pair = pw.popen.pair;
8199 if (cloexec_pipe(write_pair, 0,
false) == 0) {
8200# ifdef HAVE_WORKING_FORK
8203 char errmsg[80] = {
'\0'};
8204 *pid = rb_fork_async_signal_safe(&status, exec_popen_writer, &pw,
Qnil, errmsg,
sizeof(errmsg));
8206 *pid = rb_w32_uspawn_process(P_NOWAIT, argv[0], argv, write_pair[0], -1, -1, 0);
8207 const char *errmsg = (*pid < 0) ? strerror(
errno) : NULL;
8209 close(write_pair[0]);
8211 close(write_pair[1]);
8212 fprintf(stderr,
"ruby_popen_writer(%s): %s\n", argv[0], errmsg);
8215 return fdopen(write_pair[1],
"w");
8226 enum rb_io_mode fmode;
8235 rb_file_open_generic(io, fname, oflags, fmode, &convconfig, perm);
8273rb_io_s_open(
int argc,
VALUE *argv,
VALUE klass)
8305 VALUE fname, vmode, vperm;
8310 rb_scan_args(argc, argv,
"12", &fname, &vmode, &vperm);
8321 if (
NIL_P(vperm)) perm = 0666;
8325 fd = rb_sysopen(fname, oflags, perm);
8357 int redirect = FALSE;
8365 VALUE tmp = argv[0];
8383 return rb_io_s_open(argc, argv,
rb_cFile);
8387rb_io_open_generic(
VALUE klass,
VALUE filename,
int oflags,
enum rb_io_mode fmode,
8390 return rb_file_open_generic(io_alloc(klass), filename,
8391 oflags, fmode, convconfig, perm);
8398 enum rb_io_mode fmode;
8404 return rb_io_open_generic(io, filename, oflags, fmode, &convconfig, perm);
8410 rb_io_t *fptr, *orig;
8418 if (fptr == orig)
return io;
8419 if (RUBY_IO_EXTERNAL_P(fptr)) {
8423 rb_raise(rb_eArgError,
8424 "%s can't change access mode from \"%s\" to \"%s\"",
8425 PREP_STDIO_NAME(fptr), rb_io_fmode_modestr(fptr->
mode),
8426 rb_io_fmode_modestr(orig->
mode));
8430 if (io_fflush(fptr) < 0)
8431 rb_sys_fail_on_write(fptr);
8434 flush_before_seek(fptr,
true);
8437 pos = io_tell(orig);
8440 if (io_fflush(orig) < 0)
8441 rb_sys_fail_on_write(fptr);
8450 else if (!RUBY_IO_EXTERNAL_P(fptr)) fptr->
pathv =
Qnil;
8451 fptr_copy_finalizer(fptr, orig);
8457 rb_thread_io_close_interrupt(fptr);
8458 rb_thread_io_close_wait(fptr);
8460 if (RUBY_IO_EXTERNAL_P(fptr) || fd <= 2 || !fptr->stdio_file) {
8463 rb_sys_fail_path(orig->
pathv);
8471 rb_sys_fail_path(orig->
pathv);
8477 if (io_seek(fptr, pos, SEEK_SET) < 0 &&
errno) {
8478 rb_sys_fail_path(fptr->
pathv);
8480 if (io_seek(orig, pos, SEEK_SET) < 0 &&
errno) {
8481 rb_sys_fail_path(orig->
pathv);
8495int rb_freopen(
VALUE fname,
const char *mode, FILE *fp);
8498rb_freopen(
VALUE fname,
const char *mode, FILE *fp)
8500 if (!freopen(RSTRING_PTR(fname), mode, fp)) {
8543rb_io_reopen(
int argc,
VALUE *argv,
VALUE file)
8545 VALUE fname, nmode, opt;
8549 if (
rb_scan_args(argc, argv,
"11:", &fname, &nmode, &opt) == 1) {
8552 return io_reopen(file, tmp);
8558 fptr =
RFILE(file)->fptr;
8564 enum rb_io_mode fmode;
8568 if (RUBY_IO_EXTERNAL_P(fptr) &&
8571 rb_raise(rb_eArgError,
8572 "%s can't change access mode from \"%s\" to \"%s\"",
8573 PREP_STDIO_NAME(fptr), rb_io_fmode_modestr(fptr->
mode),
8574 rb_io_fmode_modestr(fmode));
8577 fptr->
encs = convconfig;
8580 oflags = rb_io_fmode_oflags(fptr->
mode);
8583 fptr->
pathv = fname;
8585 fptr->
fd = rb_sysopen(fptr->
pathv, oflags, 0666);
8591 if (io_fflush(fptr) < 0)
8592 rb_sys_fail_on_write(fptr);
8597 int e = rb_freopen(rb_str_encode_ospath(fptr->
pathv),
8598 rb_io_oflags_modestr(oflags),
8600 if (e) rb_syserr_fail_path(e, fptr->
pathv);
8604 if (setvbuf(fptr->
stdio_file, NULL, _IOFBF, 0) != 0)
8605 rb_warn(
"setvbuf() can't be honoured for %"PRIsVALUE, fptr->
pathv);
8608 if (setvbuf(fptr->
stdio_file, NULL, _IONBF, BUFSIZ) != 0)
8609 rb_warn(
"setvbuf() can't be honoured for %"PRIsVALUE, fptr->
pathv);
8611 else if (fptr->
stdio_file == stdout && isatty(fptr->
fd)) {
8612 if (setvbuf(fptr->
stdio_file, NULL, _IOLBF, BUFSIZ) != 0)
8613 rb_warn(
"setvbuf() can't be honoured for %"PRIsVALUE, fptr->
pathv);
8617 int tmpfd = rb_sysopen(fptr->
pathv, oflags, 0666);
8623 rb_syserr_fail_path(err, fptr->
pathv);
8634 rb_io_t *fptr, *orig;
8654 fptr->closing_ec = NULL;
8655 fptr->wakeup_mutex =
Qnil;
8656 fptr->fork_generation = GET_VM()->fork_gen;
8659 fptr_copy_finalizer(fptr, orig);
8661 fd = ruby_dup(orig->
fd);
8663 pos = io_tell(orig);
8665 io_seek(fptr, pos, SEEK_SET);
8670 write_io = GetWriteIO(io);
8671 if (io != write_io) {
8674 rb_ivar_set(dest, rb_intern(
"@tied_io_for_writing"), write_io);
8737 if (argc == 0)
return Qnil;
8738 if (RB_TYPE_P(argv[0],
T_STRING)) {
8739 out = rb_ractor_stdout();
8751extern void rb_deprecated_str_setter(
VALUE val,
ID id,
VALUE *var);
8756 rb_deprecated_str_setter(val,
id, &val);
8762 val = rb_str_frozen_bare_string(val);
8839 for (i=0; i<argc; i++) {
8843 rb_io_write(out, argv[i]);
8940 rb_io_write(io, str);
8944#define forward(obj, id, argc, argv) \
8945 rb_funcallv_kw(obj, id, argc, argv, RB_PASS_CALLED_KEYWORDS)
8946#define forward_public(obj, id, argc, argv) \
8947 rb_funcallv_public_kw(obj, id, argc, argv, RB_PASS_CALLED_KEYWORDS)
8948#define forward_current(id, argc, argv) \
8949 forward_public(ARGF.current_file, id, argc, argv)
8966 VALUE r_stdout = rb_ractor_stdout();
8967 if (recv == r_stdout) {
8968 return rb_io_putc(recv, ch);
8970 return forward(r_stdout, rb_intern(
"putc"), 1, &ch);
8975rb_str_end_with_asciichar(
VALUE str,
int c)
8977 long len = RSTRING_LEN(str);
8978 const char *
ptr = RSTRING_PTR(str);
8982 if (
len == 0)
return 0;
8983 if ((n = rb_enc_mbminlen(
enc)) == 1) {
8984 return ptr[
len - 1] == c;
8986 return rb_enc_ascget(
ptr + ((
len - 1) / n) * n,
ptr +
len, &n,
enc) == c;
8997 rb_io_puts(1, &tmp, out);
9004 rb_io_puts(1, &tmp, out);
9059 VALUE line, args[2];
9066 for (
int i = 0; i < argc; i++) {
9068 if (RB_TYPE_P(argv[i],
T_STRING)) {
9080 if (RSTRING_LEN(line) == 0) {
9085 if (!rb_str_end_with_asciichar(line,
'\n')) {
9090 rb_io_writev(out, n, args);
9108 VALUE r_stdout = rb_ractor_stdout();
9109 if (recv == r_stdout) {
9110 return rb_io_puts(argc, argv, recv);
9112 return forward(r_stdout, rb_intern(
"puts"), argc, argv);
9116rb_p_write(
VALUE str)
9121 VALUE r_stdout = rb_ractor_stdout();
9122 if (RB_TYPE_P(r_stdout,
T_FILE) &&
9123 rb_method_basic_definition_p(
CLASS_OF(r_stdout), id_write)) {
9124 io_writev(2, args, r_stdout);
9127 rb_io_writev(r_stdout, 2, args);
9139rb_p_result(
int argc,
const VALUE *argv)
9146 else if (argc > 1) {
9149 VALUE r_stdout = rb_ractor_stdout();
9150 if (RB_TYPE_P(r_stdout,
T_FILE)) {
9151 rb_uninterruptible(rb_io_flush, r_stdout);
9192 for (i=0; i<argc; i++) {
9194 rb_uninterruptible(rb_p_write, inspected);
9196 return rb_p_result(argc, argv);
9217rb_obj_display(
int argc,
VALUE *argv,
VALUE self)
9221 out = (!rb_check_arity(argc, 0, 1) ? rb_ractor_stdout() : argv[0]);
9222 rb_io_write(out, self);
9228rb_stderr_to_original_p(
VALUE err)
9230 return (err == orig_stderr ||
RFILE(orig_stderr)->fptr->
fd < 0);
9236 VALUE out = rb_ractor_stderr();
9237 if (rb_stderr_to_original_p(out)) {
9239 if (isatty(fileno(stderr))) {
9240 if (rb_w32_write_console(
rb_str_new(mesg,
len), fileno(stderr)) > 0)
return;
9243 if (fwrite(mesg,
sizeof(
char), (
size_t)
len, stderr) < (
size_t)
len) {
9260rb_write_error_str(
VALUE mesg)
9262 VALUE out = rb_ractor_stderr();
9264 if (rb_stderr_to_original_p(out)) {
9265 size_t len = (size_t)RSTRING_LEN(mesg);
9267 if (isatty(fileno(stderr))) {
9268 if (rb_w32_write_console(mesg, fileno(stderr)) > 0)
return;
9271 if (fwrite(RSTRING_PTR(mesg),
sizeof(
char),
len, stderr) <
len) {
9278 rb_io_write(out, mesg);
9283rb_stderr_tty_p(
void)
9285 if (rb_stderr_to_original_p(rb_ractor_stderr()))
9286 return isatty(fileno(stderr));
9291must_respond_to(
ID mid,
VALUE val,
ID id)
9294 rb_raise(
rb_eTypeError,
"%"PRIsVALUE
" must have %"PRIsVALUE
" method, %"PRIsVALUE
" given",
9295 rb_id2str(
id), rb_id2str(mid),
9315 must_respond_to(id_write, val,
id);
9322 return rb_ractor_stdout();
9328 must_respond_to(id_write, val,
id);
9335 return rb_ractor_stderr();
9339allocate_and_open_new_file(
VALUE klass)
9341 VALUE self = io_alloc(klass);
9342 rb_io_make_open_file(self);
9350 VALUE self = rb_protect(allocate_and_open_new_file, klass, &state);
9358 maygvl_close(descriptor, 0);
9364 rb_io_t *io =
RFILE(self)->fptr;
9366 io->
fd = descriptor;
9384 io->closing_ec = NULL;
9385 io->wakeup_mutex =
Qnil;
9386 io->fork_generation = GET_VM()->fork_gen;
9389 io->
encs = *encoding;
9398prep_io(
int fd,
enum rb_io_mode fmode,
VALUE klass,
const char *path)
9408 e = (fmode &
FMODE_BINMODE) ? rb_ascii8bit_encoding() : NULL;
9409 rb_io_ext_int_to_encs(e, NULL, &convconfig.
enc, &convconfig.
enc2, fmode);
9413#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
9415 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
9416 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
9418 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(convconfig.
enc2, convconfig.
ecflags);
9422 rb_io_t*io =
RFILE(self)->fptr;
9424 if (!io_check_tty(io)) {
9427 setmode(fd, O_BINARY);
9439 if (path && strcmp(path,
"-")) klass =
rb_cFile;
9444prep_stdio(FILE *f,
enum rb_io_mode fmode,
VALUE klass,
const char *path)
9451#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
9452 fptr->
encs.
ecflags |= TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;
9463rb_io_prep_stdin(
void)
9469rb_io_prep_stdout(
void)
9475rb_io_prep_stderr(
void)
9484 int oflags = rb_io_fmode_oflags(fptr->
mode) & ~O_EXCL;
9499static inline rb_io_t *
9502 rb_io_t *fp =
ALLOC(rb_io_t);
9511 rb_io_buffer_init(&fp->
wbuf);
9512 rb_io_buffer_init(&fp->
rbuf);
9513 rb_io_buffer_init(&fp->
cbuf);
9528 fp->closing_ec = NULL;
9529 fp->wakeup_mutex =
Qnil;
9530 fp->fork_generation = GET_VM()->fork_gen;
9535rb_io_make_open_file(
VALUE obj)
9540 if (
RFILE(obj)->fptr) {
9543 RFILE(obj)->fptr = 0;
9545 fp = rb_io_fptr_new();
9547 RFILE(obj)->fptr = fp;
9595rb_io_initialize(
int argc,
VALUE *argv,
VALUE io)
9601 return io_initialize(io, fnum, vmode, opt);
9608 int fd, oflags = O_RDONLY;
9609 enum rb_io_mode fmode;
9611#if defined(HAVE_FCNTL) && defined(F_GETFL)
9621 rb_raise(rb_eArgError,
"The given fd is not accessible because RubyVM reserves it");
9623#if defined(HAVE_FCNTL) && defined(F_GETFL)
9624 oflags = fcntl(fd, F_GETFL);
9625 if (oflags == -1) rb_sys_fail(0);
9627 if (fstat(fd, &st) < 0) rb_sys_fail(0);
9630#if defined(HAVE_FCNTL) && defined(F_GETFL)
9643 if (rb_hash_aref(opt, sym_autoclose) ==
Qfalse) {
9647 path = rb_hash_aref(opt,
RB_ID2SYM(idPath));
9658 fp->
encs = convconfig;
9662 fp->closing_ec = NULL;
9663 fp->wakeup_mutex =
Qnil;
9664 fp->fork_generation = GET_VM()->fork_gen;
9667 if (fileno(stdin) == fd)
9669 else if (fileno(stdout) == fd)
9671 else if (fileno(stderr) == fd)
9703rb_io_set_encoding_by_bom(
VALUE io)
9709 rb_raise(rb_eArgError,
"ASCII incompatible encoding needs binmode");
9712 rb_raise(rb_eArgError,
"encoding conversion is set");
9714 else if (fptr->
encs.
enc && fptr->
encs.
enc != rb_ascii8bit_encoding()) {
9715 rb_raise(rb_eArgError,
"encoding is set to %s already",
9718 if (!io_set_encoding_by_bom(io))
return Qnil;
9719 return rb_enc_from_encoding(fptr->
encs.
enc);
9764rb_file_initialize(
int argc,
VALUE *argv,
VALUE io)
9766 if (
RFILE(io)->fptr) {
9769 VALUE fname, vmode, vperm, opt;
9770 int posargc =
rb_scan_args(argc, argv,
"12:", &fname, &vmode, &vperm, &opt);
9775 return io_initialize(io, fd, vmode, opt);
9778 return rb_open_file(io, fname, vmode, vperm, opt);
9783rb_io_s_new(
int argc,
VALUE *argv,
VALUE klass)
9788 rb_warn(
"%"PRIsVALUE
"::new() does not take block; use %"PRIsVALUE
"::open() instead",
9804rb_io_s_for_fd(
int argc,
VALUE *argv,
VALUE klass)
9807 rb_io_initialize(argc, argv, io);
9820rb_io_autoclose_p(
VALUE io)
9822 rb_io_t *fptr =
RFILE(io)->fptr;
9845rb_io_set_autoclose(
VALUE io,
VALUE autoclose)
9849 if (!
RTEST(autoclose))
9857io_wait_event(
VALUE io,
int event,
VALUE timeout,
int return_io)
9861 if (!RB_TEST(result)) {
9889io_wait_readable(
int argc,
VALUE *argv,
VALUE io)
9898 rb_check_arity(argc, 0, 1);
9899 VALUE timeout = (argc == 1 ? argv[0] :
Qnil);
9913io_wait_writable(
int argc,
VALUE *argv,
VALUE io)
9920 rb_check_arity(argc, 0, 1);
9921 VALUE timeout = (argc == 1 ? argv[0] :
Qnil);
9936io_wait_priority(
int argc,
VALUE *argv,
VALUE io)
9938 rb_io_t *fptr = NULL;
9945 rb_check_arity(argc, 0, 1);
9946 VALUE timeout = argc == 1 ? argv[0] :
Qnil;
9952wait_mode_sym(
VALUE mode)
9954 if (mode ==
ID2SYM(rb_intern(
"r"))) {
9955 return RB_WAITFD_IN;
9957 if (mode ==
ID2SYM(rb_intern(
"read"))) {
9958 return RB_WAITFD_IN;
9960 if (mode ==
ID2SYM(rb_intern(
"readable"))) {
9961 return RB_WAITFD_IN;
9963 if (mode ==
ID2SYM(rb_intern(
"w"))) {
9964 return RB_WAITFD_OUT;
9966 if (mode ==
ID2SYM(rb_intern(
"write"))) {
9967 return RB_WAITFD_OUT;
9969 if (mode ==
ID2SYM(rb_intern(
"writable"))) {
9970 return RB_WAITFD_OUT;
9972 if (mode ==
ID2SYM(rb_intern(
"rw"))) {
9973 return RB_WAITFD_IN|RB_WAITFD_OUT;
9975 if (mode ==
ID2SYM(rb_intern(
"read_write"))) {
9976 return RB_WAITFD_IN|RB_WAITFD_OUT;
9978 if (mode ==
ID2SYM(rb_intern(
"readable_writable"))) {
9979 return RB_WAITFD_IN|RB_WAITFD_OUT;
9982 rb_raise(rb_eArgError,
"unsupported mode: %"PRIsVALUE, mode);
9986io_event_from_value(
VALUE value)
9990 if (events <= 0) rb_raise(rb_eArgError,
"Events must be positive integer!");
10023 if (argc != 2 || (RB_SYMBOL_P(argv[0]) || RB_SYMBOL_P(argv[1]))) {
10028 for (
int i = 0; i < argc; i += 1) {
10029 if (RB_SYMBOL_P(argv[i])) {
10030 events |= wait_mode_sym(argv[i]);
10032 else if (UNDEF_P(timeout)) {
10036 rb_raise(rb_eArgError,
"timeout given more than once");
10040 if (UNDEF_P(timeout)) timeout =
Qnil;
10048 events = io_event_from_value(argv[0]);
10053 rb_io_t *fptr = NULL;
10058 if (return_io)
return Qtrue;
10064 return io_wait_event(io, events, timeout, return_io);
10068argf_mark_and_move(
void *
ptr)
10071 rb_gc_mark_and_move(&p->filename);
10072 rb_gc_mark_and_move(&p->current_file);
10073 rb_gc_mark_and_move(&p->argv);
10074 rb_gc_mark_and_move(&p->inplace);
10075 rb_gc_mark_and_move(&p->encs.
ecopts);
10079argf_memsize(
const void *
ptr)
10082 size_t size =
sizeof(*p);
10089 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
10095 p->filename =
Qnil;
10096 p->current_file =
Qnil;
10102argf_alloc(
VALUE klass)
10107 argf_init(p,
Qnil);
10117 memset(&ARGF, 0,
sizeof(ARGF));
10118 argf_init(&ARGF, argv);
10128 ARGF = argf_of(orig);
10155 ARGF.last_lineno = ARGF.lineno;
10181 return forward_current(rb_frame_this_func(), argc, argv);
10184#define next_argv() argf_next_argv(argf)
10185#define ARGF_GENERIC_INPUT_P() \
10186 (ARGF.current_file == rb_stdin && !RB_TYPE_P(ARGF.current_file, T_FILE))
10187#define ARGF_FORWARD(argc, argv) do {\
10188 if (ARGF_GENERIC_INPUT_P())\
10189 return argf_forward((argc), (argv), argf);\
10191#define NEXT_ARGF_FORWARD(argc, argv) do {\
10192 if (!next_argv()) return Qnil;\
10193 ARGF_FORWARD((argc), (argv));\
10199 VALUE file = ARGF.current_file;
10201 if (RB_TYPE_P(file,
T_FILE)) {
10213 int stdout_binmode = 0;
10214 enum rb_io_mode fmode;
10216 VALUE r_stdout = rb_ractor_stdout();
10218 if (RB_TYPE_P(r_stdout,
T_FILE)) {
10221 stdout_binmode = 1;
10224 if (ARGF.init_p == 0) {
10234 if (
NIL_P(ARGF.argv)) {
10237 else if (ARGF.next_p == -1 &&
RARRAY_LEN(ARGF.argv) > 0) {
10242 if (ARGF.next_p == 1) {
10243 if (ARGF.init_p == 1) argf_close(
argf);
10248 ARGF.filename = filename;
10249 filename = rb_str_encode_ospath(filename);
10251 if (RSTRING_LEN(filename) == 1 && fn[0] ==
'-') {
10253 if (ARGF.inplace) {
10254 rb_warn(
"Can't do inplace edit for stdio; skipping");
10260 int fr = rb_sysopen(filename, O_RDONLY, 0);
10262 if (ARGF.inplace) {
10264#ifndef NO_SAFE_RENAME
10270 if (RB_TYPE_P(r_stdout,
T_FILE) && r_stdout != orig_stdout) {
10275 if (!
NIL_P(ARGF.inplace)) {
10276 VALUE suffix = ARGF.inplace;
10278 if (
NIL_P(rb_str_cat_conv_enc_opts(str, RSTRING_LEN(str),
10279 RSTRING_PTR(suffix), RSTRING_LEN(suffix),
10280 rb_enc_get(suffix), 0,
Qnil))) {
10283#ifdef NO_SAFE_RENAME
10285 (void)unlink(RSTRING_PTR(str));
10286 if (rename(fn, RSTRING_PTR(str)) < 0) {
10287 rb_warn(
"Can't rename %"PRIsVALUE
" to %"PRIsVALUE
": %s, skipping file",
10288 filename, str, strerror(
errno));
10291 fr = rb_sysopen(str, O_RDONLY, 0);
10293 if (rename(fn, RSTRING_PTR(str)) < 0) {
10294 rb_warn(
"Can't rename %"PRIsVALUE
" to %"PRIsVALUE
": %s, skipping file",
10295 filename, str, strerror(
errno));
10302#ifdef NO_SAFE_RENAME
10303 rb_fatal(
"Can't do inplace edit without backup");
10305 if (unlink(fn) < 0) {
10306 rb_warn(
"Can't remove %"PRIsVALUE
": %s, skipping file",
10307 filename, strerror(
errno));
10313 fw = rb_sysopen(filename, O_WRONLY|O_CREAT|O_TRUNC, 0666);
10314#ifndef NO_SAFE_RENAME
10317 fchmod(fw, st.st_mode);
10319 chmod(fn, st.st_mode);
10321 if (st.st_uid!=st2.st_uid || st.st_gid!=st2.st_gid) {
10324 err = fchown(fw, st.st_uid, st.st_gid);
10326 err = chown(fn, st.st_uid, st.st_gid);
10328 if (err && getuid() == 0 && st2.st_uid == 0) {
10329 const char *wkfn = RSTRING_PTR(filename);
10330 rb_warn(
"Can't set owner/group of %"PRIsVALUE
" to same as %"PRIsVALUE
": %s, skipping file",
10331 filename, str, strerror(
errno));
10334 (void)unlink(wkfn);
10344 if (!ARGF.binmode) {
10345 fmode |= DEFAULT_TEXTMODE;
10347 ARGF.current_file = prep_io(fr, fmode,
rb_cFile, fn);
10348 if (!
NIL_P(write_io)) {
10355 if (ARGF.encs.enc) {
10356 fptr->
encs = ARGF.encs;
10357 clear_codeconv(fptr);
10361 if (!ARGF.binmode) {
10363#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
10364 fptr->
encs.
ecflags |= TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;
10375 else if (ARGF.next_p == -1) {
10378 if (ARGF.inplace) {
10379 rb_warn(
"Can't do inplace edit for stdio");
10383 if (ARGF.init_p == -1) ARGF.init_p = 1;
10391 long lineno = ARGF.lineno;
10394 if (!next_argv())
return Qnil;
10395 if (ARGF_GENERIC_INPUT_P()) {
10396 line = forward_current(idGets, argc, argv);
10403 line = rb_io_getline(argc, argv, ARGF.current_file);
10405 if (
NIL_P(line) && ARGF.next_p != -1) {
10411 if (!
NIL_P(line)) {
10412 ARGF.lineno = ++lineno;
10413 ARGF.last_lineno = ARGF.lineno;
10419argf_lineno_getter(
ID id,
VALUE *var)
10422 return INT2FIX(ARGF.last_lineno);
10430 ARGF.last_lineno = ARGF.lineno = n;
10434rb_reset_argf_lineno(
long n)
10436 ARGF.last_lineno = ARGF.lineno = n;
10477 if (recv ==
argf) {
10478 return argf_gets(argc, argv,
argf);
10480 return forward(
argf, idGets, argc, argv);
10506 line = argf_getline(argc, argv,
argf);
10518 return rb_f_gets(0, 0,
argf);
10522 if (!next_argv())
return Qnil;
10524 if (
NIL_P(line) && ARGF.next_p != -1) {
10530 if (!
NIL_P(line)) {
10532 ARGF.last_lineno = ARGF.lineno;
10558rb_f_readline(
int argc,
VALUE *argv,
VALUE recv)
10560 if (recv ==
argf) {
10561 return argf_readline(argc, argv,
argf);
10563 return forward(
argf, rb_intern(
"readline"), argc, argv);
10590 ARGF_FORWARD(argc, argv);
10591 line = argf_gets(argc, argv,
argf);
10661rb_f_readlines(
int argc,
VALUE *argv,
VALUE recv)
10663 if (recv ==
argf) {
10664 return argf_readlines(argc, argv,
argf);
10666 return forward(
argf, rb_intern(
"readlines"), argc, argv);
10690 long lineno = ARGF.lineno;
10694 while (next_argv()) {
10695 if (ARGF_GENERIC_INPUT_P()) {
10696 lines = forward_current(rb_intern(
"readlines"), argc, argv);
10699 lines = rb_io_readlines(argc, argv, ARGF.current_file);
10705 ARGF.last_lineno = ARGF.lineno;
10740 rb_last_status_clear();
10741 port = pipe_open_s(str,
"r",
FMODE_READABLE|DEFAULT_TEXTMODE, NULL);
10745 result = read_all(fptr, remain_size(fptr),
Qnil);
10747 rb_io_fptr_cleanup_all(fptr);
10753#ifdef HAVE_SYS_SELECT_H
10754#include <sys/select.h>
10768 if (!
NIL_P(read)) {
10773 if (READ_DATA_PENDING(fptr) || READ_CHAR_PENDING(fptr)) {
10777 if (max < fptr->fd) max = fptr->
fd;
10780 timerec.tv_sec = timerec.tv_usec = 0;
10788 if (!
NIL_P(write)) {
10794 if (max < fptr->fd) max = fptr->
fd;
10801 if (!
NIL_P(except)) {
10805 VALUE write_io = GetWriteIO(io);
10808 if (max < fptr->fd) max = fptr->
fd;
10809 if (io != write_io) {
10812 if (max < fptr->fd) max = fptr->
fd;
10827 if (!pending && n == 0)
return Qnil;
10852 VALUE write_io = GetWriteIO(io);
10865 VALUE write_io = GetWriteIO(io);
10870 else if (io != write_io) {
10883 VALUE read, write, except;
10889select_call(
VALUE arg)
10893 return select_internal(p->read, p->write, p->except, p->timeout, p->fdsets);
10897select_end(
VALUE arg)
10902 for (i = 0; i < numberof(p->fdsets); ++i)
10907static VALUE sym_normal, sym_sequential, sym_random,
10908 sym_willneed, sym_dontneed, sym_noreuse;
10910#ifdef HAVE_POSIX_FADVISE
10911struct io_advise_struct {
10919io_advise_internal(
void *arg)
10921 struct io_advise_struct *
ptr = arg;
10922 return posix_fadvise(
ptr->fd,
ptr->offset,
ptr->len,
ptr->advice);
10926io_advise_sym_to_const(
VALUE sym)
10928#ifdef POSIX_FADV_NORMAL
10929 if (sym == sym_normal)
10930 return INT2NUM(POSIX_FADV_NORMAL);
10933#ifdef POSIX_FADV_RANDOM
10934 if (sym == sym_random)
10935 return INT2NUM(POSIX_FADV_RANDOM);
10938#ifdef POSIX_FADV_SEQUENTIAL
10939 if (sym == sym_sequential)
10940 return INT2NUM(POSIX_FADV_SEQUENTIAL);
10943#ifdef POSIX_FADV_WILLNEED
10944 if (sym == sym_willneed)
10945 return INT2NUM(POSIX_FADV_WILLNEED);
10948#ifdef POSIX_FADV_DONTNEED
10949 if (sym == sym_dontneed)
10950 return INT2NUM(POSIX_FADV_DONTNEED);
10953#ifdef POSIX_FADV_NOREUSE
10954 if (sym == sym_noreuse)
10955 return INT2NUM(POSIX_FADV_NOREUSE);
10962do_io_advise(rb_io_t *fptr,
VALUE advice, rb_off_t offset, rb_off_t
len)
10965 struct io_advise_struct ias;
10968 num_adv = io_advise_sym_to_const(advice);
10974 if (
NIL_P(num_adv))
10978 ias.advice =
NUM2INT(num_adv);
10979 ias.offset = offset;
10982 rv = (int)rb_io_blocking_region(fptr, io_advise_internal, &ias);
10983 if (rv && rv != ENOSYS) {
10986 VALUE message = rb_sprintf(
"%"PRIsVALUE
" "
10990 fptr->
pathv, offset,
len, advice);
11000advice_arg_check(
VALUE advice)
11005 if (advice != sym_normal &&
11006 advice != sym_sequential &&
11007 advice != sym_random &&
11008 advice != sym_willneed &&
11009 advice != sym_dontneed &&
11010 advice != sym_noreuse) {
11011 rb_raise(
rb_eNotImpError,
"Unsupported advice: %+"PRIsVALUE, advice);
11049rb_io_advise(
int argc,
VALUE *argv,
VALUE io)
11056 advice_arg_check(advice);
11058 io = GetWriteIO(io);
11064#ifdef HAVE_POSIX_FADVISE
11065 return do_io_advise(fptr, advice,
off, l);
11067 ((void)
off, (void)l);
11076 if (!RB_FLOAT_TYPE_P(x))
11079 return isinf(f) && 0 < f;
11235rb_f_select(
int argc,
VALUE *argv,
VALUE obj)
11238 if (scheduler !=
Qnil) {
11241 if (!UNDEF_P(result))
return result;
11249 rb_scan_args(argc, argv,
"13", &args.read, &args.write, &args.except, &timeout);
11250 if (
NIL_P(timeout) || is_pos_inf(timeout)) {
11255 args.timeout = &timerec;
11258 for (i = 0; i < numberof(args.fdsets); ++i)
11264#ifdef IOCTL_REQ_TYPE
11265 typedef IOCTL_REQ_TYPE ioctl_req_t;
11267 typedef int ioctl_req_t;
11268# define NUM2IOCTLREQ(num) ((int)NUM2LONG(num))
11279nogvl_ioctl(
void *
ptr)
11281 struct ioctl_arg *arg =
ptr;
11283 return (
VALUE)ioctl(arg->fd, arg->cmd, arg->narg);
11287do_ioctl(
struct rb_io *io, ioctl_req_t cmd,
long narg)
11290 struct ioctl_arg arg;
11296 retval = (int)rb_io_blocking_region(io, nogvl_ioctl, &arg);
11302#define DEFAULT_IOCTL_NARG_LEN (256)
11304#if defined(__linux__) && defined(_IOC_SIZE)
11306linux_iocparm_len(ioctl_req_t cmd)
11310 if ((cmd & 0xFFFF0000) == 0) {
11312 return DEFAULT_IOCTL_NARG_LEN;
11315 len = _IOC_SIZE(cmd);
11318 if (
len < DEFAULT_IOCTL_NARG_LEN)
11319 len = DEFAULT_IOCTL_NARG_LEN;
11327ioctl_narg_len(ioctl_req_t cmd)
11333#define IOCPARM_LEN(x) (((x) >> 16) & IOCPARM_MASK)
11337 len = IOCPARM_LEN(cmd);
11338#elif defined(__linux__) && defined(_IOC_SIZE)
11339 len = linux_iocparm_len(cmd);
11342 len = DEFAULT_IOCTL_NARG_LEN;
11351typedef long fcntl_arg_t;
11354typedef int fcntl_arg_t;
11358fcntl_narg_len(ioctl_req_t cmd)
11365 len =
sizeof(fcntl_arg_t);
11373#ifdef F_DUPFD_CLOEXEC
11374 case F_DUPFD_CLOEXEC:
11375 len =
sizeof(fcntl_arg_t);
11385 len =
sizeof(fcntl_arg_t);
11395 len =
sizeof(fcntl_arg_t);
11405 len =
sizeof(fcntl_arg_t);
11410 len =
sizeof(
struct f_owner_ex);
11415 len =
sizeof(
struct f_owner_ex);
11420 len =
sizeof(
struct flock);
11425 len =
sizeof(
struct flock);
11430 len =
sizeof(
struct flock);
11450 len =
sizeof(fcntl_arg_t);
11460 len =
sizeof(fcntl_arg_t);
11465 len =
sizeof(fcntl_arg_t);
11478fcntl_narg_len(ioctl_req_t cmd)
11484#define NARG_SENTINEL 17
11487setup_narg(ioctl_req_t cmd,
VALUE *argp,
long (*narg_len)(ioctl_req_t))
11498 else if (arg ==
Qtrue) {
11512 len = narg_len(cmd);
11513 rb_str_modify(arg);
11515 slen = RSTRING_LEN(arg);
11517 if (slen <
len+1) {
11518 rb_str_resize(arg,
len+1);
11519 MEMZERO(RSTRING_PTR(arg)+slen,
char,
len-slen);
11523 ptr = RSTRING_PTR(arg);
11524 ptr[slen - 1] = NARG_SENTINEL;
11533finish_narg(
int retval,
VALUE arg,
const rb_io_t *fptr)
11535 if (retval < 0) rb_sys_fail_path(fptr->
pathv);
11540 if (
ptr[slen-1] != NARG_SENTINEL)
11541 rb_raise(rb_eArgError,
"return value overflowed string");
11542 ptr[slen-1] =
'\0';
11552 ioctl_req_t cmd = NUM2IOCTLREQ(req);
11557 narg = setup_narg(cmd, &arg, ioctl_narg_len);
11559 retval = do_ioctl(fptr, cmd, narg);
11560 return finish_narg(retval, arg, fptr);
11587 return rb_ioctl(io, req, arg);
11590#define rb_io_ioctl rb_f_notimplement
11601nogvl_fcntl(
void *
ptr)
11603 struct fcntl_arg *arg =
ptr;
11605#if defined(F_DUPFD)
11606 if (arg->cmd == F_DUPFD)
11609 return (
VALUE)fcntl(arg->fd, arg->cmd, arg->narg);
11613do_fcntl(
struct rb_io *io,
int cmd,
long narg)
11616 struct fcntl_arg arg;
11622 retval = (int)rb_io_blocking_region(io, nogvl_fcntl, &arg);
11623 if (retval != -1) {
11625#if defined(F_DUPFD)
11628#if defined(F_DUPFD_CLOEXEC)
11629 case F_DUPFD_CLOEXEC:
11646 narg = setup_narg(cmd, &arg, fcntl_narg_len);
11648 retval = do_fcntl(fptr, cmd, narg);
11649 return finish_narg(retval, arg, fptr);
11675 return rb_fcntl(io, req, arg);
11678#define rb_io_fcntl rb_f_notimplement
11681#if defined(HAVE_SYSCALL) || defined(HAVE___SYSCALL)
11713#if SIZEOF_VOIDP == 8 && defined(HAVE___SYSCALL) && SIZEOF_INT != 8
11714# define SYSCALL __syscall
11715# define NUM2SYSCALLID(x) NUM2LONG(x)
11716# define RETVAL2NUM(x) LONG2NUM(x)
11717# if SIZEOF_LONG == 8
11718 long num, retval = -1;
11719# elif SIZEOF_LONG_LONG == 8
11720 long long num, retval = -1;
11722# error ---->> it is asserted that __syscall takes the first argument and returns retval in 64bit signed integer. <<----
11724#elif defined(__linux__)
11725# define SYSCALL syscall
11726# define NUM2SYSCALLID(x) NUM2LONG(x)
11727# define RETVAL2NUM(x) LONG2NUM(x)
11735 long num, retval = -1;
11737# define SYSCALL syscall
11738# define NUM2SYSCALLID(x) NUM2INT(x)
11739# define RETVAL2NUM(x) INT2NUM(x)
11740 int num, retval = -1;
11746 "We plan to remove a syscall function at future release. DL(Fiddle) provides safer alternative.");
11750 rb_raise(rb_eArgError,
"too few arguments for syscall");
11751 if (argc > numberof(arg))
11752 rb_raise(rb_eArgError,
"too many arguments for syscall");
11753 num = NUM2SYSCALLID(argv[0]); ++argv;
11754 for (i = argc - 1; i--; ) {
11769 retval = SYSCALL(num);
11772 retval = SYSCALL(num, arg[0]);
11775 retval = SYSCALL(num, arg[0],arg[1]);
11778 retval = SYSCALL(num, arg[0],arg[1],arg[2]);
11781 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3]);
11784 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4]);
11787 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5]);
11790 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6]);
11796 return RETVAL2NUM(retval);
11798#undef NUM2SYSCALLID
11802#define rb_f_syscall rb_f_notimplement
11806io_new_instance(
VALUE args)
11811static rb_encoding *
11812find_encoding(
VALUE v)
11814 rb_encoding *enc = rb_find_encoding(v);
11815 if (!enc)
rb_warn(
"Unsupported encoding %"PRIsVALUE
" ignored", v);
11822 rb_encoding *enc, *enc2;
11827 enc2 = find_encoding(v1);
11830 if (RSTRING_LEN(tmp) == 1 && RSTRING_PTR(tmp)[0] ==
'-') {
11836 enc = find_encoding(v2);
11843 enc = find_encoding(v2);
11849 if (enc2 == rb_ascii8bit_encoding()) {
11854 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
11860 rb_io_ext_int_to_encs(NULL, NULL, &enc, &enc2, 0);
11861 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
11866 if (!
NIL_P(tmp) && rb_enc_asciicompat(enc = rb_enc_get(tmp))) {
11867 parse_mode_enc(RSTRING_PTR(tmp), enc, &enc, &enc2, NULL);
11868 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
11872 rb_io_ext_int_to_encs(find_encoding(v1), NULL, &enc, &enc2, 0);
11873 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
11878 validate_enc_binmode(&fptr->
mode, ecflags, enc, enc2);
11883 clear_codeconv(fptr);
11895io_encoding_set_v(
VALUE v)
11898 io_encoding_set(arg->fptr, arg->v1, arg->v2, arg->opt);
11903pipe_pair_close(
VALUE rw)
11906 return rb_ensure(io_close, rwp[0], io_close, rwp[1]);
11989rb_io_s_pipe(
int argc,
VALUE *argv,
VALUE klass)
11991 int pipes[2], state;
11992 VALUE r, w, args[3], v1, v2;
11994 rb_io_t *fptr, *fptr2;
11996 enum rb_io_mode fmode = 0;
11999 argc =
rb_scan_args(argc, argv,
"02:", &v1, &v2, &opt);
12006 r = rb_protect(io_new_instance, (
VALUE)args, &state);
12010 rb_jump_tag(state);
12014 ies_args.fptr = fptr;
12017 ies_args.opt = opt;
12018 rb_protect(io_encoding_set_v, (
VALUE)&ies_args, &state);
12022 rb_jump_tag(state);
12027 w = rb_protect(io_new_instance, (
VALUE)args, &state);
12031 rb_jump_tag(state);
12036 extract_binmode(opt, &fmode);
12043#if DEFAULT_TEXTMODE
12046 setmode(fptr->
fd, O_BINARY);
12048#if RUBY_CRLF_ENVIRONMENT
12054 fptr->
mode |= fmode;
12055#if DEFAULT_TEXTMODE
12058 setmode(fptr2->
fd, O_BINARY);
12061 fptr2->
mode |= fmode;
12095 else if (!
NIL_P(v = rb_hash_aref(opt, sym_open_args))) {
12098 v = rb_to_array_type(v);
12099 n = RARRAY_LENINT(v);
12100 rb_check_arity(n, 0, 3);
12103 arg->io = rb_io_open(klass, path, vmode, vperm, opt);
12107io_s_foreach(
VALUE v)
12112 if (arg->limit == 0)
12113 rb_raise(rb_eArgError,
"invalid limit: 0 for foreach");
12114 while (!
NIL_P(str = rb_io_getline_1(arg->rs, arg->limit, arg->chomp, arg->io))) {
12198rb_io_s_foreach(
int argc,
VALUE *argv,
VALUE self)
12201 int orig_argc = argc;
12205 argc =
rb_scan_args(argc, argv,
"12:", NULL, NULL, NULL, &opt);
12207 extract_getline_args(argc-1, argv+1, &garg);
12208 open_key_args(self, argc, argv, opt, &arg);
12210 extract_getline_opts(opt, &garg);
12211 check_getline_args(&garg.rs, &garg.limit, garg.io = arg.io);
12216io_s_readlines(
VALUE v)
12219 return io_readlines(arg, arg->io);
12272rb_io_s_readlines(
int argc,
VALUE *argv,
VALUE io)
12278 argc =
rb_scan_args(argc, argv,
"12:", NULL, NULL, NULL, &opt);
12279 extract_getline_args(argc-1, argv+1, &garg);
12280 open_key_args(io, argc, argv, opt, &arg);
12282 extract_getline_opts(opt, &garg);
12283 check_getline_args(&garg.rs, &garg.limit, garg.io = arg.io);
12291 return io_read(arg->argc, arg->argv, arg->io);
12301seek_before_access(
VALUE argp)
12305 return rb_io_seek(arg->io, arg->offset, arg->mode);
12347rb_io_s_read(
int argc,
VALUE *argv,
VALUE io)
12353 argc =
rb_scan_args(argc, argv,
"13:", NULL, NULL, &offset, NULL, &opt);
12355 rb_raise(rb_eArgError,
"negative offset %ld given",
off);
12357 open_key_args(io, argc, argv, opt, &arg);
12359 if (!
NIL_P(offset)) {
12363 sarg.offset = offset;
12364 sarg.mode = SEEK_SET;
12365 rb_protect(seek_before_access, (
VALUE)&sarg, &state);
12368 rb_jump_tag(state);
12370 if (arg.argc == 2) arg.argc = 1;
12385rb_io_s_binread(
int argc,
VALUE *argv,
VALUE io)
12400 convconfig.
enc = rb_ascii8bit_encoding();
12401 arg.io = rb_io_open_generic(io, argv[0], oflags, fmode, &convconfig, 0);
12404 arg.argc = (argc > 1) ? 1 : 0;
12405 if (!
NIL_P(offset)) {
12409 sarg.offset = offset;
12410 sarg.mode = SEEK_SET;
12411 rb_protect(seek_before_access, (
VALUE)&sarg, &state);
12414 rb_jump_tag(state);
12421io_s_write0(
VALUE v)
12424 return io_write(arg->io,arg->str,arg->nosync);
12428io_s_write(
int argc,
VALUE *argv,
VALUE klass,
int binary)
12430 VALUE string, offset, opt;
12434 rb_scan_args(argc, argv,
"21:", NULL, &
string, &offset, &opt);
12436 if (
NIL_P(opt)) opt = rb_hash_new();
12437 else opt = rb_hash_dup(opt);
12440 if (
NIL_P(rb_hash_aref(opt,sym_mode))) {
12441 int mode = O_WRONLY|O_CREAT;
12443 if (binary) mode |= O_BINARY;
12445 if (
NIL_P(offset)) mode |= O_TRUNC;
12446 rb_hash_aset(opt,sym_mode,
INT2NUM(mode));
12448 open_key_args(klass, argc, argv, opt, &arg);
12451 if (binary) rb_io_binmode_m(arg.io);
12455 if (!
NIL_P(offset)) {
12459 sarg.offset = offset;
12460 sarg.mode = SEEK_SET;
12461 rb_protect(seek_before_access, (
VALUE)&sarg, &state);
12464 rb_jump_tag(state);
12516rb_io_s_write(
int argc,
VALUE *argv,
VALUE io)
12518 return io_s_write(argc, argv, io, 0);
12531rb_io_s_binwrite(
int argc,
VALUE *argv,
VALUE io)
12533 return io_s_write(argc, argv, io, 1);
12539 rb_off_t copy_length;
12540 rb_off_t src_offset;
12544 unsigned close_src : 1;
12545 unsigned close_dst : 1;
12548 const char *syserr;
12549 const char *notimp;
12551 struct stat src_stat;
12552 struct stat dst_stat;
12553#ifdef HAVE_FCOPYFILE
12554 copyfile_state_t copyfile_state;
12559exec_interrupts(
void *arg)
12562 rb_thread_execute_interrupts(th);
12576#if defined(ERESTART)
12581 rb_thread_execute_interrupts(stp->th);
12600fiber_scheduler_wait_for(
void * _arguments)
12610# define IOWAIT_SYSCALL "poll"
12611STATIC_ASSERT(pollin_expected, POLLIN == RB_WAITFD_IN);
12612STATIC_ASSERT(pollout_expected, POLLOUT == RB_WAITFD_OUT);
12614nogvl_wait_for(
VALUE th, rb_io_t *fptr,
short events,
struct timeval *timeout)
12617 if (scheduler !=
Qnil) {
12620 return RTEST(args.result);
12624 if (fd == -1)
return 0;
12629 fds.events = events;
12631 int timeout_milliseconds = -1;
12634 timeout_milliseconds = (int)(timeout->tv_sec * 1000) + (int)(timeout->tv_usec / 1000);
12637 return poll(&fds, 1, timeout_milliseconds);
12640# define IOWAIT_SYSCALL "select"
12642nogvl_wait_for(
VALUE th, rb_io_t *fptr,
short events,
struct timeval *timeout)
12645 if (scheduler !=
Qnil) {
12648 return RTEST(args.result);
12668 case RB_WAITFD_OUT:
12672 VM_UNREACHABLE(nogvl_wait_for);
12692 ret = nogvl_wait_for(stp->th, stp->src_fptr, RB_WAITFD_IN, NULL);
12694 }
while (ret < 0 && maygvl_copy_stream_continue_p(has_gvl, stp));
12697 stp->syserr = IOWAIT_SYSCALL;
12698 stp->error_no =
errno;
12710 ret = nogvl_wait_for(stp->th, stp->dst_fptr, RB_WAITFD_OUT, NULL);
12711 }
while (ret < 0 && maygvl_copy_stream_continue_p(0, stp));
12714 stp->syserr = IOWAIT_SYSCALL;
12715 stp->error_no =
errno;
12721#ifdef USE_COPY_FILE_RANGE
12724simple_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)
12726#ifdef HAVE_COPY_FILE_RANGE
12727 return copy_file_range(in_fd, in_offset, out_fd, out_offset, count, flags);
12729 return syscall(__NR_copy_file_range, in_fd, in_offset, out_fd, out_offset, count, flags);
12738 rb_off_t copy_length, src_offset, *src_offset_ptr;
12740 if (!S_ISREG(stp->src_stat.st_mode))
12743 src_size = stp->src_stat.st_size;
12744 src_offset = stp->src_offset;
12745 if (src_offset >= (rb_off_t)0) {
12746 src_offset_ptr = &src_offset;
12749 src_offset_ptr = NULL;
12752 copy_length = stp->copy_length;
12753 if (copy_length < (rb_off_t)0) {
12754 if (src_offset < (rb_off_t)0) {
12755 rb_off_t current_offset;
12757 current_offset = lseek(stp->src_fptr->
fd, 0, SEEK_CUR);
12758 if (current_offset < (rb_off_t)0 &&
errno) {
12759 stp->syserr =
"lseek";
12760 stp->error_no =
errno;
12761 return (
int)current_offset;
12763 copy_length = src_size - current_offset;
12766 copy_length = src_size - src_offset;
12770 retry_copy_file_range:
12771# if SIZEOF_OFF_T > SIZEOF_SIZE_T
12773 ss = (copy_length > (rb_off_t)SSIZE_MAX) ? SSIZE_MAX : (ssize_t)copy_length;
12775 ss = (ssize_t)copy_length;
12777 ss = simple_copy_file_range(stp->src_fptr->
fd, src_offset_ptr, stp->dst_fptr->
fd, NULL, ss, 0);
12781 if (0 < copy_length) {
12782 goto retry_copy_file_range;
12786 if (maygvl_copy_stream_continue_p(0, stp)) {
12787 goto retry_copy_file_range;
12801#if EWOULDBLOCK != EAGAIN
12805 int ret = nogvl_copy_stream_wait_write(stp);
12806 if (ret < 0)
return ret;
12808 goto retry_copy_file_range;
12812 int flags = fcntl(stp->dst_fptr->
fd, F_GETFL);
12814 if (flags != -1 && flags & O_APPEND) {
12820 stp->syserr =
"copy_file_range";
12821 stp->error_no =
errno;
12828#ifdef HAVE_FCOPYFILE
12832 rb_off_t cur, ss = 0;
12833 const rb_off_t src_offset = stp->src_offset;
12836 if (stp->copy_length >= (rb_off_t)0) {
12841 if (!S_ISREG(stp->src_stat.st_mode))
12844 if (!S_ISREG(stp->dst_stat.st_mode))
12846 if (lseek(stp->dst_fptr->
fd, 0, SEEK_CUR) > (rb_off_t)0)
12848 if (fcntl(stp->dst_fptr->
fd, F_GETFL) & O_APPEND) {
12851 rb_off_t end = lseek(stp->dst_fptr->
fd, 0, SEEK_END);
12852 lseek(stp->dst_fptr->
fd, 0, SEEK_SET);
12853 if (end > (rb_off_t)0)
return 0;
12856 if (src_offset > (rb_off_t)0) {
12861 cur = lseek(stp->src_fptr->
fd, 0, SEEK_CUR);
12862 if (cur < (rb_off_t)0 &&
errno) {
12863 stp->error_no =
errno;
12868 r = lseek(stp->src_fptr->
fd, src_offset, SEEK_SET);
12869 if (r < (rb_off_t)0 &&
errno) {
12870 stp->error_no =
errno;
12875 stp->copyfile_state = copyfile_state_alloc();
12876 ret = fcopyfile(stp->src_fptr->
fd, stp->dst_fptr->
fd, stp->copyfile_state, COPYFILE_DATA);
12877 copyfile_state_get(stp->copyfile_state, COPYFILE_STATE_COPIED, &ss);
12881 if (src_offset > (rb_off_t)0) {
12885 r = lseek(stp->src_fptr->
fd, cur, SEEK_SET);
12886 if (r < (rb_off_t)0 &&
errno) {
12887 stp->error_no =
errno;
12899 stp->syserr =
"fcopyfile";
12900 stp->error_no =
errno;
12907#ifdef HAVE_SENDFILE
12910# define USE_SENDFILE
12912# ifdef HAVE_SYS_SENDFILE_H
12913# include <sys/sendfile.h>
12917simple_sendfile(
int out_fd,
int in_fd, rb_off_t *offset, rb_off_t count)
12919 return sendfile(out_fd, in_fd, offset, (
size_t)count);
12922# elif 0 || defined(__APPLE__)
12926# define USE_SENDFILE
12929simple_sendfile(
int out_fd,
int in_fd, rb_off_t *offset, rb_off_t count)
12932 rb_off_t pos = offset ? *offset : lseek(in_fd, 0, SEEK_CUR);
12935 r = sendfile(in_fd, out_fd, pos, &count, NULL, 0);
12938 r = sendfile(in_fd, out_fd, pos, (
size_t)count, NULL, &sbytes, 0);
12940 if (r != 0 && sbytes == 0)
return r;
12945 lseek(in_fd, sbytes, SEEK_CUR);
12947 return (ssize_t)sbytes;
12960 rb_off_t copy_length;
12961 rb_off_t src_offset;
12964 if (!S_ISREG(stp->src_stat.st_mode))
12967 src_size = stp->src_stat.st_size;
12969 if ((stp->dst_stat.st_mode & S_IFMT) != S_IFSOCK)
12973 src_offset = stp->src_offset;
12974 use_pread = src_offset >= (rb_off_t)0;
12976 copy_length = stp->copy_length;
12977 if (copy_length < (rb_off_t)0) {
12979 copy_length = src_size - src_offset;
12983 cur = lseek(stp->src_fptr->
fd, 0, SEEK_CUR);
12984 if (cur < (rb_off_t)0 &&
errno) {
12985 stp->syserr =
"lseek";
12986 stp->error_no =
errno;
12989 copy_length = src_size - cur;
12994# if SIZEOF_OFF_T > SIZEOF_SIZE_T
12996 ss = (copy_length > (rb_off_t)SSIZE_MAX) ? SSIZE_MAX : (ssize_t)copy_length;
12998 ss = (ssize_t)copy_length;
13001 ss = simple_sendfile(stp->dst_fptr->
fd, stp->src_fptr->
fd, &src_offset, ss);
13004 ss = simple_sendfile(stp->dst_fptr->
fd, stp->src_fptr->
fd, NULL, ss);
13009 if (0 < copy_length) {
13010 goto retry_sendfile;
13014 if (maygvl_copy_stream_continue_p(0, stp))
13015 goto retry_sendfile;
13028#if EWOULDBLOCK != EAGAIN
13041 ret = maygvl_copy_stream_wait_read(0, stp);
13042 if (ret < 0)
return ret;
13044 ret = nogvl_copy_stream_wait_write(stp);
13045 if (ret < 0)
return ret;
13047 goto retry_sendfile;
13049 stp->syserr =
"sendfile";
13050 stp->error_no =
errno;
13058maygvl_read(
int has_gvl, rb_io_t *fptr,
void *buf,
size_t count)
13061 return rb_io_read_memory(fptr, buf, count);
13063 return read(fptr->
fd, buf, count);
13067maygvl_copy_stream_read(
int has_gvl,
struct copy_stream_struct *stp,
char *buf,
size_t len, rb_off_t offset)
13071 if (offset < (rb_off_t)0) {
13072 ss = maygvl_read(has_gvl, stp->src_fptr, buf,
len);
13075 ss = pread(stp->src_fptr->
fd, buf,
len, offset);
13081 if (maygvl_copy_stream_continue_p(has_gvl, stp))
13085#if EWOULDBLOCK != EAGAIN
13089 int ret = maygvl_copy_stream_wait_read(has_gvl, stp);
13090 if (ret < 0)
return ret;
13095 stp->notimp =
"pread";
13099 stp->syserr = offset < (rb_off_t)0 ?
"read" :
"pread";
13100 stp->error_no =
errno;
13111 ss = write(stp->dst_fptr->
fd, buf+
off,
len);
13113 if (maygvl_copy_stream_continue_p(0, stp))
13115 if (io_again_p(
errno)) {
13116 int ret = nogvl_copy_stream_wait_write(stp);
13117 if (ret < 0)
return ret;
13120 stp->syserr =
"write";
13121 stp->error_no =
errno;
13138 rb_off_t copy_length;
13139 rb_off_t src_offset;
13143 copy_length = stp->copy_length;
13144 use_eof = copy_length < (rb_off_t)0;
13145 src_offset = stp->src_offset;
13146 use_pread = src_offset >= (rb_off_t)0;
13148 if (use_pread && stp->close_src) {
13151 r = lseek(stp->src_fptr->
fd, src_offset, SEEK_SET);
13152 if (r < (rb_off_t)0 &&
errno) {
13153 stp->syserr =
"lseek";
13154 stp->error_no =
errno;
13157 src_offset = (rb_off_t)-1;
13161 while (use_eof || 0 < copy_length) {
13162 if (!use_eof && copy_length < (rb_off_t)
sizeof(buf)) {
13163 len = (size_t)copy_length;
13169 ss = maygvl_copy_stream_read(0, stp, buf,
len, src_offset);
13174 ss = maygvl_copy_stream_read(0, stp, buf,
len, (rb_off_t)-1);
13179 ret = nogvl_copy_stream_write(stp, buf, ss);
13189nogvl_copy_stream_func(
void *arg)
13192#if defined(USE_SENDFILE) || defined(USE_COPY_FILE_RANGE) || defined(HAVE_FCOPYFILE)
13196#ifdef USE_COPY_FILE_RANGE
13197 ret = nogvl_copy_file_range(stp);
13202#ifdef HAVE_FCOPYFILE
13203 ret = nogvl_fcopyfile(stp);
13209 ret = nogvl_copy_stream_sendfile(stp);
13214 nogvl_copy_stream_read_write(stp);
13216#if defined(USE_SENDFILE) || defined(USE_COPY_FILE_RANGE) || defined(HAVE_FCOPYFILE)
13230copy_stream_fallback_read(
VALUE arg)
13233 return (
VALUE)maygvl_copy_stream_read(1, p->stp, RSTRING_PTR(p->buf),
13234 p->len, p->offset);
13238copy_stream_fallback_body(
VALUE arg)
13241 const int buflen = 16*1024;
13244 rb_off_t rest = stp->copy_length;
13245 rb_off_t
off = stp->src_offset;
13246 ID read_method = id_readpartial;
13248 if (!stp->src_fptr) {
13250 read_method = id_read;
13257 rb_str_make_independent(buf);
13258 if (stp->copy_length < (rb_off_t)0) {
13263 rb_str_resize(buf, 0);
13266 l = buflen < rest ? buflen : (long)rest;
13268 if (!stp->src_fptr) {
13271 if (read_method == id_read &&
NIL_P(rc))
13275 rb_str_resize(buf, buflen);
13278 (ssize_t)rb_str_locktmp_ensure(buf, copy_stream_fallback_read,
13280 rb_str_resize(buf, ss > 0 ? ss : 0);
13285 if (
off >= (rb_off_t)0)
13288 n = rb_io_write(stp->dst, buf);
13290 stp->total += numwrote;
13292 if (read_method == id_read && RSTRING_LEN(buf) == 0) {
13303 if (!stp->src_fptr && stp->src_offset >= (rb_off_t)0) {
13304 rb_raise(rb_eArgError,
"cannot specify src_offset for non-IO");
13313copy_stream_body(
VALUE arg)
13316 VALUE src_io = stp->src, dst_io = stp->dst;
13317 const int common_oflags = 0
13327 if (src_io ==
argf ||
13328 !(RB_TYPE_P(src_io,
T_FILE) ||
13331 stp->src_fptr = NULL;
13336 if (!
NIL_P(tmp_io)) {
13339 else if (!RB_TYPE_P(src_io,
T_FILE)) {
13343 args[1] =
INT2NUM(O_RDONLY|common_oflags);
13346 stp->close_src = 1;
13351 stat_ret = fstat(stp->src_fptr->
fd, &stp->src_stat);
13352 if (stat_ret < 0) {
13353 stp->syserr =
"fstat";
13354 stp->error_no =
errno;
13359 if (dst_io ==
argf ||
13360 !(RB_TYPE_P(dst_io,
T_FILE) ||
13363 stp->dst_fptr = NULL;
13368 if (!
NIL_P(tmp_io)) {
13369 dst_io = GetWriteIO(tmp_io);
13371 else if (!RB_TYPE_P(dst_io,
T_FILE)) {
13375 args[1] =
INT2NUM(O_WRONLY|O_CREAT|O_TRUNC|common_oflags);
13379 stp->close_dst = 1;
13382 dst_io = GetWriteIO(dst_io);
13388 stat_ret = fstat(stp->dst_fptr->
fd, &stp->dst_stat);
13389 if (stat_ret < 0) {
13390 stp->syserr =
"fstat";
13391 stp->error_no =
errno;
13398 SET_BINARY_MODE_WITH_SEEK_CUR(stp->src_fptr);
13401 io_ascii8bit_binmode(stp->dst_fptr);
13403 if (stp->src_offset < (rb_off_t)0 && stp->src_fptr && stp->src_fptr->
rbuf.
len) {
13406 if (stp->copy_length >= (rb_off_t)0 && stp->copy_length < (rb_off_t)
len) {
13407 len = (size_t)stp->copy_length;
13410 rb_str_resize(str,
len);
13411 read_buffered_data(RSTRING_PTR(str),
len, stp->src_fptr);
13412 if (stp->dst_fptr) {
13413 if (io_binwrite(RSTRING_PTR(str), RSTRING_LEN(str), stp->dst_fptr, 0) < 0)
13414 rb_sys_fail_on_write(stp->dst_fptr);
13417 rb_io_write(dst_io, str);
13418 rb_str_resize(str, 0);
13420 if (stp->copy_length >= (rb_off_t)0)
13421 stp->copy_length -=
len;
13424 if (stp->dst_fptr && io_fflush(stp->dst_fptr) < 0) {
13428 if (stp->copy_length == 0)
13431 if (stp->src_fptr == NULL || stp->dst_fptr == NULL) {
13432 return copy_stream_fallback(stp);
13435 IO_WITHOUT_GVL(nogvl_copy_stream_func, stp);
13440copy_stream_finalize(
VALUE arg)
13444#ifdef HAVE_FCOPYFILE
13445 if (stp->copyfile_state) {
13446 copyfile_state_free(stp->copyfile_state);
13450 if (stp->close_src) {
13451 rb_io_close_m(stp->src);
13453 if (stp->close_dst) {
13454 rb_io_close_m(stp->dst);
13517rb_io_s_copy_stream(
int argc,
VALUE *argv,
VALUE io)
13519 VALUE src, dst, length, src_offset;
13524 rb_scan_args(argc, argv,
"22", &src, &dst, &length, &src_offset);
13529 st.src_fptr = NULL;
13530 st.dst_fptr = NULL;
13533 st.copy_length = (rb_off_t)-1;
13535 st.copy_length =
NUM2OFFT(length);
13537 if (
NIL_P(src_offset))
13538 st.src_offset = (rb_off_t)-1;
13540 st.src_offset =
NUM2OFFT(src_offset);
13559rb_io_external_encoding(
VALUE io)
13564 return rb_enc_from_encoding(fptr->
encs.
enc2);
13568 return rb_enc_from_encoding(fptr->
encs.
enc);
13571 return rb_enc_from_encoding(io_read_encoding(fptr));
13587rb_io_internal_encoding(
VALUE io)
13592 return rb_enc_from_encoding(io_read_encoding(fptr));
13626rb_io_set_encoding(
int argc,
VALUE *argv,
VALUE io)
13631 if (!RB_TYPE_P(io,
T_FILE)) {
13632 return forward(io, id_set_encoding, argc, argv);
13635 argc =
rb_scan_args(argc, argv,
"11:", &v1, &v2, &opt);
13637 io_encoding_set(fptr, v1, v2, opt);
13642rb_stdio_set_default_encoding(
void)
13647 if (isatty(fileno(stdin))) {
13648 rb_encoding *external = rb_locale_encoding();
13649 rb_encoding *internal = rb_default_internal_encoding();
13650 if (!internal) internal = rb_default_external_encoding();
13652 rb_enc_from_encoding(external),
13653 rb_enc_from_encoding(internal),
13658 rb_io_set_encoding(1, &val,
rb_stdin);
13659 rb_io_set_encoding(1, &val,
rb_stdout);
13660 rb_io_set_encoding(1, &val,
rb_stderr);
13664global_argf_p(
VALUE arg)
13666 return arg ==
argf;
13669typedef VALUE (*argf_encoding_func)(
VALUE io);
13672argf_encoding(
VALUE argf, argf_encoding_func func)
13674 if (!
RTEST(ARGF.current_file)) {
13675 return rb_enc_default_external();
13699 return argf_encoding(
argf, rb_io_external_encoding);
13718 return argf_encoding(
argf, rb_io_internal_encoding);
13757 if (!next_argv()) {
13758 rb_raise(rb_eArgError,
"no stream to set encoding");
13760 rb_io_set_encoding(argc, argv, ARGF.current_file);
13762 ARGF.encs = fptr->
encs;
13781 if (!next_argv()) {
13782 rb_raise(rb_eArgError,
"no stream to tell");
13784 ARGF_FORWARD(0, 0);
13785 return rb_io_tell(ARGF.current_file);
13798 if (!next_argv()) {
13799 rb_raise(rb_eArgError,
"no stream to seek");
13801 ARGF_FORWARD(argc, argv);
13802 return rb_io_seek_m(argc, argv, ARGF.current_file);
13819 if (!next_argv()) {
13820 rb_raise(rb_eArgError,
"no stream to set position");
13822 ARGF_FORWARD(1, &offset);
13823 return rb_io_set_pos(ARGF.current_file, offset);
13844 if (!next_argv()) {
13845 rb_raise(rb_eArgError,
"no stream to rewind");
13847 ARGF_FORWARD(0, 0);
13848 old_lineno =
RFILE(ARGF.current_file)->fptr->lineno;
13849 ret = rb_io_rewind(ARGF.current_file);
13850 if (!global_argf_p(
argf)) {
13851 ARGF.last_lineno = ARGF.lineno -= old_lineno;
13869 if (!next_argv()) {
13870 rb_raise(rb_eArgError,
"no stream");
13872 ARGF_FORWARD(0, 0);
13873 return rb_io_fileno(ARGF.current_file);
13892 ARGF_FORWARD(0, 0);
13893 return ARGF.current_file;
13918 if (
RTEST(ARGF.current_file)) {
13919 if (ARGF.init_p == 0)
return Qtrue;
13921 ARGF_FORWARD(0, 0);
13980 VALUE tmp, str, length;
13984 if (!
NIL_P(length)) {
13989 rb_str_resize(str,0);
13994 if (!next_argv()) {
13997 if (ARGF_GENERIC_INPUT_P()) {
13998 tmp = argf_forward(argc, argv,
argf);
14001 tmp = io_read(argc, argv, ARGF.current_file);
14003 if (
NIL_P(str)) str = tmp;
14006 if (ARGF.next_p != -1) {
14012 else if (argc >= 1) {
14013 long slen = RSTRING_LEN(str);
14029argf_forward_call(
VALUE arg)
14032 argf_forward(p->argc, p->argv, p->argf);
14062 return argf_getpartial(argc, argv,
argf,
Qnil, 0);
14083 return argf_getpartial(argc, argv,
argf, opts, 1);
14089 VALUE tmp, str, length;
14097 no_exception = no_exception_p(opts);
14099 if (!next_argv()) {
14101 rb_str_resize(str, 0);
14105 if (ARGF_GENERIC_INPUT_P()) {
14115 tmp = io_getpartial(argc, argv, ARGF.current_file, no_exception, nonblock);
14118 if (ARGF.next_p == -1) {
14119 return io_nonblock_eof(no_exception);
14124 return io_nonblock_eof(no_exception);
14162 if (!next_argv())
return Qnil;
14163 if (ARGF_GENERIC_INPUT_P()) {
14164 ch = forward_current(rb_intern(
"getc"), 0, 0);
14167 ch = rb_io_getc(ARGF.current_file);
14169 if (
NIL_P(ch) && ARGF.next_p != -1) {
14202 if (!next_argv())
return Qnil;
14203 if (!RB_TYPE_P(ARGF.current_file,
T_FILE)) {
14204 ch = forward_current(rb_intern(
"getbyte"), 0, 0);
14209 if (
NIL_P(ch) && ARGF.next_p != -1) {
14243 if (!RB_TYPE_P(ARGF.current_file,
T_FILE)) {
14244 ch = forward_current(rb_intern(
"getc"), 0, 0);
14247 ch = rb_io_getc(ARGF.current_file);
14249 if (
NIL_P(ch) && ARGF.next_p != -1) {
14281 NEXT_ARGF_FORWARD(0, 0);
14282 c = argf_getbyte(
argf);
14289#define FOREACH_ARGF() while (next_argv())
14294 const VALUE current = ARGF.current_file;
14296 if (ARGF.init_p == -1 || current != ARGF.current_file) {
14302#define ARGF_block_call(mid, argc, argv, func, argf) \
14303 rb_block_call_kw(ARGF.current_file, mid, argc, argv, \
14304 func, argf, rb_keyword_given_p())
14309 VALUE ret = ARGF_block_call(mid, argc, argv, argf_block_call_i,
argf);
14310 if (!UNDEF_P(ret)) ARGF.next_p = 1;
14316 if (!global_argf_p(
argf)) {
14317 ARGF.last_lineno = ++ARGF.lineno;
14319 return argf_block_call_i(i,
argf, argc, argv, blockarg);
14325 VALUE ret = ARGF_block_call(mid, argc, argv, argf_block_call_line_i,
argf);
14326 if (!UNDEF_P(ret)) ARGF.next_p = 1;
14374 argf_block_call_line(rb_intern(
"each_line"), argc, argv,
argf);
14405 argf_block_call(rb_intern(
"each_byte"), 0, 0,
argf);
14431 argf_block_call(rb_intern(
"each_char"), 0, 0,
argf);
14457 argf_block_call(rb_intern(
"each_codepoint"), 0, 0,
argf);
14488 return ARGF.filename;
14492argf_filename_getter(
ID id,
VALUE *var)
14494 return argf_filename(*var);
14519 return ARGF.current_file;
14538 ARGF_FORWARD(0, 0);
14559 return RBOOL(ARGF.binmode);
14579 if (ARGF.init_p && ARGF.next_p == 0) {
14608 if (ARGF.next_p != -1) {
14626 ARGF_FORWARD(0, 0);
14653 if (!ARGF.inplace)
return Qnil;
14661 return argf_inplace_mode_get(*var);
14692 ARGF.inplace =
Qnil;
14703 argf_inplace_mode_set(*var, val);
14707ruby_set_inplace_mode(
const char *suffix)
14733argf_argv_getter(
ID id,
VALUE *var)
14735 return argf_argv(*var);
14754 if (!
RTEST(ARGF.current_file)) {
14757 return GetWriteIO(ARGF.current_file);
14769 return rb_io_writev(argf_write_io(
argf), argc, argv);
14784 case RB_IO_WAIT_WRITABLE:
14787 c = rb_eEAGAINWaitWritable;
14789#if EAGAIN != EWOULDBLOCK
14791 c = rb_eEWOULDBLOCKWaitWritable;
14795 c = rb_eEINPROGRESSWaitWritable;
14801 case RB_IO_WAIT_READABLE:
14804 c = rb_eEAGAINWaitReadable;
14806#if EAGAIN != EWOULDBLOCK
14808 c = rb_eEWOULDBLOCKWaitReadable;
14812 c = rb_eEINPROGRESSWaitReadable;
14819 rb_bug(
"invalid read/write type passed to rb_readwrite_sys_fail: %d", waiting);
14825get_LAST_READ_LINE(
ID _x,
VALUE *_y)
15710#include <sys/cygwin.h>
15711 static struct __cygwin_perfile pf[] =
15713 {
"", O_RDONLY | O_BINARY},
15714 {
"", O_WRONLY | O_BINARY},
15715 {
"", O_RDWR | O_BINARY},
15716 {
"", O_APPEND | O_BINARY},
15719 cygwin_internal(CW_PERFILE, pf);
15725 id_write = rb_intern_const(
"write");
15726 id_read = rb_intern_const(
"read");
15727 id_getc = rb_intern_const(
"getc");
15728 id_flush = rb_intern_const(
"flush");
15729 id_readpartial = rb_intern_const(
"readpartial");
15730 id_set_encoding = rb_intern_const(
"set_encoding");
15731 id_fileno = rb_intern_const(
"fileno");
15774#if EAGAIN == EWOULDBLOCK
15775 rb_eEWOULDBLOCKWaitReadable = rb_eEAGAINWaitReadable;
15777 rb_define_const(
rb_cIO,
"EWOULDBLOCKWaitReadable", rb_eEAGAINWaitReadable);
15778 rb_eEWOULDBLOCKWaitWritable = rb_eEAGAINWaitWritable;
15780 rb_define_const(
rb_cIO,
"EWOULDBLOCKWaitWritable", rb_eEAGAINWaitWritable);
15828 rb_gvar_ractor_local(
"$/");
15830 rb_gvar_ractor_local(
"$-0");
15834 rb_gvar_ractor_local(
"$_");
15835 rb_gvar_box_dynamic(
"$_");
15951 rb_gvar_ractor_local(
"$stdin");
15952 rb_gvar_ractor_local(
"$stdout");
15953 rb_gvar_ractor_local(
"$>");
15954 rb_gvar_ractor_local(
"$stderr");
16040 rb_define_method(rb_cARGF,
"external_encoding", argf_external_encoding, 0);
16041 rb_define_method(rb_cARGF,
"internal_encoding", argf_internal_encoding, 0);
16060 rb_gvar_ractor_local(
"$-i");
16064#if defined (_WIN32) || defined(__CYGWIN__)
16065 atexit(pipe_atexit);
16072 sym_mode =
ID2SYM(rb_intern_const(
"mode"));
16073 sym_perm =
ID2SYM(rb_intern_const(
"perm"));
16074 sym_flags =
ID2SYM(rb_intern_const(
"flags"));
16075 sym_extenc =
ID2SYM(rb_intern_const(
"external_encoding"));
16076 sym_intenc =
ID2SYM(rb_intern_const(
"internal_encoding"));
16077 sym_encoding =
ID2SYM(rb_id_encoding());
16078 sym_open_args =
ID2SYM(rb_intern_const(
"open_args"));
16079 sym_textmode =
ID2SYM(rb_intern_const(
"textmode"));
16080 sym_binmode =
ID2SYM(rb_intern_const(
"binmode"));
16081 sym_autoclose =
ID2SYM(rb_intern_const(
"autoclose"));
16082 sym_normal =
ID2SYM(rb_intern_const(
"normal"));
16083 sym_sequential =
ID2SYM(rb_intern_const(
"sequential"));
16084 sym_random =
ID2SYM(rb_intern_const(
"random"));
16085 sym_willneed =
ID2SYM(rb_intern_const(
"willneed"));
16086 sym_dontneed =
ID2SYM(rb_intern_const(
"dontneed"));
16087 sym_noreuse =
ID2SYM(rb_intern_const(
"noreuse"));
16088 sym_SET =
ID2SYM(rb_intern_const(
"SET"));
16089 sym_CUR =
ID2SYM(rb_intern_const(
"CUR"));
16090 sym_END =
ID2SYM(rb_intern_const(
"END"));
16092 sym_DATA =
ID2SYM(rb_intern_const(
"DATA"));
16095 sym_HOLE =
ID2SYM(rb_intern_const(
"HOLE"));
16097 sym_wait_readable =
ID2SYM(rb_intern_const(
"wait_readable"));
16098 sym_wait_writable =
ID2SYM(rb_intern_const(
"wait_writable"));
#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.
#define STRNCASECMP
@old{st_locale_insensitive_strncasecmp}
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 ECONV_NEWLINE_DECORATOR_WRITE_MASK
Old name of RUBY_ECONV_NEWLINE_DECORATOR_WRITE_MASK.
#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 MBCLEN_INVALID_P(ret)
Old name of ONIGENC_MBCLEN_INVALID_P.
#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 ECONV_NEWLINE_DECORATOR_READ_MASK
Old name of RUBY_ECONV_NEWLINE_DECORATOR_READ_MASK.
#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 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_rescue2(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*r_proc)(VALUE, VALUE), VALUE data2,...)
An equivalent of rescue clause.
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 err, const char *msg)
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 *msg)
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_ensure(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*e_proc)(VALUE), VALUE data2)
An equivalent to ensure clause.
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.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
VALUE rb_str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to)
Encoding conversion main routine.
VALUE rb_enc_uint_chr(unsigned int code, rb_encoding *enc)
Encodes the passed code point into a series of bytes.
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.
VALUE rb_ary_concat(VALUE lhs, VALUE rhs)
Destructively appends the contents of latter into the end of former.
VALUE rb_ary_shift(VALUE ary)
Destructively deletes an element from the beginning of the passed array and returns what was deleted.
VALUE rb_check_array_type(VALUE obj)
Try converting an object to its array representation using its to_ary method, if any.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
VALUE rb_assoc_new(VALUE car, VALUE cdr)
Identical to rb_ary_new_from_values(), except it expects exactly two parameters.
#define RETURN_ENUMERATOR(obj, argc, argv)
Identical to RETURN_SIZED_ENUMERATOR(), except its size is unknown.
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 $\\endiskip.
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_output_fs
The field separator character for outputs, or the $,.
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.
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.
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.
#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_io_oflags_fmode(int oflags)
Converts an oflags (that rb_io_modestr_oflags() returns) to a fmode (that rb_io_mode_flags() returns)...
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.
struct rb_io_internal_buffer rb_io_buffer_t
Just another name of rb_io_buffer_t.
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 ...
int rb_io_read_pending(rb_io_t *fptr)
Queries if the passed IO has any pending reads.
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.
void rb_eof_error(void)
Utility function to raise rb_eEOFError.
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.
#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.
#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.
#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.
struct rb_data_type_struct rb_data_type_t
This is the struct that holds necessary info for a struct.
#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().
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 value inst...
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_current_for_threadptr(struct rb_thread_struct *thread)
Identical to rb_fiber_scheduler_current_for_thread(), except it expects a threadptr instead of a thre...
VALUE rb_fiber_scheduler_io_wait_writable(VALUE scheduler, VALUE io)
Non-blocking wait until the passed IO is ready for writing.
VALUE rb_fiber_scheduler_io_close(VALUE scheduler, VALUE io)
Non-blocking close the given IO.
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.
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
C99 shim for <stdbool.h>.
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
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
struct ccan_list_head blocking_operations
Threads that are performing a blocking operation without the GVL using this IO.
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.
void(*) finalize(struct rb_io *, int)
finalize proc
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.
#define RBIMPL_WARNING_IGNORED(flag)
Suppresses a warning.
#define RBIMPL_WARNING_PUSH()
Pushes compiler warning state.
#define RBIMPL_WARNING_POP()
Pops compiler warning state.