io.h

#ifndef INTERNAL_IO_H                                    /*-*-C-*-vi:se ft=c:*/
#define INTERNAL_IO_H
#include "ruby/ruby.h"          /* for VALUE */
 
#define HAVE_RB_IO_T
struct rb_io;
 
#include "ruby/io.h"            /* for rb_io_t */
#include "ccan/list/list.h"
#include "serial.h"
 
#define IO_WITHOUT_GVL(func, arg) rb_nogvl(func, arg, RUBY_UBF_IO, 0, RB_NOGVL_OFFLOAD_SAFE)
#define IO_WITHOUT_GVL_INT(func, arg) (int)(VALUE)IO_WITHOUT_GVL(func, arg)
 
// Represents an in-flight blocking operation:
struct rb_io_blocking_operation {
    // The linked list data structure.
    struct ccan_list_node list;
 
    // The execution context of the blocking operation:
    struct rb_execution_context_struct *ec;
};
 
struct rb_io {
 
    VALUE self;
 
    FILE *stdio_file;
 
    int fd;
 
    enum rb_io_mode mode;
 
    rb_pid_t pid;
 
    int lineno;
 
    VALUE pathv;
 
    void (*finalize)(struct rb_io*,int);
 
    rb_io_buffer_t wbuf;
 
    rb_io_buffer_t rbuf;
 
    VALUE tied_io_for_writing;
 
    struct rb_io_encoding encs; 
    rb_econv_t *readconv;
 
    rb_io_buffer_t cbuf;
 
    rb_econv_t *writeconv;
 
    VALUE writeconv_asciicompat;
 
    int writeconv_initialized;
 
    int writeconv_pre_ecflags;
 
    VALUE writeconv_pre_ecopts;
 
    VALUE write_lock;
 
    VALUE timeout;
 
    struct ccan_list_head blocking_operations;
    struct rb_execution_context_struct *closing_ec;
    VALUE wakeup_mutex;
 
    // The fork generation of the the blocking operations list.
    rb_serial_t fork_generation;
};
 
/* io.c */
void ruby_set_inplace_mode(const char *);
void rb_stdio_set_default_encoding(void);
VALUE rb_io_flush_raw(VALUE, int);
size_t rb_io_memsize(const rb_io_t *);
int rb_stderr_tty_p(void);
VALUE rb_io_popen(VALUE pname, VALUE pmode, VALUE env, VALUE opt);
 
VALUE rb_io_prep_stdin(void);
VALUE rb_io_prep_stdout(void);
VALUE rb_io_prep_stderr(void);
 
int rb_io_notify_close(struct rb_io *fptr);
 
RUBY_SYMBOL_EXPORT_BEGIN
/* io.c (export) */
void rb_maygvl_fd_fix_cloexec(int fd);
int rb_gc_for_fd(int err);
void rb_write_error_str(VALUE mesg);
 
VALUE rb_io_blocking_region_wait(struct rb_io *io, rb_blocking_function_t *function, void *argument, enum rb_io_event events);
VALUE rb_io_blocking_region(struct rb_io *io, rb_blocking_function_t *function, void *argument);
RUBY_SYMBOL_EXPORT_END
 
#endif /* INTERNAL_IO_H */