enclave 0.1.0

data/ext/enclave/mruby/mrbgems/mruby-io/include/mruby/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 {
+  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)  */
+  unsigned int readable:1,
+               writable:1,
+               eof:1,
+               sync:1,
+               is_socket:1,
+               close_fd:1,
+               close_fd2:1;
+  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 */

data/ext/enclave/mruby/mrbgems/mruby-io/mrbgem.rake

@@ -0,0 +1,34 @@
+MRuby::Gem::Specification.new('mruby-io') do |spec|
+  spec.license = 'MIT'
+  spec.authors = ['Internet Initiative Japan Inc.', 'mruby developers']
+  spec.summary = 'IO and File class'
+
+  spec.build.defines << "HAVE_MRUBY_IO_GEM"
+  spec.add_test_dependency 'mruby-time', core: 'mruby-time'
+
+  # Check if HAL gem is loaded
+  # HAL gems must be explicitly specified in build config (recommended) or via auto-selection below
+  spec.build.gems.one? { |g| g.name =~ /^hal-.*-io$/ } or begin
+    # No HAL found - determine appropriate error message or auto-load
+    suggested_hal = if spec.for_windows?
+      'hal-win-io'
+    elsif RUBY_PLATFORM =~ /linux|darwin|bsd/
+      'hal-posix-io'
+    else
+      nil
+    end
+
+    if suggested_hal
+      # Auto-load HAL gem for convenience (for development)
+      # This works because HAL gems declare dependency on mruby-io
+      warn "mruby-io: No HAL specified, loading #{suggested_hal} (explicit selection recommended)"
+      spec.build.gem core: suggested_hal
+    else
+      # Unknown platform - fail with helpful message
+      fail "mruby-io: No HAL available for platform '#{RUBY_PLATFORM}'.\n" \
+           "Please specify HAL gem explicitly in your build config:\n" \
+           "  conf.gem core: 'hal-posix-io'   # For Linux/macOS/BSD\n" \
+           "  conf.gem core: 'hal-win-io'     # For Windows"
+    end
+  end
+end

data/ext/enclave/mruby/mrbgems/mruby-io/mrblib/file.rb

@@ -0,0 +1,109 @@
+class File < IO
+  # The path to the file
+  attr_accessor :path
+
+  #
+  # call-seq:
+  #   File.new(filename, mode="r")            -> file
+  #   File.new(filename [, mode [, perm]])    -> file
+  #   File.new(fd [, mode])                   -> file
+  #
+  # Opens the file named by filename according to the given mode and returns
+  # a new File object. If a file descriptor is given instead of a filename,
+  # the new File object will be associated with that descriptor.
+  #
+  #   f = File.new("testfile", "r")
+  #   f = File.new("newfile",  "w+")
+  #   f = File.new("tmpfile",  "a")
+  #
+  def initialize(fd_or_path, mode = "r", perm = 0666)
+    if fd_or_path.kind_of? Integer
+      super(fd_or_path, mode)
+    else
+      @path = fd_or_path
+      fd = IO.sysopen(@path, mode, perm)
+      super(fd, mode)
+    end
+  end
+
+  #
+  # call-seq:
+  #   file.atime    -> time
+  #
+  # Returns the last access time for file, or epoch if the platform
+  # doesn't have access time.
+  #
+  #   File.new("testfile").atime   #=> Wed Apr 09 08:51:48 CDT 2003
+  #
+  def atime
+    t = self._atime
+    t && Time.at(t)
+  end
+
+  #
+  # call-seq:
+  #   file.ctime -> time
+  #
+  # Returns the change time for file (that is, the time directory
+  # information about the file was changed, not the file itself).
+  #
+  #   File.new("testfile").ctime   #=> Wed Apr 09 08:53:13 CDT 2003
+  #
+  def ctime
+    t = self._ctime
+    t && Time.at(t)
+  end
+
+  #
+  # call-seq:
+  #   file.mtime -> time
+  #
+  # Returns the modification time for file.
+  #
+  #   File.new("testfile").mtime   #=> Wed Apr 09 08:53:14 CDT 2003
+  #
+  def mtime
+    t = self._mtime
+    t && Time.at(t)
+  end
+
+  #
+  # call-seq:
+  #   file.inspect  -> string
+  #
+  # Return a string describing this File object.
+  #
+  #   File.new("testfile").inspect   #=> "#<File:testfile>"
+  #
+  def inspect
+    "<#{self.class}:#{@path}>"
+  end
+
+
+  #
+  # call-seq:
+  #   File.foreach(name) {|line| block }  -> nil
+  #   File.foreach(name)                  -> an_enumerator
+  #
+  # Executes the block for every line in the named I/O port, where lines
+  # are separated by sep.
+  #
+  #   File.foreach("testfile") {|x| print "GOT ", x }
+  #   GOT This is line one
+  #   GOT This is line two
+  #   GOT This is line three
+  #   GOT And so on...
+  #
+  def self.foreach(file)
+    if block_given?
+      self.open(file) do |f|
+        f.each {|l| yield l}
+      end
+    else
+      return self.new(file)
+    end
+  end
+
+
+
+end

data/ext/enclave/mruby/mrbgems/mruby-io/mrblib/file_constants.rb

@@ -0,0 +1,24 @@
+class File
+  # File name matching constants used with File.fnmatch and Dir.glob
+  module Constants
+    # Makes File.fnmatch case sensitive on systems where it's case insensitive by default
+    FNM_SYSCASE  = 0
+
+    # Disables the special meaning of the backslash escape character
+    FNM_NOESCAPE = 1
+
+    # Pathname wildcard doesn't match '/' (directory separator)
+    FNM_PATHNAME = 2
+
+    # Allows patterns to match hidden files (those starting with '.')
+    FNM_DOTMATCH = 4
+
+    # Makes the pattern case insensitive (overrides FNM_SYSCASE)
+    FNM_CASEFOLD = 8
+  end
+end
+
+class File
+  # Include Constants module to make FNM_* constants available directly on File class
+  include File::Constants
+end

data/ext/enclave/mruby/mrbgems/mruby-io/mrblib/io.rb

@@ -0,0 +1,303 @@
+##
+# IO
+#
+# ISO 15.2.20
+
+class IOError < StandardError; end
+class EOFError < IOError; end
+
+class IO
+  #
+  # call-seq:
+  #   IO.open(fd, mode="r" [, opt])                -> io
+  #   IO.open(fd, mode="r" [, opt]) {|io| block }  -> obj
+  #
+  # With no associated block, IO.open is a synonym for IO.new. If the optional
+  # code block is given, it will be passed io as an argument, and the IO object
+  # will automatically be closed when the block terminates. In this instance,
+  # IO.open returns the value of the block.
+  #
+  #   fd = IO.sysopen("/dev/tty", "w")
+  #   a = IO.open(fd,"w")
+  #   $stderr.puts "Hello"
+  #   a.close
+  #
+  def self.open(*args, &block)
+    io = self.new(*args)
+
+    return io unless block
+
+    begin
+      yield io
+    ensure
+      begin
+        io.close unless io.closed?
+      rescue StandardError
+      end
+    end
+  end
+
+  #
+  # call-seq:
+  #   IO.popen(cmd, mode="r" [, opt])               -> io
+  #   IO.popen(cmd, mode="r" [, opt]) {|io| block } -> obj
+  #
+  # Runs the specified command as a subprocess; the subprocess's standard input
+  # and output will be connected to the returned IO object.
+  #
+  #   p IO.popen("date").read   #=> "Wed Apr  9 08:56:30 CDT 2003\n"
+  #   IO.popen("dc", "r+") {|f|
+  #     f.puts "5 2 *"
+  #     f.close_write
+  #     puts f.read
+  #   }
+  #
+  def self.popen(command, mode = 'r', **opts, &block)
+    if !self.respond_to?(:_popen)
+      raise NotImplementedError, "popen is not supported on this platform"
+    end
+    io = self._popen(command, mode, **opts)
+    return io unless block
+
+    begin
+      yield io
+    ensure
+      begin
+        io.close unless io.closed?
+      rescue IOError
+        # nothing
+      end
+    end
+  end
+
+  #
+  # call-seq:
+  #   IO.pipe                    -> [read_io, write_io]
+  #   IO.pipe {|read_io, write_io| ... } -> obj
+  #
+  # Creates a pair of pipe endpoints (connected to each other) and returns
+  # them as a two-element array of IO objects: [read_io, write_io].
+  #
+  #   rd, wr = IO.pipe
+  #   if fork
+  #     wr.close
+  #     puts rd.read
+  #     rd.close
+  #     Process.wait
+  #   else
+  #     rd.close
+  #     wr.write "Hello, parent!"
+  #     wr.close
+  #     exit
+  #   end
+  #
+  def self.pipe(&block)
+    if !self.respond_to?(:_pipe)
+      raise NotImplementedError, "pipe is not supported on this platform"
+    end
+    if block
+      begin
+        r, w = IO._pipe
+        yield r, w
+      ensure
+        r.close unless r.closed?
+        w.close unless w.closed?
+      end
+    else
+      IO._pipe
+    end
+  end
+
+  #
+  # call-seq:
+  #   IO.read(name, [length [, offset]] )   -> string
+  #   IO.read(name, [length [, offset]], mode: mode)   -> string
+  #
+  # Opens the file, optionally seeks to the given offset, then returns length
+  # bytes (defaulting to the rest of the file). read ensures the file is
+  # closed before returning.
+  #
+  #   IO.read("testfile")           #=> "This is line one\nThis is line two\n"
+  #   IO.read("testfile", 20)       #=> "This is line one\nTh"
+  #   IO.read("testfile", 20, 10)   #=> "ne one\nThis is line "
+  #
+  def self.read(path, length=nil, offset=0, mode: "r")
+    str = ""
+    fd = -1
+    io = nil
+    begin
+      fd = IO.sysopen(path, mode)
+      io = IO.open(fd, mode)
+      io.seek(offset) if offset > 0
+      str = io.read(length)
+    ensure
+      if io
+        io.close
+      elsif fd != -1
+        IO._sysclose(fd)
+      end
+    end
+    str
+  end
+
+
+
+  #
+  # call-seq:
+  #   ios.hash   -> integer
+  #
+  # Compute a hash based on the IO object. Two IO objects with the same
+  # content will have the same hash code (and will compare using eql?).
+  # We must define IO#hash here because IO includes Enumerable and
+  # Enumerable#hash will call IO#read() otherwise.
+  #
+  def hash
+    # We must define IO#hash here because IO includes Enumerable and
+    # Enumerable#hash will call IO#read() otherwise
+    self.__id__
+  end
+
+
+  # Alias for eof?
+  alias_method :eof, :eof?
+  # Alias for pos
+  alias_method :tell, :pos
+
+  #
+  # call-seq:
+  #   ios.pos = integer    -> integer
+  #
+  # Seeks to the given position (in bytes) in ios. It is not guaranteed that
+  # seeking to the right position when ios is textmode.
+  #
+  #   f = File.new("testfile")
+  #   f.pos = 17
+  #   f.gets   #=> "This is line two\n"
+  #
+  def pos=(i)
+    seek(i, SEEK_SET)
+  end
+
+  #
+  # call-seq:
+  #   ios.rewind    -> 0
+  #
+  # Positions ios to the beginning of input, resetting lineno to zero.
+  #
+  #   f = File.new("testfile")
+  #   f.readline   #=> "This is line one\n"
+  #   f.rewind     #=> 0
+  #   f.lineno     #=> 0
+  #   f.readline   #=> "This is line one\n"
+  #
+  def rewind
+    seek(0, SEEK_SET)
+  end
+
+
+  #
+  # call-seq:
+  #   ios.each(sep=$/) {|line| block }         -> ios
+  #   ios.each(limit) {|line| block }          -> ios
+  #   ios.each(sep,limit) {|line| block }      -> ios
+  #   ios.each(...)                            -> an_enumerator
+  #
+  # Executes the block for every line in ios, where lines are separated by sep.
+  # ios must be opened for reading. If no block is given, an enumerator is returned instead.
+  #
+  #   f = File.new("testfile")
+  #   f.each {|line| puts "#{f.lineno}: #{line}" }
+  #
+  # 15.2.20.5.3
+  def each(&block)
+    return to_enum(:each) unless block
+
+    while line = self.gets
+      block.call(line)
+    end
+    self
+  end
+
+  #
+  # call-seq:
+  #   ios.each_byte {|byte| block }  -> ios
+  #   ios.each_byte                  -> an_enumerator
+  #
+  # Calls the given block once for each byte (0..255) in ios, passing the byte
+  # as an argument. The stream must be opened for reading or an IOError will be raised.
+  #
+  #   f = File.new("testfile")
+  #   checksum = 0
+  #   f.each_byte {|x| checksum ^= x }   #=> #<File:testfile>
+  #   checksum                           #=> 12
+  #
+  # 15.2.20.5.4
+  def each_byte(&block)
+    return to_enum(:each_byte) unless block
+
+    while byte = self.getbyte
+      block.call(byte)
+    end
+    self
+  end
+
+  # Alias for each - 15.2.20.5.5
+  alias each_line each
+
+  #
+  # call-seq:
+  #   ios.each_char {|c| block }  -> ios
+  #   ios.each_char               -> an_enumerator
+  #
+  # Calls the given block once for each character in ios, passing the character
+  # as an argument. The stream must be opened for reading or an IOError will be raised.
+  #
+  #   f = File.new("testfile")
+  #   ios.each_char {|c| print c, ' ' }   #=> #<File:testfile>
+  #
+  def each_char(&block)
+    return to_enum(:each_char) unless block
+
+    while char = self.getc
+      block.call(char)
+    end
+    self
+  end
+
+
+
+  #
+  # call-seq:
+  #   ios.printf(format_string [, obj, ...])    -> nil
+  #
+  # Formats and writes to ios, converting parameters under control of the format string.
+  # See sprintf for details of the format string.
+  #
+  #   $stdout.printf "Number: %5.2f,\nString: %s\n", 1.23, "hello"
+  #   Number:  1.23,
+  #   String: hello
+  #
+  def printf(*args)
+    write sprintf(*args)
+    nil
+  end
+
+  # Alias for fileno - returns the integer file descriptor for ios
+  alias_method :to_i, :fileno
+  # Alias for isatty - returns true if ios is associated with a terminal device
+  alias_method :tty?, :isatty
+end
+
+# Standard input stream - connected to file descriptor 0
+STDIN  = IO.open(0, "r")
+# Standard output stream - connected to file descriptor 1
+STDOUT = IO.open(1, "w")
+# Standard error stream - connected to file descriptor 2
+STDERR = IO.open(2, "w")
+
+# Global variable for standard input
+$stdin  = STDIN
+# Global variable for standard output
+$stdout = STDOUT
+# Global variable for standard error
+$stderr = STDERR