portable_mruby 0.1.0

data/vendor/mruby/include/mruby/gc.h

@@ -0,0 +1,72 @@
+/**
+** @file mruby/gc.h - garbage collector for mruby
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_GC_H
+#define MRUBY_GC_H
+
+#include "common.h"
+
+/**
+ * Uncommon memory management stuffs.
+ */
+MRB_BEGIN_DECL
+
+
+struct mrb_state;
+
+#define MRB_EACH_OBJ_OK 0
+#define MRB_EACH_OBJ_BREAK 1
+typedef int (mrb_each_object_callback)(struct mrb_state *mrb, struct RBasic *obj, void *data);
+void mrb_objspace_each_objects(struct mrb_state *mrb, mrb_each_object_callback *callback, void *data);
+size_t mrb_objspace_page_slot_size(void);
+MRB_API void mrb_free_context(struct mrb_state *mrb, struct mrb_context *c);
+
+#ifndef MRB_GC_ARENA_SIZE
+#define MRB_GC_ARENA_SIZE 100
+#endif
+
+typedef enum {
+  MRB_GC_STATE_ROOT = 0,
+  MRB_GC_STATE_MARK,
+  MRB_GC_STATE_SWEEP
+} mrb_gc_state;
+
+typedef struct mrb_gc {
+  struct mrb_heap_page *heaps;     /* all heaps pages */
+  struct mrb_heap_page *free_heaps;/* heaps for allocation */
+  struct mrb_heap_page *sweeps;    /* page where sweep starts */
+  struct RBasic *gray_list;        /* list of gray objects to be traversed incrementally */
+  struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */
+  size_t live;                     /* count of live objects */
+  size_t live_after_mark;          /* old generation objects */
+  size_t threshold;                /* threshold to start GC */
+  size_t oldgen_threshold;         /* threshold to kick major GC */
+  mrb_gc_state state;              /* current state of gc */
+  int interval_ratio;
+  int step_ratio;
+  int current_white_part :2;       /* make white object by white_part */
+  mrb_bool iterating     :1;       /* currently iterating over objects */
+  mrb_bool disabled      :1;       /* GC disabled */
+  mrb_bool generational  :1;       /* generational GC mode */
+  mrb_bool full          :1;       /* major GC mode */
+  mrb_bool out_of_memory :1;       /* out-of-memory error occurred */
+
+#ifdef MRB_GC_FIXED_ARENA
+  struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */
+#else
+  struct RBasic **arena;                   /* GC protection array */
+  int arena_capa;                          /* size of protection array */
+#endif
+  int arena_idx;
+} mrb_gc;
+
+MRB_API mrb_bool mrb_object_dead_p(struct mrb_state *mrb, struct RBasic *object);
+
+#define MRB_GC_RED 7
+
+MRB_END_DECL
+
+#endif  /* MRUBY_GC_H */

data/vendor/mruby/include/mruby/gems/mruby-dir/include/dir_hal.h

@@ -0,0 +1,79 @@
+/*
+** dir_hal.h - Directory HAL interface for mruby
+**
+** See Copyright Notice in mruby.h
+**
+** Hardware Abstraction Layer for directory operations.
+** Provides platform-independent interface for filesystem directory operations.
+*/
+
+#ifndef MRUBY_DIR_HAL_H
+#define MRUBY_DIR_HAL_H
+
+#include <mruby.h>
+
+/*
+ * Platform-independent directory handle
+ * Each HAL implementation defines this structure internally
+ */
+typedef struct mrb_dir_handle mrb_dir_handle;
+
+/*
+ * Directory Operations
+ */
+
+/* Open directory for reading. Returns handle or NULL on error (sets errno). */
+mrb_dir_handle* mrb_hal_dir_open(mrb_state *mrb, const char *path);
+
+/* Close directory handle. Returns 0 on success, -1 on error. */
+int mrb_hal_dir_close(mrb_state *mrb, mrb_dir_handle *dir);
+
+/* Read next entry from directory. Returns name or NULL at end/error. */
+const char* mrb_hal_dir_read(mrb_state *mrb, mrb_dir_handle *dir);
+
+/* Rewind directory to beginning */
+void mrb_hal_dir_rewind(mrb_state *mrb, mrb_dir_handle *dir);
+
+/*
+ * Optional Operations (may not be available on all platforms)
+ */
+
+/* Seek to position in directory. Returns -1 if unsupported (sets errno to ENOSYS). */
+int mrb_hal_dir_seek(mrb_state *mrb, mrb_dir_handle *dir, long pos);
+
+/* Get current position in directory. Returns -1 if unsupported (sets errno to ENOSYS). */
+long mrb_hal_dir_tell(mrb_state *mrb, mrb_dir_handle *dir);
+
+/*
+ * Filesystem Operations
+ */
+
+/* Create directory with mode (mode may be ignored on some platforms). Returns 0 on success, -1 on error. */
+int mrb_hal_dir_mkdir(mrb_state *mrb, const char *path, int mode);
+
+/* Remove empty directory. Returns 0 on success, -1 on error. */
+int mrb_hal_dir_rmdir(mrb_state *mrb, const char *path);
+
+/* Change current working directory. Returns 0 on success, -1 on error. */
+int mrb_hal_dir_chdir(mrb_state *mrb, const char *path);
+
+/* Get current working directory. Returns 0 on success, -1 on error. */
+int mrb_hal_dir_getcwd(mrb_state *mrb, char *buf, size_t size);
+
+/* Change root directory (privileged operation). Returns -1 if unsupported (sets errno to ENOSYS). */
+int mrb_hal_dir_chroot(mrb_state *mrb, const char *path);
+
+/* Check if path is a directory. Returns 1 if directory, 0 if not. */
+int mrb_hal_dir_is_directory(mrb_state *mrb, const char *path);
+
+/*
+ * HAL Initialization/Finalization
+ */
+
+/* Initialize HAL (called once at gem initialization) */
+void mrb_hal_dir_init(mrb_state *mrb);
+
+/* Cleanup HAL (called once at gem finalization) */
+void mrb_hal_dir_final(mrb_state *mrb);
+
+#endif /* MRUBY_DIR_HAL_H */

data/vendor/mruby/include/mruby/gems/mruby-io/include/io_hal.h

@@ -0,0 +1,451 @@
+/*
+** io_hal.h - IO Hardware Abstraction Layer (HAL)
+**
+** See Copyright Notice in mruby.h
+**
+** This header defines the HAL interface for platform-specific I/O operations.
+** Platform-specific implementations (hal-posix-io, hal-win-io, etc.) must
+** provide all functions declared here.
+*/
+
+#ifndef MRUBY_IO_HAL_H
+#define MRUBY_IO_HAL_H
+
+#include <mruby.h>
+#include <stdint.h>
+
+/*
+ * Platform-independent type definitions
+ */
+
+/* File status structure - platform-independent representation */
+typedef struct mrb_io_stat {
+  uint64_t st_dev;       /* Device ID */
+  uint64_t st_ino;       /* Inode number */
+  uint32_t st_mode;      /* File mode/permissions */
+  uint32_t st_nlink;     /* Number of hard links */
+  uint32_t st_uid;       /* User ID */
+  uint32_t st_gid;       /* Group ID */
+  uint64_t st_rdev;      /* Device ID (if special file) */
+  int64_t  st_size;      /* File size in bytes */
+  int64_t  st_atime;     /* Last access time */
+  int64_t  st_mtime;     /* Last modification time */
+  int64_t  st_ctime;     /* Last status change time */
+  int64_t  st_blksize;   /* Block size for filesystem I/O */
+  int64_t  st_blocks;    /* Number of 512B blocks allocated */
+} mrb_io_stat;
+
+/* Timeval structure for select() */
+typedef struct mrb_io_timeval {
+  int64_t tv_sec;        /* Seconds */
+  int64_t tv_usec;       /* Microseconds */
+} mrb_io_timeval;
+
+/* File descriptor set for select() */
+typedef struct mrb_io_fdset mrb_io_fdset;
+
+/*
+ * File mode constants (POSIX-style)
+ */
+
+/* File type masks */
+#define MRB_IO_S_IFMT   0170000  /* Type of file mask */
+#define MRB_IO_S_IFSOCK 0140000  /* Socket */
+#define MRB_IO_S_IFLNK  0120000  /* Symbolic link */
+#define MRB_IO_S_IFREG  0100000  /* Regular file */
+#define MRB_IO_S_IFBLK  0060000  /* Block device */
+#define MRB_IO_S_IFDIR  0040000  /* Directory */
+#define MRB_IO_S_IFCHR  0020000  /* Character device */
+#define MRB_IO_S_IFIFO  0010000  /* FIFO */
+
+/* File type test macros */
+#define MRB_IO_S_ISREG(m)  (((m) & MRB_IO_S_IFMT) == MRB_IO_S_IFREG)
+#define MRB_IO_S_ISDIR(m)  (((m) & MRB_IO_S_IFMT) == MRB_IO_S_IFDIR)
+#define MRB_IO_S_ISCHR(m)  (((m) & MRB_IO_S_IFMT) == MRB_IO_S_IFCHR)
+#define MRB_IO_S_ISBLK(m)  (((m) & MRB_IO_S_IFMT) == MRB_IO_S_IFBLK)
+#define MRB_IO_S_ISFIFO(m) (((m) & MRB_IO_S_IFMT) == MRB_IO_S_IFIFO)
+#define MRB_IO_S_ISLNK(m)  (((m) & MRB_IO_S_IFMT) == MRB_IO_S_IFLNK)
+#define MRB_IO_S_ISSOCK(m) (((m) & MRB_IO_S_IFMT) == MRB_IO_S_IFSOCK)
+
+/* File lock constants */
+#define MRB_IO_LOCK_SH 1  /* Shared lock */
+#define MRB_IO_LOCK_EX 2  /* Exclusive lock */
+#define MRB_IO_LOCK_NB 4  /* Non-blocking */
+#define MRB_IO_LOCK_UN 8  /* Unlock */
+
+/* Seek constants */
+#define MRB_IO_SEEK_SET 0  /* Seek from beginning */
+#define MRB_IO_SEEK_CUR 1  /* Seek from current position */
+#define MRB_IO_SEEK_END 2  /* Seek from end */
+
+/*
+ * HAL Interface - File Operations
+ */
+
+/**
+ * Get file status by path
+ *
+ * @param mrb mruby state
+ * @param path File path (UTF-8)
+ * @param st Output stat structure
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_stat(mrb_state *mrb, const char *path, mrb_io_stat *st);
+
+/**
+ * Get file status by descriptor
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor
+ * @param st Output stat structure
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_fstat(mrb_state *mrb, int fd, mrb_io_stat *st);
+
+/**
+ * Get link status (don't follow symlinks)
+ *
+ * @param mrb mruby state
+ * @param path File path (UTF-8)
+ * @param st Output stat structure
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_lstat(mrb_state *mrb, const char *path, mrb_io_stat *st);
+
+/**
+ * Change file permissions
+ *
+ * @param mrb mruby state
+ * @param path File path (UTF-8)
+ * @param mode New permission mode
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_chmod(mrb_state *mrb, const char *path, uint32_t mode);
+
+/**
+ * Set/get file creation mask
+ *
+ * @param mrb mruby state
+ * @param mask New umask value (if < 0, only returns current value)
+ * @return Previous umask value
+ */
+uint32_t mrb_hal_io_umask(mrb_state *mrb, int32_t mask);
+
+/**
+ * Truncate file to specified length
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor
+ * @param length New file length
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_ftruncate(mrb_state *mrb, int fd, int64_t length);
+
+/**
+ * Apply or remove advisory lock on file
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor
+ * @param operation Lock operation (MRB_IO_LOCK_*)
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_flock(mrb_state *mrb, int fd, int operation);
+
+/**
+ * Delete a file
+ *
+ * @param mrb mruby state
+ * @param path File path (UTF-8)
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_unlink(mrb_state *mrb, const char *path);
+
+/**
+ * Rename a file
+ *
+ * @param mrb mruby state
+ * @param oldpath Old file path (UTF-8)
+ * @param newpath New file path (UTF-8)
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_rename(mrb_state *mrb, const char *oldpath, const char *newpath);
+
+/**
+ * Create a symbolic link
+ *
+ * @param mrb mruby state
+ * @param target Target path (UTF-8)
+ * @param linkpath Link path (UTF-8)
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_symlink(mrb_state *mrb, const char *target, const char *linkpath);
+
+/**
+ * Read value of a symbolic link
+ *
+ * @param mrb mruby state
+ * @param path Symlink path (UTF-8)
+ * @param buf Buffer to store result (UTF-8)
+ * @param bufsize Buffer size
+ * @return Number of bytes placed in buf, -1 on error (sets errno)
+ */
+int64_t mrb_hal_io_readlink(mrb_state *mrb, const char *path, char *buf, size_t bufsize);
+
+/**
+ * Resolve pathname to absolute path
+ *
+ * @param mrb mruby state
+ * @param path Pathname (UTF-8)
+ * @param resolved Buffer for resolved path (must be at least PATH_MAX size)
+ * @return Pointer to resolved on success, NULL on error (sets errno)
+ */
+char* mrb_hal_io_realpath(mrb_state *mrb, const char *path, char *resolved);
+
+/**
+ * Get current working directory
+ *
+ * @param mrb mruby state
+ * @param buf Buffer to store result (UTF-8)
+ * @param size Buffer size
+ * @return Pointer to buf on success, NULL on error (sets errno)
+ */
+char* mrb_hal_io_getcwd(mrb_state *mrb, char *buf, size_t size);
+
+/**
+ * Get environment variable
+ *
+ * @param mrb mruby state
+ * @param name Variable name
+ * @return Value string (UTF-8) or NULL if not found
+ */
+const char* mrb_hal_io_getenv(mrb_state *mrb, const char *name);
+
+/**
+ * Get user's home directory
+ *
+ * @param mrb mruby state
+ * @param username User name (NULL for current user)
+ * @return Home directory path (UTF-8) or NULL on error (sets errno)
+ */
+const char* mrb_hal_io_gethome(mrb_state *mrb, const char *username);
+
+/*
+ * HAL Interface - Core I/O Operations
+ */
+
+/**
+ * Open file
+ *
+ * @param mrb mruby state
+ * @param path File path (UTF-8)
+ * @param flags Open flags (O_RDONLY, O_WRONLY, O_RDWR, etc.)
+ * @param mode Creation mode (used if O_CREAT is set)
+ * @return File descriptor on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_open(mrb_state *mrb, const char *path, int flags, uint32_t mode);
+
+/**
+ * Close file descriptor
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_close(mrb_state *mrb, int fd);
+
+/**
+ * Read from file descriptor
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor
+ * @param buf Buffer to store data
+ * @param count Maximum bytes to read
+ * @return Number of bytes read, 0 on EOF, -1 on error (sets errno)
+ */
+int64_t mrb_hal_io_read(mrb_state *mrb, int fd, void *buf, size_t count);
+
+/**
+ * Write to file descriptor
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor
+ * @param buf Data to write
+ * @param count Number of bytes to write
+ * @return Number of bytes written, -1 on error (sets errno)
+ */
+int64_t mrb_hal_io_write(mrb_state *mrb, int fd, const void *buf, size_t count);
+
+/**
+ * Reposition file offset
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor
+ * @param offset Offset value
+ * @param whence Reference point (MRB_IO_SEEK_SET/CUR/END)
+ * @return New offset from beginning of file, -1 on error (sets errno)
+ */
+int64_t mrb_hal_io_lseek(mrb_state *mrb, int fd, int64_t offset, int whence);
+
+/**
+ * Duplicate file descriptor
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor to duplicate
+ * @return New descriptor on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_dup(mrb_state *mrb, int fd);
+
+/**
+ * Manipulate file descriptor
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor
+ * @param cmd Command (F_GETFD, F_SETFD, etc.)
+ * @param arg Command argument
+ * @return Depends on command, -1 on error (sets errno)
+ */
+int mrb_hal_io_fcntl(mrb_state *mrb, int fd, int cmd, int arg);
+
+/**
+ * Check if descriptor refers to terminal
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor
+ * @return 1 if TTY, 0 if not, -1 on error (sets errno)
+ */
+int mrb_hal_io_isatty(mrb_state *mrb, int fd);
+
+/**
+ * Create pipe
+ *
+ * @param mrb mruby state
+ * @param fds Array to store two file descriptors [read_end, write_end]
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_pipe(mrb_state *mrb, int fds[2]);
+
+/*
+ * HAL Interface - Process Operations
+ */
+
+/**
+ * Spawn a new process
+ *
+ * Creates a new process and executes the command. File descriptors can be
+ * redirected for stdin/stdout/stderr (-1 means don't redirect).
+ *
+ * POSIX: Uses fork() + dup2() + execl()
+ * Windows: Uses CreateProcess() with STARTUPINFO
+ *
+ * @param mrb mruby state
+ * @param cmd Command to execute (shell command)
+ * @param stdin_fd File descriptor to use for stdin (-1 = don't redirect)
+ * @param stdout_fd File descriptor to use for stdout (-1 = don't redirect)
+ * @param stderr_fd File descriptor to use for stderr (-1 = don't redirect)
+ * @param pid Output parameter for process ID
+ * @return 0 on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_spawn_process(mrb_state *mrb, const char *cmd,
+                               int stdin_fd, int stdout_fd, int stderr_fd,
+                               int *pid);
+
+/**
+ * Wait for process to change state
+ *
+ * @param mrb mruby state
+ * @param pid Process ID to wait for
+ * @param status Output parameter for exit status
+ * @param options Wait options (0 for blocking wait)
+ * @return Process ID on success, -1 on error (sets errno)
+ */
+int mrb_hal_io_waitpid(mrb_state *mrb, int pid, int *status, int options);
+
+/*
+ * HAL Interface - I/O Multiplexing
+ */
+
+/**
+ * Allocate file descriptor set
+ *
+ * @param mrb mruby state
+ * @return Pointer to fdset or NULL on error
+ */
+mrb_io_fdset* mrb_hal_io_fdset_alloc(mrb_state *mrb);
+
+/**
+ * Free file descriptor set
+ *
+ * @param mrb mruby state
+ * @param fdset File descriptor set to free
+ */
+void mrb_hal_io_fdset_free(mrb_state *mrb, mrb_io_fdset *fdset);
+
+/**
+ * Clear file descriptor set
+ *
+ * @param mrb mruby state
+ * @param fdset File descriptor set
+ */
+void mrb_hal_io_fdset_zero(mrb_state *mrb, mrb_io_fdset *fdset);
+
+/**
+ * Add descriptor to set
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor
+ * @param fdset File descriptor set
+ */
+void mrb_hal_io_fdset_set(mrb_state *mrb, int fd, mrb_io_fdset *fdset);
+
+/**
+ * Check if descriptor is in set
+ *
+ * @param mrb mruby state
+ * @param fd File descriptor
+ * @param fdset File descriptor set
+ * @return Non-zero if fd is in set, 0 otherwise
+ */
+int mrb_hal_io_fdset_isset(mrb_state *mrb, int fd, mrb_io_fdset *fdset);
+
+/**
+ * Monitor multiple file descriptors
+ *
+ * @param mrb mruby state
+ * @param nfds Highest file descriptor number + 1
+ * @param readfds Set of descriptors to check for reading (NULL = ignore)
+ * @param writefds Set of descriptors to check for writing (NULL = ignore)
+ * @param errorfds Set of descriptors to check for errors (NULL = ignore)
+ * @param timeout Timeout (NULL = block indefinitely)
+ * @return Number of ready descriptors, 0 on timeout, -1 on error (sets errno)
+ */
+int mrb_hal_io_select(mrb_state *mrb, int nfds,
+                       mrb_io_fdset *readfds,
+                       mrb_io_fdset *writefds,
+                       mrb_io_fdset *errorfds,
+                       mrb_io_timeval *timeout);
+
+/*
+ * HAL Initialization/Finalization
+ */
+
+/**
+ * Initialize I/O HAL
+ *
+ * Called during gem initialization. Platform-specific HAL should perform
+ * any necessary setup here.
+ *
+ * @param mrb mruby state
+ */
+void mrb_hal_io_init(mrb_state *mrb);
+
+/**
+ * Finalize I/O HAL
+ *
+ * Called during gem finalization. Platform-specific HAL should perform
+ * any necessary cleanup here.
+ *
+ * @param mrb mruby state
+ */
+void mrb_hal_io_final(mrb_state *mrb);
+
+#endif /* MRUBY_IO_HAL_H */

data/vendor/mruby/include/mruby/gems/mruby-io/include/mruby/ext/io.h

@@ -0,0 +1,76 @@
+/*
+** io.h - IO class
+*/
+
+#ifndef MRUBY_IO_H
+#define MRUBY_IO_H
+
+#include <mruby.h>
+
+#ifdef MRB_NO_STDIO
+# error IO and File conflicts 'MRB_NO_STDIO' in your build configuration
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#if defined(MRB_NO_IO_PREAD_PWRITE) || defined(MRB_WITHOUT_IO_PREAD_PWRITE)
+# undef MRB_USE_IO_PREAD_PWRITE
+#elif !defined(MRB_USE_IO_PREAD_PWRITE)
+# if defined(__unix__) || defined(__MACH__) || defined(MRB_WITH_IO_PREAD_PWRITE)
+#  define MRB_USE_IO_PREAD_PWRITE
+# endif
+#endif
+
+#define MRB_IO_BUF_SIZE 4096
+
+struct mrb_io_buf {
+  short start;
+  short len;
+  char mem[MRB_IO_BUF_SIZE];
+};
+
+struct mrb_io {
+  unsigned int readable:1,
+               writable:1,
+               eof:1,
+               sync:1,
+               is_socket:1,
+               close_fd:1,
+               close_fd2:1;
+  int fd;   /* file descriptor, or -1 */
+  int fd2;  /* file descriptor to write if it's different from fd, or -1 */
+  int pid;  /* child's pid (for pipes)  */
+  struct mrb_io_buf *buf;
+};
+
+#define MRB_O_RDONLY            0x0000
+#define MRB_O_WRONLY            0x0001
+#define MRB_O_RDWR              0x0002
+#define MRB_O_ACCMODE           (MRB_O_RDONLY | MRB_O_WRONLY | MRB_O_RDWR)
+#define MRB_O_NONBLOCK          0x0004
+#define MRB_O_APPEND            0x0008
+#define MRB_O_SYNC              0x0010
+#define MRB_O_NOFOLLOW          0x0020
+#define MRB_O_CREAT             0x0040
+#define MRB_O_TRUNC             0x0080
+#define MRB_O_EXCL              0x0100
+#define MRB_O_NOCTTY            0x0200
+#define MRB_O_DIRECT            0x0400
+#define MRB_O_BINARY            0x0800
+#define MRB_O_SHARE_DELETE      0x1000
+#define MRB_O_TMPFILE           0x2000
+#define MRB_O_NOATIME           0x4000
+#define MRB_O_DSYNC             0x00008000
+#define MRB_O_RSYNC             0x00010000
+
+#define E_IO_ERROR              mrb_exc_get_id(mrb, MRB_ERROR_SYM(IOError))
+#define E_EOF_ERROR             mrb_exc_get_id(mrb, MRB_ERROR_SYM(EOFError))
+
+int mrb_io_fileno(mrb_state *mrb, mrb_value io);
+
+#if defined(__cplusplus)
+} /* extern "C" { */
+#endif
+#endif /* MRUBY_IO_H */