mruby-io: use mrb_int consistently in IO HAL interface

Replace all int64_t, uint64_t, uint32_t, and int32_t with mrb_int
in the HAL struct, timeval, and function signatures. All values
originate from or end up as mrb_int at the Ruby layer. Also removes
dead overflow checks in callers and the stdint.h dependency from
io_hal.h.

Co-authored-by: Claude <noreply@anthropic.com>

mrbgems/hal-posix-io/src/io_hal.c

@@ -67,25 +67,25 @@ convert_stat(const struct stat *src, mrb_io_stat *dst)
 #undef st_mtime
 #undef st_ctime
 
-  dst->st_dev = (uint64_t)src->st_dev;
-  dst->st_ino = (uint64_t)src->st_ino;
-  dst->st_mode = (uint32_t)src->st_mode;
-  dst->st_nlink = (uint32_t)src->st_nlink;
-  dst->st_uid = (uint32_t)src->st_uid;
-  dst->st_gid = (uint32_t)src->st_gid;
-  dst->st_rdev = (uint64_t)src->st_rdev;
-  dst->st_size = (int64_t)src->st_size;
-  dst->st_atime = (int64_t)atime_val;
-  dst->st_mtime = (int64_t)mtime_val;
-  dst->st_ctime = (int64_t)ctime_val;
+  dst->st_dev = (mrb_int)src->st_dev;
+  dst->st_ino = (mrb_int)src->st_ino;
+  dst->st_mode = (mrb_int)src->st_mode;
+  dst->st_nlink = (mrb_int)src->st_nlink;
+  dst->st_uid = (mrb_int)src->st_uid;
+  dst->st_gid = (mrb_int)src->st_gid;
+  dst->st_rdev = (mrb_int)src->st_rdev;
+  dst->st_size = (mrb_int)src->st_size;
+  dst->st_atime = (mrb_int)atime_val;
+  dst->st_mtime = (mrb_int)mtime_val;
+  dst->st_ctime = (mrb_int)ctime_val;
 
 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
-  dst->st_blksize = (int64_t)src->st_blksize;
+  dst->st_blksize = (mrb_int)src->st_blksize;
 #else
   dst->st_blksize = 512;
 #endif
 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
-  dst->st_blocks = (int64_t)src->st_blocks;
+  dst->st_blocks = (mrb_int)src->st_blocks;
 #else
   dst->st_blocks = (dst->st_size + 511) / 512;
 #endif
@@ -135,14 +135,14 @@ mrb_hal_io_lstat(mrb_state *mrb, const char *path, mrb_io_stat *st)
 }
 
 int
-mrb_hal_io_chmod(mrb_state *mrb, const char *path, uint32_t mode)
+mrb_hal_io_chmod(mrb_state *mrb, const char *path, mrb_int mode)
 {
   (void)mrb;
   return chmod(path, (mode_t)mode);
 }
 
-uint32_t
-mrb_hal_io_umask(mrb_state *mrb, int32_t mask)
+mrb_int
+mrb_hal_io_umask(mrb_state *mrb, mrb_int mask)
 {
   mode_t old;
   (void)mrb;
@@ -155,11 +155,11 @@ mrb_hal_io_umask(mrb_state *mrb, int32_t mask)
   else {
     old = umask((mode_t)mask);
   }
-  return (uint32_t)old;
+  return (mrb_int)old;
 }
 
 int
-mrb_hal_io_ftruncate(mrb_state *mrb, int fd, int64_t length)
+mrb_hal_io_ftruncate(mrb_state *mrb, int fd, mrb_int length)
 {
   (void)mrb;
   return ftruncate(fd, (off_t)length);
@@ -259,7 +259,7 @@ mrb_hal_io_gethome(mrb_state *mrb, const char *username)
  */
 
 int
-mrb_hal_io_open(mrb_state *mrb, const char *path, int flags, uint32_t mode)
+mrb_hal_io_open(mrb_state *mrb, const char *path, int flags, mrb_int mode)
 {
   int fd;
   (void)mrb;
@@ -289,30 +289,23 @@ mrb_hal_io_close(mrb_state *mrb, int fd)
   return close(fd);
 }
 
-int64_t
+mrb_int
 mrb_hal_io_read(mrb_state *mrb, int fd, void *buf, size_t count)
 {
-  ssize_t n;
   (void)mrb;
-
-  n = read(fd, buf, count);
-  return (int64_t)n;
+  return (mrb_int)read(fd, buf, count);
 }
 
-int64_t
+mrb_int
 mrb_hal_io_write(mrb_state *mrb, int fd, const void *buf, size_t count)
 {
-  ssize_t n;
   (void)mrb;
-
-  n = write(fd, buf, count);
-  return (int64_t)n;
+  return (mrb_int)write(fd, buf, count);
 }
 
-int64_t
-mrb_hal_io_lseek(mrb_state *mrb, int fd, int64_t offset, int whence)
+mrb_int
+mrb_hal_io_lseek(mrb_state *mrb, int fd, mrb_int offset, int whence)
 {
-  off_t pos;
   int posix_whence;
   (void)mrb;
 
@@ -326,8 +319,7 @@ mrb_hal_io_lseek(mrb_state *mrb, int fd, int64_t offset, int whence)
       return -1;
   }
 
-  pos = lseek(fd, (off_t)offset, posix_whence);
-  return (int64_t)pos;
+  return (mrb_int)lseek(fd, (off_t)offset, posix_whence);
 }
 
 int

mrbgems/hal-win-io/src/io_hal.c

@@ -34,17 +34,17 @@
 static void
 convert_stat(const struct _stat64 *src, mrb_io_stat *dst)
 {
-  dst->st_dev = (uint64_t)src->st_dev;
-  dst->st_ino = (uint64_t)src->st_ino;
-  dst->st_mode = (uint32_t)src->st_mode;
-  dst->st_nlink = (uint32_t)src->st_nlink;
+  dst->st_dev = (mrb_int)src->st_dev;
+  dst->st_ino = (mrb_int)src->st_ino;
+  dst->st_mode = (mrb_int)src->st_mode;
+  dst->st_nlink = (mrb_int)src->st_nlink;
   dst->st_uid = 0;  /* Windows doesn't have Unix-style UIDs */
   dst->st_gid = 0;  /* Windows doesn't have Unix-style GIDs */
-  dst->st_rdev = (uint64_t)src->st_rdev;
-  dst->st_size = (int64_t)src->st_size;
-  dst->st_atime = (int64_t)src->st_atime;
-  dst->st_mtime = (int64_t)src->st_mtime;
-  dst->st_ctime = (int64_t)src->st_ctime;
+  dst->st_rdev = (mrb_int)src->st_rdev;
+  dst->st_size = (mrb_int)src->st_size;
+  dst->st_atime = (mrb_int)src->st_atime;
+  dst->st_mtime = (mrb_int)src->st_mtime;
+  dst->st_ctime = (mrb_int)src->st_ctime;
   dst->st_blksize = 512;
   dst->st_blocks = (dst->st_size + 511) / 512;
 }
@@ -114,14 +114,14 @@ mrb_hal_io_lstat(mrb_state *mrb, const char *path, mrb_io_stat *st)
 }
 
 int
-mrb_hal_io_chmod(mrb_state *mrb, const char *path, uint32_t mode)
+mrb_hal_io_chmod(mrb_state *mrb, const char *path, mrb_int mode)
 {
   (void)mrb;
   return _chmod(path, (int)mode);
 }
 
-uint32_t
-mrb_hal_io_umask(mrb_state *mrb, int32_t mask)
+mrb_int
+mrb_hal_io_umask(mrb_state *mrb, mrb_int mask)
 {
   int old;
   (void)mrb;
@@ -134,14 +134,14 @@ mrb_hal_io_umask(mrb_state *mrb, int32_t mask)
   else {
     old = _umask((int)mask);
   }
-  return (uint32_t)old;
+  return (mrb_int)old;
 }
 
 int
-mrb_hal_io_ftruncate(mrb_state *mrb, int fd, int64_t length)
+mrb_hal_io_ftruncate(mrb_state *mrb, int fd, mrb_int length)
 {
   (void)mrb;
-  return _chsize_s(fd, length);
+  return _chsize_s(fd, (__int64)length);
 }
 
 int
@@ -280,7 +280,7 @@ mrb_hal_io_gethome(mrb_state *mrb, const char *username)
  */
 
 int
-mrb_hal_io_open(mrb_state *mrb, const char *path, int flags, uint32_t mode)
+mrb_hal_io_open(mrb_state *mrb, const char *path, int flags, mrb_int mode)
 {
   int fd;
   (void)mrb;
@@ -306,30 +306,23 @@ mrb_hal_io_close(mrb_state *mrb, int fd)
   return _close(fd);
 }
 
-int64_t
+mrb_int
 mrb_hal_io_read(mrb_state *mrb, int fd, void *buf, size_t count)
 {
-  int n;
   (void)mrb;
-
-  n = _read(fd, buf, (unsigned int)count);
-  return (int64_t)n;
+  return (mrb_int)_read(fd, buf, (unsigned int)count);
 }
 
-int64_t
+mrb_int
 mrb_hal_io_write(mrb_state *mrb, int fd, const void *buf, size_t count)
 {
-  int n;
   (void)mrb;
-
-  n = _write(fd, buf, (unsigned int)count);
-  return (int64_t)n;
+  return (mrb_int)_write(fd, buf, (unsigned int)count);
 }
 
-int64_t
-mrb_hal_io_lseek(mrb_state *mrb, int fd, int64_t offset, int whence)
+mrb_int
+mrb_hal_io_lseek(mrb_state *mrb, int fd, mrb_int offset, int whence)
 {
-  __int64 pos;
   int win_whence;
   (void)mrb;
 
@@ -343,8 +336,7 @@ mrb_hal_io_lseek(mrb_state *mrb, int fd, int64_t offset, int whence)
       return -1;
   }
 
-  pos = _lseeki64(fd, (__int64)offset, win_whence);
-  return (int64_t)pos;
+  return (mrb_int)_lseeki64(fd, (__int64)offset, win_whence);
 }
 
 int

mrbgems/mruby-io/include/io_hal.h

@@ -12,7 +12,6 @@
 #define MRUBY_IO_HAL_H
 
 #include <mruby.h>
-#include <stdint.h>
 
 /*
  * Platform-independent type definitions
@@ -20,25 +19,25 @@
 
 /* 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_int st_dev;       /* Device ID */
+  mrb_int st_ino;       /* Inode number */
+  mrb_int st_mode;      /* File mode/permissions */
+  mrb_int st_nlink;     /* Number of hard links */
+  mrb_int st_uid;       /* User ID */
+  mrb_int st_gid;       /* Group ID */
+  mrb_int st_rdev;      /* Device ID (if special file) */
+  mrb_int  st_size;      /* File size in bytes */
+  mrb_int  st_atime;     /* Last access time */
+  mrb_int  st_mtime;     /* Last modification time */
+  mrb_int  st_ctime;     /* Last status change time */
+  mrb_int  st_blksize;   /* Block size for filesystem I/O */
+  mrb_int  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_int tv_sec;        /* Seconds */
+  mrb_int tv_usec;       /* Microseconds */
 } mrb_io_timeval;
 
 /* File descriptor set for select() */
@@ -120,7 +119,7 @@ int mrb_hal_io_lstat(mrb_state *mrb, const char *path, mrb_io_stat *st);
  * @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);
+int mrb_hal_io_chmod(mrb_state *mrb, const char *path, mrb_int mode);
 
 /**
  * Set/get file creation mask
@@ -129,7 +128,7 @@ int mrb_hal_io_chmod(mrb_state *mrb, const char *path, uint32_t mode);
  * @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);
+mrb_int mrb_hal_io_umask(mrb_state *mrb, mrb_int mask);
 
 /**
  * Truncate file to specified length
@@ -139,7 +138,7 @@ uint32_t mrb_hal_io_umask(mrb_state *mrb, int32_t mask);
  * @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);
+int mrb_hal_io_ftruncate(mrb_state *mrb, int fd, mrb_int length);
 
 /**
  * Apply or remove advisory lock on file
@@ -242,7 +241,7 @@ const char* mrb_hal_io_gethome(mrb_state *mrb, const char *username);
  * @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);
+int mrb_hal_io_open(mrb_state *mrb, const char *path, int flags, mrb_int mode);
 
 /**
  * Close file descriptor
@@ -262,7 +261,7 @@ int mrb_hal_io_close(mrb_state *mrb, int fd);
  * @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);
+mrb_int mrb_hal_io_read(mrb_state *mrb, int fd, void *buf, size_t count);
 
 /**
  * Write to file descriptor
@@ -273,7 +272,7 @@ int64_t mrb_hal_io_read(mrb_state *mrb, int fd, void *buf, size_t count);
  * @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);
+mrb_int mrb_hal_io_write(mrb_state *mrb, int fd, const void *buf, size_t count);
 
 /**
  * Reposition file offset
@@ -284,7 +283,7 @@ int64_t mrb_hal_io_write(mrb_state *mrb, int fd, const void *buf, size_t count);
  * @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);
+mrb_int mrb_hal_io_lseek(mrb_state *mrb, int fd, mrb_int offset, int whence);
 
 /**
  * Duplicate file descriptor

mrbgems/mruby-io/src/file.c

@@ -114,14 +114,13 @@
 static mrb_value
 mrb_file_s_umask(mrb_state *mrb, mrb_value klass)
 {
-  mrb_int mask;
-  uint32_t omask;
+  mrb_int mask, omask;
 
   if (mrb_get_args(mrb, "|i", &mask) == 0) {
     omask = mrb_hal_io_umask(mrb, -1);
   }
   else {
-    omask = mrb_hal_io_umask(mrb, (int32_t)mask);
+    omask = mrb_hal_io_umask(mrb, mask);
   }
   return mrb_fixnum_value(omask);
 }
@@ -658,18 +657,6 @@ mrb_file_absolute_path_p(mrb_state *mrb, mrb_value klass)
   return mrb_bool_value(path_absolute_p(RSTRING_CSTR(mrb, path)));
 }
 
-#define TIME_OVERFLOW_P(a) (sizeof(time_t) >= sizeof(mrb_int) && ((a) > MRB_INT_MAX || (a) < MRB_INT_MIN))
-#define TIME_T_UINT (~(time_t)0 > 0)
-#if defined(MRB_USE_BITINT)
-#define TIME_BIGTIME(mrb, a)                                                   \
-  return (TIME_T_UINT ? mrb_bint_new_uint64((mrb), (uint64_t)(a))              \
-               : mrb_bint_new_int64(mrb, (int64_t)(a)))
-#elif !defined(MRB_NO_FLOAT)
-#define TIME_BIGTIME(mrb,a) return mrb_float_value((mrb), (mrb_float)(a))
-#else
-#define TIME_BIGTIME(mrb, a) mrb_raise(mrb, E_IO_ERROR, #a " overflow")
-#endif
-
 static mrb_value
 mrb_file_atime(mrb_state *mrb, mrb_value self)
 {
@@ -679,10 +666,7 @@ mrb_file_atime(mrb_state *mrb, mrb_value self)
   mrb->c->ci->mid = 0;
   if (mrb_hal_io_fstat(mrb, fd, &st) == -1)
     mrb_sys_fail(mrb, "atime");
-  if (TIME_OVERFLOW_P(st.st_atime)) {
-    TIME_BIGTIME(mrb, st.st_atime);
-  }
-  return mrb_int_value(mrb, (mrb_int)st.st_atime);
+  return mrb_int_value(mrb, st.st_atime);
 }
 
 static mrb_value
@@ -694,10 +678,7 @@ mrb_file_ctime(mrb_state *mrb, mrb_value self)
   mrb->c->ci->mid = 0;
   if (mrb_hal_io_fstat(mrb, fd, &st) == -1)
     mrb_sys_fail(mrb, "ctime");
-  if (TIME_OVERFLOW_P(st.st_ctime)) {
-    TIME_BIGTIME(mrb, st.st_ctime);
-  }
-  return mrb_int_value(mrb, (mrb_int)st.st_ctime);
+  return mrb_int_value(mrb, st.st_ctime);
 }
 
 static mrb_value
@@ -709,10 +690,7 @@ mrb_file_mtime(mrb_state *mrb, mrb_value self)
   mrb->c->ci->mid = 0;
   if (mrb_hal_io_fstat(mrb, fd, &st) == -1)
     mrb_sys_fail(mrb, "mtime");
-  if (TIME_OVERFLOW_P(st.st_mtime)) {
-    TIME_BIGTIME(mrb, st.st_mtime);
-  }
-  return mrb_int_value(mrb, (mrb_int)st.st_mtime);
+  return mrb_int_value(mrb, st.st_mtime);
 }
 
 /*
@@ -775,22 +753,13 @@ mrb_file_size(mrb_state *mrb, mrb_value self)
   if (mrb_hal_io_fstat(mrb, fd, &st) == -1) {
     mrb_sys_fail(mrb, "fstat");
   }
-
-  if (sizeof(st.st_size) >= sizeof(mrb_int) && st.st_size > MRB_INT_MAX) {
-#ifdef MRB_NO_FLOAT
-    mrb_raise(mrb, E_RUNTIME_ERROR, "File#size too large for MRB_NO_FLOAT");
-#else
-    return mrb_float_value(mrb, (mrb_float)st.st_size);
-#endif
-  }
-
-  return mrb_int_value(mrb, (mrb_int)st.st_size);
+  return mrb_int_value(mrb, st.st_size);
 }
 
 static int
 mrb_ftruncate(mrb_state *mrb, int fd, mrb_int length)
 {
-  return mrb_hal_io_ftruncate(mrb, fd, (int64_t)length);
+  return mrb_hal_io_ftruncate(mrb, fd, length);
 }
 
 /*
@@ -865,7 +834,7 @@ mrb_file_s_chmod(mrb_state *mrb, mrb_value klass)
     mrb_ensure_string_type(mrb, filenames[i]);
     const char *utf8_path = RSTRING_CSTR(mrb, filenames[i]);
     char *path = mrb_locale_from_utf8(utf8_path, -1);
-    if (mrb_hal_io_chmod(mrb, path, (uint32_t)mode) == -1) {
+    if (mrb_hal_io_chmod(mrb, path, mode) == -1) {
       mrb_locale_free(path);
       mrb_sys_fail(mrb, utf8_path);
     }

mrbgems/mruby-io/src/file_test.c

@@ -20,23 +20,6 @@
 
 extern struct mrb_data_type mrb_io_type;
 
-/* Helper function to convert int64_t to mrb_value with overflow handling */
-static mrb_value
-mrb_int64_value(mrb_state *mrb, int64_t val)
-{
-  if (sizeof(val) >= sizeof(mrb_int) && val > MRB_INT_MAX) {
-#ifdef MRB_USE_BIGINT
-    return mrb_bint_new_int64(mrb, val);
-#elif !defined(MRB_NO_FLOAT)
-    return mrb_float_value(mrb, (mrb_float)val);
-#else
-    mrb_raise(mrb, E_RANGE_ERROR, "value too large for this platform");
-#endif
-  }
-
-  return mrb_int_value(mrb, (mrb_int)val);
-}
-
 static int
 mrb_stat0(mrb_state *mrb, mrb_value obj, mrb_io_stat *st, int do_lstat)
 {
@@ -340,7 +323,7 @@ mrb_filetest_s_size(mrb_state *mrb, mrb_value klass)
   if (mrb_stat(mrb, obj, &st) < 0)
     mrb_sys_fail(mrb, "mrb_stat");
 
-  return mrb_int64_value(mrb, st.st_size);
+  return mrb_int_value(mrb, st.st_size);
 }
 
 /*
@@ -366,7 +349,7 @@ mrb_filetest_s_size_p(mrb_state *mrb, mrb_value klass)
   if (st.st_size == 0)
     return mrb_nil_value();
 
-  return mrb_int64_value(mrb, st.st_size);
+  return mrb_int_value(mrb, st.st_size);
 }
 
 void

mrbgems/mruby-io/src/io.c

@@ -1268,14 +1268,14 @@ time2timeval(mrb_state *mrb, mrb_value time)
 
   switch (mrb_type(time)) {
     case MRB_TT_INTEGER:
-      t.tv_sec = (int64_t)mrb_integer(time);
+      t.tv_sec = mrb_integer(time);
       t.tv_usec = 0;
       break;
 
 #ifndef MRB_NO_FLOAT
     case MRB_TT_FLOAT:
-      t.tv_sec = (int64_t)mrb_float(time);
-      t.tv_usec = (int64_t)((mrb_float(time) - t.tv_sec) * 1000000.0);
+      t.tv_sec = (mrb_int)mrb_float(time);
+      t.tv_usec = (mrb_int)((mrb_float(time) - t.tv_sec) * 1000000.0);
       break;
 #endif