14#include "ruby/internal/config.h"
25# if defined(__linux__)
28# if defined(__FreeBSD_version) && __FreeBSD_version >= 1100000
38#define free(x) xfree(x)
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(__CYGWIN__) || defined(_WIN32)
52# define NO_SAFE_RENAME
55#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__sun)
60#ifdef HAVE_SYS_IOCTL_H
63#if defined(HAVE_FCNTL_H)
65#elif defined(HAVE_SYS_FCNTL_H)
75#if defined(HAVE_SYS_PARAM_H)
76# include <sys/param.h>
89#elif defined HAVE_SYS_SYSCALL_H
90#include <sys/syscall.h>
101#ifdef HAVE_COPYFILE_H
102# include <copyfile.h>
106# include <AvailabilityMacros.h>
110#include "ccan/list/list.h"
115#include "internal/class.h"
116#include "internal/encoding.h"
117#include "internal/error.h"
118#include "internal/inits.h"
119#include "internal/io.h"
120#include "internal/numeric.h"
121#include "internal/object.h"
122#include "internal/process.h"
123#include "internal/string.h"
124#include "internal/thread.h"
125#include "internal/transcode.h"
126#include "internal/variable.h"
129#include "ruby/missing.h"
132#include "ruby_atomic.h"
142#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
146# ifdef _POSIX_PIPE_BUF
147# define PIPE_BUF _POSIX_PIPE_BUF
154# define EWOULDBLOCK EAGAIN
157#if defined(HAVE___SYSCALL) && (defined(__APPLE__) || defined(__OpenBSD__))
159off_t __syscall(quad_t number, ...);
162#define IO_RBUF_CAPA_MIN 8192
163#define IO_CBUF_CAPA_MIN (128*1024)
164#define IO_RBUF_CAPA_FOR(fptr) (NEED_READCONV(fptr) ? IO_CBUF_CAPA_MIN : IO_RBUF_CAPA_MIN)
165#define IO_WBUF_CAPA_MIN 8192
167#define IO_MAX_BUFFER_GROWTH 8 * 1024 * 1024
172#define open rb_w32_uopen
174#define rename(f, t) rb_w32_urename((f), (t))
175#include "win32/file.h"
185static VALUE rb_eEAGAINWaitReadable;
186static VALUE rb_eEAGAINWaitWritable;
187#if EAGAIN != EWOULDBLOCK
188static VALUE rb_eEWOULDBLOCKWaitReadable;
189static VALUE rb_eEWOULDBLOCKWaitWritable;
191static VALUE rb_eEINPROGRESSWaitWritable;
192static VALUE rb_eEINPROGRESSWaitReadable;
195static VALUE orig_stdout, orig_stderr;
204static ID id_write, id_read, id_flush, id_readpartial, id_set_encoding, id_fileno;
205static VALUE sym_mode, sym_perm, sym_flags, sym_extenc, sym_intenc, sym_encoding, sym_open_args;
206static VALUE sym_textmode, sym_binmode, sym_autoclose;
207static VALUE sym_SET, sym_CUR, sym_END;
208static VALUE sym_wait_readable, sym_wait_writable;
210static VALUE sym_DATA;
213static VALUE sym_HOLE;
216static VALUE prep_io(
int fd,
enum rb_io_mode fmode,
VALUE klass,
const char *path);
219rb_io_blocking_region_wait(
struct rb_io *io, rb_blocking_function_t *function,
void *argument,
enum rb_io_event events)
221 return rb_thread_io_blocking_call(io, function, argument, events);
224VALUE rb_io_blocking_region(
struct rb_io *io, rb_blocking_function_t *function,
void *argument)
226 return rb_io_blocking_region_wait(io, function, argument, 0);
230 VALUE filename, current_file;
236 int8_t init_p, next_p, binmode;
240#if defined(__APPLE__) && \
241 (!defined(MAC_OS_VERSION_27_0) || (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_VERSION_27_0))
243# if __has_attribute(availability) && __has_warning("-Wunguarded-availability-new")
249static inline int (*rb_dup3(
void))(int, int, int) {
return &dup3;}
250# define dup3 rb_dup3()
254static inline int (*rb_pipe2(
void))(
int [2], int) {
return &pipe2;}
255# define pipe2 rb_pipe2()
280 if (fd < 0 || afd <= max_fd)
283#if defined(HAVE_FCNTL) && defined(F_GETFL)
284 err = fcntl(fd, F_GETFL) == -1;
288 err = fstat(fd, &buf) != 0;
291 if (err &&
errno == EBADF) {
292 rb_bug(
"rb_update_max_fd: invalid fd (%d) given.", fd);
295 while (max_fd < afd) {
296 max_fd = ATOMIC_CAS(max_file_descriptor, max_fd, afd);
301rb_maygvl_fd_fix_cloexec(
int fd)
304#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
305 int flags, flags2, ret;
306 flags = fcntl(fd, F_GETFD);
308 rb_bug(
"rb_maygvl_fd_fix_cloexec: fcntl(%d, F_GETFD) failed: %s", fd, strerror(
errno));
311 flags2 = flags & ~FD_CLOEXEC;
313 flags2 = flags | FD_CLOEXEC;
314 if (flags != flags2) {
315 ret = fcntl(fd, F_SETFD, flags2);
317 rb_bug(
"rb_maygvl_fd_fix_cloexec: fcntl(%d, F_SETFD, %d) failed: %s", fd, flags2, strerror(
errno));
326 rb_maygvl_fd_fix_cloexec(fd);
333 return (e == EWOULDBLOCK) || (e == EAGAIN);
341 static const int retry_interval = 0;
342 static const int retry_max_count = 10000;
348#elif defined O_NOINHERIT
349 flags |= O_NOINHERIT;
352 while ((ret = open(pathname, flags, mode)) == -1) {
354 if (!io_again_p(e))
break;
355 if (retry_count++ >= retry_max_count)
break;
357 sleep(retry_interval);
360 if (ret < 0)
return ret;
362 if (ret > 2)
return ret;
364 rb_maygvl_fd_fix_cloexec(ret);
382 if (oldfd == newfd) {
386#if defined(HAVE_DUP3) && defined(O_CLOEXEC)
387# if defined(__APPLE__)
388# define try_dup3 (dup3 != NULL)
389# define abandon_dup3() true
391 static bool try_dup3 =
true;
392# define abandon_dup3() (errno != ENOSYS || !!(try_dup3 = false))
398 ret = dup3(oldfd, newfd, O_CLOEXEC);
405 if (abandon_dup3())
return ret;
408 ret = dup2(oldfd, newfd);
409 if (ret < 0)
return ret;
411 rb_maygvl_fd_fix_cloexec(ret);
416rb_fd_set_nonblock(
int fd)
419 return rb_w32_set_nonblock(fd);
420#elif defined(F_GETFL)
421 int oflags = fcntl(fd, F_GETFL);
425 if (oflags & O_NONBLOCK)
427 oflags |= O_NONBLOCK;
428 return fcntl(fd, F_SETFL, oflags);
434cloexec_pipe(
int descriptors[2],
int flags,
bool force_cloexec)
438# if defined(__APPLE__)
439# define try_pipe2 (pipe2 != NULL)
440# define abandon_pipe2() true
442 static bool try_pipe2 =
true;
443# define abandon_pipe2() (errno != ENOSYS || !!(try_pipe2 = false))
446 result = pipe2(descriptors, O_CLOEXEC | flags);
447 if (result == 0)
return result;
448 if (abandon_pipe2())
return result;
451 if (result < 0 && (result = pipe(descriptors)) < 0)
455 if (result == 0 && descriptors[1] == -1) {
456 close(descriptors[0]);
463 if (!force_cloexec)
return result;
466 rb_maygvl_fd_fix_cloexec(descriptors[0]);
467 rb_maygvl_fd_fix_cloexec(descriptors[1]);
470 rb_fd_set_nonblock(descriptors[0]);
471 rb_fd_set_nonblock(descriptors[1]);
480 return cloexec_pipe(descriptors, O_NONBLOCK,
true);
488#if defined(HAVE_FCNTL) && defined(F_DUPFD_CLOEXEC)
489 ret = fcntl(fd, F_DUPFD_CLOEXEC, minfd);
490 if (ret > 2)
return ret;
491#elif defined(HAVE_FCNTL) && defined(F_DUPFD)
492 ret = fcntl(fd, F_DUPFD, minfd);
495 if (ret >= 0 && ret < minfd) {
496 const int prev_fd = ret;
502 if (ret < 0)
return ret;
503 rb_maygvl_fd_fix_cloexec(ret);
507#define argf_of(obj) (*(struct argf *)DATA_PTR(obj))
508#define ARGF argf_of(argf)
509#define ARGF_SET(field, value) RB_OBJ_WRITE(argf, &ARGF.field, value)
511#define GetWriteIO(io) rb_io_get_write_io(io)
513#define READ_DATA_PENDING(fptr) ((fptr)->rbuf.len)
514#define READ_DATA_PENDING_COUNT(fptr) ((fptr)->rbuf.len)
515#define READ_DATA_PENDING_PTR(fptr) ((fptr)->rbuf.ptr+(fptr)->rbuf.off)
516#define READ_DATA_BUFFERED(fptr) READ_DATA_PENDING(fptr)
518#define READ_CHAR_PENDING(fptr) ((fptr)->cbuf.len)
519#define READ_CHAR_PENDING_COUNT(fptr) ((fptr)->cbuf.len)
520#define READ_CHAR_PENDING_PTR(fptr) ((fptr)->cbuf.ptr+(fptr)->cbuf.off)
523#define WAIT_FD_IN_WIN32(fptr) \
524 (rb_w32_io_cancelable_p((fptr)->fd) ? Qnil : rb_io_wait(fptr->self, RB_INT2NUM(RUBY_IO_READABLE), RUBY_IO_TIMEOUT_DEFAULT))
526#define WAIT_FD_IN_WIN32(fptr)
529#define READ_CHECK(fptr) do {\
530 if (!READ_DATA_PENDING(fptr)) {\
531 WAIT_FD_IN_WIN32(fptr);\
532 rb_io_check_closed(fptr);\
538# define S_ISSOCK(m) _S_ISSOCK(m)
541# define S_ISSOCK(m) (((m) & S_IFMT) == _S_IFSOCK)
544# define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)
550static int io_fflush(rb_io_t *);
551static rb_io_t *flush_before_seek(rb_io_t *fptr,
bool discard_rbuf);
552static void clear_readconv(rb_io_t *fptr);
553static void clear_codeconv(rb_io_t *fptr);
555#define FMODE_SIGNAL_ON_EPIPE (1<<17)
557#define fptr_signal_on_epipe(fptr) \
558 (((fptr)->mode & FMODE_SIGNAL_ON_EPIPE) != 0)
560#define fptr_set_signal_on_epipe(fptr, flag) \
562 (fptr)->mode |= FMODE_SIGNAL_ON_EPIPE : \
563 (fptr)->mode &= ~FMODE_SIGNAL_ON_EPIPE)
565extern ID ruby_static_id_signo;
567NORETURN(
static void rb_sys_fail_on_write(rb_io_t *fptr));
569rb_sys_fail_on_write(rb_io_t *fptr)
572 VALUE errinfo = rb_syserr_new_path(e, (fptr)->pathv);
574 if (fptr_signal_on_epipe(fptr) && (e == EPIPE)) {
586#define NEED_NEWLINE_DECORATOR_ON_READ(fptr) ((fptr)->mode & FMODE_TEXTMODE)
587#define NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) ((fptr)->mode & FMODE_TEXTMODE)
588#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
589# define RUBY_CRLF_ENVIRONMENT 1
591# define RUBY_CRLF_ENVIRONMENT 0
594#if RUBY_CRLF_ENVIRONMENT
596# define DEFAULT_TEXTMODE FMODE_TEXTMODE
597# define TEXTMODE_NEWLINE_DECORATOR_ON_WRITE ECONV_CRLF_NEWLINE_DECORATOR
605#define NEED_READCONV(fptr) ((fptr)->encs.enc2 != NULL || (fptr)->encs.ecflags & ~ECONV_CRLF_NEWLINE_DECORATOR)
606#define WRITECONV_MASK ( \
607 (ECONV_DECORATOR_MASK & ~ECONV_CRLF_NEWLINE_DECORATOR)|\
608 ECONV_STATEFUL_DECORATOR_MASK|\
610#define NEED_WRITECONV(fptr) ( \
611 ((fptr)->encs.enc != NULL && (fptr)->encs.enc != rb_ascii8bit_encoding()) || \
612 ((fptr)->encs.ecflags & WRITECONV_MASK) || \
614#define SET_BINARY_MODE(fptr) setmode((fptr)->fd, O_BINARY)
616#define NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr) do {\
617 if (NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {\
618 if (((fptr)->mode & FMODE_READABLE) &&\
619 !((fptr)->encs.ecflags & ECONV_NEWLINE_DECORATOR_MASK)) {\
620 setmode((fptr)->fd, O_BINARY);\
623 setmode((fptr)->fd, O_TEXT);\
628#define SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags) do {\
629 if ((enc2) && ((ecflags) & ECONV_DEFAULT_NEWLINE_DECORATOR)) {\
630 (ecflags) |= ECONV_UNIVERSAL_NEWLINE_DECORATOR;\
638io_unread(rb_io_t *fptr,
bool discard_rbuf)
654 if (!rb_w32_fd_is_text(fptr->
fd)) {
655 r = lseek(fptr->
fd, -fptr->
rbuf.
len, SEEK_CUR);
656 if (r < 0 &&
errno) {
659 if (!discard_rbuf)
return;
665 pos = lseek(fptr->
fd, 0, SEEK_CUR);
666 if (pos < 0 &&
errno) {
669 if (!discard_rbuf)
goto end;
674 (
long)(pos - fptr->
rbuf.
len) : fptr->rbuf.
len;
677 for (i = 0; i < fptr->
rbuf.
len; i++) {
678 if (*p ==
'\n') newlines++;
679 if (extra_max == newlines)
break;
685 newlines < pos - fptr->rbuf.len) {
690 while (newlines >= 0) {
691 r = lseek(fptr->
fd, pos - fptr->
rbuf.
len - newlines, SEEK_SET);
692 if (newlines == 0)
break;
697 read_size = _read(fptr->
fd, buf, fptr->
rbuf.
len + newlines);
701 rb_syserr_fail_path(e, fptr->
pathv);
703 if (read_size == fptr->
rbuf.
len) {
704 lseek(fptr->
fd, r, SEEK_SET);
715 clear_codeconv(fptr);
727set_binary_mode_with_seek_cur(rb_io_t *fptr)
729 if (!rb_w32_fd_is_text(fptr->
fd))
return O_BINARY;
732 return setmode(fptr->
fd, O_BINARY);
734 flush_before_seek(fptr,
false);
735 return setmode(fptr->
fd, O_BINARY);
737#define SET_BINARY_MODE_WITH_SEEK_CUR(fptr) set_binary_mode_with_seek_cur(fptr)
741# define DEFAULT_TEXTMODE 0
742#define NEED_READCONV(fptr) ((fptr)->encs.enc2 != NULL || NEED_NEWLINE_DECORATOR_ON_READ(fptr))
743#define NEED_WRITECONV(fptr) ( \
744 ((fptr)->encs.enc != NULL && (fptr)->encs.enc != rb_ascii8bit_encoding()) || \
745 NEED_NEWLINE_DECORATOR_ON_WRITE(fptr) || \
746 ((fptr)->encs.ecflags & (ECONV_DECORATOR_MASK|ECONV_STATEFUL_DECORATOR_MASK)) || \
748#define SET_BINARY_MODE(fptr) (void)(fptr)
749#define NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr) (void)(fptr)
750#define SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags) ((void)(enc2), (void)(ecflags))
751#define SET_BINARY_MODE_WITH_SEEK_CUR(fptr) (void)(fptr)
754#if !defined HAVE_SHUTDOWN && !defined shutdown
755#define shutdown(a,b) 0
759#define is_socket(fd, path) rb_w32_is_socket(fd)
760#elif !defined(S_ISSOCK)
761#define is_socket(fd, path) 0
764is_socket(
int fd,
VALUE path)
767 if (fstat(fd, &sbuf) < 0)
768 rb_sys_fail_path(path);
769 return S_ISSOCK(sbuf.st_mode);
773static const char closed_stream[] =
"closed stream";
776io_fd_check_closed(
int fd)
809 io_fd_check_closed(fptr->
fd);
813rb_io_get_fptr(
VALUE io)
815 rb_io_t *fptr =
RFILE(io)->fptr;
823 return rb_convert_type_with_id(io,
T_FILE,
"IO", idTo_io);
829 return rb_check_convert_type_with_id(io,
T_FILE,
"IO", idTo_io);
836 write_io = rb_io_get_fptr(io)->tied_io_for_writing;
847 rb_io_t *fptr = rb_io_get_fptr(io);
856 return write_io ? write_io :
Qnil;
869 rb_io_t *fptr = rb_io_get_fptr(self);
899 if (
RTEST(timeout)) {
903 rb_io_t *fptr = rb_io_get_fptr(self);
928#if !RUBY_CRLF_ENVIRONMENT
930io_unread(rb_io_t *fptr,
bool discard_rbuf)
938 r = lseek(fptr->
fd, -fptr->
rbuf.
len, SEEK_CUR);
939 if (r < 0 &&
errno) {
942 if (!discard_rbuf)
return;
946 clear_codeconv(fptr);
951static rb_encoding *io_input_encoding(rb_io_t *fptr);
954io_ungetbyte(
VALUE str, rb_io_t *fptr)
959 const int min_capa = IO_RBUF_CAPA_FOR(fptr);
962#if SIZEOF_RB_LEN_T > SIZEOF_INT
987io_restore_read_buffer(
VALUE str, rb_io_t *fptr)
995 io_ungetbyte(str, fptr);
1013flush_before_seek(rb_io_t *fptr,
bool discard_rbuf)
1015 if (io_fflush(fptr) < 0)
1016 rb_sys_fail_on_write(fptr);
1017 io_unread(fptr, discard_rbuf);
1022#define io_seek(fptr, ofs, whence) (errno = 0, lseek(flush_before_seek(fptr, true)->fd, (ofs), (whence)))
1023#define io_tell(fptr) lseek(flush_before_seek(fptr, false)->fd, 0, SEEK_CUR)
1039 if (io_fflush(fptr) < 0)
1040 rb_sys_fail_on_write(fptr);
1045 if (io_fflush(wfptr) < 0)
1046 rb_sys_fail_on_write(wfptr);
1054 if (READ_CHAR_PENDING(fptr)) {
1055 rb_raise(
rb_eIOError,
"byte oriented read for character buffered IO");
1066io_read_encoding(rb_io_t *fptr)
1075io_input_encoding(rb_io_t *fptr)
1080 return io_read_encoding(fptr);
1091 io_unread(fptr,
true);
1099 if (READ_CHAR_PENDING(fptr))
1101 return READ_DATA_PENDING(fptr);
1107 if (!READ_DATA_PENDING(fptr)) {
1114rb_gc_for_fd(
int err)
1116 if (err == EMFILE || err == ENFILE || err == ENOMEM) {
1126#define TRY_WITH_GC(expr) \
1127 for (int first_errno, retried_errno = 0, retried = 0; \
1130 (!rb_gc_for_fd(first_errno = errno) || !(expr)) && \
1131 (retried_errno = errno, 1)); \
1132 (void)retried_errno, retried = 1)
1147io_alloc(
VALUE klass)
1149 UNPROTECTED_NEWOBJ_OF(io,
struct RFile, klass,
T_FILE,
sizeof(
struct RFile));
1157# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
1183struct io_internal_writev_struct {
1190 const struct iovec *iov;
1195static int nogvl_wait_for(
VALUE th, rb_io_t *fptr,
short events,
struct timeval *timeout);
1203io_internal_wait(
VALUE thread, rb_io_t *fptr,
int error,
int events,
struct timeval *timeout)
1205 if (!timeout && rb_thread_mn_schedulable(thread)) {
1210 int ready = nogvl_wait_for(thread, fptr, events, timeout);
1215 else if (ready == 0) {
1232internal_read_func(
void *ptr)
1237 if (iis->timeout && !iis->nonblock) {
1238 if (io_internal_wait(iis->th, iis->fptr, 0, RB_WAITFD_IN, iis->timeout) == -1) {
1244 result = read(iis->fd, iis->buf, iis->capa);
1246 if (result < 0 && !iis->nonblock) {
1247 if (io_again_p(
errno)) {
1248 if (io_internal_wait(iis->th, iis->fptr,
errno, RB_WAITFD_IN, iis->timeout) == -1) {
1260#if defined __APPLE__
1261# define do_write_retry(code) do {result = code;} while (result == -1 && errno == EPROTOTYPE)
1263# define do_write_retry(code) result = code
1267internal_write_func(
void *ptr)
1272 if (iis->timeout && !iis->nonblock) {
1273 if (io_internal_wait(iis->th, iis->fptr, 0, RB_WAITFD_OUT, iis->timeout) == -1) {
1279 do_write_retry(write(iis->fd, iis->buf, iis->capa));
1281 if (result < 0 && !iis->nonblock) {
1283 if (io_again_p(e)) {
1284 if (io_internal_wait(iis->th, iis->fptr,
errno, RB_WAITFD_OUT, iis->timeout) == -1) {
1298internal_writev_func(
void *ptr)
1300 struct io_internal_writev_struct *iis = ptr;
1303 if (iis->timeout && !iis->nonblock) {
1304 if (io_internal_wait(iis->th, iis->fptr, 0, RB_WAITFD_OUT, iis->timeout) == -1) {
1310 do_write_retry(writev(iis->fd, iis->iov, iis->iovcnt));
1312 if (result < 0 && !iis->nonblock) {
1313 if (io_again_p(
errno)) {
1314 if (io_internal_wait(iis->th, iis->fptr,
errno, RB_WAITFD_OUT, iis->timeout) == -1) {
1328rb_io_read_memory(rb_io_t *fptr,
void *buf,
size_t count)
1330 rb_thread_t *th = GET_THREAD();
1332 if (scheduler !=
Qnil) {
1335 if (!UNDEF_P(result)) {
1351 struct timeval timeout_storage;
1355 iis.timeout = &timeout_storage;
1358 return (ssize_t)rb_io_blocking_region_wait(fptr, internal_read_func, &iis,
RUBY_IO_READABLE);
1362rb_io_write_memory(rb_io_t *fptr,
const void *buf,
size_t count)
1364 rb_thread_t *th = GET_THREAD();
1366 if (scheduler !=
Qnil) {
1369 if (!UNDEF_P(result)) {
1385 struct timeval timeout_storage;
1389 iis.timeout = &timeout_storage;
1392 return (ssize_t)rb_io_blocking_region_wait(fptr, internal_write_func, &iis,
RUBY_IO_WRITABLE);
1397rb_writev_internal(rb_io_t *fptr,
const struct iovec *iov,
int iovcnt)
1399 if (!iovcnt)
return 0;
1401 rb_thread_t *th = GET_THREAD();
1404 if (scheduler !=
Qnil) {
1408 if (!UNDEF_P(result)) {
1413 struct io_internal_writev_struct iis = {
1424 struct timeval timeout_storage;
1428 iis.timeout = &timeout_storage;
1431 return (ssize_t)rb_io_blocking_region_wait(fptr, internal_writev_func, &iis,
RUBY_IO_WRITABLE);
1436io_flush_buffer_sync(
void *arg)
1438 rb_io_t *fptr = arg;
1458io_flush_buffer_fiber_scheduler(
VALUE scheduler, rb_io_t *fptr)
1461 if (!UNDEF_P(ret)) {
1473io_flush_buffer_async(
VALUE arg)
1475 rb_io_t *fptr = (rb_io_t *)arg;
1478 if (scheduler !=
Qnil) {
1479 VALUE result = io_flush_buffer_fiber_scheduler(scheduler, fptr);
1480 if (!UNDEF_P(result)) {
1485 return rb_io_blocking_region_wait(fptr, io_flush_buffer_sync, fptr,
RUBY_IO_WRITABLE);
1489io_flush_buffer(rb_io_t *fptr)
1492 return (
int)io_flush_buffer_async((
VALUE)fptr);
1500io_fflush(rb_io_t *fptr)
1507 while (fptr->
wbuf.
len > 0 && io_flush_buffer(fptr) != 0) {
1520 rb_thread_t *th = GET_THREAD();
1523 if (scheduler !=
Qnil) {
1527 rb_io_t * fptr = NULL;
1533 if (NIL_OR_UNDEF_P(timeout)) {
1537 if (timeout !=
Qnil) {
1542 int ready = rb_thread_io_wait(th, fptr,
RB_NUM2INT(events), tv);
1566io_wait_for_single_fd(
int fd,
int events,
struct timeval *timeout, rb_thread_t *th,
VALUE scheduler)
1568 if (scheduler !=
Qnil) {
1574 return rb_thread_wait_for_single_fd(th, fd, events, timeout);
1580 io_fd_check_closed(f);
1582 rb_thread_t *th = GET_THREAD();
1587#if defined(ERESTART)
1594#if EWOULDBLOCK != EAGAIN
1597 if (scheduler !=
Qnil) {
1615 io_fd_check_closed(f);
1617 rb_thread_t *th = GET_THREAD();
1622#if defined(ERESTART)
1638#if EWOULDBLOCK != EAGAIN
1641 if (scheduler !=
Qnil) {
1659 rb_thread_t *th = GET_THREAD();
1661 return io_wait_for_single_fd(fd, events, timeout, th, scheduler);
1695#if defined(ERESTART)
1705#if EWOULDBLOCK != EAGAIN
1728 if (
RTEST(result)) {
1743 if (
RTEST(result)) {
1754make_writeconv(rb_io_t *fptr)
1757 const char *senc, *denc;
1791 denc = rb_enc_name(enc);
1823io_binwrite_string_internal(rb_io_t *fptr,
const char *ptr,
rb_len_t length)
1826 struct iovec iov[2];
1829 iov[0].iov_len = fptr->
wbuf.
len;
1830 iov[1].iov_base = (
void*)ptr;
1831 iov[1].iov_len = length;
1833 ssize_t result = rb_writev_internal(fptr, iov, 2);
1838 if (result >= fptr->
wbuf.
len) {
1846 fptr->
wbuf.
off += (int)result;
1847 fptr->
wbuf.
len -= (int)result;
1855 return rb_io_write_memory(fptr, ptr, length);
1860io_binwrite_string_internal(rb_io_t *fptr,
const char *ptr,
rb_len_t length)
1865 if (fptr->
wbuf.
len+length <= fptr->wbuf.capa) {
1872 fptr->
wbuf.
len += (int)length;
1879 if (io_fflush(fptr) < 0) {
1884 if (remaining == 0) {
1890 return rb_io_write_memory(fptr, ptr, length);
1895io_binwrite_string(
VALUE arg)
1899 const char *ptr = p->ptr;
1900 size_t remaining = p->length;
1904 ssize_t result = io_binwrite_string_internal(p->fptr, ptr, remaining);
1910 else if (result > 0) {
1911 if ((
size_t)result == remaining)
break;
1913 remaining -= result;
1929io_allocate_write_buffer(rb_io_t *fptr,
int sync)
1934 fptr->
wbuf.
capa = IO_WBUF_CAPA_MIN;
1945io_binwrite_requires_flush_write(rb_io_t *fptr,
rb_len_t len,
int nosync)
1960io_binwrite(
const char *ptr,
rb_len_t len, rb_io_t *fptr,
int nosync)
1962 if (
len <= 0)
return len;
1967 io_allocate_write_buffer(fptr, !nosync);
1969 if (io_binwrite_requires_flush_write(fptr,
len, nosync)) {
1980 return io_binwrite_string((
VALUE)&arg);
1997# define MODE_BTMODE(a,b,c) ((fmode & FMODE_BINMODE) ? (b) : \
1998 (fmode & FMODE_TEXTMODE) ? (c) : (a))
2000#define MODE_BTXMODE(a, b, c, d, e, f) ((fmode & FMODE_EXCL) ? \
2001 MODE_BTMODE(d, e, f) : \
2002 MODE_BTMODE(a, b, c))
2005do_writeconv(
VALUE str, rb_io_t *fptr,
int *converted)
2007 if (NEED_WRITECONV(fptr)) {
2009 SET_BINARY_MODE(fptr);
2011 make_writeconv(fptr);
2014#define fmode (fptr->mode)
2017 else if (MODE_BTMODE(DEFAULT_TEXTMODE,0,1) && !rb_enc_asciicompat(rb_enc_get(str))) {
2018 rb_raise(rb_eArgError,
"ASCII incompatible string written for text mode IO without encoding conversion: %s",
2019 rb_enc_name(rb_enc_get(str)));
2025 common_encoding = rb_enc_from_encoding(fptr->
encs.
enc2);
2026 else if (fptr->
encs.
enc != rb_ascii8bit_encoding())
2027 common_encoding = rb_enc_from_encoding(fptr->
encs.
enc);
2030 if (!
NIL_P(common_encoding)) {
2041#if RUBY_CRLF_ENVIRONMENT
2042#define fmode (fptr->mode)
2043 else if (MODE_BTMODE(DEFAULT_TEXTMODE,0,1)) {
2046 setmode(fptr->
fd, O_BINARY);
2049 setmode(fptr->
fd, O_TEXT);
2051 if (!rb_enc_asciicompat(rb_enc_get(str))) {
2052 rb_raise(rb_eArgError,
"ASCII incompatible string written for text mode IO without encoding conversion: %s",
2053 rb_enc_name(rb_enc_get(str)));
2062io_fwrite(
VALUE str, rb_io_t *fptr,
int nosync)
2071 if (rb_w32_write_console(str, fptr->
fd) > 0)
return RSTRING_LEN(str);
2075 str = do_writeconv(str, fptr, &converted);
2081 n = io_binwrite(ptr,
len, fptr, nosync);
2094 return (ssize_t)io_binwrite(buf, (
rb_len_t)size, fptr, 0);
2104 io = GetWriteIO(io);
2114 if (RSTRING_LEN(str) == 0)
return INT2FIX(0);
2119 n = io_fwrite(str, fptr, nosync);
2120 if (n < 0L) rb_sys_fail_on_write(fptr);
2126struct binwritev_arg {
2134io_binwritev_internal(
VALUE arg)
2136 struct binwritev_arg *p = (
struct binwritev_arg *)arg;
2138 size_t remaining = p->total;
2141 rb_io_t *fptr = p->fptr;
2142 struct iovec *iov = p->iov;
2143 int iovcnt = p->iovcnt;
2146 rb_len_t result = rb_writev_internal(fptr, iov, iovcnt);
2151 if (offset < (
size_t)fptr->
wbuf.
len) {
2156 offset -= (size_t)fptr->
wbuf.
len;
2162 if (offset == p->total) {
2166 while (result >= (ssize_t)iov->iov_len) {
2168 result -= iov->iov_len;
2178 iov->iov_base = (
char *)iov->iov_base + result;
2179 iov->iov_len -= result;
2193io_binwritev(
struct iovec *iov,
int iovcnt, rb_io_t *fptr)
2198 if (iovcnt == 0)
return 0;
2201 for (
int i = 1; i < iovcnt; i++) total += iov[i].iov_len;
2203 io_allocate_write_buffer(fptr, 1);
2209 if (offset + total <= (
size_t)fptr->
wbuf.
capa) {
2210 for (
int i = 1; i < iovcnt; i++) {
2211 memcpy(fptr->
wbuf.
ptr+offset, iov[i].iov_base, iov[i].iov_len);
2212 offset += iov[i].iov_len;
2223 if (io_fflush(fptr) < 0)
return -1;
2229 iov[0].iov_len = fptr->
wbuf.
len;
2242 struct binwritev_arg arg;
2245 arg.iovcnt = iovcnt;
2252 return io_binwritev_internal((
VALUE)&arg);
2257io_fwritev(
int argc,
const VALUE *argv, rb_io_t *fptr)
2259 int i, converted, iovcnt = argc + 1;
2261 VALUE v1, v2, str, tmp, *tmp_array;
2267 for (i = 0; i < argc; i++) {
2270 str = do_writeconv(str, fptr, &converted);
2275 tmp = rb_str_tmp_frozen_acquire(str);
2279 iov[i+1].iov_base = RSTRING_PTR(tmp);
2280 iov[i+1].iov_len = RSTRING_LEN(tmp);
2283 n = io_binwritev(iov, iovcnt, fptr);
2286 for (i = 0; i < argc; i++) {
2287 rb_str_tmp_frozen_release(argv[i], tmp_array[i]);
2296iovcnt_ok(
int iovcnt)
2299 return iovcnt < IOV_MAX;
2307io_writev(
int argc,
const VALUE *argv,
VALUE io)
2314 io = GetWriteIO(io);
2327 for (i = 0; i < argc; i += cnt) {
2330 n = io_fwritev(cnt, &argv[i], fptr);
2341 rb_sys_fail_on_write(fptr);
2343 total = rb_int_plus(
LEN2NUM(n), total);
2374 return io_writev(argc, argv, io);
2377 VALUE str = argv[0];
2378 return io_write(io, str, 0);
2389rb_io_writev(
VALUE io,
int argc,
const VALUE *argv)
2394 char sep = RCLASS_SINGLETON_P(klass) ? (klass = io,
'.') :
'#';
2397 " which accepts just one argument",
2402 do rb_io_write(io, *argv++);
while (--argc);
2433 rb_io_write(io, str);
2439nogvl_fsync(
void *ptr)
2441 rb_io_t *fptr = ptr;
2444 if (GetFileType((HANDLE)rb_w32_get_osfhandle(fptr->
fd)) != FILE_TYPE_DISK)
2447 return (
VALUE)fsync(fptr->
fd);
2452rb_io_flush_raw(
VALUE io,
int sync)
2460 io = GetWriteIO(io);
2464 if (io_fflush(fptr) < 0)
2465 rb_sys_fail_on_write(fptr);
2468 io_unread(fptr,
true);
2489 return rb_io_flush_raw(io, 1);
2515 pos = io_tell(fptr);
2516 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2522rb_io_seek(
VALUE io,
VALUE offset,
int whence)
2529 pos = io_seek(fptr, pos, whence);
2530 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2531 if (fptr->
readconv) clear_readconv(fptr);
2537interpret_seek_whence(
VALUE vwhence)
2539 if (vwhence == sym_SET)
2541 if (vwhence == sym_CUR)
2543 if (vwhence == sym_END)
2546 if (vwhence == sym_DATA)
2550 if (vwhence == sym_HOLE)
2606 VALUE offset, ptrname;
2607 int whence = SEEK_SET;
2609 if (
rb_scan_args(argc, argv,
"11", &offset, &ptrname) == 2) {
2610 whence = interpret_seek_whence(ptrname);
2613 return rb_io_seek(io, offset, whence);
2641 pos = io_seek(fptr, pos, SEEK_SET);
2642 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2643 if (fptr->
readconv) clear_readconv(fptr);
2673rb_io_rewind(
VALUE io)
2678 if (io_seek(fptr, 0L, 0) < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
2679 if (io == ARGF.current_file) {
2680 ARGF.lineno -= fptr->
lineno;
2684 clear_readconv(fptr);
2691fptr_wait_readable(rb_io_t *fptr)
2702io_fillbuf(rb_io_t *fptr)
2709 fptr->
rbuf.
capa = IO_RBUF_CAPA_FOR(fptr);
2717 if (fptr_wait_readable(fptr))
2721 VALUE path = rb_sprintf(
"fd:%d ", fptr->
fd);
2726 rb_syserr_fail_path(e, path);
2780 if (READ_CHAR_PENDING(fptr))
return Qfalse;
2781 if (READ_DATA_PENDING(fptr))
return Qfalse;
2783#if RUBY_CRLF_ENVIRONMENT
2784 if (!NEED_READCONV(fptr) && NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {
2785 return RBOOL(eof(fptr->
fd));
2788 return RBOOL(io_fillbuf(fptr) < 0);
2812 io = GetWriteIO(io);
2849 io = GetWriteIO(io);
2879rb_io_fsync(
VALUE io)
2883 io = GetWriteIO(io);
2886 if (io_fflush(fptr) < 0)
2887 rb_sys_fail_on_write(fptr);
2889 if ((
int)rb_io_blocking_region(fptr, nogvl_fsync, fptr))
2890 rb_sys_fail_path(fptr->
pathv);
2895# define rb_io_fsync rb_f_notimplement
2896# define rb_io_sync rb_f_notimplement
2905#ifdef HAVE_FDATASYNC
2907nogvl_fdatasync(
void *ptr)
2909 rb_io_t *fptr = ptr;
2911 return (
VALUE)fdatasync(fptr->
fd);
2926rb_io_fdatasync(
VALUE io)
2930 io = GetWriteIO(io);
2933 if (io_fflush(fptr) < 0)
2934 rb_sys_fail_on_write(fptr);
2936 if ((
int)rb_io_blocking_region(fptr, nogvl_fdatasync, fptr) == 0)
2940 return rb_io_fsync(io);
2943#define rb_io_fdatasync rb_io_fsync
2961rb_io_fileno(
VALUE io)
2963 rb_io_t *fptr =
RFILE(io)->fptr;
2975 rb_io_t *fptr =
RFILE(io)->fptr;
2981 if (!UNDEF_P(fileno)) {
3053 rb_io_t *fptr =
RFILE(io)->fptr;
3074rb_io_inspect(
VALUE obj)
3078 static const char closed[] =
" (closed)";
3080 fptr =
RFILE(obj)->fptr;
3087 rb_str_cat(result, closed+1, strlen(closed)-1);
3090 rb_str_catf(result,
"fd %d", fptr->
fd);
3111rb_io_to_io(
VALUE io)
3118read_buffered_data(
char *ptr,
rb_len_t len, rb_io_t *fptr)
3122 n = READ_DATA_PENDING_COUNT(fptr);
3123 if (n <= 0)
return 0;
3124 if (n >
len) n = (int)
len;
3139 if (READ_DATA_PENDING(fptr) == 0) {
3143 c = rb_io_read_memory(fptr, ptr+offset, n);
3146 if (fptr_wait_readable(fptr))
3152 if ((n -= c) <= 0)
break;
3158 c = read_buffered_data(ptr+offset, n, fptr);
3162 if ((n -= c) <= 0)
break;
3165 if (io_fillbuf(fptr) < 0) {
3183bufread_body(
VALUE arg)
3186 p->len = io_bufread(p->str_ptr + p->offset, p->len, p->fptr, &p->read_len);
3195 if (p->offset + p->read_len > 0) {
3197 io_restore_read_buffer(str, p->fptr);
3204bufread_call(
VALUE arg)
3209 return bufread_body(arg);
3211 return rb_rescue2(bufread_body, arg, bufread_timeout, arg,
3221 io_setstrbuf(&str, offset + size);
3222 if (!READ_DATA_PENDING(fptr))
3223 rb_str_make_heap(str);
3224 arg.str_ptr = RSTRING_PTR(str);
3225 arg.offset = offset;
3229 rb_str_locktmp_ensure(str, bufread_call, (
VALUE)&arg);
3231 if (
len < 0) rb_sys_fail_path(fptr->
pathv);
3236remain_size(rb_io_t *fptr)
3239 rb_off_t siz = READ_DATA_PENDING_COUNT(fptr);
3242 if (fstat(fptr->
fd, &st) == 0 && S_ISREG(st.st_mode)
3243#
if defined(__HAIKU__)
3248 if (io_fflush(fptr) < 0)
3249 rb_sys_fail_on_write(fptr);
3250 pos = lseek(fptr->
fd, 0, SEEK_CUR);
3251 if (st.st_size >= pos && pos >= 0) {
3252 siz += st.st_size - pos;
3254 rb_raise(
rb_eIOError,
"file too big for single read");
3265io_enc_str(
VALUE str, rb_io_t *fptr)
3267 rb_enc_associate(str, io_read_encoding(fptr));
3272make_readconv(rb_io_t *fptr,
int size)
3277 const char *sname, *dname;
3281 sname = rb_enc_name(fptr->
encs.
enc2);
3282 dname = rb_enc_name(io_read_encoding(fptr));
3292 if (size < IO_CBUF_CAPA_MIN) size = IO_CBUF_CAPA_MIN;
3298#define MORE_CHAR_SUSPENDED Qtrue
3299#define MORE_CHAR_FINISHED Qnil
3301fill_cbuf(rb_io_t *fptr,
int ec_flags)
3303 const unsigned char *ss, *sp, *se;
3304 unsigned char *ds, *dp, *de;
3313 return MORE_CHAR_SUSPENDED;
3324 ss = sp = (
const unsigned char *)fptr->
rbuf.
ptr + fptr->
rbuf.
off;
3329 fptr->
rbuf.
off += (int)(sp - ss);
3330 fptr->
rbuf.
len -= (int)(sp - ss);
3331 fptr->
cbuf.
len += (int)(dp - ds);
3337 if (putbackable > fptr->
rbuf.
off)
3341 fptr->
rbuf.
off -= putbackable;
3342 fptr->
rbuf.
len += putbackable;
3349 if (cbuf_len0 != fptr->
cbuf.
len)
3350 return MORE_CHAR_SUSPENDED;
3353 return MORE_CHAR_FINISHED;
3359 if (io_fillbuf(fptr) < 0) {
3361 return MORE_CHAR_FINISHED;
3366 fptr->
cbuf.
len += (int)(dp - ds);
3373 if (cbuf_len0 != fptr->
cbuf.
len)
3374 return MORE_CHAR_SUSPENDED;
3376 return MORE_CHAR_FINISHED;
3380more_char(rb_io_t *fptr)
3384 if (v != MORE_CHAR_SUSPENDED && v != MORE_CHAR_FINISHED)
3390io_shift_cbuf(rb_io_t *fptr,
int len,
VALUE *strp)
3401 rb_enc_associate(str, fptr->
encs.
enc);
3438#define MAX_REALLOC_GAP 4096
3443 rb_str_resize(str, n);
3450 if (RSTRING_LEN(str) != n) {
3453 if (shrinkable) io_shrink_read_string(str, n);
3467 if (NEED_READCONV(fptr)) {
3468 int first = !
NIL_P(str);
3469 SET_BINARY_MODE(fptr);
3470 shrinkable = io_setstrbuf(&str,0);
3471 make_readconv(fptr, 0);
3476 io_shift_cbuf(fptr, fptr->
cbuf.
len, &str);
3478 v = fill_cbuf(fptr, 0);
3479 if (v != MORE_CHAR_SUSPENDED && v != MORE_CHAR_FINISHED) {
3482 io_shift_cbuf(fptr, fptr->
cbuf.
len, &str);
3486 if (v == MORE_CHAR_FINISHED) {
3487 clear_readconv(fptr);
3489 if (shrinkable) io_shrink_read_string(str, RSTRING_LEN(str));
3490 return io_enc_str(str, fptr);
3495 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
3499 enc = io_read_encoding(fptr);
3512 shrinkable = io_setstrbuf(&str, siz);
3515 n = io_fread(str, bytes, siz - bytes, fptr);
3516 if (n == 0 && bytes == 0) {
3524 if (bytes < siz)
break;
3528 if (
capa < (
size_t)RSTRING_LEN(str) + BUFSIZ) {
3529 if (
capa < BUFSIZ) {
3532 else if (
capa > IO_MAX_BUFFER_GROWTH) {
3533 capa = IO_MAX_BUFFER_GROWTH;
3538 if (shrinkable) io_shrink_read_string(str, RSTRING_LEN(str));
3539 str = io_enc_str(str, fptr);
3547 if (rb_fd_set_nonblock(fptr->
fd) != 0) {
3548 rb_sys_fail_path(fptr->
pathv);
3553io_read_memory_call(
VALUE arg)
3558 if (scheduler !=
Qnil) {
3561 if (!UNDEF_P(result)) {
3567 if (iis->nonblock) {
3568 return rb_io_blocking_region(iis->fptr, internal_read_func, iis);
3571 return rb_io_blocking_region_wait(iis->fptr, internal_read_func, iis,
RUBY_IO_READABLE);
3578 return (
rb_len_t)rb_str_locktmp_ensure(str, io_read_memory_call, (
VALUE)iis);
3581#define no_exception_p(opts) !rb_opts_exception_p((opts), TRUE)
3584io_getpartial(
VALUE io,
VALUE length,
VALUE str,
int no_exception,
int nonblock)
3592 rb_raise(rb_eArgError,
"negative length %"PRIdLEN
" given",
len);
3595 shrinkable = io_setstrbuf(&str,
len);
3601 io_set_read_length(str, 0, shrinkable);
3607 n = read_buffered_data(RSTRING_PTR(str),
len, fptr);
3612 rb_fd_set_nonblock(fptr->
fd);
3614 io_setstrbuf(&str,
len);
3615 rb_str_make_heap(str);
3618 iis.nonblock = nonblock;
3620 iis.buf = RSTRING_PTR(str);
3623 n = io_read_memory_locktmp(str, &iis);
3626 if (!nonblock && fptr_wait_readable(fptr))
3628 if (nonblock && (io_again_p(e))) {
3630 return sym_wait_readable;
3633 e,
"read would block");
3635 rb_syserr_fail_path(e, fptr->
pathv);
3638 io_set_read_length(str, n, shrinkable);
3739io_readpartial(
int argc,
VALUE *argv,
VALUE io)
3741 VALUE ret, length, str;
3744 ret = io_getpartial(io, length, str, 0, 0);
3751io_nonblock_eof(
int no_exception)
3753 if (!no_exception) {
3763 int no_exception = !rb_bool_expected(ex,
"exception", TRUE);
3764 VALUE ret = io_getpartial(io, length, str, no_exception, 1);
3766 io_nonblock_eof(no_exception);
3773io_write_nonblock(rb_execution_context_t *ec,
VALUE io,
VALUE str,
VALUE ex)
3780 rb_bool_expected(ex,
"exception", TRUE);
3782 io = GetWriteIO(io);
3786 if (io_fflush(fptr) < 0)
3787 rb_sys_fail_on_write(fptr);
3789 rb_fd_set_nonblock(fptr->
fd);
3790 n = write(fptr->
fd, RSTRING_PTR(str), RSTRING_LEN(str));
3795 if (io_again_p(e)) {
3797 return sym_wait_writable;
3803 rb_syserr_fail_path(e, fptr->
pathv);
3887#if RUBY_CRLF_ENVIRONMENT
3893 if (
NIL_P(length)) {
3896 return read_all(fptr, remain_size(fptr), str);
3900 rb_raise(rb_eArgError,
"negative length %"PRIdLEN
" given",
len);
3903 shrinkable = io_setstrbuf(&str,
len);
3908 io_set_read_length(str, 0, shrinkable);
3913#if RUBY_CRLF_ENVIRONMENT
3914 previous_mode = set_binary_mode_with_seek_cur(fptr);
3916 n = io_fread(str, 0,
len, fptr);
3917 io_set_read_length(str, n, shrinkable);
3918#if RUBY_CRLF_ENVIRONMENT
3919 if (previous_mode == O_TEXT) {
3920 setmode(fptr->
fd, O_TEXT);
3923 if (n == 0)
return Qnil;
3932 if (RSTRING_PTR(rs) != rsptr && RSTRING_LEN(rs) != rslen)
3937search_delim(
const char *p,
rb_len_t len,
int delim, rb_encoding *enc)
3939 if (delim < 0)
return NULL;
3940 if (rb_enc_mbminlen(enc) == 1) {
3941 p = memchr(p, delim,
len);
3942 if (p)
return p + 1;
3945 const char *end = p +
len;
3947 int r = rb_enc_precise_mbclen(p, end, enc);
3949 p += rb_enc_mbminlen(enc);
3953 if (rb_enc_mbc_to_codepoint(p, end, enc) == (
unsigned int)delim) {
3963read_raw_character(rb_io_t *fptr, rb_encoding *enc,
char *buf)
3969 if (!READ_DATA_PENDING(fptr)) {
3971 if (io_fillbuf(fptr) < 0)
break;
3973 buf[n++] = *READ_DATA_PENDING_PTR(fptr);
3976 r = rb_enc_precise_mbclen(buf, buf + n, enc);
3983unread_raw_character(rb_io_t *fptr,
const char *buf,
int len)
3995search_wide_delim(
const char *p,
long len,
const char *delim,
int width)
3997 const char *e = p +
len;
4000 while (index < width && delim[index] == 0) index++;
4001 if (index == width) index = 0;
4003 const char *candidate = p + index;
4004 while (candidate < e) {
4005 candidate = memchr(candidate, (
unsigned char)delim[index], e - candidate);
4006 if (candidate == NULL)
break;
4007 const char *start = candidate - index;
4008 if ((start - p) % width == 0 && start + width <= e &&
4009 memcmp(start, delim, width) == 0) {
4018appendline(rb_io_t *fptr,
int delim,
VALUE *strp,
rb_len_t *lp, rb_encoding *enc)
4023 if (NEED_READCONV(fptr)) {
4024 SET_BINARY_MODE(fptr);
4025 make_readconv(fptr, 0);
4028 int searchlen = READ_CHAR_PENDING_COUNT(fptr);
4030 p = READ_CHAR_PENDING_PTR(fptr);
4031 if (0 < limit && limit < searchlen)
4032 searchlen = (int)limit;
4033 e = search_delim(p, searchlen, delim, enc);
4035 int len = (int)(e-p);
4057 return (
unsigned char)RSTRING_PTR(str)[RSTRING_LEN(str)-1];
4060 }
while (more_char(fptr) != MORE_CHAR_FINISHED);
4061 clear_readconv(fptr);
4066 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
4067 if (rb_enc_mbminlen(enc) != 1) {
4068 char buf[ONIGENC_CODE_TO_MBC_MAXLEN];
4072 int width = rb_enc_mbminlen(enc);
4073 int delim_len = rb_enc_codelen(delim, enc);
4075 if (delim_len == width) {
4076 rb_enc_mbcput(delim, buf, enc);
4078 if (!READ_DATA_PENDING(fptr)) {
4080 if (io_fillbuf(fptr) < 0)
return EOF;
4082 long pending = READ_DATA_PENDING_COUNT(fptr);
4083 long complete = pending - pending % width;
4084 const char *p = READ_DATA_PENDING_PTR(fptr);
4085 const char *q = complete ? search_wide_delim(p, complete, buf, width) : NULL;
4086 long take = q ? q - p + width : complete;
4095 if (q)
return delim;
4096 if (complete == pending)
continue;
4098 len = read_raw_character(fptr, enc, buf);
4099 if (
len == 0)
return EOF;
4103 int r = rb_enc_precise_mbclen(buf, buf +
len, enc);
4105 rb_enc_mbc_to_codepoint(buf, buf +
len, enc) == (
unsigned int)delim)
4111 while ((
len = read_raw_character(fptr, enc, buf)) > 0) {
4118 return (
unsigned char)buf[
len - 1];
4122 int r = rb_enc_precise_mbclen(buf, buf +
len, enc);
4124 rb_enc_mbc_to_codepoint(buf, buf +
len, enc) == (
unsigned int)delim)
4127 return (
unsigned char)buf[
len - 1];
4133 rb_len_t pending = READ_DATA_PENDING_COUNT(fptr);
4135 const char *p = READ_DATA_PENDING_PTR(fptr);
4139 if (limit > 0 && pending > limit) pending = limit;
4140 e = search_delim(p, pending, delim, enc);
4141 if (e) pending = e - p;
4143 last = RSTRING_LEN(str);
4144 rb_str_resize(str, last + pending);
4151 read_buffered_data(RSTRING_PTR(str) + last, pending, fptr);
4154 if (e)
return delim;
4156 return (
unsigned char)RSTRING_PTR(str)[RSTRING_LEN(str)-1];
4159 }
while (io_fillbuf(fptr) >= 0);
4165swallow(rb_io_t *fptr,
int term)
4167 if (NEED_READCONV(fptr)) {
4168 rb_encoding *enc = io_read_encoding(fptr);
4169 int needconv = rb_enc_mbminlen(enc) != 1;
4170 SET_BINARY_MODE(fptr);
4171 make_readconv(fptr, 0);
4174 while ((cnt = READ_CHAR_PENDING_COUNT(fptr)) > 0) {
4175 const char *p = READ_CHAR_PENDING_PTR(fptr);
4178 if (*p != term)
return TRUE;
4180 while (--i && *++p == term);
4183 const char *e = p + cnt;
4184 if (rb_enc_ascget(p, e, &i, enc) != term)
return TRUE;
4185 while ((p += i) < e && rb_enc_ascget(p, e, &i, enc) == term);
4188 io_shift_cbuf(fptr, (
int)cnt - i, NULL);
4190 }
while (more_char(fptr) != MORE_CHAR_FINISHED);
4194 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
4195 rb_encoding *enc = io_read_encoding(fptr);
4196 int widechar = rb_enc_mbminlen(enc) != 1;
4198 char buf[ONIGENC_CODE_TO_MBC_MAXLEN];
4201 while ((
len = read_raw_character(fptr, enc, buf)) > 0) {
4202 if (rb_enc_ascget(buf, buf +
len, NULL, enc) != term) {
4203 unread_raw_character(fptr, buf,
len);
4211 while ((cnt = READ_DATA_PENDING_COUNT(fptr)) > 0) {
4213 const char *p = READ_DATA_PENDING_PTR(fptr);
4215 if (cnt >
sizeof buf) cnt =
sizeof buf;
4216 if (*p != term)
return TRUE;
4218 while (--i && *++p == term);
4219 if (!read_buffered_data(buf, cnt - i, fptr))
4220 rb_sys_fail_path(fptr->
pathv);
4223 }
while (io_fillbuf(fptr) == 0);
4228rb_io_getline_fast(rb_io_t *fptr, rb_encoding *enc,
int chomp)
4236 int pending = READ_DATA_PENDING_COUNT(fptr);
4239 const char *p = READ_DATA_PENDING_PTR(fptr);
4243 e = memchr(p,
'\n', pending);
4245 pending = (int)(e - p + 1);
4247 chomplen = (pending > 1 && *(e-1) ==
'\r') + 1;
4256 rb_str_resize(str,
len + pending - chomplen);
4257 read_buffered_data(RSTRING_PTR(str)+
len, pending - chomplen, fptr);
4260 if (pending == 1 && chomplen == 1 &&
len > 0) {
4261 if (RSTRING_PTR(str)[
len-1] ==
'\r') {
4262 rb_str_resize(str, --
len);
4267 len += pending - chomplen;
4273 }
while (io_fillbuf(fptr) >= 0);
4276 str = io_enc_str(str, fptr);
4287 unsigned int chomp: 1;
4301 chomp = (!UNDEF_P(vchomp)) &&
RTEST(vchomp);
4303 args->chomp = chomp;
4321 else if (2 <= argc) {
4322 rs = argv[0], lim = argv[1];
4337 rb_encoding *enc_rs, *enc_io;
4340 enc_rs = rb_enc_get(rs);
4341 enc_io = io_read_encoding(fptr);
4342 if (enc_io != enc_rs &&
4343 (!is_ascii_string(rs) ||
4344 (RSTRING_LEN(rs) > 0 && !rb_enc_asciicompat(enc_io)))) {
4346 rs = rb_enc_str_new(0, 0, enc_io);
4351 rb_raise(rb_eArgError,
"encoding mismatch: %s IO with %s RS",
4352 rb_enc_name(enc_io),
4353 rb_enc_name(enc_rs));
4363 argc =
rb_scan_args(argc, argv,
"02:", NULL, NULL, &opts);
4364 extract_getline_args(argc, argv, args);
4365 extract_getline_opts(opts, args);
4366 check_getline_args(&args->rs, &args->limit, io);
4370rb_io_getline_0(
VALUE rs,
rb_len_t limit,
int chomp, rb_io_t *fptr)
4377 if (
NIL_P(rs) && limit < 0) {
4378 str = read_all(fptr, 0,
Qnil);
4379 if (RSTRING_LEN(str) == 0)
return Qnil;
4381 else if (limit == 0) {
4382 return rb_enc_str_new(0, 0, io_read_encoding(fptr));
4384 else if (rs ==
rb_default_rs && limit < 0 && !NEED_READCONV(fptr) &&
4385 rb_enc_asciicompat(enc = io_read_encoding(fptr))) {
4386 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
4387 return rb_io_getline_fast(fptr, enc, chomp);
4390 int c, newline = -1;
4391 const char *rsptr = 0;
4394 int extra_limit = 16;
4395 int chomp_cr = chomp;
4397 SET_BINARY_MODE(fptr);
4398 enc = io_read_encoding(fptr);
4401 rslen = RSTRING_LEN(rs);
4406 swallow(fptr,
'\n');
4408 if (!rb_enc_asciicompat(enc)) {
4412 rsptr = RSTRING_PTR(rs);
4413 rslen = RSTRING_LEN(rs);
4417 else if (rb_enc_mbminlen(enc) == 1) {
4418 rsptr = RSTRING_PTR(rs);
4419 newline = (
unsigned char)rsptr[rslen - 1];
4423 rsptr = RSTRING_PTR(rs);
4424 const char *e = rsptr + rslen;
4425 const char *last = rb_enc_prev_char(rsptr, e, e, enc);
4427 newline = rb_enc_codepoint_len(last, e, &n, enc);
4428 if (last + n != e) rb_raise(rb_eArgError,
"broken separator");
4430 chomp_cr = chomp && newline ==
'\n' && rslen == rb_enc_mbminlen(enc);
4434 while ((c = appendline(fptr, newline, &str, &limit, enc)) != EOF) {
4435 const char *s, *p, *pp, *e;
4437 if (c == newline && RSTRING_LEN(str) >= rslen) {
4438 s = RSTRING_PTR(str);
4441 if (at_char_boundary(s, p, e, enc)) {
4442 if (!rspara) rscheck(rsptr, rslen, rs);
4443 if (memcmp(p, rsptr, rslen) == 0) {
4445 if (chomp_cr && p > s && *(p-1) ==
'\r') --p;
4453 s = RSTRING_PTR(str);
4455 pp = rb_enc_prev_char(s, p, p, enc);
4456 if (extra_limit && pp &&
4470 if (rspara && c != EOF)
4471 swallow(fptr,
'\n');
4473 str = io_enc_str(str, fptr);
4476 if (!
NIL_P(str) && !nolimit) {
4487 int old_lineno, new_lineno;
4491 old_lineno = fptr->
lineno;
4492 str = rb_io_getline_0(rs, limit, chomp, fptr);
4493 if (!
NIL_P(str) && (new_lineno = fptr->
lineno) != old_lineno) {
4494 if (io == ARGF.current_file) {
4495 ARGF.lineno += new_lineno - old_lineno;
4496 ARGF.last_lineno = ARGF.lineno;
4499 ARGF.last_lineno = new_lineno;
4507rb_io_getline(
int argc,
VALUE *argv,
VALUE io)
4511 prepare_getline_args(argc, argv, &args, io);
4512 return rb_io_getline_1(args.rs, args.limit, args.chomp, io);
4530rb_io_gets_internal(
VALUE io)
4532 return rb_io_gets_limit_internal(io, -1);
4612 str = rb_io_getline(argc, argv, io);
4628rb_io_lineno(
VALUE io)
4683 check_getline_args(&sep, &limit, io);
4685 VALUE line = rb_io_getline_1(sep, limit,
RTEST(chomp), io);
4686 rb_lastline_set_up(line, 1);
4761rb_io_readlines(
int argc,
VALUE *argv,
VALUE io)
4765 prepare_getline_args(argc, argv, &args, io);
4766 return io_readlines(&args, io);
4774 if (arg->limit == 0)
4775 rb_raise(rb_eArgError,
"invalid limit: 0 for readlines");
4777 while (!
NIL_P(line = rb_io_getline_1(arg->rs, arg->limit, arg->chomp, io))) {
4890rb_io_each_line(
int argc,
VALUE *argv,
VALUE io)
4896 prepare_getline_args(argc, argv, &args, io);
4897 if (args.limit == 0)
4898 rb_raise(rb_eArgError,
"invalid limit: 0 for each_line");
4899 while (!
NIL_P(str = rb_io_getline_1(args.rs, args.limit, args.chomp, io))) {
4927rb_io_each_byte(
VALUE io)
4943 }
while (io_fillbuf(fptr) >= 0);
4948io_getc(rb_io_t *fptr, rb_encoding *enc)
4953 if (NEED_READCONV(fptr)) {
4954 rb_encoding *read_enc = io_read_encoding(fptr);
4957 SET_BINARY_MODE(fptr);
4958 make_readconv(fptr, 0);
4972 if (more_char(fptr) == MORE_CHAR_FINISHED) {
4974 clear_readconv(fptr);
4978 str = rb_enc_str_new(fptr->
cbuf.
ptr+fptr->
cbuf.
off, 1, read_enc);
4981 if (fptr->
cbuf.
len == 0) clear_readconv(fptr);
4990 io_shift_cbuf(fptr, r, &str);
4997 ISASCII(RSTRING_PTR(str)[0])) {
5001 str = io_enc_str(str, fptr);
5006 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
5007 if (io_fillbuf(fptr) < 0) {
5010 if (rb_enc_asciicompat(enc) && ISASCII(fptr->
rbuf.
ptr[fptr->
rbuf.
off])) {
5029 if (io_fillbuf(fptr) != -1) {
5033 r = rb_enc_precise_mbclen(RSTRING_PTR(str), RSTRING_PTR(str)+RSTRING_LEN(str), enc);
5049 str = io_enc_str(str, fptr);
5076rb_io_each_char(
VALUE io)
5086 enc = io_input_encoding(fptr);
5088 while (!
NIL_P(c = io_getc(fptr, enc))) {
5115rb_io_each_codepoint(
VALUE io)
5127 enc = io_read_encoding(fptr);
5128 if (NEED_READCONV(fptr)) {
5129 SET_BINARY_MODE(fptr);
5132 make_readconv(fptr, 0);
5144 if (more_char(fptr) == MORE_CHAR_FINISHED) {
5145 clear_readconv(fptr);
5165 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
5166 while (io_fillbuf(fptr) >= 0) {
5181 char cbuf[8], *p = cbuf;
5183 if (more > numberof(cbuf))
goto invalid;
5185 if (more > numberof(cbuf))
goto invalid;
5186 while ((n = (
int)read_buffered_data(p, more, fptr)) > 0 &&
5187 (p += n, (more -= n) > 0)) {
5188 if (io_fillbuf(fptr) < 0)
goto invalid;
5189 if ((n = fptr->
rbuf.
len) > more) n = more;
5191 r = rb_enc_precise_mbclen(cbuf, p, enc);
5204 rb_raise(rb_eArgError,
"invalid byte sequence in %s", rb_enc_name(enc));
5237 enc = io_input_encoding(fptr);
5239 return io_getc(fptr, enc);
5263rb_io_readchar(
VALUE io)
5265 VALUE c = rb_io_getc(io);
5306 rb_io_flush(r_stdout);
5309 if (io_fillbuf(fptr) < 0) {
5339rb_io_readbyte(
VALUE io)
5400 unsigned char c =
NUM2INT(v) & 0xFF;
5406 io_ungetbyte(b, fptr);
5462 else if (RB_BIGNUM_TYPE_P(c)) {
5468 if (NEED_READCONV(fptr)) {
5469 SET_BINARY_MODE(fptr);
5470 len = RSTRING_LEN(c);
5471#if SIZEOF_RB_LEN_T > SIZEOF_INT
5475 make_readconv(fptr, (
int)
len);
5489 NEED_NEWLINE_DECORATOR_ON_READ_CHECK(fptr);
5490 io_ungetbyte(c, fptr);
5510rb_io_isatty(
VALUE io)
5515 return RBOOL(isatty(fptr->
fd) != 0);
5518#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
5534rb_io_close_on_exec_p(
VALUE io)
5540 write_io = GetWriteIO(io);
5541 if (io != write_io) {
5543 if (fptr && 0 <= (fd = fptr->
fd)) {
5544 if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5545 if (!(ret & FD_CLOEXEC))
return Qfalse;
5550 if (fptr && 0 <= (fd = fptr->
fd)) {
5551 if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5552 if (!(ret & FD_CLOEXEC))
return Qfalse;
5557#define rb_io_close_on_exec_p rb_f_notimplement
5560#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
5584 int flag =
RTEST(arg) ? FD_CLOEXEC : 0;
5589 write_io = GetWriteIO(io);
5590 if (io != write_io) {
5592 if (fptr && 0 <= (fd = fptr->
fd)) {
5593 if ((ret = fcntl(fptr->
fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5594 if ((ret & FD_CLOEXEC) != flag) {
5595 ret = (ret & ~FD_CLOEXEC) | flag;
5596 ret = fcntl(fd, F_SETFD, ret);
5597 if (ret != 0) rb_sys_fail_path(fptr->
pathv);
5604 if (fptr && 0 <= (fd = fptr->
fd)) {
5605 if ((ret = fcntl(fd, F_GETFD)) == -1) rb_sys_fail_path(fptr->
pathv);
5606 if ((ret & FD_CLOEXEC) != flag) {
5607 ret = (ret & ~FD_CLOEXEC) | flag;
5608 ret = fcntl(fd, F_SETFD, ret);
5609 if (ret != 0) rb_sys_fail_path(fptr->
pathv);
5615#define rb_io_set_close_on_exec rb_f_notimplement
5618#define RUBY_IO_EXTERNAL_P(f) ((f)->mode & FMODE_EXTERNAL)
5619#define PREP_STDIO_NAME(f) (RSTRING_PTR((f)->pathv))
5622finish_writeconv(rb_io_t *fptr,
int noalloc)
5624 unsigned char *ds, *dp, *de;
5628 unsigned char buf[1024];
5633 de = buf +
sizeof(buf);
5636 size_t remaining = dp-ds;
5637 rb_len_t result = rb_io_write_memory(fptr, ds, remaining);
5641 if ((
size_t)result == remaining)
break;
5664 if (io_fflush(fptr) < 0) {
5672 fptr->
wbuf.
len += (int)(dp - ds);
5688finish_writeconv_sync(
VALUE arg)
5691 return finish_writeconv(p->fptr, p->noalloc);
5695nogvl_close(
void *ptr)
5699 return (
void*)(intptr_t)close(*fd);
5703maygvl_close(
int fd,
int keepgvl)
5712 return IO_WITHOUT_GVL_INT(nogvl_close, &fd);
5716nogvl_fclose(
void *ptr)
5720 return (
void*)(intptr_t)fclose(file);
5724maygvl_fclose(FILE *file,
int keepgvl)
5727 return fclose(file);
5729 return IO_WITHOUT_GVL_INT(nogvl_fclose, file);
5735fptr_finalize_flush(rb_io_t *fptr,
int noraise,
int keepgvl)
5740 int mode = fptr->
mode;
5746 arg.noalloc = noraise;
5750 error = finish_writeconv(fptr, noraise);
5763 io_flush_buffer_sync(fptr);
5766 if (io_fflush(fptr) < 0 &&
NIL_P(error)) {
5774 if (RUBY_IO_EXTERNAL_P(fptr) || fd <= 2) {
5784 rb_thread_io_close_wait(fptr);
5786 if (!done && stdio_file) {
5788 if ((maygvl_fclose(stdio_file, noraise) < 0) &&
NIL_P(error)) {
5798 if (!done && fd >= 0 && scheduler !=
Qnil) {
5801 if (!UNDEF_P(result)) {
5802 done =
RTEST(result);
5806 if (!done && fd >= 0) {
5812 if ((maygvl_close(fd, keepgvl) < 0) &&
NIL_P(error)) {
5821 if (!
NIL_P(error) && !noraise) {
5830fptr_finalize(rb_io_t *fptr,
int noraise)
5832 fptr_finalize_flush(fptr, noraise, FALSE);
5833 free_io_buffer(&fptr->
rbuf);
5834 free_io_buffer(&fptr->
wbuf);
5835 clear_codeconv(fptr);
5839rb_io_fptr_cleanup(rb_io_t *fptr,
int noraise)
5845 fptr_finalize(fptr, noraise);
5853 ruby_xfree_sized(buf->ptr, (
size_t)buf->capa);
5856 buf->off = buf->len = buf->capa = 0;
5860clear_readconv(rb_io_t *fptr)
5866 free_io_buffer(&fptr->
cbuf);
5870clear_writeconv(rb_io_t *fptr)
5880clear_codeconv(rb_io_t *fptr)
5882 clear_readconv(fptr);
5883 clear_writeconv(fptr);
5887rb_io_fptr_cleanup_all(rb_io_t *fptr)
5891 rb_io_fptr_cleanup(fptr, TRUE);
5893 free_io_buffer(&fptr->
rbuf);
5894 free_io_buffer(&fptr->
wbuf);
5895 clear_codeconv(fptr);
5902 rb_io_fptr_cleanup_all(io);
5909rb_io_fptr_finalize_closed(
struct rb_io *io)
5911 if (!io)
return true;
5912 if (io->
fd >= 0)
return false;
5918rb_io_memsize(
const rb_io_t *io)
5920 size_t size =
sizeof(rb_io_t);
5930 rb_serial_t fork_generation = GET_VM()->fork_gen;
5931 if (io->fork_generation == fork_generation) {
5942# define KEEPGVL TRUE
5944# define KEEPGVL FALSE
5948io_close_fptr(
VALUE io)
5952 rb_io_t *write_fptr;
5954 write_io = GetWriteIO(io);
5955 if (io != write_io) {
5956 write_fptr =
RFILE(write_io)->fptr;
5957 if (write_fptr && 0 <= write_fptr->
fd) {
5958 rb_io_fptr_cleanup(write_fptr, TRUE);
5962 fptr =
RFILE(io)->fptr;
5963 if (!fptr)
return 0;
5964 if (fptr->
fd < 0)
return 0;
5967 if (rb_thread_io_close_interrupt(fptr)) {
5969 fptr_finalize_flush(fptr, FALSE, KEEPGVL);
5972 rb_io_fptr_cleanup(fptr, FALSE);
5977fptr_waitpid(rb_io_t *fptr,
int nohang)
5981 rb_last_status_clear();
5990 rb_io_t *fptr = io_close_fptr(io);
5991 if (fptr) fptr_waitpid(fptr, 0);
6031rb_io_close_m(
VALUE io)
6033 rb_io_t *fptr = rb_io_get_fptr(io);
6042io_call_close(
VALUE io)
6051 enum {mesg_len =
sizeof(closed_stream)-1};
6052 VALUE mesg = rb_attr_get(exc, idMesg);
6054 RSTRING_LEN(mesg) != mesg_len ||
6055 memcmp(RSTRING_PTR(mesg), closed_stream, mesg_len)) {
6065 if (!UNDEF_P(closed) &&
RTEST(closed))
return io;
6066 rb_rescue2(io_call_close, io, ignore_closed_stream, io,
6100 rb_io_t *write_fptr;
6102 write_io = GetWriteIO(io);
6103 if (io != write_io) {
6104 write_fptr =
RFILE(write_io)->fptr;
6105 if (write_fptr && 0 <= write_fptr->
fd) {
6110 fptr = rb_io_get_fptr(io);
6111 return RBOOL(0 > fptr->
fd);
6147rb_io_close_read(
VALUE io)
6153 if (fptr->
fd < 0)
return Qnil;
6154 if (is_socket(fptr->
fd, fptr->
pathv)) {
6158 if (shutdown(fptr->
fd, SHUT_RD) < 0)
6159 rb_sys_fail_path(fptr->
pathv);
6166 write_io = GetWriteIO(io);
6167 if (io != write_io) {
6172 RFILE(io)->fptr = wfptr;
6175 RFILE(write_io)->fptr = fptr;
6176 rb_io_fptr_cleanup(fptr, FALSE);
6182 rb_raise(
rb_eIOError,
"closing non-duplex IO for reading");
6220rb_io_close_write(
VALUE io)
6225 write_io = GetWriteIO(io);
6227 if (fptr->
fd < 0)
return Qnil;
6228 if (is_socket(fptr->
fd, fptr->
pathv)) {
6239 if (io_fflush(fptr) < 0)
6240 rb_sys_fail_on_write(fptr);
6242 if (shutdown(fptr->
fd, SHUT_WR) < 0)
6243 rb_sys_fail_path(fptr->
pathv);
6251 rb_raise(
rb_eIOError,
"closing non-duplex IO for writing");
6254 if (io != write_io) {
6274rb_io_sysseek(
int argc,
VALUE *argv,
VALUE io)
6276 VALUE offset, ptrname;
6277 int whence = SEEK_SET;
6281 if (
rb_scan_args(argc, argv,
"11", &offset, &ptrname) == 2) {
6282 whence = interpret_seek_whence(ptrname);
6287 (READ_DATA_BUFFERED(fptr) || READ_CHAR_PENDING(fptr))) {
6291 rb_warn(
"sysseek for buffered IO");
6294 pos = lseek(fptr->
fd, pos, whence);
6295 if (pos < 0 &&
errno) rb_sys_fail_path(fptr->
pathv);
6329 io = GetWriteIO(io);
6334 rb_warn(
"syswrite for buffered IO");
6337 tmp = rb_str_tmp_frozen_acquire(str);
6339 n = rb_io_write_memory(fptr, ptr,
len);
6340 if (n < 0) rb_sys_fail_path(fptr->
pathv);
6341 rb_str_tmp_frozen_release(str, tmp);
6358rb_io_sysread(
int argc,
VALUE *argv,
VALUE io)
6369 rb_raise(rb_eArgError,
"negative length %"PRIdLEN
" given", ilen);
6371 shrinkable = io_setstrbuf(&str, ilen);
6376 if (READ_DATA_BUFFERED(fptr)) {
6381 io_set_read_length(str, 0, shrinkable);
6387 io_setstrbuf(&str, ilen);
6388 rb_str_make_heap(str);
6393 iis.buf = RSTRING_PTR(str);
6396 n = io_read_memory_locktmp(str, &iis);
6399 rb_sys_fail_path(fptr->
pathv);
6402 io_set_read_length(str, n, shrinkable);
6420internal_pread_func(
void *_arg)
6424 return (
VALUE)pread(arg->fd, arg->buf, arg->count, arg->offset);
6428pread_internal_call(
VALUE _arg)
6433 if (scheduler !=
Qnil) {
6436 if (!UNDEF_P(result)) {
6441 return rb_io_blocking_region_wait(arg->io, internal_pread_func, arg,
RUBY_IO_READABLE);
6485 rb_raise(rb_eArgError,
"negative length %"PRIdLEN
" given", ilen);
6489 shrinkable = io_setstrbuf(&str, ilen);
6495 io_set_read_length(str, 0, shrinkable);
6499 io_setstrbuf(&str, ilen);
6500 rb_str_make_heap(str);
6503 arg.buf = RSTRING_PTR(str);
6504 arg.count = (size_t)ilen;
6511 rb_sys_fail_path(fptr->
pathv);
6513 io_set_read_length(str, n, shrinkable);
6522internal_pwrite_func(
void *_arg)
6526 return (
VALUE)pwrite(arg->fd, arg->buf, arg->count, arg->offset);
6530pwrite_internal_call(
VALUE _arg)
6535 if (scheduler !=
Qnil) {
6538 if (!UNDEF_P(result)) {
6543 return rb_io_blocking_region_wait(arg->io, internal_pwrite_func, arg,
RUBY_IO_WRITABLE);
6584 io = GetWriteIO(io);
6591 tmp = rb_str_tmp_frozen_acquire(str);
6592 arg.buf = RSTRING_PTR(tmp);
6593 arg.count = (size_t)RSTRING_LEN(tmp);
6595 n = (ssize_t)pwrite_internal_call((
VALUE)&arg);
6596 if (n < 0) rb_sys_fail_path(fptr->
pathv);
6597 rb_str_tmp_frozen_release(str, tmp);
6617 SET_BINARY_MODE_WITH_SEEK_CUR(fptr);
6620 setmode(fptr->
fd, O_BINARY);
6627io_ascii8bit_binmode(rb_io_t *fptr)
6639 SET_BINARY_MODE_WITH_SEEK_CUR(fptr);
6645 clear_codeconv(fptr);
6654 io_ascii8bit_binmode(fptr);
6671rb_io_binmode_m(
VALUE io)
6677 write_io = GetWriteIO(io);
6692rb_io_binmode_p(
VALUE io)
6700rb_io_fmode_modestr(
enum rb_io_mode fmode)
6704 return MODE_BTMODE(
"a+",
"ab+",
"at+");
6706 return MODE_BTMODE(
"a",
"ab",
"at");
6710 rb_raise(rb_eArgError,
"invalid access fmode 0x%x", fmode);
6712 return MODE_BTMODE(
"r",
"rb",
"rt");
6714 return MODE_BTXMODE(
"w",
"wb",
"wt",
"wx",
"wbx",
"wtx");
6717 return MODE_BTXMODE(
"w+",
"wb+",
"wt+",
"w+x",
"wb+x",
"wt+x");
6719 return MODE_BTMODE(
"r+",
"rb+",
"rt+");
6723static const char bom_prefix[] =
"bom|";
6724static const char utf_prefix[] =
"utf-";
6725enum {bom_prefix_len = (int)
sizeof(bom_prefix) - 1};
6726enum {utf_prefix_len = (int)
sizeof(utf_prefix) - 1};
6731 return len > bom_prefix_len &&
STRNCASECMP(name, bom_prefix, bom_prefix_len) == 0;
6737 enum rb_io_mode fmode = 0;
6738 const char *m = modestr, *p = NULL;
6766 if (modestr[0] !=
'w')
6787 rb_raise(rb_eArgError,
"invalid access mode %s", modestr);
6794 enum rb_io_mode fmode = 0;
6796 switch (oflags & O_ACCMODE) {
6808 if (oflags & O_APPEND) {
6811 if (oflags & O_TRUNC) {
6814 if (oflags & O_CREAT) {
6817 if (oflags & O_EXCL) {
6821 if (oflags & O_BINARY) {
6830rb_io_fmode_oflags(
enum rb_io_mode fmode)
6874rb_io_oflags_modestr(
int oflags)
6877# define MODE_BINARY(a,b) ((oflags & O_BINARY) ? (b) : (a))
6879# define MODE_BINARY(a,b) (a)
6882 if (oflags & O_EXCL) {
6883 rb_raise(rb_eArgError,
"exclusive access mode is not supported");
6885 accmode = oflags & (O_RDONLY|O_WRONLY|O_RDWR);
6886 if (oflags & O_APPEND) {
6887 if (accmode == O_WRONLY) {
6888 return MODE_BINARY(
"a",
"ab");
6890 if (accmode == O_RDWR) {
6891 return MODE_BINARY(
"a+",
"ab+");
6896 rb_raise(rb_eArgError,
"invalid access oflags 0x%x", oflags);
6898 return MODE_BINARY(
"r",
"rb");
6900 return MODE_BINARY(
"w",
"wb");
6902 if (oflags & O_TRUNC) {
6903 return MODE_BINARY(
"w+",
"wb+");
6905 return MODE_BINARY(
"r+",
"rb+");
6915rb_io_ext_int_to_encs(rb_encoding *ext, rb_encoding *intern, rb_encoding **enc, rb_encoding **enc2,
enum rb_io_mode fmode)
6917 int default_ext = 0;
6923 if (rb_is_ascii8bit_enc(ext)) {
6927 else if (intern == NULL) {
6930 if (intern == NULL || intern == (rb_encoding *)
Qnil ||
6933 *enc = (default_ext && intern != ext) ? NULL : ext;
6943unsupported_encoding(
const char *name, rb_encoding *enc)
6945 rb_enc_warn(enc,
"Unsupported encoding %s ignored", name);
6949parse_mode_enc(
const char *estr, rb_encoding *estr_enc,
6950 rb_encoding **enc_p, rb_encoding **enc2_p,
enum rb_io_mode *fmode_p)
6955 enum rb_io_mode fmode = fmode_p ? *fmode_p : 0;
6956 rb_encoding *ext_enc, *int_enc;
6961 p = strrchr(estr,
':');
6964 estr += bom_prefix_len;
6965 len -= bom_prefix_len;
6966 if (!
STRNCASECMP(estr, utf_prefix, utf_prefix_len)) {
6970 rb_enc_warn(estr_enc,
"BOM with non-UTF encoding %s is nonsense", estr);
6979 memcpy(encname, estr,
len);
6980 encname[
len] =
'\0';
6983 idx = rb_enc_find_index(estr);
6985 if (fmode_p) *fmode_p = fmode;
6988 ext_enc = rb_enc_from_index(idx);
6991 unsupported_encoding(estr, estr_enc);
6997 if (*p ==
'-' && *(p+1) ==
'\0') {
6999 int_enc = (rb_encoding *)
Qnil;
7002 idx2 = rb_enc_find_index(p);
7004 unsupported_encoding(p, estr_enc);
7006 int_enc = (rb_encoding *)
Qnil;
7009 int_enc = rb_enc_from_index(idx2);
7013 rb_io_ext_int_to_encs(ext_enc, int_enc, enc_p, enc2_p, fmode);
7021 rb_encoding *extencoding = NULL;
7022 rb_encoding *intencoding = NULL;
7026 v = rb_hash_lookup2(opt, sym_encoding,
Qnil);
7027 if (v !=
Qnil) encoding = v;
7028 v = rb_hash_lookup2(opt, sym_extenc,
Qundef);
7029 if (v !=
Qnil) extenc = v;
7030 v = rb_hash_lookup2(opt, sym_intenc,
Qundef);
7031 if (!UNDEF_P(v)) intenc = v;
7033 if ((!UNDEF_P(extenc) || !UNDEF_P(intenc)) && !
NIL_P(encoding)) {
7035 int idx = rb_to_encoding_index(encoding);
7036 if (idx >= 0) encoding = rb_enc_from_encoding(rb_enc_from_index(idx));
7037 rb_warn(
"Ignoring encoding parameter '%"PRIsVALUE
"': %s_encoding is used",
7038 encoding, UNDEF_P(extenc) ?
"internal" :
"external");
7042 if (!NIL_OR_UNDEF_P(extenc)) {
7043 extencoding = rb_to_encoding(extenc);
7045 if (!UNDEF_P(intenc)) {
7046 if (
NIL_P(intenc)) {
7048 intencoding = (rb_encoding *)
Qnil;
7053 if (*p ==
'-' && *(p+1) ==
'\0') {
7055 intencoding = (rb_encoding *)
Qnil;
7058 intencoding = rb_to_encoding(intenc);
7062 intencoding = rb_to_encoding(intenc);
7064 if (extencoding == intencoding) {
7065 intencoding = (rb_encoding *)
Qnil;
7068 if (!
NIL_P(encoding)) {
7072 enc_p, enc2_p, fmode_p);
7075 rb_io_ext_int_to_encs(rb_to_encoding(encoding), NULL, enc_p, enc2_p, 0);
7078 else if (!UNDEF_P(extenc) || !UNDEF_P(intenc)) {
7080 rb_io_ext_int_to_encs(extencoding, intencoding, enc_p, enc2_p, 0);
7086validate_enc_binmode(
enum rb_io_mode *fmode_p,
int ecflags, rb_encoding *enc, rb_encoding *enc2)
7088 enum rb_io_mode fmode = *fmode_p;
7094 rb_raise(rb_eArgError,
"ASCII incompatible encoding needs binmode");
7097 rb_raise(rb_eArgError,
"newline decorator with binary mode");
7104#if !DEFAULT_TEXTMODE
7113extract_binmode(
VALUE opthash,
enum rb_io_mode *fmode)
7115 if (!
NIL_P(opthash)) {
7117 v = rb_hash_aref(opthash, sym_textmode);
7120 rb_raise(rb_eArgError,
"textmode specified twice");
7122 rb_raise(rb_eArgError,
"both textmode and binmode specified");
7126 v = rb_hash_aref(opthash, sym_binmode);
7129 rb_raise(rb_eArgError,
"binmode specified twice");
7131 rb_raise(rb_eArgError,
"both textmode and binmode specified");
7137 rb_raise(rb_eArgError,
"both textmode and binmode specified");
7143 int *oflags_p,
enum rb_io_mode *fmode_p,
struct rb_io_encoding *convconfig_p)
7147 enum rb_io_mode fmode;
7148 rb_encoding *enc, *enc2;
7151 int has_enc = 0, has_vmode = 0;
7157 rb_io_ext_int_to_encs(NULL, NULL, &enc, &enc2, 0);
7175 oflags = rb_io_fmode_oflags(fmode);
7179 parse_mode_enc(p+1, rb_enc_get(vmode), &enc, &enc2, &fmode);
7185 rb_io_ext_int_to_encs(e, NULL, &enc, &enc2, fmode);
7189 if (
NIL_P(opthash)) {
7193#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
7195 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
7196 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
7198 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
7208 else if (
NIL_P(vmode)) {
7209 fmode |= DEFAULT_TEXTMODE;
7216 v = rb_hash_aref(opthash, sym_mode);
7218 if (!
NIL_P(vmode)) {
7219 rb_raise(rb_eArgError,
"mode specified twice");
7226 v = rb_hash_aref(opthash, sym_flags);
7233 extract_binmode(opthash, &fmode);
7242 else if (
NIL_P(vmode)) {
7243 fmode |= DEFAULT_TEXTMODE;
7246 v = rb_hash_aref(opthash, sym_perm);
7249 if (!
NIL_P(*vperm_p)) {
7250 rb_raise(rb_eArgError,
"perm specified twice");
7261#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
7263 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
7264 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
7269 rb_raise(rb_eArgError,
"encoding specified twice");
7272 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
7276 validate_enc_binmode(&fmode, ecflags, enc, enc2);
7282 convconfig_p->
enc = enc;
7283 convconfig_p->
enc2 = enc2;
7284 convconfig_p->
ecflags = ecflags;
7285 convconfig_p->
ecopts = ecopts;
7295sysopen_func(
void *ptr)
7298 const char *fname = RSTRING_PTR(data->fname);
7307 fd = IO_WITHOUT_GVL_INT(sysopen_func, data);
7308 }
while (fd < 0 &&
errno == EINTR);
7315rb_sysopen(
VALUE fname,
int oflags, mode_t perm)
7320 data.fname = rb_str_encode_ospath(fname);
7322 data.oflags = oflags;
7325 TRY_WITH_GC((fd = rb_sysopen_internal(&data)) >= 0) {
7326 rb_syserr_fail_path(first_errno, fname);
7332fdopen_internal(
int fd,
const char *modestr)
7339 file = fdopen(fd, modestr);
7355 TRY_WITH_GC((file = fdopen_internal(fd, modestr)) != 0) {
7361 if (setvbuf(file, NULL, _IOFBF, 0) != 0)
7362 rb_warn(
"setvbuf() can't be honoured (fd=%d)", fd);
7368io_check_tty(rb_io_t *fptr)
7370 int t = isatty(fptr->
fd);
7380io_strip_bom(
VALUE io)
7382 VALUE b1, b2, b3, b4;
7403 return ENCINDEX_UTF_16BE;
7414 return ENCINDEX_UTF_32LE;
7419 return ENCINDEX_UTF_16LE;
7429 return ENCINDEX_UTF_32BE;
7443io_set_encoding_by_bom(
VALUE io)
7445 int idx = io_strip_bom(io);
7447 rb_encoding *extenc = NULL;
7451 extenc = rb_enc_from_index(idx);
7452 io_encoding_set(fptr, rb_enc_from_encoding(extenc),
7453 rb_io_internal_encoding(io),
Qnil);
7462rb_file_open_generic(
VALUE io,
VALUE filename,
int oflags,
enum rb_io_mode fmode,
7470 rb_io_ext_int_to_encs(NULL, NULL, &cc.enc, &cc.enc2, fmode);
7475 validate_enc_binmode(&fmode, convconfig->
ecflags,
7476 convconfig->
enc, convconfig->
enc2);
7480 fptr->
encs = *convconfig;
7483 if (!(oflags & O_TMPFILE)) {
7484 fptr->
pathv = pathv;
7487 fptr->
pathv = pathv;
7489 fptr->
fd = rb_sysopen(pathv, oflags, perm);
7497rb_file_open_internal(
VALUE io,
VALUE filename,
const char *modestr)
7500 const char *p = strchr(modestr,
':');
7505 &convconfig.
enc, &convconfig.
enc2, &fmode);
7512 rb_io_ext_int_to_encs(e, NULL, &convconfig.
enc, &convconfig.
enc2, fmode);
7518#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
7520 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
7521 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
7523 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(convconfig.
enc2, convconfig.
ecflags);
7526 return rb_file_open_generic(io, filename,
7527 rb_io_fmode_oflags(fmode),
7537 return rb_file_open_internal(io_alloc(
rb_cFile), fname, modestr);
7546#if defined(__CYGWIN__) || !defined(HAVE_WORKING_FORK)
7553pipe_add_fptr(rb_io_t *fptr)
7564pipe_del_fptr(rb_io_t *fptr)
7569 while ((tmp = *prev) != 0) {
7570 if (tmp->fptr == fptr) {
7579#if defined (_WIN32) || defined(__CYGWIN__)
7588 if (!rb_current_execution_context(
false))
return;
7599pipe_finalize(rb_io_t *fptr,
int noraise)
7601#if !defined(HAVE_WORKING_FORK) && !defined(_WIN32)
7610 fptr_finalize(fptr, noraise);
7612 pipe_del_fptr(fptr);
7617fptr_copy_finalizer(rb_io_t *fptr,
const rb_io_t *orig)
7619#if defined(__CYGWIN__) || !defined(HAVE_WORKING_FORK)
7620 void (*
const old_finalize)(
struct rb_io*,int) = fptr->
finalize;
7622 if (old_finalize == orig->finalize)
return;
7627#if defined(__CYGWIN__) || !defined(HAVE_WORKING_FORK)
7628 if (old_finalize != pipe_finalize) {
7630 for (list =
pipe_list; list; list = list->next) {
7631 if (list->fptr == fptr)
break;
7633 if (!list) pipe_add_fptr(fptr);
7636 pipe_del_fptr(fptr);
7662#define spawnv(mode, cmd, args) rb_w32_uaspawn((mode), (cmd), (args))
7663#define spawn(mode, cmd) rb_w32_uspawn((mode), (cmd), 0)
7666#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
7669 struct rb_execarg *eargp;
7676#ifdef HAVE_WORKING_FORK
7677# ifndef __EMSCRIPTEN__
7679popen_redirect(
struct popen_arg *p)
7682 close(p->write_pair[1]);
7683 if (p->write_pair[0] != 0) {
7684 dup2(p->write_pair[0], 0);
7685 close(p->write_pair[0]);
7688 if (p->pair[1] != 1) {
7689 dup2(p->pair[1], 1);
7695 if (p->pair[1] != 1) {
7696 dup2(p->pair[1], 1);
7702 if (p->pair[0] != 0) {
7703 dup2(p->pair[0], 0);
7710#if defined(__linux__)
7721linux_get_maxfd(
void)
7724 char buf[4096], *p, *np, *e;
7727 if (fd < 0)
return fd;
7728 ss = read(fd, buf,
sizeof(buf));
7729 if (ss < 0)
goto err;
7732 while ((
int)
sizeof(
"FDSize:\t0\n")-1 <= e-p &&
7733 (np = memchr(p,
'\n', e-p)) != NULL) {
7734 if (memcmp(p,
"FDSize:",
sizeof(
"FDSize:")-1) == 0) {
7736 p +=
sizeof(
"FDSize:")-1;
7756#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
7758 int max = (int)max_file_descriptor;
7761 ret = fcntl(0, F_MAXFD);
7763 maxhint = max = ret;
7764# elif defined(__linux__)
7765 ret = linux_get_maxfd();
7772 for (fd = lowfd; fd <= max; fd++) {
7773 if (!
NIL_P(noclose_fds) &&
7776 ret = fcntl(fd, F_GETFD);
7777 if (ret != -1 && !(ret & FD_CLOEXEC)) {
7778 fcntl(fd, F_SETFD, ret|FD_CLOEXEC);
7780# define CONTIGUOUS_CLOSED_FDS 20
7782 if (max < fd + CONTIGUOUS_CLOSED_FDS)
7783 max = fd + CONTIGUOUS_CLOSED_FDS;
7789# ifndef __EMSCRIPTEN__
7791popen_exec(
void *pp,
char *errmsg,
size_t errmsg_len)
7793 struct popen_arg *p = (
struct popen_arg*)pp;
7795 return rb_exec_async_signal_safe(p->eargp, errmsg, errmsg_len);
7800#if (defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)) && !defined __EMSCRIPTEN__
7802rb_execarg_fixup_v(
VALUE execarg_obj)
7804 rb_execarg_parent_start(execarg_obj);
7808char *rb_execarg_commandline(
const struct rb_execarg *eargp,
VALUE *prog);
7811#ifndef __EMSCRIPTEN__
7813pipe_open(
VALUE execarg_obj,
const char *modestr,
enum rb_io_mode fmode,
7816 struct rb_execarg *eargp =
NIL_P(execarg_obj) ? NULL : rb_execarg_get(execarg_obj);
7817 VALUE prog = eargp ? (eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name) :
Qfalse ;
7821 rb_io_t *write_fptr;
7823#if defined(HAVE_WORKING_FORK)
7825 char errmsg[80] = {
'\0' };
7827#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
7829 struct popen_arg arg;
7832#if defined(HAVE_SPAWNV)
7833# define DO_SPAWN(cmd, args) ((args) ? \
7834 spawnv(P_NOWAIT, (cmd), (args)) : \
7835 spawn(P_NOWAIT, (cmd)))
7836# if !defined(HAVE_WORKING_FORK)
7840#if !defined(HAVE_WORKING_FORK)
7846#if !defined(HAVE_WORKING_FORK)
7847 const char *cmd = 0;
7853#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
7854 arg.execarg_obj = execarg_obj;
7857 arg.pair[0] = arg.pair[1] = -1;
7858 arg.write_pair[0] = arg.write_pair[1] = -1;
7859# if !defined(HAVE_WORKING_FORK)
7860 if (eargp && !eargp->use_shell) {
7861 args = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str);
7866 if (
rb_pipe(arg.write_pair) < 0)
7867 rb_sys_fail_str(prog);
7870 close(arg.write_pair[0]);
7871 close(arg.write_pair[1]);
7875 rb_execarg_addopt(execarg_obj,
INT2FIX(0),
INT2FIX(arg.write_pair[0]));
7876 rb_execarg_addopt(execarg_obj,
INT2FIX(1),
INT2FIX(arg.pair[1]));
7881 rb_sys_fail_str(prog);
7883 rb_execarg_addopt(execarg_obj,
INT2FIX(1),
INT2FIX(arg.pair[1]));
7887 rb_sys_fail_str(prog);
7889 rb_execarg_addopt(execarg_obj,
INT2FIX(0),
INT2FIX(arg.pair[0]));
7892 rb_sys_fail_str(prog);
7894 if (!
NIL_P(execarg_obj)) {
7895 rb_protect(rb_execarg_fixup_v, execarg_obj, &state);
7897 if (0 <= arg.write_pair[0]) close(arg.write_pair[0]);
7898 if (0 <= arg.write_pair[1]) close(arg.write_pair[1]);
7899 if (0 <= arg.pair[0]) close(arg.pair[0]);
7900 if (0 <= arg.pair[1]) close(arg.pair[1]);
7901 rb_execarg_parent_end(execarg_obj);
7905# if defined(HAVE_WORKING_FORK)
7906 pid = rb_fork_async_signal_safe(&status, popen_exec, &arg, arg.eargp->redirect_fds, errmsg,
sizeof(errmsg));
7908 rb_execarg_run_options(eargp, sargp, NULL, 0);
7909 while ((pid = DO_SPAWN(cmd, args)) < 0) {
7911 switch (e =
errno) {
7913# if EWOULDBLOCK != EAGAIN
7922 rb_execarg_run_options(sargp, NULL, NULL, 0);
7924 rb_execarg_parent_end(execarg_obj);
7927# if defined(HAVE_WORKING_FORK)
7928 pid = rb_call_proc__fork();
7930 popen_redirect(&arg);
7942# if defined(HAVE_WORKING_FORK)
7948 close(arg.write_pair[0]);
7949 close(arg.write_pair[1]);
7951# if defined(HAVE_WORKING_FORK)
7960 close(arg.write_pair[0]);
7961 write_fd = arg.write_pair[1];
7972 cmd = rb_execarg_commandline(eargp, &prog);
7973 if (!
NIL_P(execarg_obj)) {
7974 rb_execarg_parent_start(execarg_obj);
7975 rb_execarg_run_options(eargp, sargp, NULL, 0);
7977 fp = popen(cmd, modestr);
7980 rb_execarg_parent_end(execarg_obj);
7981 rb_execarg_run_options(sargp, NULL, NULL, 0);
7983 if (!fp) rb_syserr_fail_path(e, prog);
7993 fptr->
encs = *convconfig;
7994#if RUBY_CRLF_ENVIRONMENT
8001 if (NEED_NEWLINE_DECORATOR_ON_READ(fptr)) {
8004#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
8005 if (NEED_NEWLINE_DECORATOR_ON_WRITE(fptr)) {
8006 fptr->
encs.
ecflags |= TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;
8012 if (0 <= write_fd) {
8013 write_port = io_alloc(
rb_cIO);
8015 write_fptr->
fd = write_fd;
8019 rb_ivar_set(port, rb_intern(
"@tied_io_for_writing"), write_port);
8022#if defined (__CYGWIN__) || !defined(HAVE_WORKING_FORK)
8024 pipe_add_fptr(fptr);
8030pipe_open(
VALUE execarg_obj,
const char *modestr,
enum rb_io_mode fmode,
8038is_popen_fork(
VALUE prog)
8040 if (RSTRING_LEN(prog) == 1 && RSTRING_PTR(prog)[0] ==
'-') {
8041#if !defined(HAVE_WORKING_FORK)
8043 "fork() function is unimplemented on this machine");
8052pipe_open_s(
VALUE prog,
const char *modestr,
enum rb_io_mode fmode,
8056 VALUE *argv = &prog;
8059 if (!is_popen_fork(prog))
8060 execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE);
8061 return pipe_open(execarg_obj, modestr, fmode, convconfig);
8067 rb_io_t *fptr = io_close_fptr(io);
8236rb_io_s_popen(
int argc,
VALUE *argv,
VALUE klass)
8240 if (argc > 1 && !
NIL_P(opt = rb_check_hash_type(argv[argc-1]))) --argc;
8241 if (argc > 1 && !
NIL_P(env = rb_check_hash_type(argv[0]))) --argc, ++argv;
8250 int ex = !
NIL_P(opt);
8251 rb_error_arity(argc + ex, 1 + ex, 2 + ex);
8254 return popen_finish(rb_io_popen(pname, pmode, env, opt), klass);
8260 const char *modestr;
8263 enum rb_io_mode fmode;
8269#if SIZEOF_RB_LEN_T > SIZEOF_INT
8270 if (
len > INT_MAX) {
8271 rb_raise(rb_eArgError,
"too many arguments");
8280 if (!is_popen_fork(pname))
8281 execarg_obj = rb_execarg_new(1, &pname, TRUE, FALSE);
8283 if (!
NIL_P(execarg_obj)) {
8285 opt = rb_execarg_extract_options(execarg_obj, opt);
8287 rb_execarg_setenv(execarg_obj, env);
8290 modestr = rb_io_oflags_modestr(oflags);
8292 return pipe_open(execarg_obj, modestr, fmode, &convconfig);
8304 _exit(EXIT_SUCCESS);
8308 RBASIC_SET_CLASS(port, klass);
8315#if defined(HAVE_WORKING_FORK) && !defined(__EMSCRIPTEN__)
8316struct popen_writer_arg {
8318 struct popen_arg popen;
8322exec_popen_writer(
void *arg,
char *errmsg,
size_t buflen)
8324 struct popen_writer_arg *pw = arg;
8326 popen_redirect(&pw->popen);
8327 execv(pw->argv[0], pw->argv);
8328 strlcpy(errmsg, strerror(
errno), buflen);
8334ruby_popen_writer(
char *
const *argv, rb_pid_t *pid)
8336#if (defined(HAVE_WORKING_FORK) && !defined(__EMSCRIPTEN__)) || defined(_WIN32)
8337# ifdef HAVE_WORKING_FORK
8338 struct popen_writer_arg pw;
8339 int *
const write_pair = pw.popen.pair;
8345 if (cloexec_pipe(write_pair, 0,
false) == 0) {
8346# ifdef HAVE_WORKING_FORK
8349 char errmsg[80] = {
'\0'};
8350 *pid = rb_fork_async_signal_safe(&status, exec_popen_writer, &pw,
Qnil, errmsg,
sizeof(errmsg));
8352 *pid = rb_w32_uspawn_process(P_NOWAIT, argv[0], argv, write_pair[0], -1, -1, 0);
8353 const char *errmsg = (*pid < 0) ? strerror(
errno) : NULL;
8355 close(write_pair[0]);
8357 close(write_pair[1]);
8358 fprintf(stderr,
"ruby_popen_writer(%s): %s\n", argv[0], errmsg);
8361 return fdopen(write_pair[1],
"w");
8372 enum rb_io_mode fmode;
8381 rb_file_open_generic(io, fname, oflags, fmode, &convconfig, perm);
8433rb_io_s_open(
int argc,
VALUE *argv,
VALUE klass)
8465 VALUE fname, vmode, vperm;
8470 rb_scan_args(argc, argv,
"12", &fname, &vmode, &vperm);
8481 if (
NIL_P(vperm)) perm = 0666;
8485 fd = rb_sysopen(fname, oflags, perm);
8517 int redirect = FALSE;
8525 VALUE tmp = argv[0];
8543 return rb_io_s_open(argc, argv,
rb_cFile);
8547rb_io_open_generic(
VALUE klass,
VALUE filename,
int oflags,
enum rb_io_mode fmode,
8550 return rb_file_open_generic(io_alloc(klass), filename,
8551 oflags, fmode, convconfig, perm);
8558 enum rb_io_mode fmode;
8564 return rb_io_open_generic(io, filename, oflags, fmode, &convconfig, perm);
8570 rb_io_t *fptr, *orig;
8578 if (fptr == orig)
return io;
8579 if (RUBY_IO_EXTERNAL_P(fptr)) {
8583 rb_raise(rb_eArgError,
8584 "%s can't change access mode from \"%s\" to \"%s\"",
8585 PREP_STDIO_NAME(fptr), rb_io_fmode_modestr(fptr->
mode),
8586 rb_io_fmode_modestr(orig->
mode));
8589 flush_before_seek(fptr,
true);
8591 clear_codeconv(fptr);
8593 pos = io_tell(orig);
8596 if (io_fflush(orig) < 0)
8597 rb_sys_fail_on_write(fptr);
8606 else if (!RUBY_IO_EXTERNAL_P(fptr)) fptr->
pathv =
Qnil;
8607 fptr_copy_finalizer(fptr, orig);
8613 rb_thread_io_close_interrupt(fptr);
8614 rb_thread_io_close_wait(fptr);
8616 if (RUBY_IO_EXTERNAL_P(fptr) || fd <= 2 || !fptr->stdio_file) {
8619 rb_sys_fail_path(orig->
pathv);
8627 rb_sys_fail_path(orig->
pathv);
8633 if (io_seek(fptr, pos, SEEK_SET) < 0 &&
errno) {
8634 rb_sys_fail_path(fptr->
pathv);
8636 if (io_seek(orig, pos, SEEK_SET) < 0 &&
errno) {
8637 rb_sys_fail_path(orig->
pathv);
8651int rb_freopen(
VALUE fname,
const char *mode, FILE *fp);
8654rb_freopen(
VALUE fname,
const char *mode, FILE *fp)
8656 if (!freopen(RSTRING_PTR(fname), mode, fp)) {
8699rb_io_reopen(
int argc,
VALUE *argv,
VALUE file)
8701 VALUE fname, nmode, opt;
8705 if (
rb_scan_args(argc, argv,
"11:", &fname, &nmode, &opt) == 1) {
8708 return io_reopen(file, tmp);
8714 fptr =
RFILE(file)->fptr;
8718 enum rb_io_mode fmode;
8722 if (RUBY_IO_EXTERNAL_P(fptr) &&
8725 rb_raise(rb_eArgError,
8726 "%s can't change access mode from \"%s\" to \"%s\"",
8727 PREP_STDIO_NAME(fptr), rb_io_fmode_modestr(fptr->
mode),
8728 rb_io_fmode_modestr(fmode));
8731 fptr->
encs = convconfig;
8734 oflags = rb_io_fmode_oflags(fptr->
mode);
8737 fptr->
pathv = fname;
8739 fptr->
fd = rb_sysopen(fptr->
pathv, oflags, 0666);
8745 if (io_fflush(fptr) < 0)
8746 rb_sys_fail_on_write(fptr);
8749 clear_codeconv(fptr);
8752 int e = rb_freopen(rb_str_encode_ospath(fptr->
pathv),
8753 rb_io_oflags_modestr(oflags),
8755 if (e) rb_syserr_fail_path(e, fptr->
pathv);
8759 if (setvbuf(fptr->
stdio_file, NULL, _IOFBF, 0) != 0)
8760 rb_warn(
"setvbuf() can't be honoured for %"PRIsVALUE, fptr->
pathv);
8763 if (setvbuf(fptr->
stdio_file, NULL, _IONBF, BUFSIZ) != 0)
8764 rb_warn(
"setvbuf() can't be honoured for %"PRIsVALUE, fptr->
pathv);
8766 else if (fptr->
stdio_file == stdout && isatty(fptr->
fd)) {
8767 if (setvbuf(fptr->
stdio_file, NULL, _IOLBF, BUFSIZ) != 0)
8768 rb_warn(
"setvbuf() can't be honoured for %"PRIsVALUE, fptr->
pathv);
8772 int tmpfd = rb_sysopen(fptr->
pathv, oflags, 0666);
8778 rb_syserr_fail_path(err, fptr->
pathv);
8789 rb_io_t *fptr, *orig;
8809 fptr->closing_ec = NULL;
8810 fptr->wakeup_mutex =
Qnil;
8811 fptr->fork_generation = GET_VM()->fork_gen;
8814 fptr_copy_finalizer(fptr, orig);
8816 fd = ruby_dup(orig->
fd);
8818 pos = io_tell(orig);
8820 io_seek(fptr, pos, SEEK_SET);
8825 write_io = GetWriteIO(io);
8826 if (io != write_io) {
8829 rb_ivar_set(dest, rb_intern(
"@tied_io_for_writing"), write_io);
8892 if (argc == 0)
return Qnil;
8906extern void rb_deprecated_str_setter(
VALUE val,
ID id,
VALUE *var);
8911 rb_deprecated_str_setter(val,
id, &val);
8917 val = rb_str_frozen_bare_string(val);
8994 for (i=0; i<argc; i++) {
8998 rb_io_write(out, argv[i]);
9095 rb_io_write(io, str);
9099#define forward(obj, id, argc, argv) \
9100 rb_funcallv_kw(obj, id, argc, argv, RB_PASS_CALLED_KEYWORDS)
9101#define forward_public(obj, id, argc, argv) \
9102 rb_funcallv_public_kw(obj, id, argc, argv, RB_PASS_CALLED_KEYWORDS)
9103#define forward_current(id, argc, argv) \
9104 forward_public(ARGF.current_file, id, argc, argv)
9122 if (recv == r_stdout) {
9123 return rb_io_putc(recv, ch);
9125 return forward(r_stdout, rb_intern(
"putc"), 1, &ch);
9130rb_str_end_with_asciichar(
VALUE str,
int c)
9133 const char *ptr = RSTRING_PTR(str);
9137 if (
len == 0)
return 0;
9138 if ((n = rb_enc_mbminlen(
enc)) == 1) {
9139 return ptr[
len - 1] == c;
9141 return rb_enc_ascget(ptr + ((
len - 1) / n) * n, ptr +
len, &n,
enc) == c;
9152 rb_io_puts(1, &tmp, out);
9159 rb_io_puts(1, &tmp, out);
9214 VALUE line, args[2];
9221 for (
int i = 0; i < argc; i++) {
9235 if (RSTRING_LEN(line) == 0) {
9240 if (!rb_str_end_with_asciichar(line,
'\n')) {
9245 rb_io_writev(out, n, args);
9264 if (recv == r_stdout) {
9265 return rb_io_puts(argc, argv, recv);
9267 return forward(r_stdout, rb_intern(
"puts"), argc, argv);
9271rb_p_write(
VALUE str)
9279 io_writev(2, args, r_stdout);
9282 rb_io_writev(r_stdout, 2, args);
9294rb_p_result(
int argc,
const VALUE *argv)
9301 else if (argc > 1) {
9306 rb_uninterruptible(rb_io_flush, r_stdout);
9347 for (i=0; i<argc; i++) {
9349 rb_uninterruptible(rb_p_write, inspected);
9351 return rb_p_result(argc, argv);
9372rb_obj_display(
int argc,
VALUE *argv,
VALUE self)
9377 rb_io_write(out, self);
9383rb_stderr_to_original_p(
VALUE err)
9385 return (err == orig_stderr ||
RFILE(orig_stderr)->fptr->
fd < 0);
9392 if (rb_stderr_to_original_p(out)) {
9394 if (isatty(fileno(stderr))) {
9395 if (rb_w32_write_console(
rb_str_new(mesg,
len), fileno(stderr)) > 0)
return;
9398 if (fwrite(mesg,
sizeof(
char), (
size_t)
len, stderr) < (
size_t)
len) {
9415rb_write_error_str(
VALUE mesg)
9419 if (rb_stderr_to_original_p(out)) {
9420 size_t len = (size_t)RSTRING_LEN(mesg);
9422 if (isatty(fileno(stderr))) {
9423 if (rb_w32_write_console(mesg, fileno(stderr)) > 0)
return;
9426 if (fwrite(RSTRING_PTR(mesg),
sizeof(
char),
len, stderr) <
len) {
9433 rb_io_write(out, mesg);
9438rb_stderr_tty_p(
void)
9441 return isatty(fileno(stderr));
9446must_respond_to(
ID mid,
VALUE val,
ID id)
9449 rb_raise(
rb_eTypeError,
"%"PRIsVALUE
" must have %"PRIsVALUE
" method, %"PRIsVALUE
" given",
9450 rb_id2str(
id), rb_id2str(mid),
9462stdin_getter(
ID id,
VALUE *ptr)
9470 must_respond_to(id_write, val,
id);
9475stdout_getter(
ID id,
VALUE *ptr)
9483 must_respond_to(id_write, val,
id);
9488stderr_getter(
ID id,
VALUE *ptr)
9494allocate_and_open_new_file(
VALUE klass)
9496 VALUE self = io_alloc(klass);
9497 rb_io_make_open_file(self);
9505 VALUE self = rb_protect(allocate_and_open_new_file, klass, &state);
9513 maygvl_close(descriptor, 0);
9519 rb_io_t *io =
RFILE(self)->fptr;
9521 io->
fd = descriptor;
9539 io->closing_ec = NULL;
9540 io->wakeup_mutex =
Qnil;
9541 io->fork_generation = GET_VM()->fork_gen;
9544 io->
encs = *encoding;
9553prep_io(
int fd,
enum rb_io_mode fmode,
VALUE klass,
const char *path)
9564 rb_io_ext_int_to_encs(e, NULL, &convconfig.
enc, &convconfig.
enc2, fmode);
9568#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
9570 MODE_BTMODE(TEXTMODE_NEWLINE_DECORATOR_ON_WRITE,
9571 0, TEXTMODE_NEWLINE_DECORATOR_ON_WRITE) : 0;
9573 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(convconfig.
enc2, convconfig.
ecflags);
9577 rb_io_t*io =
RFILE(self)->fptr;
9579 if (!io_check_tty(io)) {
9582 setmode(fd, O_BINARY);
9594 if (path && strcmp(path,
"-")) klass =
rb_cFile;
9599prep_stdio(FILE *f,
enum rb_io_mode fmode,
VALUE klass,
const char *path)
9606#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
9607 fptr->
encs.
ecflags |= TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;
9618rb_io_prep_stdin(
void)
9624rb_io_prep_stdout(
void)
9630rb_io_prep_stderr(
void)
9639 int oflags = rb_io_fmode_oflags(fptr->
mode) & ~O_EXCL;
9654static inline rb_io_t *
9657 rb_io_t *fp =
ALLOC(rb_io_t);
9666 rb_io_buffer_init(&fp->
wbuf);
9667 rb_io_buffer_init(&fp->
rbuf);
9668 rb_io_buffer_init(&fp->
cbuf);
9683 fp->closing_ec = NULL;
9684 fp->wakeup_mutex =
Qnil;
9685 fp->fork_generation = GET_VM()->fork_gen;
9690rb_io_make_open_file(
VALUE obj)
9695 if (
RFILE(obj)->fptr) {
9698 RFILE(obj)->fptr = 0;
9700 fp = rb_io_fptr_new();
9702 RFILE(obj)->fptr = fp;
9751rb_io_initialize(
int argc,
VALUE *argv,
VALUE io)
9757 return io_initialize(io, fnum, vmode, opt);
9764 int fd, oflags = O_RDONLY;
9765 enum rb_io_mode fmode;
9767#if defined(HAVE_FCNTL) && defined(F_GETFL)
9777 rb_raise(rb_eArgError,
"The given fd is not accessible because RubyVM reserves it");
9779#if defined(HAVE_FCNTL) && defined(F_GETFL)
9780 oflags = fcntl(fd, F_GETFL);
9781 if (oflags == -1) rb_sys_fail(0);
9783 if (fstat(fd, &st) < 0) rb_sys_fail(0);
9786#if defined(HAVE_FCNTL) && defined(F_GETFL)
9799 if (rb_hash_aref(opt, sym_autoclose) ==
Qfalse) {
9803 path = rb_hash_aref(opt,
RB_ID2SYM(idPath));
9814 fp->
encs = convconfig;
9818 fp->closing_ec = NULL;
9819 fp->wakeup_mutex =
Qnil;
9820 fp->fork_generation = GET_VM()->fork_gen;
9823 if (fileno(stdin) == fd)
9825 else if (fileno(stdout) == fd)
9827 else if (fileno(stderr) == fd)
9859rb_io_set_encoding_by_bom(
VALUE io)
9865 rb_raise(rb_eArgError,
"ASCII incompatible encoding needs binmode");
9868 rb_raise(rb_eArgError,
"encoding conversion is set");
9870 else if (fptr->
encs.
enc && fptr->
encs.
enc != rb_ascii8bit_encoding()) {
9871 rb_raise(rb_eArgError,
"encoding is set to %s already",
9874 if (!io_set_encoding_by_bom(io))
return Qnil;
9875 return rb_enc_from_encoding(fptr->
encs.
enc);
9928rb_file_initialize(
int argc,
VALUE *argv,
VALUE io)
9930 if (
RFILE(io)->fptr) {
9933 VALUE fname, vmode, vperm, opt;
9934 int posargc =
rb_scan_args(argc, argv,
"12:", &fname, &vmode, &vperm, &opt);
9939 return io_initialize(io, fd, vmode, opt);
9942 return rb_open_file(io, fname, vmode, vperm, opt);
9947rb_io_s_new(
int argc,
VALUE *argv,
VALUE klass)
9952 rb_warn(
"%"PRIsVALUE
"::new() does not take block; use %"PRIsVALUE
"::open() instead",
9968rb_io_s_for_fd(
int argc,
VALUE *argv,
VALUE klass)
9971 rb_io_initialize(argc, argv, io);
9984rb_io_autoclose_p(
VALUE io)
9986 rb_io_t *fptr =
RFILE(io)->fptr;
10009rb_io_set_autoclose(
VALUE io,
VALUE autoclose)
10013 if (!
RTEST(autoclose))
10021io_wait_event(
VALUE io,
int event,
VALUE timeout,
int return_io)
10031 if (mask & event) {
10053io_wait_readable(
int argc,
VALUE *argv,
VALUE io)
10063 VALUE timeout = (argc == 1 ? argv[0] :
Qnil);
10077io_wait_writable(
int argc,
VALUE *argv,
VALUE io)
10085 VALUE timeout = (argc == 1 ? argv[0] :
Qnil);
10100io_wait_priority(
int argc,
VALUE *argv,
VALUE io)
10102 rb_io_t *fptr = NULL;
10110 VALUE timeout = argc == 1 ? argv[0] :
Qnil;
10116wait_mode_sym(
VALUE mode)
10118 if (mode ==
ID2SYM(rb_intern(
"r"))) {
10119 return RB_WAITFD_IN;
10121 if (mode ==
ID2SYM(rb_intern(
"read"))) {
10122 return RB_WAITFD_IN;
10124 if (mode ==
ID2SYM(rb_intern(
"readable"))) {
10125 return RB_WAITFD_IN;
10127 if (mode ==
ID2SYM(rb_intern(
"w"))) {
10128 return RB_WAITFD_OUT;
10130 if (mode ==
ID2SYM(rb_intern(
"write"))) {
10131 return RB_WAITFD_OUT;
10133 if (mode ==
ID2SYM(rb_intern(
"writable"))) {
10134 return RB_WAITFD_OUT;
10136 if (mode ==
ID2SYM(rb_intern(
"rw"))) {
10137 return RB_WAITFD_IN|RB_WAITFD_OUT;
10139 if (mode ==
ID2SYM(rb_intern(
"read_write"))) {
10140 return RB_WAITFD_IN|RB_WAITFD_OUT;
10142 if (mode ==
ID2SYM(rb_intern(
"readable_writable"))) {
10143 return RB_WAITFD_IN|RB_WAITFD_OUT;
10146 rb_raise(rb_eArgError,
"unsupported mode: %"PRIsVALUE, mode);
10150io_event_from_value(
VALUE value)
10154 if (events <= 0) rb_raise(rb_eArgError,
"Events must be positive integer!");
10192 for (
int i = 0; i < argc; i += 1) {
10194 events |= wait_mode_sym(argv[i]);
10196 else if (UNDEF_P(timeout)) {
10200 rb_raise(rb_eArgError,
"timeout given more than once");
10204 if (UNDEF_P(timeout)) timeout =
Qnil;
10212 events = io_event_from_value(argv[0]);
10217 rb_io_t *fptr = NULL;
10222 if (return_io)
return Qtrue;
10228 return io_wait_event(io, events, timeout, return_io);
10232argf_mark_and_move(
void *ptr)
10234 struct argf *p = ptr;
10235 rb_gc_mark_and_move(&p->filename);
10236 rb_gc_mark_and_move(&p->current_file);
10237 rb_gc_mark_and_move(&p->argv);
10238 rb_gc_mark_and_move(&p->inplace);
10239 rb_gc_mark_and_move(&p->encs.
ecopts);
10243argf_memsize(
const void *ptr)
10245 const struct argf *p = ptr;
10246 size_t size =
sizeof(*p);
10253 0, 0, RUBY_TYPED_THREAD_SAFE_FREE | RUBY_TYPED_WB_PROTECTED
10259 p->filename =
Qnil;
10260 p->current_file =
Qnil;
10266argf_alloc(
VALUE klass)
10281 memset(&ARGF, 0,
sizeof(ARGF));
10282 argf_init(
argf, &ARGF, argv);
10292 ARGF = argf_of(orig);
10293 rb_gc_writebarrier_remember(
argf);
10320 ARGF.last_lineno = ARGF.lineno;
10349#define next_argv() argf_next_argv(argf)
10350#define ARGF_GENERIC_INPUT_P() \
10351 (ARGF.current_file == rb_stdin && !RB_TYPE_P(ARGF.current_file, T_FILE))
10352#define ARGF_FORWARD(argc, argv) do {\
10353 if (ARGF_GENERIC_INPUT_P())\
10354 return argf_forward((argc), (argv), argf);\
10356#define NEXT_ARGF_FORWARD(argc, argv) do {\
10357 if (!next_argv()) return Qnil;\
10358 ARGF_FORWARD((argc), (argv));\
10364 VALUE file = ARGF.current_file;
10378 int stdout_binmode = 0;
10379 enum rb_io_mode fmode;
10386 stdout_binmode = 1;
10389 if (ARGF.init_p == 0) {
10399 if (
NIL_P(ARGF.argv)) {
10402 else if (ARGF.next_p == -1 &&
RARRAY_LEN(ARGF.argv) > 0) {
10407 if (ARGF.next_p == 1) {
10408 if (ARGF.init_p == 1) argf_close(
argf);
10413 ARGF_SET(filename, filename);
10414 filename = rb_str_encode_ospath(filename);
10416 if (RSTRING_LEN(filename) == 1 && fn[0] ==
'-') {
10418 if (ARGF.inplace) {
10419 rb_warn(
"Can't do inplace edit for stdio; skipping");
10425 int fr = rb_sysopen(filename, O_RDONLY, 0);
10427 if (ARGF.inplace) {
10429#ifndef NO_SAFE_RENAME
10440 if (!
NIL_P(ARGF.inplace)) {
10441 VALUE suffix = ARGF.inplace;
10443 if (
NIL_P(rb_str_cat_conv_enc_opts(str, RSTRING_LEN(str),
10444 RSTRING_PTR(suffix), RSTRING_LEN(suffix),
10445 rb_enc_get(suffix), 0,
Qnil))) {
10448#ifdef NO_SAFE_RENAME
10450 (void)unlink(RSTRING_PTR(str));
10451 if (rename(fn, RSTRING_PTR(str)) < 0) {
10452 rb_warn(
"Can't rename %"PRIsVALUE
" to %"PRIsVALUE
": %s, skipping file",
10453 filename, str, strerror(
errno));
10456 fr = rb_sysopen(str, O_RDONLY, 0);
10458 if (rename(fn, RSTRING_PTR(str)) < 0) {
10459 rb_warn(
"Can't rename %"PRIsVALUE
" to %"PRIsVALUE
": %s, skipping file",
10460 filename, str, strerror(
errno));
10467#ifdef NO_SAFE_RENAME
10468 rb_fatal(
"Can't do inplace edit without backup");
10470 if (unlink(fn) < 0) {
10471 rb_warn(
"Can't remove %"PRIsVALUE
": %s, skipping file",
10472 filename, strerror(
errno));
10478 fw = rb_sysopen(filename, O_WRONLY|O_CREAT|O_TRUNC, 0666);
10479#ifndef NO_SAFE_RENAME
10482 fchmod(fw, st.st_mode);
10484 chmod(fn, st.st_mode);
10486 if (st.st_uid!=st2.st_uid || st.st_gid!=st2.st_gid) {
10489 err = fchown(fw, st.st_uid, st.st_gid);
10491 err = chown(fn, st.st_uid, st.st_gid);
10493 if (err && getuid() == 0 && st2.st_uid == 0) {
10494 const char *wkfn = RSTRING_PTR(filename);
10495 rb_warn(
"Can't set owner/group of %"PRIsVALUE
" to same as %"PRIsVALUE
": %s, skipping file",
10496 filename, str, strerror(
errno));
10499 (void)unlink(wkfn);
10509 if (!ARGF.binmode) {
10510 fmode |= DEFAULT_TEXTMODE;
10512 ARGF_SET(current_file, prep_io(fr, fmode,
rb_cFile, fn));
10513 if (!
NIL_P(write_io)) {
10520 if (ARGF.encs.enc) {
10521 fptr->
encs = ARGF.encs;
10522 clear_codeconv(fptr);
10526 if (!ARGF.binmode) {
10528#ifdef TEXTMODE_NEWLINE_DECORATOR_ON_WRITE
10529 fptr->
encs.
ecflags |= TEXTMODE_NEWLINE_DECORATOR_ON_WRITE;
10540 else if (ARGF.next_p == -1) {
10543 if (ARGF.inplace) {
10544 rb_warn(
"Can't do inplace edit for stdio");
10548 if (ARGF.init_p == -1) ARGF.init_p = 1;
10556 long lineno = ARGF.lineno;
10559 if (!next_argv())
return Qnil;
10560 if (ARGF_GENERIC_INPUT_P()) {
10561 line = forward_current(idGets, argc, argv);
10568 line = rb_io_getline(argc, argv, ARGF.current_file);
10570 if (
NIL_P(line) && ARGF.next_p != -1) {
10576 if (!
NIL_P(line)) {
10577 ARGF.lineno = ++lineno;
10578 ARGF.last_lineno = ARGF.lineno;
10584argf_lineno_getter(
ID id,
VALUE *var)
10587 return INT2FIX(ARGF.last_lineno);
10595 ARGF.last_lineno = ARGF.lineno = n;
10599rb_reset_argf_lineno(
long n)
10601 ARGF.last_lineno = ARGF.lineno = n;
10642 if (recv ==
argf) {
10643 return argf_gets(argc, argv,
argf);
10645 return forward(
argf, idGets, argc, argv);
10671 line = argf_getline(argc, argv,
argf);
10683 return rb_f_gets(0, 0,
argf);
10687 if (!next_argv())
return Qnil;
10689 if (
NIL_P(line) && ARGF.next_p != -1) {
10695 if (!
NIL_P(line)) {
10697 ARGF.last_lineno = ARGF.lineno;
10723rb_f_readline(
int argc,
VALUE *argv,
VALUE recv)
10725 if (recv ==
argf) {
10726 return argf_readline(argc, argv,
argf);
10728 return forward(
argf, rb_intern(
"readline"), argc, argv);
10755 ARGF_FORWARD(argc, argv);
10756 line = argf_gets(argc, argv,
argf);
10826rb_f_readlines(
int argc,
VALUE *argv,
VALUE recv)
10828 if (recv ==
argf) {
10829 return argf_readlines(argc, argv,
argf);
10831 return forward(
argf, rb_intern(
"readlines"), argc, argv);
10855 long lineno = ARGF.lineno;
10859 while (next_argv()) {
10860 if (ARGF_GENERIC_INPUT_P()) {
10861 lines = forward_current(rb_intern(
"readlines"), argc, argv);
10864 lines = rb_io_readlines(argc, argv, ARGF.current_file);
10870 ARGF.last_lineno = ARGF.lineno;
10905 rb_last_status_clear();
10906 port = pipe_open_s(str,
"r",
FMODE_READABLE|DEFAULT_TEXTMODE, NULL);
10910 result = read_all(fptr, remain_size(fptr),
Qnil);
10912 rb_io_fptr_cleanup_all(fptr);
10918#ifdef HAVE_SYS_SELECT_H
10919#include <sys/select.h>
10933 if (!
NIL_P(read)) {
10938 if (READ_DATA_PENDING(fptr) || READ_CHAR_PENDING(fptr)) {
10942 if (max < fptr->fd) max = fptr->
fd;
10945 timerec.tv_sec = timerec.tv_usec = 0;
10953 if (!
NIL_P(write)) {
10959 if (max < fptr->fd) max = fptr->
fd;
10966 if (!
NIL_P(except)) {
10970 VALUE write_io = GetWriteIO(io);
10973 if (max < fptr->fd) max = fptr->
fd;
10974 if (io != write_io) {
10977 if (max < fptr->fd) max = fptr->
fd;
10992 if (!pending && n == 0)
return Qnil;
11017 VALUE write_io = GetWriteIO(io);
11030 VALUE write_io = GetWriteIO(io);
11035 else if (io != write_io) {
11048 VALUE read, write, except;
11054select_call(
VALUE arg)
11058 return select_internal(p->read, p->write, p->except, p->timeout, p->fdsets);
11062select_end(
VALUE arg)
11067 for (i = 0; i < numberof(p->fdsets); ++i)
11072static VALUE sym_normal, sym_sequential, sym_random,
11073 sym_willneed, sym_dontneed, sym_noreuse;
11075#ifdef HAVE_POSIX_FADVISE
11076struct io_advise_struct {
11084io_advise_internal(
void *arg)
11086 struct io_advise_struct *ptr = arg;
11087 return posix_fadvise(ptr->fd, ptr->offset, ptr->len, ptr->advice);
11091io_advise_sym_to_const(
VALUE sym)
11093#ifdef POSIX_FADV_NORMAL
11094 if (sym == sym_normal)
11095 return INT2NUM(POSIX_FADV_NORMAL);
11098#ifdef POSIX_FADV_RANDOM
11099 if (sym == sym_random)
11100 return INT2NUM(POSIX_FADV_RANDOM);
11103#ifdef POSIX_FADV_SEQUENTIAL
11104 if (sym == sym_sequential)
11105 return INT2NUM(POSIX_FADV_SEQUENTIAL);
11108#ifdef POSIX_FADV_WILLNEED
11109 if (sym == sym_willneed)
11110 return INT2NUM(POSIX_FADV_WILLNEED);
11113#ifdef POSIX_FADV_DONTNEED
11114 if (sym == sym_dontneed)
11115 return INT2NUM(POSIX_FADV_DONTNEED);
11118#ifdef POSIX_FADV_NOREUSE
11119 if (sym == sym_noreuse)
11120 return INT2NUM(POSIX_FADV_NOREUSE);
11127do_io_advise(rb_io_t *fptr,
VALUE advice, rb_off_t offset, rb_off_t
len)
11130 struct io_advise_struct ias;
11133 num_adv = io_advise_sym_to_const(advice);
11139 if (
NIL_P(num_adv))
11143 ias.advice =
NUM2INT(num_adv);
11144 ias.offset = offset;
11147 rv = (int)rb_io_blocking_region(fptr, io_advise_internal, &ias);
11148 if (rv && rv != ENOSYS) {
11151 VALUE message = rb_sprintf(
"%"PRIsVALUE
" "
11155 fptr->
pathv, offset,
len, advice);
11165advice_arg_check(
VALUE advice)
11170 if (advice != sym_normal &&
11171 advice != sym_sequential &&
11172 advice != sym_random &&
11173 advice != sym_willneed &&
11174 advice != sym_dontneed &&
11175 advice != sym_noreuse) {
11176 rb_raise(
rb_eNotImpError,
"Unsupported advice: %+"PRIsVALUE, advice);
11214rb_io_advise(
int argc,
VALUE *argv,
VALUE io)
11221 advice_arg_check(advice);
11223 io = GetWriteIO(io);
11229#ifdef HAVE_POSIX_FADVISE
11230 return do_io_advise(fptr, advice,
off, l);
11232 ((void)
off, (void)l);
11244 return isinf(f) && 0 < f;
11400rb_f_select(
int argc,
VALUE *argv,
VALUE obj)
11403 if (scheduler !=
Qnil) {
11406 if (!UNDEF_P(result))
return result;
11414 rb_scan_args(argc, argv,
"13", &args.read, &args.write, &args.except, &timeout);
11415 if (
NIL_P(timeout) || is_pos_inf(timeout)) {
11420 args.timeout = &timerec;
11423 for (i = 0; i < numberof(args.fdsets); ++i)
11429#ifdef IOCTL_REQ_TYPE
11430 typedef IOCTL_REQ_TYPE ioctl_req_t;
11432 typedef int ioctl_req_t;
11433# define NUM2IOCTLREQ(num) ((int)NUM2LONG(num))
11444nogvl_ioctl(
void *ptr)
11446 struct ioctl_arg *arg = ptr;
11448 return (
VALUE)ioctl(arg->fd, arg->cmd, arg->narg);
11452do_ioctl(
struct rb_io *io, ioctl_req_t cmd,
long narg)
11455 struct ioctl_arg arg;
11461 retval = (int)rb_io_blocking_region(io, nogvl_ioctl, &arg);
11467#define DEFAULT_IOCTL_NARG_LEN (256)
11469#if defined(__linux__) && defined(_IOC_SIZE)
11471linux_iocparm_len(ioctl_req_t cmd)
11475 if ((cmd & 0xFFFF0000) == 0) {
11477 return DEFAULT_IOCTL_NARG_LEN;
11480 len = _IOC_SIZE(cmd);
11483 if (
len < DEFAULT_IOCTL_NARG_LEN)
11484 len = DEFAULT_IOCTL_NARG_LEN;
11492ioctl_narg_len(ioctl_req_t cmd)
11498#define IOCPARM_LEN(x) (((x) >> 16) & IOCPARM_MASK)
11502 len = IOCPARM_LEN(cmd);
11503#elif defined(__linux__) && defined(_IOC_SIZE)
11504 len = linux_iocparm_len(cmd);
11507 len = DEFAULT_IOCTL_NARG_LEN;
11516typedef long fcntl_arg_t;
11519typedef int fcntl_arg_t;
11523fcntl_narg_len(ioctl_req_t cmd)
11530 len =
sizeof(fcntl_arg_t);
11538#ifdef F_DUPFD_CLOEXEC
11539 case F_DUPFD_CLOEXEC:
11540 len =
sizeof(fcntl_arg_t);
11550 len =
sizeof(fcntl_arg_t);
11560 len =
sizeof(fcntl_arg_t);
11570 len =
sizeof(fcntl_arg_t);
11575 len =
sizeof(
struct f_owner_ex);
11580 len =
sizeof(
struct f_owner_ex);
11585 len =
sizeof(
struct flock);
11590 len =
sizeof(
struct flock);
11595 len =
sizeof(
struct flock);
11615 len =
sizeof(fcntl_arg_t);
11625 len =
sizeof(fcntl_arg_t);
11630 len =
sizeof(fcntl_arg_t);
11643fcntl_narg_len(ioctl_req_t cmd)
11649#define NARG_SENTINEL 17
11652setup_narg(ioctl_req_t cmd,
VALUE *argp,
long (*narg_len)(ioctl_req_t))
11663 else if (arg ==
Qtrue) {
11678 req_len = narg_len(cmd);
11679 rb_str_modify(arg);
11681 slen = RSTRING_LEN(arg);
11683 if (slen < req_len+1) {
11684 rb_str_resize(arg, req_len+1);
11685 MEMZERO(RSTRING_PTR(arg)+slen,
char, req_len-slen);
11689 ptr = RSTRING_PTR(arg);
11690 ptr[slen - 1] = NARG_SENTINEL;
11699finish_narg(
int retval,
VALUE arg,
const rb_io_t *fptr)
11701 if (retval < 0) rb_sys_fail_path(fptr->
pathv);
11706 if (ptr[slen-1] != NARG_SENTINEL)
11707 rb_raise(rb_eArgError,
"return value overflowed string");
11708 ptr[slen-1] =
'\0';
11718 ioctl_req_t cmd = NUM2IOCTLREQ(req);
11723 narg = setup_narg(cmd, &arg, ioctl_narg_len);
11725 retval = do_ioctl(fptr, cmd, narg);
11726 return finish_narg(retval, arg, fptr);
11753 return rb_ioctl(io, req, arg);
11756#define rb_io_ioctl rb_f_notimplement
11767nogvl_fcntl(
void *ptr)
11769 struct fcntl_arg *arg = ptr;
11771#if defined(F_DUPFD)
11772 if (arg->cmd == F_DUPFD)
11775 return (
VALUE)fcntl(arg->fd, arg->cmd, arg->narg);
11779do_fcntl(
struct rb_io *io,
int cmd,
long narg)
11782 struct fcntl_arg arg;
11788 retval = (int)rb_io_blocking_region(io, nogvl_fcntl, &arg);
11789 if (retval != -1) {
11791#if defined(F_DUPFD)
11794#if defined(F_DUPFD_CLOEXEC)
11795 case F_DUPFD_CLOEXEC:
11812 narg = setup_narg(cmd, &arg, fcntl_narg_len);
11814 retval = do_fcntl(fptr, cmd, narg);
11815 return finish_narg(retval, arg, fptr);
11841 return rb_fcntl(io, req, arg);
11844#define rb_io_fcntl rb_f_notimplement
11847#if defined(HAVE_SYSCALL) || defined(HAVE___SYSCALL)
11879#if SIZEOF_VOIDP == 8 && defined(HAVE___SYSCALL) && SIZEOF_INT != 8
11880# define SYSCALL __syscall
11881# define NUM2SYSCALLID(x) NUM2LONG(x)
11882# define RETVAL2NUM(x) LONG2NUM(x)
11883# if SIZEOF_LONG == 8
11884 long num, retval = -1;
11885# elif SIZEOF_LONG_LONG == 8
11886 long long num, retval = -1;
11888# error ---->> it is asserted that __syscall takes the first argument and returns retval in 64bit signed integer. <<----
11890#elif defined(__linux__)
11891# define SYSCALL syscall
11892# define NUM2SYSCALLID(x) NUM2LONG(x)
11893# define RETVAL2NUM(x) LONG2NUM(x)
11901 long num, retval = -1;
11903# define SYSCALL syscall
11904# define NUM2SYSCALLID(x) NUM2INT(x)
11905# define RETVAL2NUM(x) INT2NUM(x)
11906 int num, retval = -1;
11912 "We plan to remove a syscall function at future release. DL(Fiddle) provides safer alternative.");
11916 rb_raise(rb_eArgError,
"too few arguments for syscall");
11917 if (argc > numberof(arg))
11918 rb_raise(rb_eArgError,
"too many arguments for syscall");
11919 num = NUM2SYSCALLID(argv[0]); ++argv;
11920 for (i = argc - 1; i--; ) {
11935 retval = SYSCALL(num);
11938 retval = SYSCALL(num, arg[0]);
11941 retval = SYSCALL(num, arg[0],arg[1]);
11944 retval = SYSCALL(num, arg[0],arg[1],arg[2]);
11947 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3]);
11950 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4]);
11953 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5]);
11956 retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6]);
11962 return RETVAL2NUM(retval);
11964#undef NUM2SYSCALLID
11968#define rb_f_syscall rb_f_notimplement
11972io_new_instance(
VALUE args)
11977static rb_encoding *
11978find_encoding(
VALUE v)
11980 rb_encoding *enc = rb_find_encoding(v);
11981 if (!enc)
rb_warn(
"Unsupported encoding %"PRIsVALUE
" ignored", v);
11988 rb_encoding *enc, *enc2;
11993 enc2 = find_encoding(v1);
11996 if (RSTRING_LEN(tmp) == 1 && RSTRING_PTR(tmp)[0] ==
'-') {
12002 enc = find_encoding(v2);
12009 enc = find_encoding(v2);
12020 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
12026 rb_io_ext_int_to_encs(NULL, NULL, &enc, &enc2, 0);
12027 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
12032 if (!
NIL_P(tmp) && rb_enc_asciicompat(enc = rb_enc_get(tmp))) {
12033 parse_mode_enc(RSTRING_PTR(tmp), enc, &enc, &enc2, NULL);
12034 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
12037 rb_io_ext_int_to_encs(find_encoding(v1), NULL, &enc, &enc2, 0);
12038 SET_UNIVERSAL_NEWLINE_DECORATOR_IF_ENC2(enc2, ecflags);
12043 validate_enc_binmode(&fptr->
mode, ecflags, enc, enc2);
12048 clear_codeconv(fptr);
12060io_encoding_set_v(
VALUE v)
12063 io_encoding_set(arg->fptr, arg->v1, arg->v2, arg->opt);
12068pipe_pair_close(
VALUE rw)
12071 return rb_ensure(io_close, rwp[0], io_close, rwp[1]);
12154rb_io_s_pipe(
int argc,
VALUE *argv,
VALUE klass)
12156 int pipes[2], state;
12157 VALUE r, w, args[3], v1, v2;
12159 rb_io_t *fptr, *fptr2;
12161 enum rb_io_mode fmode = 0;
12164 argc =
rb_scan_args(argc, argv,
"02:", &v1, &v2, &opt);
12171 r = rb_protect(io_new_instance, (
VALUE)args, &state);
12175 rb_jump_tag(state);
12179 ies_args.fptr = fptr;
12182 ies_args.opt = opt;
12183 rb_protect(io_encoding_set_v, (
VALUE)&ies_args, &state);
12187 rb_jump_tag(state);
12192 w = rb_protect(io_new_instance, (
VALUE)args, &state);
12196 rb_jump_tag(state);
12201 extract_binmode(opt, &fmode);
12208#if DEFAULT_TEXTMODE
12211 setmode(fptr->
fd, O_BINARY);
12213#if RUBY_CRLF_ENVIRONMENT
12219 fptr->
mode |= fmode;
12220#if DEFAULT_TEXTMODE
12223 setmode(fptr2->
fd, O_BINARY);
12226 fptr2->
mode |= fmode;
12260 else if (!
NIL_P(v = rb_hash_aref(opt, sym_open_args))) {
12263 v = rb_to_array_type(v);
12268 arg->io = rb_io_open(klass, path, vmode, vperm, opt);
12272io_s_foreach(
VALUE v)
12277 if (arg->limit == 0)
12278 rb_raise(rb_eArgError,
"invalid limit: 0 for foreach");
12279 while (!
NIL_P(str = rb_io_getline_1(arg->rs, arg->limit, arg->chomp, arg->io))) {
12363rb_io_s_foreach(
int argc,
VALUE *argv,
VALUE self)
12366 int orig_argc = argc;
12370 argc =
rb_scan_args(argc, argv,
"12:", NULL, NULL, NULL, &opt);
12372 extract_getline_args(argc-1, argv+1, &garg);
12373 open_key_args(self, argc, argv, opt, &arg);
12375 extract_getline_opts(opt, &garg);
12376 check_getline_args(&garg.rs, &garg.limit, garg.io = arg.io);
12381io_s_readlines(
VALUE v)
12384 return io_readlines(arg, arg->io);
12437rb_io_s_readlines(
int argc,
VALUE *argv,
VALUE io)
12443 argc =
rb_scan_args(argc, argv,
"12:", NULL, NULL, NULL, &opt);
12444 extract_getline_args(argc-1, argv+1, &garg);
12445 open_key_args(io, argc, argv, opt, &arg);
12447 extract_getline_opts(opt, &garg);
12448 check_getline_args(&garg.rs, &garg.limit, garg.io = arg.io);
12456 return io_read(arg->argc, arg->argv, arg->io);
12466seek_before_access(
VALUE argp)
12470 return rb_io_seek(arg->io, arg->offset, arg->mode);
12537rb_io_s_read(
int argc,
VALUE *argv,
VALUE io)
12543 argc =
rb_scan_args(argc, argv,
"13:", NULL, NULL, &offset, NULL, &opt);
12545 rb_raise(rb_eArgError,
"negative offset %"PRIdLEN
" given",
off);
12547 open_key_args(io, argc, argv, opt, &arg);
12549 if (!
NIL_P(offset)) {
12553 sarg.offset = offset;
12554 sarg.mode = SEEK_SET;
12555 rb_protect(seek_before_access, (
VALUE)&sarg, &state);
12558 rb_jump_tag(state);
12560 if (arg.argc == 2) arg.argc = 1;
12575rb_io_s_binread(
int argc,
VALUE *argv,
VALUE io)
12591 arg.io = rb_io_open_generic(io, argv[0], oflags, fmode, &convconfig, 0);
12594 arg.argc = (argc > 1) ? 1 : 0;
12595 if (!
NIL_P(offset)) {
12599 sarg.offset = offset;
12600 sarg.mode = SEEK_SET;
12601 rb_protect(seek_before_access, (
VALUE)&sarg, &state);
12604 rb_jump_tag(state);
12611io_s_write0(
VALUE v)
12614 return io_write(arg->io,arg->str,arg->nosync);
12618io_s_write(
int argc,
VALUE *argv,
VALUE klass,
int binary)
12620 VALUE string, offset, opt;
12624 rb_scan_args(argc, argv,
"21:", NULL, &
string, &offset, &opt);
12627 else opt = rb_hash_dup(opt);
12630 if (
NIL_P(rb_hash_aref(opt,sym_mode))) {
12631 int mode = O_WRONLY|O_CREAT;
12633 if (binary) mode |= O_BINARY;
12635 if (
NIL_P(offset)) mode |= O_TRUNC;
12636 rb_hash_aset(opt,sym_mode,
INT2NUM(mode));
12638 open_key_args(klass, argc, argv, opt, &arg);
12641 if (binary) rb_io_binmode_m(arg.io);
12645 if (!
NIL_P(offset)) {
12649 sarg.offset = offset;
12650 sarg.mode = SEEK_SET;
12651 rb_protect(seek_before_access, (
VALUE)&sarg, &state);
12654 rb_jump_tag(state);
12720rb_io_s_write(
int argc,
VALUE *argv,
VALUE io)
12722 return io_s_write(argc, argv, io, 0);
12735rb_io_s_binwrite(
int argc,
VALUE *argv,
VALUE io)
12737 return io_s_write(argc, argv, io, 1);
12743 rb_off_t copy_length;
12744 rb_off_t src_offset;
12748 unsigned close_src : 1;
12749 unsigned close_dst : 1;
12752 const char *syserr;
12753 const char *notimp;
12755 struct stat src_stat;
12756 struct stat dst_stat;
12757#ifdef HAVE_FCOPYFILE
12758 copyfile_state_t copyfile_state;
12763exec_interrupts(
void *arg)
12766 rb_thread_execute_interrupts(th);
12780#if defined(ERESTART)
12785 rb_thread_execute_interrupts(stp->th);
12804fiber_scheduler_wait_for(
void * _arguments)
12814# define IOWAIT_SYSCALL "poll"
12815STATIC_ASSERT(pollin_expected, POLLIN == RB_WAITFD_IN);
12816STATIC_ASSERT(pollout_expected, POLLOUT == RB_WAITFD_OUT);
12818nogvl_wait_for(
VALUE th, rb_io_t *fptr,
short events,
struct timeval *timeout)
12821 if (scheduler !=
Qnil) {
12824 return RTEST(args.result);
12828 if (fd == -1)
return 0;
12833 fds.events = events;
12835 int timeout_milliseconds = -1;
12838 timeout_milliseconds = (int)(timeout->tv_sec * 1000) + (int)(timeout->tv_usec / 1000);
12841 return poll(&fds, 1, timeout_milliseconds);
12844# define IOWAIT_SYSCALL "select"
12846nogvl_wait_for(
VALUE th, rb_io_t *fptr,
short events,
struct timeval *timeout)
12849 if (scheduler !=
Qnil) {
12852 return RTEST(args.result);
12872 case RB_WAITFD_OUT:
12876 VM_UNREACHABLE(nogvl_wait_for);
12896 ret = nogvl_wait_for(stp->th, stp->src_fptr, RB_WAITFD_IN, NULL);
12898 }
while (ret < 0 && maygvl_copy_stream_continue_p(has_gvl, stp));
12901 stp->syserr = IOWAIT_SYSCALL;
12902 stp->error_no =
errno;
12914 ret = nogvl_wait_for(stp->th, stp->dst_fptr, RB_WAITFD_OUT, NULL);
12915 }
while (ret < 0 && maygvl_copy_stream_continue_p(0, stp));
12918 stp->syserr = IOWAIT_SYSCALL;
12919 stp->error_no =
errno;
12925#ifdef USE_COPY_FILE_RANGE
12928simple_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)
12930#ifdef HAVE_COPY_FILE_RANGE
12931 return copy_file_range(in_fd, in_offset, out_fd, out_offset, count, flags);
12933 return syscall(__NR_copy_file_range, in_fd, in_offset, out_fd, out_offset, count, flags);
12942 rb_off_t copy_length, src_offset, *src_offset_ptr;
12944 if (!S_ISREG(stp->src_stat.st_mode))
12947 src_size = stp->src_stat.st_size;
12948 src_offset = stp->src_offset;
12949 if (src_offset >= (rb_off_t)0) {
12950 src_offset_ptr = &src_offset;
12953 src_offset_ptr = NULL;
12956 copy_length = stp->copy_length;
12957 if (copy_length < (rb_off_t)0) {
12958 if (src_offset < (rb_off_t)0) {
12959 rb_off_t current_offset;
12961 current_offset = lseek(stp->src_fptr->
fd, 0, SEEK_CUR);
12962 if (current_offset < (rb_off_t)0 &&
errno) {
12963 stp->syserr =
"lseek";
12964 stp->error_no =
errno;
12965 return (
int)current_offset;
12967 copy_length = src_size - current_offset;
12970 copy_length = src_size - src_offset;
12974 retry_copy_file_range:
12975# if SIZEOF_OFF_T > SIZEOF_SIZE_T
12977 ss = (copy_length > (rb_off_t)SSIZE_MAX) ? SSIZE_MAX : (ssize_t)copy_length;
12979 ss = (ssize_t)copy_length;
12981 ss = simple_copy_file_range(stp->src_fptr->
fd, src_offset_ptr, stp->dst_fptr->
fd, NULL, ss, 0);
12985 if (0 < copy_length) {
12986 goto retry_copy_file_range;
12990 if (maygvl_copy_stream_continue_p(0, stp)) {
12991 goto retry_copy_file_range;
13005#if EWOULDBLOCK != EAGAIN
13009 int ret = nogvl_copy_stream_wait_write(stp);
13010 if (ret < 0)
return ret;
13012 goto retry_copy_file_range;
13016 int flags = fcntl(stp->dst_fptr->
fd, F_GETFL);
13018 if (flags != -1 && flags & O_APPEND) {
13024 stp->syserr =
"copy_file_range";
13025 stp->error_no =
errno;
13032#ifdef HAVE_FCOPYFILE
13036 rb_off_t cur, ss = 0;
13037 const rb_off_t src_offset = stp->src_offset;
13040 if (stp->copy_length >= (rb_off_t)0) {
13045 if (!S_ISREG(stp->src_stat.st_mode))
13048 if (!S_ISREG(stp->dst_stat.st_mode))
13050 if (lseek(stp->dst_fptr->
fd, 0, SEEK_CUR) > (rb_off_t)0)
13052 if (fcntl(stp->dst_fptr->
fd, F_GETFL) & O_APPEND) {
13055 rb_off_t end = lseek(stp->dst_fptr->
fd, 0, SEEK_END);
13056 lseek(stp->dst_fptr->
fd, 0, SEEK_SET);
13057 if (end > (rb_off_t)0)
return 0;
13060 if (src_offset > (rb_off_t)0) {
13065 cur = lseek(stp->src_fptr->
fd, 0, SEEK_CUR);
13066 if (cur < (rb_off_t)0 &&
errno) {
13067 stp->error_no =
errno;
13072 r = lseek(stp->src_fptr->
fd, src_offset, SEEK_SET);
13073 if (r < (rb_off_t)0 &&
errno) {
13074 stp->error_no =
errno;
13079 stp->copyfile_state = copyfile_state_alloc();
13080 ret = fcopyfile(stp->src_fptr->
fd, stp->dst_fptr->
fd, stp->copyfile_state, COPYFILE_DATA);
13081 copyfile_state_get(stp->copyfile_state, COPYFILE_STATE_COPIED, &ss);
13085 if (src_offset > (rb_off_t)0) {
13089 r = lseek(stp->src_fptr->
fd, cur, SEEK_SET);
13090 if (r < (rb_off_t)0 &&
errno) {
13091 stp->error_no =
errno;
13103 stp->syserr =
"fcopyfile";
13104 stp->error_no =
errno;
13111#ifdef HAVE_SENDFILE
13114# define USE_SENDFILE
13116# ifdef HAVE_SYS_SENDFILE_H
13117# include <sys/sendfile.h>
13121simple_sendfile(
int out_fd,
int in_fd, rb_off_t *offset, rb_off_t count)
13123 return sendfile(out_fd, in_fd, offset, (
size_t)count);
13126# elif 0 || defined(__APPLE__)
13130# define USE_SENDFILE
13133simple_sendfile(
int out_fd,
int in_fd, rb_off_t *offset, rb_off_t count)
13136 rb_off_t pos = offset ? *offset : lseek(in_fd, 0, SEEK_CUR);
13139 r = sendfile(in_fd, out_fd, pos, &count, NULL, 0);
13142 r = sendfile(in_fd, out_fd, pos, (
size_t)count, NULL, &sbytes, 0);
13144 if (r != 0 && sbytes == 0)
return r;
13149 lseek(in_fd, sbytes, SEEK_CUR);
13151 return (ssize_t)sbytes;
13164 rb_off_t copy_length;
13165 rb_off_t src_offset;
13168 if (!S_ISREG(stp->src_stat.st_mode))
13171 src_size = stp->src_stat.st_size;
13173 if ((stp->dst_stat.st_mode & S_IFMT) != S_IFSOCK)
13177 src_offset = stp->src_offset;
13178 use_pread = src_offset >= (rb_off_t)0;
13180 copy_length = stp->copy_length;
13181 if (copy_length < (rb_off_t)0) {
13183 copy_length = src_size - src_offset;
13187 cur = lseek(stp->src_fptr->
fd, 0, SEEK_CUR);
13188 if (cur < (rb_off_t)0 &&
errno) {
13189 stp->syserr =
"lseek";
13190 stp->error_no =
errno;
13193 copy_length = src_size - cur;
13198# if SIZEOF_OFF_T > SIZEOF_SIZE_T
13200 ss = (copy_length > (rb_off_t)SSIZE_MAX) ? SSIZE_MAX : (ssize_t)copy_length;
13202 ss = (ssize_t)copy_length;
13205 ss = simple_sendfile(stp->dst_fptr->
fd, stp->src_fptr->
fd, &src_offset, ss);
13208 ss = simple_sendfile(stp->dst_fptr->
fd, stp->src_fptr->
fd, NULL, ss);
13213 if (0 < copy_length) {
13214 goto retry_sendfile;
13218 if (maygvl_copy_stream_continue_p(0, stp))
13219 goto retry_sendfile;
13232#if EWOULDBLOCK != EAGAIN
13245 ret = maygvl_copy_stream_wait_read(0, stp);
13246 if (ret < 0)
return ret;
13248 ret = nogvl_copy_stream_wait_write(stp);
13249 if (ret < 0)
return ret;
13251 goto retry_sendfile;
13253 stp->syserr =
"sendfile";
13254 stp->error_no =
errno;
13262maygvl_read(
int has_gvl, rb_io_t *fptr,
void *buf,
size_t count)
13265 return rb_io_read_memory(fptr, buf, count);
13267 return read(fptr->
fd, buf, count);
13271maygvl_copy_stream_read(
int has_gvl,
struct copy_stream_struct *stp,
char *buf,
size_t len, rb_off_t offset)
13275 if (offset < (rb_off_t)0) {
13276 ss = maygvl_read(has_gvl, stp->src_fptr, buf,
len);
13279 ss = pread(stp->src_fptr->
fd, buf,
len, offset);
13285 if (maygvl_copy_stream_continue_p(has_gvl, stp))
13289#if EWOULDBLOCK != EAGAIN
13293 int ret = maygvl_copy_stream_wait_read(has_gvl, stp);
13294 if (ret < 0)
return ret;
13299 stp->notimp =
"pread";
13303 stp->syserr = offset < (rb_off_t)0 ?
"read" :
"pread";
13304 stp->error_no =
errno;
13315 ss = write(stp->dst_fptr->
fd, buf+
off,
len);
13317 if (maygvl_copy_stream_continue_p(0, stp))
13319 if (io_again_p(
errno)) {
13320 int ret = nogvl_copy_stream_wait_write(stp);
13321 if (ret < 0)
return ret;
13324 stp->syserr =
"write";
13325 stp->error_no =
errno;
13342 rb_off_t copy_length;
13343 rb_off_t src_offset;
13347 copy_length = stp->copy_length;
13348 use_eof = copy_length < (rb_off_t)0;
13349 src_offset = stp->src_offset;
13350 use_pread = src_offset >= (rb_off_t)0;
13352 if (use_pread && stp->close_src) {
13355 r = lseek(stp->src_fptr->
fd, src_offset, SEEK_SET);
13356 if (r < (rb_off_t)0 &&
errno) {
13357 stp->syserr =
"lseek";
13358 stp->error_no =
errno;
13361 src_offset = (rb_off_t)-1;
13365 while (use_eof || 0 < copy_length) {
13366 if (!use_eof && copy_length < (rb_off_t)
sizeof(buf)) {
13367 len = (size_t)copy_length;
13373 ss = maygvl_copy_stream_read(0, stp, buf,
len, src_offset);
13378 ss = maygvl_copy_stream_read(0, stp, buf,
len, (rb_off_t)-1);
13383 ret = nogvl_copy_stream_write(stp, buf, ss);
13393nogvl_copy_stream_func(
void *arg)
13396#if defined(USE_SENDFILE) || defined(USE_COPY_FILE_RANGE) || defined(HAVE_FCOPYFILE)
13400#ifdef USE_COPY_FILE_RANGE
13401 ret = nogvl_copy_file_range(stp);
13406#ifdef HAVE_FCOPYFILE
13407 ret = nogvl_fcopyfile(stp);
13413 ret = nogvl_copy_stream_sendfile(stp);
13418 nogvl_copy_stream_read_write(stp);
13420#if defined(USE_SENDFILE) || defined(USE_COPY_FILE_RANGE) || defined(HAVE_FCOPYFILE)
13434copy_stream_fallback_read(
VALUE arg)
13437 return (
VALUE)maygvl_copy_stream_read(1, p->stp, RSTRING_PTR(p->buf),
13438 p->len, p->offset);
13442copy_stream_fallback_body(
VALUE arg)
13445 const int buflen = 16*1024;
13448 rb_off_t rest = stp->copy_length;
13449 rb_off_t
off = stp->src_offset;
13450 ID read_method = id_readpartial;
13452 if (!stp->src_fptr) {
13454 read_method = id_read;
13461 rb_str_make_independent(buf);
13462 if (stp->copy_length < (rb_off_t)0) {
13467 rb_str_resize(buf, 0);
13470 l = buflen < rest ? buflen : (
rb_len_t)rest;
13472 if (!stp->src_fptr) {
13475 if (read_method == id_read &&
NIL_P(rc))
13479 rb_str_resize(buf, buflen);
13482 (ssize_t)rb_str_locktmp_ensure(buf, copy_stream_fallback_read,
13484 rb_str_resize(buf, ss > 0 ? ss : 0);
13489 if (
off >= (rb_off_t)0)
13492 n = rb_io_write(stp->dst, buf);
13494 stp->total += numwrote;
13496 if (read_method == id_read && RSTRING_LEN(buf) == 0) {
13507 if (!stp->src_fptr && stp->src_offset >= (rb_off_t)0) {
13508 rb_raise(rb_eArgError,
"cannot specify src_offset for non-IO");
13517copy_stream_body(
VALUE arg)
13520 VALUE src_io = stp->src, dst_io = stp->dst;
13521 const int common_oflags = 0
13531 if (src_io ==
argf ||
13535 stp->src_fptr = NULL;
13540 if (!
NIL_P(tmp_io)) {
13547 args[1] =
INT2NUM(O_RDONLY|common_oflags);
13550 stp->close_src = 1;
13555 stat_ret = fstat(stp->src_fptr->
fd, &stp->src_stat);
13556 if (stat_ret < 0) {
13557 stp->syserr =
"fstat";
13558 stp->error_no =
errno;
13563 if (dst_io ==
argf ||
13567 stp->dst_fptr = NULL;
13572 if (!
NIL_P(tmp_io)) {
13573 dst_io = GetWriteIO(tmp_io);
13579 args[1] =
INT2NUM(O_WRONLY|O_CREAT|O_TRUNC|common_oflags);
13583 stp->close_dst = 1;
13586 dst_io = GetWriteIO(dst_io);
13592 stat_ret = fstat(stp->dst_fptr->
fd, &stp->dst_stat);
13593 if (stat_ret < 0) {
13594 stp->syserr =
"fstat";
13595 stp->error_no =
errno;
13602 SET_BINARY_MODE_WITH_SEEK_CUR(stp->src_fptr);
13605 io_ascii8bit_binmode(stp->dst_fptr);
13607 if (stp->src_offset < (rb_off_t)0 && stp->src_fptr && stp->src_fptr->
rbuf.
len) {
13610 if (stp->copy_length >= (rb_off_t)0 && stp->copy_length < (rb_off_t)
len) {
13611 len = (size_t)stp->copy_length;
13614 rb_str_resize(str,
len);
13615 read_buffered_data(RSTRING_PTR(str),
len, stp->src_fptr);
13616 if (stp->dst_fptr) {
13617 if (io_binwrite(RSTRING_PTR(str), RSTRING_LEN(str), stp->dst_fptr, 0) < 0)
13618 rb_sys_fail_on_write(stp->dst_fptr);
13621 rb_io_write(dst_io, str);
13622 rb_str_resize(str, 0);
13624 if (stp->copy_length >= (rb_off_t)0)
13625 stp->copy_length -=
len;
13628 if (stp->dst_fptr && io_fflush(stp->dst_fptr) < 0) {
13632 if (stp->copy_length == 0)
13635 if (stp->src_fptr == NULL || stp->dst_fptr == NULL) {
13636 return copy_stream_fallback(stp);
13639 IO_WITHOUT_GVL(nogvl_copy_stream_func, stp);
13644copy_stream_finalize(
VALUE arg)
13648#ifdef HAVE_FCOPYFILE
13649 if (stp->copyfile_state) {
13650 copyfile_state_free(stp->copyfile_state);
13654 if (stp->close_src) {
13655 rb_io_close_m(stp->src);
13657 if (stp->close_dst) {
13658 rb_io_close_m(stp->dst);
13721rb_io_s_copy_stream(
int argc,
VALUE *argv,
VALUE io)
13723 VALUE src, dst, length, src_offset;
13728 rb_scan_args(argc, argv,
"22", &src, &dst, &length, &src_offset);
13733 st.src_fptr = NULL;
13734 st.dst_fptr = NULL;
13737 st.copy_length = (rb_off_t)-1;
13739 st.copy_length =
NUM2OFFT(length);
13741 if (
NIL_P(src_offset))
13742 st.src_offset = (rb_off_t)-1;
13744 st.src_offset =
NUM2OFFT(src_offset);
13763rb_io_external_encoding(
VALUE io)
13768 return rb_enc_from_encoding(fptr->
encs.
enc2);
13772 return rb_enc_from_encoding(fptr->
encs.
enc);
13775 return rb_enc_from_encoding(io_read_encoding(fptr));
13791rb_io_internal_encoding(
VALUE io)
13796 return rb_enc_from_encoding(io_read_encoding(fptr));
13830rb_io_set_encoding(
int argc,
VALUE *argv,
VALUE io)
13836 return forward(io, id_set_encoding, argc, argv);
13839 argc =
rb_scan_args(argc, argv,
"11:", &v1, &v2, &opt);
13841 io_encoding_set(fptr, v1, v2, opt);
13846rb_stdio_set_default_encoding(
void)
13851 if (isatty(fileno(stdin))) {
13856 rb_enc_from_encoding(external),
13857 rb_enc_from_encoding(internal),
13862 rb_io_set_encoding(1, &val,
rb_stdin);
13863 rb_io_set_encoding(1, &val,
rb_stdout);
13864 rb_io_set_encoding(1, &val,
rb_stderr);
13868global_argf_p(
VALUE arg)
13870 return arg ==
argf;
13873typedef VALUE (*argf_encoding_func)(
VALUE io);
13876argf_encoding(
VALUE argf, argf_encoding_func func)
13878 if (!
RTEST(ARGF.current_file)) {
13903 return argf_encoding(
argf, rb_io_external_encoding);
13922 return argf_encoding(
argf, rb_io_internal_encoding);
13961 if (!next_argv()) {
13962 rb_raise(rb_eArgError,
"no stream to set encoding");
13964 rb_io_set_encoding(argc, argv, ARGF.current_file);
13966 ARGF.encs = fptr->
encs;
13986 if (!next_argv()) {
13987 rb_raise(rb_eArgError,
"no stream to tell");
13989 ARGF_FORWARD(0, 0);
13990 return rb_io_tell(ARGF.current_file);
14003 if (!next_argv()) {
14004 rb_raise(rb_eArgError,
"no stream to seek");
14006 ARGF_FORWARD(argc, argv);
14007 return rb_io_seek_m(argc, argv, ARGF.current_file);
14024 if (!next_argv()) {
14025 rb_raise(rb_eArgError,
"no stream to set position");
14027 ARGF_FORWARD(1, &offset);
14028 return rb_io_set_pos(ARGF.current_file, offset);
14049 if (!next_argv()) {
14050 rb_raise(rb_eArgError,
"no stream to rewind");
14052 ARGF_FORWARD(0, 0);
14053 old_lineno =
RFILE(ARGF.current_file)->fptr->lineno;
14054 ret = rb_io_rewind(ARGF.current_file);
14055 if (!global_argf_p(
argf)) {
14056 ARGF.last_lineno = ARGF.lineno -= old_lineno;
14074 if (!next_argv()) {
14075 rb_raise(rb_eArgError,
"no stream");
14077 ARGF_FORWARD(0, 0);
14078 return rb_io_fileno(ARGF.current_file);
14097 ARGF_FORWARD(0, 0);
14098 return ARGF.current_file;
14123 if (
RTEST(ARGF.current_file)) {
14124 if (ARGF.init_p == 0)
return Qtrue;
14126 ARGF_FORWARD(0, 0);
14185 VALUE tmp, str, length;
14189 if (!
NIL_P(length)) {
14194 rb_str_resize(str,0);
14199 if (!next_argv()) {
14202 if (ARGF_GENERIC_INPUT_P()) {
14203 tmp = argf_forward(argc, argv,
argf);
14206 tmp = io_read(argc, argv, ARGF.current_file);
14208 if (
NIL_P(str)) str = tmp;
14211 if (ARGF.next_p != -1) {
14217 else if (argc >= 1) {
14234argf_forward_call(
VALUE arg)
14237 argf_forward(p->argc, p->argv, p->argf);
14267 return argf_getpartial(argc, argv,
argf,
Qnil, 0);
14288 return argf_getpartial(argc, argv,
argf, opts, 1);
14294 VALUE tmp, str, length;
14302 no_exception = no_exception_p(opts);
14304 if (!next_argv()) {
14306 rb_str_resize(str, 0);
14310 if (ARGF_GENERIC_INPUT_P()) {
14320 tmp = io_getpartial(ARGF.current_file, length, str, no_exception, nonblock);
14323 if (ARGF.next_p == -1) {
14324 return io_nonblock_eof(no_exception);
14329 return io_nonblock_eof(no_exception);
14367 if (!next_argv())
return Qnil;
14368 if (ARGF_GENERIC_INPUT_P()) {
14369 ch = forward_current(rb_intern(
"getc"), 0, 0);
14372 ch = rb_io_getc(ARGF.current_file);
14374 if (
NIL_P(ch) && ARGF.next_p != -1) {
14407 if (!next_argv())
return Qnil;
14409 ch = forward_current(rb_intern(
"getbyte"), 0, 0);
14414 if (
NIL_P(ch) && ARGF.next_p != -1) {
14449 ch = forward_current(rb_intern(
"getc"), 0, 0);
14452 ch = rb_io_getc(ARGF.current_file);
14454 if (
NIL_P(ch) && ARGF.next_p != -1) {
14486 NEXT_ARGF_FORWARD(0, 0);
14487 c = argf_getbyte(
argf);
14494#define FOREACH_ARGF() while (next_argv())
14499 const VALUE current = ARGF.current_file;
14501 if (ARGF.init_p == -1 || current != ARGF.current_file) {
14507#define ARGF_block_call(mid, argc, argv, func, argf) \
14508 rb_block_call_kw(ARGF.current_file, mid, argc, argv, \
14509 func, argf, rb_keyword_given_p())
14514 VALUE ret = ARGF_block_call(mid, argc, argv, argf_block_call_i,
argf);
14515 if (!UNDEF_P(ret)) ARGF.next_p = 1;
14521 if (!global_argf_p(
argf)) {
14522 ARGF.last_lineno = ++ARGF.lineno;
14524 return argf_block_call_i(i,
argf, argc, argv, blockarg);
14530 VALUE ret = ARGF_block_call(mid, argc, argv, argf_block_call_line_i,
argf);
14531 if (!UNDEF_P(ret)) ARGF.next_p = 1;
14579 argf_block_call_line(rb_intern(
"each_line"), argc, argv,
argf);
14610 argf_block_call(rb_intern(
"each_byte"), 0, 0,
argf);
14636 argf_block_call(rb_intern(
"each_char"), 0, 0,
argf);
14662 argf_block_call(rb_intern(
"each_codepoint"), 0, 0,
argf);
14693 return ARGF.filename;
14697argf_filename_getter(
ID id,
VALUE *var)
14699 return argf_filename(*var);
14724 return ARGF.current_file;
14743 ARGF_FORWARD(0, 0);
14764 return RBOOL(ARGF.binmode);
14784 if (ARGF.init_p && ARGF.next_p == 0) {
14813 if (ARGF.next_p != -1) {
14831 ARGF_FORWARD(0, 0);
14858 if (!ARGF.inplace)
return Qnil;
14866 return argf_inplace_mode_get(*var);
14897 ARGF.inplace =
Qnil;
14908 argf_inplace_mode_set(*var, val);
14912ruby_set_inplace_mode(
const char *suffix)
14938argf_argv_getter(
ID id,
VALUE *var)
14940 return argf_argv(*var);
14959 if (!
RTEST(ARGF.current_file)) {
14962 return GetWriteIO(ARGF.current_file);
14974 return rb_io_writev(argf_write_io(
argf), argc, argv);
14989 case RB_IO_WAIT_WRITABLE:
14992 c = rb_eEAGAINWaitWritable;
14994#if EAGAIN != EWOULDBLOCK
14996 c = rb_eEWOULDBLOCKWaitWritable;
15000 c = rb_eEINPROGRESSWaitWritable;
15006 case RB_IO_WAIT_READABLE:
15009 c = rb_eEAGAINWaitReadable;
15011#if EAGAIN != EWOULDBLOCK
15013 c = rb_eEWOULDBLOCKWaitReadable;
15017 c = rb_eEINPROGRESSWaitReadable;
15024 rb_bug(
"invalid read/write type passed to rb_readwrite_sys_fail: %d", waiting);
15030get_LAST_READ_LINE(
ID _x,
VALUE *_y)
15920#include <sys/cygwin.h>
15921 static struct __cygwin_perfile pf[] =
15923 {
"", O_RDONLY | O_BINARY},
15924 {
"", O_WRONLY | O_BINARY},
15925 {
"", O_RDWR | O_BINARY},
15926 {
"", O_APPEND | O_BINARY},
15929 cygwin_internal(CW_PERFILE, pf);
15978 rb_eEAGAINWaitReadable = rb_define_class_under(
rb_cIO,
"EAGAINWaitReadable", rb_eEAGAIN);
15981 rb_eEAGAINWaitWritable = rb_define_class_under(
rb_cIO,
"EAGAINWaitWritable", rb_eEAGAIN);
15983#if EAGAIN == EWOULDBLOCK
15985 rb_define_const(
rb_cIO,
"EWOULDBLOCKWaitReadable", rb_eEAGAINWaitReadable);
15987 rb_define_const(
rb_cIO,
"EWOULDBLOCKWaitWritable", rb_eEAGAINWaitWritable);
15990 rb_eEWOULDBLOCKWaitReadable = rb_define_class_under(
rb_cIO,
"EWOULDBLOCKWaitReadable", rb_eEWOULDBLOCK);
15993 rb_eEWOULDBLOCKWaitWritable = rb_define_class_under(
rb_cIO,
"EWOULDBLOCKWaitWritable", rb_eEWOULDBLOCK);
15997 rb_eEINPROGRESSWaitReadable = rb_define_class_under(
rb_cIO,
"EINPROGRESSWaitReadable", rb_eEINPROGRESS);
16000 rb_eEINPROGRESSWaitWritable = rb_define_class_under(
rb_cIO,
"EINPROGRESSWaitWritable", rb_eEINPROGRESS);
16035 rb_gvar_ractor_local(
"$/");
16037 rb_gvar_ractor_local(
"$-0");
16041 rb_gvar_ractor_local(
"$_");
16042 rb_gvar_box_dynamic(
"$_");
16158 rb_gvar_ractor_local(
"$stdin");
16159 rb_gvar_ractor_local(
"$stdout");
16160 rb_gvar_ractor_local(
"$>");
16161 rb_gvar_ractor_local(
"$stderr");
16163 rb_gvar_box_dynamic(
"$stdin");
16164 rb_gvar_box_dynamic(
"$stdout");
16165 rb_gvar_box_dynamic(
"$>");
16166 rb_gvar_box_dynamic(
"$stderr");
16187 rb_cARGF = rb_define_class(
"ARGF",
rb_cObject);
16252 rb_define_method(rb_cARGF,
"external_encoding", argf_external_encoding, 0);
16253 rb_define_method(rb_cARGF,
"internal_encoding", argf_internal_encoding, 0);
16272 rb_gvar_ractor_local(
"$-i");
16276#if defined (_WIN32) || defined(__CYGWIN__)
16277 atexit(pipe_atexit);
16289 sym_encoding =
ID2SYM(rb_id_encoding());
16313static void init_builtin_io(
void);
16314#define Init_builtin_io init_builtin_io
16316#undef Init_builtin_io
16319Init_builtin_io(
void)
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_class_new(VALUE super)
Creates a new, anonymous class.
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 REALLOC_N
Old name of RB_REALLOC_N.
#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 LEN2NUM
Old name of RB_LEN2NUM.
#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 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 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 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 NUM2LEN
Old name of RB_NUM2LEN.
#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_category_warn(rb_warning_category_t category, const char *fmt,...)
Identical to rb_category_warning(), except it reports unless $VERBOSE is nil.
void rb_category_warning(rb_warning_category_t category, const char *fmt,...)
Identical to rb_warning(), except it takes additional "category" parameter.
VALUE rb_eNotImpError
NotImplementedError exception.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
void rb_syserr_fail(int e, const char *mesg)
Raises appropriate exception that represents a C errno.
void rb_readwrite_syserr_fail(enum rb_io_wait_readwrite waiting, int n, const char *mesg)
Identical to rb_readwrite_sys_fail(), except it does not depend on C global variable errno.
VALUE rb_eIOError
IOError exception.
VALUE rb_eStandardError
StandardError exception.
void rb_mod_syserr_fail_str(VALUE mod, int e, VALUE mesg)
Identical to rb_mod_syserr_fail(), except it takes the message in Ruby's String instead of C's.
#define rb_notimplement()
void rb_syserr_fail_str(int e, VALUE mesg)
Identical to rb_syserr_fail(), except it takes the message in Ruby's String instead of C's.
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eEOFError
EOFError exception.
void rb_readwrite_sys_fail(enum rb_io_wait_readwrite waiting, const char *mesg)
Raises appropriate exception using the parameters.
void rb_iter_break_value(VALUE val)
Identical to rb_iter_break(), except it additionally takes the "value" of this breakage.
rb_io_wait_readwrite
for rb_readwrite_sys_fail first argument
VALUE rb_eRuntimeError
RuntimeError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
VALUE rb_eSystemCallError
SystemCallError exception.
@ RB_WARN_CATEGORY_DEPRECATED
Warning is for deprecated features.
VALUE rb_mKernel
Kernel module.
VALUE rb_check_to_int(VALUE val)
Identical to rb_check_to_integer(), except it uses #to_int for conversion.
VALUE rb_cObject
Object class.
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)
Same as RB_OBJ_FREEZE(), but returns the given object.
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_WRITTEN(old, oldv, young)
Identical to RB_OBJ_WRITE(), except it doesn't write any values, but only a WB declaration.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
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_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_wait(VALUE scheduler, VALUE io, VALUE events, VALUE timeout)
Non-blocking version of rb_io_wait().
static ssize_t rb_fiber_scheduler_io_result_apply(VALUE result)
Apply an io result to the local thread, returning the value of the original system call that created ...
VALUE rb_fiber_scheduler_io_pread_memory(VALUE scheduler, VALUE io, rb_off_t from, void *base, size_t size)
Non-blocking pread from the passed IO using a native buffer.
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_read_memory(VALUE scheduler, VALUE io, void *base, size_t size)
Non-blocking read from 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_pwrite_memory(VALUE scheduler, VALUE io, rb_off_t from, const void *base, size_t size)
Non-blocking pwrite 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.
VALUE rb_fiber_scheduler_io_write_memory(VALUE scheduler, VALUE io, const void *base, size_t size)
Non-blocking write to the passed IO using a native buffer.
rb_encoding * rb_ascii8bit_encoding(void)
Queries the encoding that represents ASCII-8BIT a.k.a.
rb_encoding * rb_default_internal_encoding(void)
Queries the "default internal" encoding.
int rb_utf8_encindex(void)
Identical to rb_utf8_encoding(), except it returns the encoding's index instead of the encoding itsel...
VALUE rb_enc_default_external(void)
Identical to rb_default_external_encoding(), except it returns the Ruby-level counterpart instance of...
static unsigned int rb_enc_codepoint(const char *p, const char *e, rb_encoding *enc)
Queries the code point of character pointed by the passed pointer.
rb_encoding * rb_default_external_encoding(void)
Queries the "default external" encoding.
static int rb_enc_mbmaxlen(rb_encoding *enc)
Queries the maximum number of bytes that the passed encoding needs to represent a character.
rb_encoding * rb_locale_encoding(void)
Queries the encoding that represents the current locale.
rb_encoding * rb_usascii_encoding(void)
Queries the encoding that represents US-ASCII.
VALUE rb_str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to)
Encoding conversion main routine.
rb_len_t rb_str_coderange_scan_restartable(const char *str, const char *end, rb_encoding *enc, int *cr)
Scans the passed string until it finds something odd.
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_funcallv(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcall(), except it takes the method arguments as a C array.
void rb_gc(void)
Triggers a GC process.
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_ary_entry(VALUE ary, rb_len_t off)
Queries an element of an array.
VALUE rb_ary_new_capa(rb_len_t capa)
Identical to rb_ary_new(), except it additionally specifies how many rooms of objects it should alloc...
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_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.
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
ID rb_frame_this_func(void)
Queries the name of the Ruby level method that is calling this function.
VALUE rb_hash_new(void)
Creates a new, empty hash object.
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_error2(const char *str, rb_len_t len)
Identical to rb_write_error(), except it additionally takes the message's length.
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_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_provide(const char *feature)
Declares that the given feature is already provided by someone else.
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 $?.
void rb_str_modify_expand(VALUE str, rb_len_t capa)
Identical to rb_str_modify(), except it additionally expands the capacity of the receiver.
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.
void rb_str_set_len(VALUE str, rb_len_t len)
Overwrites the length of the string.
VALUE rb_str_dup(VALUE str)
Duplicates a string.
VALUE rb_str_cat(VALUE dst, const char *src, rb_len_t 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_no_gvl_safe_acquire(VALUE orig)
Creates a frozen copy of orig that guarantees the RSTRING_PTR is safe to use in operations that relea...
VALUE rb_str_equal(VALUE str1, VALUE str2)
Equality of two strings.
void rb_str_no_gvl_safe_release(VALUE orig, VALUE tmp)
Releases a string created from rb_str_no_gvl_safe_acquire.
VALUE rb_str_substr(VALUE str, rb_len_t beg, rb_len_t len)
This is the implementation of two-argumented String#slice.
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_str_buf_new(rb_len_t capa)
Allocates a "string buffer".
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
VALUE rb_str_unlocktmp(VALUE str)
Releases a lock formerly obtained by rb_str_locktmp().
#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.
int rb_method_basic_definition_p(VALUE klass, ID mid)
Well... Let us hesitate from describing what a "basic definition" is.
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it returns RUBY_Qundef instead of raising rb_eNoMethodError.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
#define RB_ID2SYM
Just another name of rb_id2sym.
void rb_define_global_const(const char *name, VALUE val)
Identical to rb_define_const(), except it defines that of "global", i.e.
void rb_define_readonly_variable(const char *name, const VALUE *var)
Identical to rb_define_variable(), except it does not allow Ruby programs to assign values to such gl...
rb_gvar_setter_t rb_gvar_readonly_setter
This function just raises rb_eNameError.
#define FMODE_READABLE
The IO is opened for reading.
enum rb_io_mode rb_io_modestr_fmode(const char *modestr)
Maps a file mode string (that rb_file_open() takes) into a mixture of FMODE_ flags.
VALUE rb_io_get_io(VALUE io)
Identical to rb_io_check_io(), except it raises exceptions on conversion failures.
VALUE rb_io_timeout(VALUE io)
Get the timeout associated with the specified io object.
VALUE rb_io_taint_check(VALUE obj)
void rb_io_read_check(rb_io_t *fptr)
Blocks until there is a pending read in the passed IO.
int rb_io_modestr_oflags(const char *modestr)
Identical to rb_io_modestr_fmode(), except it returns a mixture of O_ flags.
#define FMODE_SETENC_BY_BOM
This flag amends the encoding of the IO so that the BOM of the contents of the IO takes effect.
rb_io_event
Type of events that an IO can wait.
@ RUBY_IO_READABLE
IO::READABLE
@ RUBY_IO_PRIORITY
IO::PRIORITY
@ RUBY_IO_WRITABLE
IO::WRITABLE
#define FMODE_READWRITE
The IO is opened for both read/write.
#define FMODE_EXTERNAL
This flag means that an IO object is wrapping an "external" file descriptor, which is owned by someth...
#define GetOpenFile
This is an old name of RB_IO_POINTER.
void rb_io_check_byte_readable(rb_io_t *fptr)
Asserts that an IO is opened for byte-based reading.
#define FMODE_TTY
The IO is a TTY.
#define FMODE_CREATE
The IO is opened for creating.
void rb_io_check_readable(rb_io_t *fptr)
Just another name of rb_io_check_byte_readable.
int rb_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.
#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_stderr(void)
Queries the standard error of the current Ractor that is calling this function.
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.
VALUE rb_ractor_stdout(void)
Queries the standard output of the current Ractor that is calling this function.
void rb_ractor_stdout_set(VALUE io)
Assigns an IO to the standard output of the Ractor that is calling this function.
void rb_ractor_stdin_set(VALUE io)
Assigns an IO to the standard input of the Ractor that is calling this function.
void * rb_thread_call_with_gvl(void *(*func)(void *), void *data1)
(Re-)acquires the GVL.
#define RB_NUM2INT
Just another name of rb_num2int_inline.
#define RB_INT2NUM
Just another name of rb_int2num_inline.
VALUE rb_f_sprintf(int argc, const VALUE *argv)
Identical to rb_str_format(), except how the arguments are arranged.
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
Shim for block function parameters.
VALUE rb_yield_values2(int n, const VALUE *argv)
Identical to rb_yield_values(), except it takes the parameters as a C array instead of variadic argum...
VALUE rb_yield(VALUE val)
Yields the block.
void rb_fd_term(rb_fdset_t *f)
Destroys the rb_fdset_t, releasing any memory and resources it used.
#define MEMZERO(p, type, n)
Handy macro to erase a region of memory.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
#define MEMMOVE(p1, p2, type, n)
Handy macro to call memmove.
#define NUM2MODET
Converts a C's mode_t into an instance of rb_cInteger.
void rb_define_hooked_variable(const char *q, VALUE *w, type *e, void_type *r)
Define a function-backended global variable.
void rb_define_virtual_variable(const char *q, type *w, void_type *e)
Define a function-backended global variable.
VALUE rb_rescue2(type *q, VALUE w, type *e, VALUE r,...)
An equivalent of rescue clause.
VALUE rb_ensure(type *q, VALUE w, type *e, VALUE r)
An equivalent of ensure clause.
#define PRI_OFFT_PREFIX
A rb_sprintf() format prefix to be used for an off_t parameter.
#define OFFT2NUM
Converts a C's off_t into an instance of rb_cInteger.
#define NUM2OFFT
Converts an instance of rb_cNumeric into C's off_t.
#define PIDT2NUM
Converts a C's pid_t into an instance of rb_cInteger.
#define rb_fd_isset
Queries if the given fd is in the rb_fdset_t.
#define rb_fd_select
Waits for multiple file descriptors at once.
#define rb_fd_init
Initialises the :given :rb_fdset_t.
#define rb_fd_set
Sets the given fd to the rb_fdset_t.
#define RARRAY_LEN
Just another name of rb_array_len.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
#define RARRAY_AREF(a, i)
References an object in an array.
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
#define RFILE(obj)
Convenient casting macro.
#define StringValue(v)
Ensures that the parameter object is a String.
static char * RSTRING_END(VALUE str)
Queries the end of the contents pointer of the string.
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Convenient macro to obtain the contents and length at once.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
#define RUBY_TYPED_DEFAULT_FREE
This is a value you can set to rb_data_type_struct::dfree.
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.
int rb_thread_fd_select(int nfds, rb_fdset_t *rfds, rb_fdset_t *wfds, rb_fdset_t *efds, struct timeval *timeout)
Waits for multiple file descriptors at once.
static bool RB_TEST(VALUE obj)
Emulates Ruby's "if" statement.
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
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
void(* finalize)(struct rb_io *, int)
finalize proc
rb_econv_t * readconv
Encoding converter used when reading from this IO.
rb_econv_t * writeconv
Encoding converter used when writing to this IO.
struct rb_io_encoding encs
Decomposed encoding flags.
VALUE self
The IO's Ruby level counterpart.
VALUE write_lock
This is a Ruby level mutex.
VALUE timeout
The timeout associated with this IO when performing blocking operations.
FILE * stdio_file
stdio ptr for read/write, if available.
VALUE writeconv_pre_ecopts
Value of rb_io_t::rb_io_enc_t::ecopts stored right before initialising rb_io_t::writeconv.
VALUE tied_io_for_writing
Duplex IO object, if set.
int writeconv_initialized
Whether rb_io_t::writeconv is already set up.
rb_io_buffer_t rbuf
(Byte) read buffer.
int lineno
number of lines read
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.
VALUE pathv
pathname for file
long rb_len_t
A signed integer type for lengths and indices of objects such as String and Array.
#define RB_LEN_MAX
Maximum possible value that a rb_len_t can take.
intptr_t SIGNED_VALUE
A signed integer type that has the same width with VALUE.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static bool RB_FLOAT_TYPE_P(VALUE obj)
Queries if the object is an instance of rb_cFloat.
static bool RB_SYMBOL_P(VALUE obj)
Queries if the object is an instance of rb_cSymbol.
static void Check_Type(VALUE v, enum ruby_value_type t)
Identical to RB_TYPE_P(), except it raises exceptions on predication failure.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
#define RBIMPL_WARNING_IGNORED(flag)
Suppresses a warning.
#define RBIMPL_WARNING_PUSH()
Pushes compiler warning state.
#define RBIMPL_WARNING_POP()
Pops compiler warning state.