Fresh start

7 files changed, 1458 insertions, 0 deletions

diff --git a/jni/ruby/lib/shell/builtin-command.rb b/jni/ruby/lib/shell/builtin-command.rb
new file mode 100644
index 0000000..8e549dd
--- /dev/null
+++ b/jni/ruby/lib/shell/builtin-command.rb
@@ -0,0 +1,146 @@
+#
+#   shell/builtin-command.rb -
+#       $Release Version: 0.7 $
+#       $Revision: 47246 $
+#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require "shell/filter"
+
+class Shell
+  class BuiltInCommand<Filter
+    def wait?
+      false
+    end
+    def active?
+      true
+    end
+  end
+
+  class Void < BuiltInCommand
+    def initialize(sh, *opts)
+      super sh
+    end
+
+    def each(rs = nil)
+      # do nothing
+    end
+  end
+
+  class Echo < BuiltInCommand
+    def initialize(sh, *strings)
+      super sh
+      @strings = strings
+    end
+
+    def each(rs = nil)
+      rs =  @shell.record_separator unless rs
+      for str  in @strings
+        yield str + rs
+      end
+    end
+  end
+
+  class Cat < BuiltInCommand
+    def initialize(sh, *filenames)
+      super sh
+      @cat_files = filenames
+    end
+
+    def each(rs = nil)
+      if @cat_files.empty?
+        super
+      else
+        for src in @cat_files
+          @shell.foreach(src, rs){|l| yield l}
+        end
+      end
+    end
+  end
+
+  class Glob < BuiltInCommand
+    def initialize(sh, pattern)
+      super sh
+
+      @pattern = pattern
+    end
+
+    def each(rs = nil)
+      if @pattern[0] == ?/
+        @files = Dir[@pattern]
+      else
+        prefix = @shell.pwd+"/"
+        @files = Dir[prefix+@pattern].collect{|p| p.sub(prefix, "")}
+      end
+      rs =  @shell.record_separator unless rs
+      for f in @files
+        yield f+rs
+      end
+    end
+  end
+
+  class AppendIO < BuiltInCommand
+    def initialize(sh, io, filter)
+      super sh
+      @input = filter
+      @io = io
+    end
+
+    def input=(filter)
+      @input.input=filter
+      for l in @input
+        @io << l
+      end
+    end
+
+  end
+
+  class AppendFile < AppendIO
+    def initialize(sh, to_filename, filter)
+      @file_name = to_filename
+      io = sh.open(to_filename, "a")
+      super(sh, io, filter)
+    end
+
+    def input=(filter)
+      begin
+        super
+      ensure
+        @io.close
+      end
+    end
+  end
+
+  class Tee < BuiltInCommand
+    def initialize(sh, filename)
+      super sh
+      @to_filename = filename
+    end
+
+    def each(rs = nil)
+      to = @shell.open(@to_filename, "w")
+      begin
+        super{|l| to << l; yield l}
+      ensure
+        to.close
+      end
+    end
+  end
+
+  class Concat < BuiltInCommand
+    def initialize(sh, *jobs)
+      super(sh)
+      @jobs = jobs
+    end
+
+    def each(rs = nil)
+      while job = @jobs.shift
+        job.each{|l| yield l}
+      end
+    end
+  end
+end
diff --git a/jni/ruby/lib/shell/command-processor.rb b/jni/ruby/lib/shell/command-processor.rb
new file mode 100644
index 0000000..488ed93
--- /dev/null
+++ b/jni/ruby/lib/shell/command-processor.rb
@@ -0,0 +1,667 @@
+#
+#   shell/command-controller.rb -
+#       $Release Version: 0.7 $
+#       $Revision: 47246 $
+#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require "e2mmap"
+require "thread"
+
+require "shell/error"
+require "shell/filter"
+require "shell/system-command"
+require "shell/builtin-command"
+
+class Shell
+  # In order to execute a command on your OS, you need to define it as a
+  # Shell method.
+  #
+  # Alternatively, you can execute any command via
+  # Shell::CommandProcessor#system even if it is not defined.
+  class CommandProcessor
+
+    #
+    # initialize of Shell and related classes.
+    #
+    m = [:initialize, :expand_path]
+    if Object.methods.first.kind_of?(String)
+      NoDelegateMethods = m.collect{|x| x.id2name}
+    else
+      NoDelegateMethods = m
+    end
+
+    def self.initialize
+
+      install_builtin_commands
+
+      # define CommandProcessor#methods to Shell#methods and Filter#methods
+      for m in CommandProcessor.instance_methods(false) - NoDelegateMethods
+        add_delegate_command_to_shell(m)
+      end
+
+      def self.method_added(id)
+        add_delegate_command_to_shell(id)
+      end
+    end
+
+    #
+    # include run file.
+    #
+    def self.run_config
+      begin
+        load File.expand_path("~/.rb_shell") if ENV.key?("HOME")
+      rescue LoadError, Errno::ENOENT
+      rescue
+        print "load error: #{rc}\n"
+        print $!.class, ": ", $!, "\n"
+        for err in $@[0, $@.size - 2]
+          print "\t", err, "\n"
+        end
+      end
+    end
+
+    def initialize(shell)
+      @shell = shell
+      @system_commands = {}
+    end
+
+    #
+    # CommandProcessor#expand_path(path)
+    #     path:   String
+    #     return: String
+    #   returns the absolute path for <path>
+    #
+    def expand_path(path)
+      @shell.expand_path(path)
+    end
+
+    # call-seq:
+    #   foreach(path, record_separator) -> Enumerator
+    #   foreach(path, record_separator) { block }
+    #
+    # See IO.foreach when +path+ is a file.
+    #
+    # See Dir.foreach when +path+ is a directory.
+    #
+    def foreach(path = nil, *rs)
+      path = "." unless path
+      path = expand_path(path)
+
+      if File.directory?(path)
+        Dir.foreach(path){|fn| yield fn}
+      else
+        IO.foreach(path, *rs){|l| yield l}
+      end
+    end
+
+    # call-seq:
+    #   open(path, mode, permissions) -> Enumerator
+    #   open(path, mode, permissions) { block }
+    #
+    # See IO.open when +path+ is a file.
+    #
+    # See Dir.open when +path+ is a directory.
+    #
+    def open(path, mode = nil, perm = 0666, &b)
+      path = expand_path(path)
+      if File.directory?(path)
+        Dir.open(path, &b)
+      else
+        if @shell.umask
+          f = File.open(path, mode, perm)
+          File.chmod(perm & ~@shell.umask, path)
+          if block_given?
+            f.each(&b)
+          end
+          f
+        else
+          File.open(path, mode, perm, &b)
+        end
+      end
+    end
+
+    # call-seq:
+    #   unlink(path)
+    #
+    # See IO.unlink when +path+ is a file.
+    #
+    # See Dir.unlink when +path+ is a directory.
+    #
+    def unlink(path)
+      @shell.check_point
+
+      path = expand_path(path)
+      if File.directory?(path)
+        Dir.unlink(path)
+      else
+        IO.unlink(path)
+      end
+      Void.new(@shell)
+    end
+
+    # See Shell::CommandProcessor#test
+    alias top_level_test test
+    # call-seq:
+    #   test(command, file1, file2) ->  true or false
+    #   [command, file1, file2] ->  true or false
+    #
+    # Tests if the given +command+ exists in +file1+, or optionally +file2+.
+    #
+    # Example:
+    #     sh[?e, "foo"]
+    #     sh[:e, "foo"]
+    #     sh["e", "foo"]
+    #     sh[:exists?, "foo"]
+    #     sh["exists?", "foo"]
+    #
+    def test(command, file1, file2=nil)
+      file1 = expand_path(file1)
+      file2 = expand_path(file2) if file2
+      command = command.id2name if command.kind_of?(Symbol)
+
+      case command
+      when Integer
+        if file2
+          top_level_test(command, file1, file2)
+        else
+          top_level_test(command, file1)
+        end
+      when String
+        if command.size == 1
+          if file2
+            top_level_test(command, file1, file2)
+          else
+            top_level_test(command, file1)
+          end
+        else
+          if file2
+            FileTest.send(command, file1, file2)
+          else
+            FileTest.send(command, file1)
+          end
+        end
+      end
+    end
+    # See Shell::CommandProcessor#test
+    alias [] test
+
+    # call-seq:
+    #   mkdir(path)
+    #
+    # Same as Dir.mkdir, except multiple directories are allowed.
+    def mkdir(*path)
+      @shell.check_point
+      notify("mkdir #{path.join(' ')}")
+
+      perm = nil
+      if path.last.kind_of?(Integer)
+        perm = path.pop
+      end
+      for dir in path
+        d = expand_path(dir)
+        if perm
+          Dir.mkdir(d, perm)
+        else
+          Dir.mkdir(d)
+        end
+        File.chmod(d, 0666 & ~@shell.umask) if @shell.umask
+      end
+      Void.new(@shell)
+    end
+
+    # call-seq:
+    #   rmdir(path)
+    #
+    # Same as Dir.rmdir, except multiple directories are allowed.
+    def rmdir(*path)
+      @shell.check_point
+      notify("rmdir #{path.join(' ')}")
+
+      for dir in path
+        Dir.rmdir(expand_path(dir))
+      end
+      Void.new(@shell)
+    end
+
+    # call-seq:
+    #   system(command, *options) -> SystemCommand
+    #
+    # Executes the given +command+ with the +options+ parameter.
+    #
+    # Example:
+    #     print sh.system("ls", "-l")
+    #     sh.system("ls", "-l") | sh.head > STDOUT
+    #
+    def system(command, *opts)
+      if opts.empty?
+        if command =~ /\*|\?|\{|\}|\[|\]|<|>|\(|\)|~|&|\||\\|\$|;|'|`|"|\n/
+          return SystemCommand.new(@shell, find_system_command("sh"), "-c", command)
+        else
+          command, *opts = command.split(/\s+/)
+        end
+      end
+      SystemCommand.new(@shell, find_system_command(command), *opts)
+    end
+
+    # call-seq:
+    #   rehash
+    #
+    # Clears the command hash table.
+    def rehash
+      @system_commands = {}
+    end
+
+    def check_point # :nodoc:
+      @shell.process_controller.wait_all_jobs_execution
+    end
+    alias finish_all_jobs check_point # :nodoc:
+
+    # call-seq:
+    #   transact { block }
+    #
+    # Executes a block as self
+    #
+    # Example:
+    #   sh.transact { system("ls", "-l") | head > STDOUT }
+    def transact(&block)
+      begin
+        @shell.instance_eval(&block)
+      ensure
+        check_point
+      end
+    end
+
+    # call-seq:
+    #   out(device) { block }
+    #
+    # Calls <code>device.print</code> on the result passing the _block_ to
+    # #transact
+    def out(dev = STDOUT, &block)
+      dev.print transact(&block)
+    end
+
+    # call-seq:
+    #   echo(*strings) ->  Echo
+    #
+    # Returns a Echo object, for the given +strings+
+    def echo(*strings)
+      Echo.new(@shell, *strings)
+    end
+
+    # call-seq:
+    #   cat(*filename) ->  Cat
+    #
+    # Returns a Cat object, for the given +filenames+
+    def cat(*filenames)
+      Cat.new(@shell, *filenames)
+    end
+
+    #   def sort(*filenames)
+    #     Sort.new(self, *filenames)
+    #   end
+    # call-seq:
+    #   glob(pattern) ->  Glob
+    #
+    # Returns a Glob filter object, with the given +pattern+ object
+    def glob(pattern)
+      Glob.new(@shell, pattern)
+    end
+
+    def append(to, filter)
+      case to
+      when String
+        AppendFile.new(@shell, to, filter)
+      when IO
+        AppendIO.new(@shell, to, filter)
+      else
+        Shell.Fail Error::CantApplyMethod, "append", to.class
+      end
+    end
+
+    # call-seq:
+    #   tee(file) ->  Tee
+    #
+    # Returns a Tee filter object, with the given +file+ command
+    def tee(file)
+      Tee.new(@shell, file)
+    end
+
+    # call-seq:
+    #   concat(*jobs) ->  Concat
+    #
+    # Returns a Concat object, for the given +jobs+
+    def concat(*jobs)
+      Concat.new(@shell, *jobs)
+    end
+
+    # %pwd, %cwd -> @pwd
+    def notify(*opts)
+      Shell.notify(*opts) {|mes|
+        yield mes if iterator?
+
+        mes.gsub!("%pwd", "#{@cwd}")
+        mes.gsub!("%cwd", "#{@cwd}")
+      }
+    end
+
+    #
+    # private functions
+    #
+    def find_system_command(command)
+      return command if /^\// =~ command
+      case path = @system_commands[command]
+      when String
+        if exists?(path)
+          return path
+        else
+          Shell.Fail Error::CommandNotFound, command
+        end
+      when false
+        Shell.Fail Error::CommandNotFound, command
+      end
+
+      for p in @shell.system_path
+        path = join(p, command)
+        begin
+          st = File.stat(path)
+        rescue SystemCallError
+          next
+        else
+          next unless st.executable? and !st.directory?
+          @system_commands[command] = path
+          return path
+        end
+      end
+      @system_commands[command] = false
+      Shell.Fail Error::CommandNotFound, command
+    end
+
+    # call-seq:
+    #   def_system_command(command, path)  ->  Shell::SystemCommand
+    #
+    # Defines a command, registering +path+ as a Shell method for the given
+    # +command+.
+    #
+    #     Shell::CommandProcessor.def_system_command "ls"
+    #       #=> Defines ls.
+    #
+    #     Shell::CommandProcessor.def_system_command "sys_sort", "sort"
+    #       #=> Defines sys_sort as sort
+    #
+    def self.def_system_command(command, path = command)
+      begin
+        eval((d = %Q[def #{command}(*opts)
+                  SystemCommand.new(@shell, '#{path}', *opts)
+               end]), nil, __FILE__, __LINE__ - 1)
+      rescue SyntaxError
+        Shell.notify "warn: Can't define #{command} path: #{path}."
+      end
+      Shell.notify "Define #{command} path: #{path}.", Shell.debug?
+      Shell.notify("Definition of #{command}: ", d,
+             Shell.debug.kind_of?(Integer) && Shell.debug > 1)
+    end
+
+    # call-seq:
+    #   undef_system_command(command) ->  self
+    #
+    # Undefines a command
+    def self.undef_system_command(command)
+      command = command.id2name if command.kind_of?(Symbol)
+      remove_method(command)
+      Shell.module_eval{remove_method(command)}
+      Filter.module_eval{remove_method(command)}
+      self
+    end
+
+    @alias_map = {}
+    # Returns a list of aliased commands
+    def self.alias_map
+      @alias_map
+    end
+    # call-seq:
+    #   alias_command(alias, command, *options) ->  self
+    #
+    # Creates a command alias at the given +alias+ for the given +command+,
+    # passing any +options+ along with it.
+    #
+    #     Shell::CommandProcessor.alias_command "lsC", "ls", "-CBF", "--show-control-chars"
+    #     Shell::CommandProcessor.alias_command("lsC", "ls"){|*opts| ["-CBF", "--show-control-chars", *opts]}
+    #
+    def self.alias_command(ali, command, *opts)
+      ali = ali.id2name if ali.kind_of?(Symbol)
+      command = command.id2name if command.kind_of?(Symbol)
+      begin
+        if iterator?
+          @alias_map[ali.intern] = proc
+
+          eval((d = %Q[def #{ali}(*opts)
+                          @shell.__send__(:#{command},
+                                          *(CommandProcessor.alias_map[:#{ali}].call *opts))
+                        end]), nil, __FILE__, __LINE__ - 1)
+
+        else
+           args = opts.collect{|opt| '"' + opt + '"'}.join(",")
+           eval((d = %Q[def #{ali}(*opts)
+                          @shell.__send__(:#{command}, #{args}, *opts)
+                        end]), nil, __FILE__, __LINE__ - 1)
+        end
+      rescue SyntaxError
+        Shell.notify "warn: Can't alias #{ali} command: #{command}."
+        Shell.notify("Definition of #{ali}: ", d)
+        raise
+      end
+      Shell.notify "Define #{ali} command: #{command}.", Shell.debug?
+      Shell.notify("Definition of #{ali}: ", d,
+             Shell.debug.kind_of?(Integer) && Shell.debug > 1)
+      self
+    end
+
+    # call-seq:
+    #   unalias_command(alias)  ->  self
+    #
+    # Unaliases the given +alias+ command.
+    def self.unalias_command(ali)
+      ali = ali.id2name if ali.kind_of?(Symbol)
+      @alias_map.delete ali.intern
+      undef_system_command(ali)
+    end
+
+    # :nodoc:
+    #
+    # Delegates File and FileTest methods into Shell, including the following
+    # commands:
+    #
+    # * Shell#blockdev?(file)
+    # * Shell#chardev?(file)
+    # * Shell#directory?(file)
+    # * Shell#executable?(file)
+    # * Shell#executable_real?(file)
+    # * Shell#exist?(file)/Shell#exists?(file)
+    # * Shell#file?(file)
+    # * Shell#grpowned?(file)
+    # * Shell#owned?(file)
+    # * Shell#pipe?(file)
+    # * Shell#readable?(file)
+    # * Shell#readable_real?(file)
+    # * Shell#setgid?(file)
+    # * Shell#setuid?(file)
+    # * Shell#size(file)/Shell#size?(file)
+    # * Shell#socket?(file)
+    # * Shell#sticky?(file)
+    # * Shell#symlink?(file)
+    # * Shell#writable?(file)
+    # * Shell#writable_real?(file)
+    # * Shell#zero?(file)
+    # * Shell#syscopy(filename_from, filename_to)
+    # * Shell#copy(filename_from, filename_to)
+    # * Shell#move(filename_from, filename_to)
+    # * Shell#compare(filename_from, filename_to)
+    # * Shell#safe_unlink(*filenames)
+    # * Shell#makedirs(*filenames)
+    # * Shell#install(filename_from, filename_to, mode)
+    #
+    # And also, there are some aliases for convenience:
+    #
+    # * Shell#cmp	<- Shell#compare
+    # * Shell#mv	<- Shell#move
+    # * Shell#cp	<- Shell#copy
+    # * Shell#rm_f	<- Shell#safe_unlink
+    # * Shell#mkpath	<- Shell#makedirs
+    #
+    def self.def_builtin_commands(delegation_class, command_specs)
+      for meth, args in command_specs
+        arg_str = args.collect{|arg| arg.downcase}.join(", ")
+        call_arg_str = args.collect{
+          |arg|
+          case arg
+          when /^(FILENAME.*)$/
+            format("expand_path(%s)", $1.downcase)
+          when /^(\*FILENAME.*)$/
+            # \*FILENAME* -> filenames.collect{|fn| expand_path(fn)}.join(", ")
+            $1.downcase + '.collect{|fn| expand_path(fn)}'
+          else
+            arg
+          end
+        }.join(", ")
+        d = %Q[def #{meth}(#{arg_str})
+                    #{delegation_class}.#{meth}(#{call_arg_str})
+                 end]
+        Shell.notify "Define #{meth}(#{arg_str})", Shell.debug?
+        Shell.notify("Definition of #{meth}: ", d,
+                     Shell.debug.kind_of?(Integer) && Shell.debug > 1)
+        eval d
+      end
+    end
+
+    # call-seq:
+    #     install_system_commands(prefix = "sys_")
+    #
+    # Defines all commands in the Shell.default_system_path as Shell method,
+    # all with given +prefix+ appended to their names.
+    #
+    # Any invalid character names are converted to +_+, and errors are passed
+    # to Shell.notify.
+    #
+    # Methods already defined are skipped.
+    def self.install_system_commands(pre = "sys_")
+      defined_meth = {}
+      for m in Shell.methods
+        defined_meth[m] = true
+      end
+      sh = Shell.new
+      for path in Shell.default_system_path
+        next unless sh.directory? path
+        sh.cd path
+        sh.foreach do
+          |cn|
+          if !defined_meth[pre + cn] && sh.file?(cn) && sh.executable?(cn)
+            command = (pre + cn).gsub(/\W/, "_").sub(/^([0-9])/, '_\1')
+            begin
+              def_system_command(command, sh.expand_path(cn))
+            rescue
+              Shell.notify "warn: Can't define #{command} path: #{cn}"
+            end
+            defined_meth[command] = command
+          end
+        end
+      end
+    end
+
+    def self.add_delegate_command_to_shell(id) # :nodoc:
+      id = id.intern if id.kind_of?(String)
+      name = id.id2name
+      if Shell.method_defined?(id)
+        Shell.notify "warn: override definition of Shell##{name}."
+        Shell.notify "warn: alias Shell##{name} to Shell##{name}_org.\n"
+        Shell.module_eval "alias #{name}_org #{name}"
+      end
+      Shell.notify "method added: Shell##{name}.", Shell.debug?
+      Shell.module_eval(%Q[def #{name}(*args, &block)
+                            begin
+                              @command_processor.__send__(:#{name}, *args, &block)
+                            rescue Exception
+                              $@.delete_if{|s| /:in `__getobj__'$/ =~ s} #`
+                              $@.delete_if{|s| /^\\(eval\\):/ =~ s}
+                            raise
+                            end
+                          end], __FILE__, __LINE__)
+
+      if Shell::Filter.method_defined?(id)
+        Shell.notify "warn: override definition of Shell::Filter##{name}."
+        Shell.notify "warn: alias Shell##{name} to Shell::Filter##{name}_org."
+        Filter.module_eval "alias #{name}_org #{name}"
+      end
+      Shell.notify "method added: Shell::Filter##{name}.", Shell.debug?
+      Filter.module_eval(%Q[def #{name}(*args, &block)
+                            begin
+                              self | @shell.__send__(:#{name}, *args, &block)
+                            rescue Exception
+                              $@.delete_if{|s| /:in `__getobj__'$/ =~ s} #`
+                              $@.delete_if{|s| /^\\(eval\\):/ =~ s}
+                            raise
+                            end
+                          end], __FILE__, __LINE__)
+    end
+
+    # Delegates File methods into Shell, including the following commands:
+    #
+    # * Shell#atime(file)
+    # * Shell#basename(file, *opt)
+    # * Shell#chmod(mode, *files)
+    # * Shell#chown(owner, group, *file)
+    # * Shell#ctime(file)
+    # * Shell#delete(*file)
+    # * Shell#dirname(file)
+    # * Shell#ftype(file)
+    # * Shell#join(*file)
+    # * Shell#link(file_from, file_to)
+    # * Shell#lstat(file)
+    # * Shell#mtime(file)
+    # * Shell#readlink(file)
+    # * Shell#rename(file_from, file_to)
+    # * Shell#split(file)
+    # * Shell#stat(file)
+    # * Shell#symlink(file_from, file_to)
+    # * Shell#truncate(file, length)
+    # * Shell#utime(atime, mtime, *file)
+    #
+    def self.install_builtin_commands
+      # method related File.
+      # (exclude open/foreach/unlink)
+      normal_delegation_file_methods = [
+        ["atime", ["FILENAME"]],
+        ["basename", ["fn", "*opts"]],
+        ["chmod", ["mode", "*FILENAMES"]],
+        ["chown", ["owner", "group", "*FILENAME"]],
+        ["ctime", ["FILENAMES"]],
+        ["delete", ["*FILENAMES"]],
+        ["dirname", ["FILENAME"]],
+        ["ftype", ["FILENAME"]],
+        ["join", ["*items"]],
+        ["link", ["FILENAME_O", "FILENAME_N"]],
+        ["lstat", ["FILENAME"]],
+        ["mtime", ["FILENAME"]],
+        ["readlink", ["FILENAME"]],
+        ["rename", ["FILENAME_FROM", "FILENAME_TO"]],
+        ["split", ["pathname"]],
+        ["stat", ["FILENAME"]],
+        ["symlink", ["FILENAME_O", "FILENAME_N"]],
+        ["truncate", ["FILENAME", "length"]],
+        ["utime", ["atime", "mtime", "*FILENAMES"]]]
+
+      def_builtin_commands(File, normal_delegation_file_methods)
+      alias_method :rm, :delete
+
+      # method related FileTest
+      def_builtin_commands(FileTest,
+                   FileTest.singleton_methods(false).collect{|m| [m, ["FILENAME"]]})
+
+    end
+
+  end
+end
diff --git a/jni/ruby/lib/shell/error.rb b/jni/ruby/lib/shell/error.rb
new file mode 100644
index 0000000..66520c6
--- /dev/null
+++ b/jni/ruby/lib/shell/error.rb
@@ -0,0 +1,25 @@
+#
+#   shell/error.rb -
+#       $Release Version: 0.7 $
+#       $Revision: 31641 $
+#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require "e2mmap"
+
+class Shell
+  module Error
+    extend Exception2MessageMapper
+    def_e2message TypeError, "wrong argument type %s (expected %s)"
+
+    def_exception :DirStackEmpty, "Directory stack empty."
+    def_exception :CantDefine, "Can't define method(%s, %s)."
+    def_exception :CantApplyMethod, "This method(%s) does not apply to this type(%s)."
+    def_exception :CommandNotFound, "Command not found(%s)."
+  end
+end
+
diff --git a/jni/ruby/lib/shell/filter.rb b/jni/ruby/lib/shell/filter.rb
new file mode 100644
index 0000000..6960217
--- /dev/null
+++ b/jni/ruby/lib/shell/filter.rb
@@ -0,0 +1,137 @@
+#
+#   shell/filter.rb -
+#       $Release Version: 0.7 $
+#       $Revision: 44221 $
+#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+class Shell #:nodoc:
+  # Any result of command execution is a Filter.
+  #
+  # This class includes Enumerable, therefore a Filter object can use all
+  # Enumerable
+  # facilities.
+  #
+  class Filter
+    include Enumerable
+
+    def initialize(sh)
+      @shell = sh         # parent shell
+      @input = nil        # input filter
+    end
+
+    attr_reader :input
+
+    def input=(filter)
+      @input = filter
+    end
+
+    # call-seq:
+    #   each(record_separator=nil) { block }
+    #
+    # Iterates a block for each line.
+    def each(rs = nil)
+      rs = @shell.record_separator unless rs
+      if @input
+        @input.each(rs){|l| yield l}
+      end
+    end
+
+    # call-seq:
+    #   < source
+    #
+    # Inputs from +source+, which is either a string of a file name or an IO
+    # object.
+    def < (src)
+      case src
+      when String
+        cat = Cat.new(@shell, src)
+        cat | self
+      when IO
+        self.input = src
+        self
+      else
+        Shell.Fail Error::CantApplyMethod, "<", to.class
+      end
+    end
+
+    # call-seq:
+    #   > source
+    #
+    # Outputs from +source+, which is either a string of a file name or an IO
+    # object.
+    def > (to)
+      case to
+      when String
+        dst = @shell.open(to, "w")
+        begin
+          each(){|l| dst << l}
+        ensure
+          dst.close
+        end
+      when IO
+        each(){|l| to << l}
+      else
+        Shell.Fail Error::CantApplyMethod, ">", to.class
+      end
+      self
+    end
+
+    # call-seq:
+    #   >> source
+    #
+    # Appends the output to +source+, which is either a string of a file name
+    # or an IO object.
+    def >> (to)
+      begin
+        Shell.cd(@shell.pwd).append(to, self)
+      rescue CantApplyMethod
+        Shell.Fail Error::CantApplyMethod, ">>", to.class
+      end
+    end
+
+    # call-seq:
+    #   | filter
+    #
+    # Processes a pipeline.
+    def | (filter)
+      filter.input = self
+      if active?
+        @shell.process_controller.start_job filter
+      end
+      filter
+    end
+
+    # call-seq:
+    #   filter1 + filter2
+    #
+    # Outputs +filter1+, and then +filter2+ using Join.new
+    def + (filter)
+      Join.new(@shell, self, filter)
+    end
+
+    def to_a
+      ary = []
+      each(){|l| ary.push l}
+      ary
+    end
+
+    def to_s
+      str = ""
+      each(){|l| str.concat l}
+      str
+    end
+
+    def inspect
+      if @shell.debug.kind_of?(Integer) && @shell.debug > 2
+        super
+      else
+        to_s
+      end
+    end
+  end
+end
diff --git a/jni/ruby/lib/shell/process-controller.rb b/jni/ruby/lib/shell/process-controller.rb
new file mode 100644
index 0000000..0fed143
--- /dev/null
+++ b/jni/ruby/lib/shell/process-controller.rb
@@ -0,0 +1,310 @@
+#
+#   shell/process-controller.rb -
+#       $Release Version: 0.7 $
+#       $Revision: 47284 $
+#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+require "forwardable"
+
+require "thread"
+require "sync"
+
+class Shell
+  class ProcessController
+
+    @ProcessControllers = {}
+    @ProcessControllersMonitor = Mutex.new
+    @ProcessControllersCV = ConditionVariable.new
+
+    @BlockOutputMonitor = Mutex.new
+    @BlockOutputCV = ConditionVariable.new
+
+    class << self
+      extend Forwardable
+
+      def_delegator("@ProcessControllersMonitor",
+                    "synchronize", "process_controllers_exclusive")
+
+      def active_process_controllers
+        process_controllers_exclusive do
+          @ProcessControllers.dup
+        end
+      end
+
+      def activate(pc)
+        process_controllers_exclusive do
+          @ProcessControllers[pc] ||= 0
+          @ProcessControllers[pc] += 1
+        end
+      end
+
+      def inactivate(pc)
+        process_controllers_exclusive do
+          if @ProcessControllers[pc]
+            if (@ProcessControllers[pc] -= 1) == 0
+              @ProcessControllers.delete(pc)
+              @ProcessControllersCV.signal
+            end
+          end
+        end
+      end
+
+      def each_active_object
+        process_controllers_exclusive do
+          for ref in @ProcessControllers.keys
+            yield ref
+          end
+        end
+      end
+
+      def block_output_synchronize(&b)
+        @BlockOutputMonitor.synchronize(&b)
+      end
+
+      def wait_to_finish_all_process_controllers
+        process_controllers_exclusive do
+          while !@ProcessControllers.empty?
+            Shell::notify("Process finishing, but active shell exists",
+                          "You can use Shell#transact or Shell#check_point for more safe execution.")
+            if Shell.debug?
+              for pc in @ProcessControllers.keys
+                Shell::notify(" Not finished jobs in "+pc.shell.to_s)
+                for com in pc.jobs
+                  com.notify("  Jobs: %id")
+                end
+              end
+            end
+            @ProcessControllersCV.wait(@ProcessControllersMonitor)
+          end
+        end
+      end
+    end
+
+    # for shell-command complete finish at this process exit.
+    USING_AT_EXIT_WHEN_PROCESS_EXIT = true
+    at_exit do
+      wait_to_finish_all_process_controllers unless $@
+    end
+
+    def initialize(shell)
+      @shell = shell
+      @waiting_jobs = []
+      @active_jobs = []
+      @jobs_sync = Sync.new
+
+      @job_monitor = Mutex.new
+      @job_condition = ConditionVariable.new
+    end
+
+    attr_reader :shell
+
+    def jobs
+      jobs = []
+      @jobs_sync.synchronize(:SH) do
+        jobs.concat @waiting_jobs
+        jobs.concat @active_jobs
+      end
+      jobs
+    end
+
+    def active_jobs
+      @active_jobs
+    end
+
+    def waiting_jobs
+      @waiting_jobs
+    end
+
+    def jobs_exist?
+      @jobs_sync.synchronize(:SH) do
+        @active_jobs.empty? or @waiting_jobs.empty?
+      end
+    end
+
+    def active_jobs_exist?
+      @jobs_sync.synchronize(:SH) do
+        @active_jobs.empty?
+      end
+    end
+
+    def waiting_jobs_exist?
+      @jobs_sync.synchronize(:SH) do
+        @waiting_jobs.empty?
+      end
+    end
+
+    # schedule a command
+    def add_schedule(command)
+      @jobs_sync.synchronize(:EX) do
+        ProcessController.activate(self)
+        if @active_jobs.empty?
+          start_job command
+        else
+          @waiting_jobs.push(command)
+        end
+      end
+    end
+
+    # start a job
+    def start_job(command = nil)
+      @jobs_sync.synchronize(:EX) do
+        if command
+          return if command.active?
+          @waiting_jobs.delete command
+        else
+          command = @waiting_jobs.shift
+
+          return unless command
+        end
+        @active_jobs.push command
+        command.start
+
+        # start all jobs that input from the job
+        for job in @waiting_jobs.dup
+          start_job(job) if job.input == command
+        end
+      end
+    end
+
+    def waiting_job?(job)
+      @jobs_sync.synchronize(:SH) do
+        @waiting_jobs.include?(job)
+      end
+    end
+
+    def active_job?(job)
+      @jobs_sync.synchronize(:SH) do
+        @active_jobs.include?(job)
+      end
+    end
+
+    # terminate a job
+    def terminate_job(command)
+      @jobs_sync.synchronize(:EX) do
+        @active_jobs.delete command
+        ProcessController.inactivate(self)
+        if @active_jobs.empty?
+          command.notify("start_job in terminate_job(%id)", Shell::debug?)
+          start_job
+        end
+      end
+    end
+
+    # kill a job
+    def kill_job(sig, command)
+      @jobs_sync.synchronize(:EX) do
+        if @waiting_jobs.delete command
+          ProcessController.inactivate(self)
+          return
+        elsif @active_jobs.include?(command)
+          begin
+            r = command.kill(sig)
+            ProcessController.inactivate(self)
+          rescue
+            print "Shell: Warn: $!\n" if @shell.verbose?
+            return nil
+          end
+          @active_jobs.delete command
+          r
+        end
+      end
+    end
+
+    # wait for all jobs to terminate
+    def wait_all_jobs_execution
+      @job_monitor.synchronize do
+        begin
+          while !jobs.empty?
+            @job_condition.wait(@job_monitor)
+            for job in jobs
+              job.notify("waiting job(%id)", Shell::debug?)
+            end
+          end
+        ensure
+          redo unless jobs.empty?
+        end
+      end
+    end
+
+    # simple fork
+    def sfork(command)
+      pipe_me_in, pipe_peer_out = IO.pipe
+      pipe_peer_in, pipe_me_out = IO.pipe
+
+
+      pid = nil
+      pid_mutex = Mutex.new
+      pid_cv = ConditionVariable.new
+
+      Thread.start do
+        ProcessController.block_output_synchronize do
+          STDOUT.flush
+          ProcessController.each_active_object do |pc|
+            for jobs in pc.active_jobs
+              jobs.flush
+            end
+          end
+
+          pid = fork {
+            Thread.list.each do |th|
+              th.kill unless Thread.current == th
+            end
+
+            STDIN.reopen(pipe_peer_in)
+            STDOUT.reopen(pipe_peer_out)
+
+            ObjectSpace.each_object(IO) do |io|
+              if ![STDIN, STDOUT, STDERR].include?(io)
+                io.close unless io.closed?
+              end
+            end
+
+            yield
+          }
+        end
+        pid_cv.signal
+
+        pipe_peer_in.close
+        pipe_peer_out.close
+        command.notify "job(%name:##{pid}) start", @shell.debug?
+
+        begin
+          _pid = nil
+          command.notify("job(%id) start to waiting finish.", @shell.debug?)
+          _pid = Process.waitpid(pid, nil)
+        rescue Errno::ECHILD
+          command.notify "warn: job(%id) was done already waitpid."
+          _pid = true
+        ensure
+          command.notify("Job(%id): Wait to finish when Process finished.", @shell.debug?)
+          # when the process ends, wait until the command terminates
+          if USING_AT_EXIT_WHEN_PROCESS_EXIT or _pid
+          else
+            command.notify("notice: Process finishing...",
+                           "wait for Job[%id] to finish.",
+                           "You can use Shell#transact or Shell#check_point for more safe execution.")
+            redo
+          end
+
+          @job_monitor.synchronize do
+            terminate_job(command)
+            @job_condition.signal
+            command.notify "job(%id) finish.", @shell.debug?
+          end
+        end
+      end
+
+      pid_mutex.synchronize do
+        while !pid
+          pid_cv.wait(pid_mutex)
+        end
+      end
+
+      return pid, pipe_me_in, pipe_me_out
+    end
+  end
+end
diff --git a/jni/ruby/lib/shell/system-command.rb b/jni/ruby/lib/shell/system-command.rb
new file mode 100644
index 0000000..382a337
--- /dev/null
+++ b/jni/ruby/lib/shell/system-command.rb
@@ -0,0 +1,158 @@
+#
+#   shell/system-command.rb -
+#       $Release Version: 0.7 $
+#       $Revision: 46969 $
+#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+require "shell/filter"
+
+class Shell
+  class SystemCommand < Filter
+    def initialize(sh, command, *opts)
+      if t = opts.find{|opt| !opt.kind_of?(String) && opt.class}
+        Shell.Fail Error::TypeError, t.class, "String"
+      end
+      super(sh)
+      @command = command
+      @opts = opts
+
+      @input_queue = Queue.new
+      @pid = nil
+
+      sh.process_controller.add_schedule(self)
+    end
+
+    attr_reader :command
+    alias name command
+
+    def wait?
+      @shell.process_controller.waiting_job?(self)
+    end
+
+    def active?
+      @shell.process_controller.active_job?(self)
+    end
+
+    def input=(inp)
+      super
+      if active?
+        start_export
+      end
+    end
+
+    def start
+      notify([@command, *@opts].join(" "))
+
+      @pid, @pipe_in, @pipe_out = @shell.process_controller.sfork(self) {
+        Dir.chdir @shell.pwd
+        $0 = @command
+        exec(@command, *@opts)
+      }
+      if @input
+        start_export
+      end
+      start_import
+    end
+
+    def flush
+      @pipe_out.flush if @pipe_out and !@pipe_out.closed?
+    end
+
+    def terminate
+      begin
+        @pipe_in.close
+      rescue IOError
+      end
+      begin
+        @pipe_out.close
+      rescue IOError
+      end
+    end
+
+    def kill(sig)
+      if @pid
+        Process.kill(sig, @pid)
+      end
+    end
+
+    def start_import
+      notify "Job(%id) start imp-pipe.", @shell.debug?
+      _eop = true
+      Thread.start {
+        begin
+          while l = @pipe_in.gets
+            @input_queue.push l
+          end
+          _eop = false
+        rescue Errno::EPIPE
+          _eop = false
+        ensure
+          if !ProcessController::USING_AT_EXIT_WHEN_PROCESS_EXIT and _eop
+            notify("warn: Process finishing...",
+                   "wait for Job[%id] to finish pipe importing.",
+                   "You can use Shell#transact or Shell#check_point for more safe execution.")
+            redo
+          end
+          notify "job(%id}) close imp-pipe.", @shell.debug?
+          @input_queue.push :EOF
+          @pipe_in.close
+        end
+      }
+    end
+
+    def start_export
+      notify "job(%id) start exp-pipe.", @shell.debug?
+      _eop = true
+      Thread.start{
+        begin
+          @input.each do |l|
+            ProcessController::block_output_synchronize do
+              @pipe_out.print l
+            end
+          end
+          _eop = false
+        rescue Errno::EPIPE, Errno::EIO
+          _eop = false
+        ensure
+          if !ProcessController::USING_AT_EXIT_WHEN_PROCESS_EXIT and _eop
+            notify("shell: warn: Process finishing...",
+                   "wait for Job(%id) to finish pipe exporting.",
+                   "You can use Shell#transact or Shell#check_point for more safe execution.")
+            redo
+          end
+          notify "job(%id) close exp-pipe.", @shell.debug?
+          @pipe_out.close
+        end
+      }
+    end
+
+    alias super_each each
+    def each(rs = nil)
+      while (l = @input_queue.pop) != :EOF
+        yield l
+      end
+    end
+
+    # ex)
+    #    if you wish to output:
+    #       "shell: job(#{@command}:#{@pid}) close pipe-out."
+    #    then
+    #       mes: "job(%id) close pipe-out."
+    #    yorn: Boolean(@shell.debug? or @shell.verbose?)
+    def notify(*opts)
+      @shell.notify(*opts) do |mes|
+        yield mes if iterator?
+
+        mes.gsub!("%id", "#{@command}:##{@pid}")
+        mes.gsub!("%name", "#{@command}")
+        mes.gsub!("%pid", "#{@pid}")
+        mes
+      end
+    end
+  end
+end
diff --git a/jni/ruby/lib/shell/version.rb b/jni/ruby/lib/shell/version.rb
new file mode 100644
index 0000000..8d3aa7b
--- /dev/null
+++ b/jni/ruby/lib/shell/version.rb
@@ -0,0 +1,15 @@
+#
+#   version.rb - shell version definition file
+#       $Release Version: 0.7$
+#       $Revision: 38201 $
+#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+class Shell # :nodoc:
+  @RELEASE_VERSION = "0.7"
+  @LAST_UPDATE_DATE = "07/03/20"
+end