rb2exe 0.1.58 → 0.1.60

data/bin/traveling-ruby-2.2.2/osx/lib/ruby/2.2.0/expect.rb

@@ -0,0 +1,71 @@
+$expect_verbose = false
+
+# Expect library adds the IO instance method #expect, which does similar act to
+# tcl's expect extension.
+#
+# In order to use this method, you must require expect:
+#
+#   require 'expect'
+#
+# Please see #expect for usage.
+class IO
+  # call-seq:
+  #   IO#expect(pattern,timeout=9999999)                  ->  Array
+  #   IO#expect(pattern,timeout=9999999) { |result| ... } ->  nil
+  #
+  # Reads from the IO until the given +pattern+ matches or the +timeout+ is over.
+  #
+  # It returns an array with the read buffer, followed by the matches.
+  # If a block is given, the result is yielded to the block and returns nil.
+  #
+  # When called without a block, it waits until the input that matches the
+  # given +pattern+ is obtained from the IO or the time specified as the
+  # timeout passes. An array is returned when the pattern is obtained from the
+  # IO. The first element of the array is the entire string obtained from the
+  # IO until the pattern matches, followed by elements indicating which the
+  # pattern which matched to the anchor in the regular expression.
+  #
+  # The optional timeout parameter defines, in seconds, the total time to wait
+  # for the pattern.  If the timeout expires or eof is found, nil is returned
+  # or yielded.  However, the buffer in a timeout session is kept for the next
+  # expect call.  The default timeout is 9999999 seconds.
+  def expect(pat,timeout=9999999)
+    buf = ''
+    case pat
+    when String
+      e_pat = Regexp.new(Regexp.quote(pat))
+    when Regexp
+      e_pat = pat
+    else
+      raise TypeError, "unsupported pattern class: #{pat.class}"
+    end
+    @unusedBuf ||= ''
+    while true
+      if not @unusedBuf.empty?
+        c = @unusedBuf.slice!(0).chr
+      elsif !IO.select([self],nil,nil,timeout) or eof? then
+        result = nil
+        @unusedBuf = buf
+        break
+      else
+        c = getc.chr
+      end
+      buf << c
+      if $expect_verbose
+        STDOUT.print c
+        STDOUT.flush
+      end
+      if mat=e_pat.match(buf) then
+        result = [buf,*mat.to_a[1..-1]]
+        break
+      end
+    end
+    if block_given? then
+      yield result
+    else
+      return result
+    end
+    nil
+  end
+end
+

data/bin/traveling-ruby-2.2.2/osx/lib/ruby/2.2.0/fiddle.rb

@@ -0,0 +1,55 @@
+require 'fiddle.so'
+require 'fiddle/function'
+require 'fiddle/closure'
+
+module Fiddle
+  if WINDOWS
+    # Returns the last win32 +Error+ of the current executing +Thread+ or nil
+    # if none
+    def self.win32_last_error
+      Thread.current[:__FIDDLE_WIN32_LAST_ERROR__]
+    end
+
+    # Sets the last win32 +Error+ of the current executing +Thread+ to +error+
+    def self.win32_last_error= error
+      Thread.current[:__FIDDLE_WIN32_LAST_ERROR__] = error
+    end
+  end
+
+  # Returns the last +Error+ of the current executing +Thread+ or nil if none
+  def self.last_error
+    Thread.current[:__FIDDLE_LAST_ERROR__]
+  end
+
+  # Sets the last +Error+ of the current executing +Thread+ to +error+
+  def self.last_error= error
+    Thread.current[:__DL2_LAST_ERROR__] = error
+    Thread.current[:__FIDDLE_LAST_ERROR__] = error
+  end
+
+  # call-seq: dlopen(library) => Fiddle::Handle
+  #
+  # Creates a new handler that opens +library+, and returns an instance of
+  # Fiddle::Handle.
+  #
+  # If +nil+ is given for the +library+, Fiddle::Handle::DEFAULT is used, which
+  # is the equivalent to RTLD_DEFAULT. See <code>man 3 dlopen</code> for more.
+  #
+  #   lib = Fiddle.dlopen(nil)
+  #
+  # The default is dependent on OS, and provide a handle for all libraries
+  # already loaded. For example, in most cases you can use this to access
+  # +libc+ functions, or ruby functions like +rb_str_new+.
+  #
+  # See Fiddle::Handle.new for more.
+  def dlopen library
+    Fiddle::Handle.new library
+  end
+  module_function :dlopen
+
+  # Add constants for backwards compat
+
+  RTLD_GLOBAL = Handle::RTLD_GLOBAL # :nodoc:
+  RTLD_LAZY   = Handle::RTLD_LAZY   # :nodoc:
+  RTLD_NOW    = Handle::RTLD_NOW    # :nodoc:
+end

data/bin/traveling-ruby-2.2.2/osx/lib/ruby/2.2.0/fiddle/closure.rb

@@ -0,0 +1,48 @@
+module Fiddle
+  class Closure
+
+    # the C type of the return of the FFI closure
+    attr_reader :ctype
+
+    # arguments of the FFI closure
+    attr_reader :args
+
+    # Extends Fiddle::Closure to allow for building the closure in a block
+    class BlockCaller < Fiddle::Closure
+
+      # == Description
+      #
+      # Construct a new BlockCaller object.
+      #
+      # * +ctype+ is the C type to be returned
+      # * +args+ are passed the callback
+      # * +abi+ is the abi of the closure
+      #
+      # If there is an error in preparing the +ffi_cif+ or +ffi_prep_closure+,
+      # then a RuntimeError will be raised.
+      #
+      # == Example
+      #
+      #   include Fiddle
+      #
+      #   cb = Closure::BlockCaller.new(TYPE_INT, [TYPE_INT]) do |one|
+      #     one
+      #   end
+      #
+      #   func = Function.new(cb, [TYPE_INT], TYPE_INT)
+      #
+      def initialize ctype, args, abi = Fiddle::Function::DEFAULT, &block
+        super(ctype, args, abi)
+        @block = block
+      end
+
+      # Calls the constructed BlockCaller, with +args+
+      #
+      # For an example see Fiddle::Closure::BlockCaller.new
+      #
+      def call *args
+        @block.call(*args)
+      end
+    end
+  end
+end

data/bin/traveling-ruby-2.2.2/osx/lib/ruby/2.2.0/fiddle/cparser.rb

@@ -0,0 +1,176 @@
+module Fiddle
+  # A mixin that provides methods for parsing C struct and prototype signatures.
+  #
+  # == Example
+  #   require 'fiddle/import'
+  #
+  #   include Fiddle::CParser
+  #     #=> Object
+  #
+  #   parse_ctype('int increment(int)')
+  #     #=> ["increment", Fiddle::TYPE_INT, [Fiddle::TYPE_INT]]
+  #
+  module CParser
+    # Parses a C struct's members
+    #
+    # Example:
+    #
+    #   include Fiddle::CParser
+    #     #=> Object
+    #
+    #   parse_struct_signature(['int i', 'char c'])
+    #     #=> [[Fiddle::TYPE_INT, Fiddle::TYPE_CHAR], ["i", "c"]]
+    #
+    def parse_struct_signature(signature, tymap=nil)
+      if( signature.is_a?(String) )
+        signature = signature.split(/\s*,\s*/)
+      end
+      mems = []
+      tys  = []
+      signature.each{|msig|
+        tks = msig.split(/\s+(\*)?/)
+        ty = tks[0..-2].join(" ")
+        member = tks[-1]
+
+        case ty
+        when /\[(\d+)\]/
+          n = $1.to_i
+          ty.gsub!(/\s*\[\d+\]/,"")
+          ty = [ty, n]
+        when /\[\]/
+          ty.gsub!(/\s*\[\]/, "*")
+        end
+
+        case member
+        when /\[(\d+)\]/
+          ty = [ty, $1.to_i]
+          member.gsub!(/\s*\[\d+\]/,"")
+        when /\[\]/
+          ty = ty + "*"
+          member.gsub!(/\s*\[\]/, "")
+        end
+
+        mems.push(member)
+        tys.push(parse_ctype(ty,tymap))
+      }
+      return tys, mems
+    end
+
+    # Parses a C prototype signature
+    #
+    # If Hash +tymap+ is provided, the return value and the arguments from the
+    # +signature+ are expected to be keys, and the value will be the C type to
+    # be looked up.
+    #
+    # Example:
+    #
+    #   include Fiddle::CParser
+    #     #=> Object
+    #
+    #   parse_signature('double sum(double, double)')
+    #     #=> ["sum", Fiddle::TYPE_DOUBLE, [Fiddle::TYPE_DOUBLE, Fiddle::TYPE_DOUBLE]]
+    #
+    def parse_signature(signature, tymap=nil)
+      tymap ||= {}
+      signature = signature.gsub(/\s+/, " ").strip
+      case signature
+      when /^([\w@\*\s]+)\(([\w\*\s\,\[\]]*)\)$/
+        ret = $1
+        (args = $2).strip!
+        ret = ret.split(/\s+/)
+        args = args.split(/\s*,\s*/)
+        func = ret.pop
+        if( func =~ /^\*/ )
+          func.gsub!(/^\*+/,"")
+          ret.push("*")
+        end
+        ret  = ret.join(" ")
+        return [func, parse_ctype(ret, tymap), args.collect{|arg| parse_ctype(arg, tymap)}]
+      else
+        raise(RuntimeError,"can't parse the function prototype: #{signature}")
+      end
+    end
+
+    # Given a String of C type +ty+, returns the corresponding Fiddle constant.
+    #
+    # +ty+ can also accept an Array of C type Strings, and will be returned in
+    # a corresponding Array.
+    #
+    # If Hash +tymap+ is provided, +ty+ is expected to be the key, and the
+    # value will be the C type to be looked up.
+    #
+    # Example:
+    #
+    #   include Fiddle::CParser
+    #     #=> Object
+    #
+    #   parse_ctype('int')
+    #     #=> Fiddle::TYPE_INT
+    #
+    #   parse_ctype('double')
+    #     #=> Fiddle::TYPE_DOUBLE
+    #
+    #   parse_ctype('unsigned char')
+    #     #=> -Fiddle::TYPE_CHAR
+    #
+    def parse_ctype(ty, tymap=nil)
+      tymap ||= {}
+      case ty
+      when Array
+        return [parse_ctype(ty[0], tymap), ty[1]]
+      when "void"
+        return TYPE_VOID
+      when "char"
+        return TYPE_CHAR
+      when "unsigned char"
+        return  -TYPE_CHAR
+      when "short"
+        return TYPE_SHORT
+      when "unsigned short"
+        return -TYPE_SHORT
+      when "int"
+        return TYPE_INT
+      when "unsigned int", 'uint'
+        return -TYPE_INT
+      when "long"
+        return TYPE_LONG
+      when "unsigned long"
+        return -TYPE_LONG
+      when "long long"
+        if( defined?(TYPE_LONG_LONG) )
+          return TYPE_LONG_LONG
+        else
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+      when "unsigned long long"
+        if( defined?(TYPE_LONG_LONG) )
+          return -TYPE_LONG_LONG
+        else
+          raise(RuntimeError, "unsupported type: #{ty}")
+        end
+      when "float"
+        return TYPE_FLOAT
+      when "double"
+        return TYPE_DOUBLE
+      when "size_t"
+        return TYPE_SIZE_T
+      when "ssize_t"
+        return TYPE_SSIZE_T
+      when "ptrdiff_t"
+        return TYPE_PTRDIFF_T
+      when "intptr_t"
+        return TYPE_INTPTR_T
+      when "uintptr_t"
+        return TYPE_UINTPTR_T
+      when /\*/, /\[\s*\]/
+        return TYPE_VOIDP
+      else
+        if( tymap[ty] )
+          return parse_ctype(tymap[ty], tymap)
+        else
+          raise(DLError, "unknown type: #{ty}")
+        end
+      end
+    end
+  end
+end

data/bin/traveling-ruby-2.2.2/osx/lib/ruby/2.2.0/fiddle/function.rb

@@ -0,0 +1,17 @@
+module Fiddle
+  class Function
+    # The ABI of the Function.
+    attr_reader :abi
+
+    # The address of this function
+    attr_reader :ptr
+
+    # The name of this function
+    attr_reader :name
+
+    # The integer memory location of this function
+    def to_i
+      ptr.to_i
+    end
+  end
+end

data/bin/traveling-ruby-2.2.2/osx/lib/ruby/2.2.0/fiddle/import.rb

@@ -0,0 +1,314 @@
+require 'fiddle'
+require 'fiddle/struct'
+require 'fiddle/cparser'
+
+module Fiddle
+
+  # Used internally by Fiddle::Importer
+  class CompositeHandler
+    # Create a new handler with the open +handlers+
+    #
+    # Used internally by Fiddle::Importer.dlload
+    def initialize(handlers)
+      @handlers = handlers
+    end
+
+    # Array of the currently loaded libraries.
+    def handlers()
+      @handlers
+    end
+
+    # Returns the address as an Integer from any handlers with the function
+    # named +symbol+.
+    #
+    # Raises a DLError if the handle is closed.
+    def sym(symbol)
+      @handlers.each{|handle|
+        if( handle )
+          begin
+            addr = handle.sym(symbol)
+            return addr
+          rescue DLError
+          end
+        end
+      }
+      return nil
+    end
+
+    # See Fiddle::CompositeHandler.sym
+    def [](symbol)
+      sym(symbol)
+    end
+  end
+
+  # A DSL that provides the means to dynamically load libraries and build
+  # modules around them including calling extern functions within the C
+  # library that has been loaded.
+  #
+  # == Example
+  #
+  #   require 'fiddle'
+  #   require 'fiddle/import'
+  #
+  #   module LibSum
+  #   	extend Fiddle::Importer
+  #   	dlload './libsum.so'
+  #   	extern 'double sum(double*, int)'
+  #   	extern 'double split(double)'
+  #   end
+  #
+  module Importer
+    include Fiddle
+    include CParser
+    extend Importer
+
+    # Creates an array of handlers for the given +libs+, can be an instance of
+    # Fiddle::Handle, Fiddle::Importer, or will create a new instance of
+    # Fiddle::Handle using Fiddle.dlopen
+    #
+    # Raises a DLError if the library cannot be loaded.
+    #
+    # See Fiddle.dlopen
+    def dlload(*libs)
+      handles = libs.collect{|lib|
+        case lib
+        when nil
+          nil
+        when Handle
+          lib
+        when Importer
+          lib.handlers
+        else
+          begin
+            Fiddle.dlopen(lib)
+          rescue DLError
+            raise(DLError, "can't load #{lib}")
+          end
+        end
+      }.flatten()
+      @handler = CompositeHandler.new(handles)
+      @func_map = {}
+      @type_alias = {}
+    end
+
+    # Sets the type alias for +alias_type+ as +orig_type+
+    def typealias(alias_type, orig_type)
+      @type_alias[alias_type] = orig_type
+    end
+
+    # Returns the sizeof +ty+, using Fiddle::Importer.parse_ctype to determine
+    # the C type and the appropriate Fiddle constant.
+    def sizeof(ty)
+      case ty
+      when String
+        ty = parse_ctype(ty, @type_alias).abs()
+        case ty
+        when TYPE_CHAR
+          return SIZEOF_CHAR
+        when TYPE_SHORT
+          return SIZEOF_SHORT
+        when TYPE_INT
+          return SIZEOF_INT
+        when TYPE_LONG
+          return SIZEOF_LONG
+        when TYPE_LONG_LONG
+          return SIZEOF_LONG_LONG
+        when TYPE_FLOAT
+          return SIZEOF_FLOAT
+        when TYPE_DOUBLE
+          return SIZEOF_DOUBLE
+        when TYPE_VOIDP
+          return SIZEOF_VOIDP
+        else
+          raise(DLError, "unknown type: #{ty}")
+        end
+      when Class
+        if( ty.instance_methods().include?(:to_ptr) )
+          return ty.size()
+        end
+      end
+      return Pointer[ty].size()
+    end
+
+    def parse_bind_options(opts)
+      h = {}
+      while( opt = opts.shift() )
+        case opt
+        when :stdcall, :cdecl
+          h[:call_type] = opt
+        when :carried, :temp, :temporal, :bind
+          h[:callback_type] = opt
+          h[:carrier] = opts.shift()
+        else
+          h[opt] = true
+        end
+      end
+      h
+    end
+    private :parse_bind_options
+
+    # :stopdoc:
+    CALL_TYPE_TO_ABI = Hash.new { |h, k|
+      raise RuntimeError, "unsupported call type: #{k}"
+    }.merge({ :stdcall => (Function::STDCALL rescue Function::DEFAULT),
+              :cdecl   => Function::DEFAULT,
+              nil      => Function::DEFAULT
+            }).freeze
+    private_constant :CALL_TYPE_TO_ABI
+    # :startdoc:
+
+    # Creates a global method from the given C +signature+.
+    def extern(signature, *opts)
+      symname, ctype, argtype = parse_signature(signature, @type_alias)
+      opt = parse_bind_options(opts)
+      f = import_function(symname, ctype, argtype, opt[:call_type])
+      name = symname.gsub(/@.+/,'')
+      @func_map[name] = f
+      # define_method(name){|*args,&block| f.call(*args,&block)}
+      begin
+        /^(.+?):(\d+)/ =~ caller.first
+        file, line = $1, $2.to_i
+      rescue
+        file, line = __FILE__, __LINE__+3
+      end
+      module_eval(<<-EOS, file, line)
+        def #{name}(*args, &block)
+          @func_map['#{name}'].call(*args,&block)
+        end
+      EOS
+      module_function(name)
+      f
+    end
+
+    # Creates a global method from the given C +signature+ using the given
+    # +opts+ as bind parameters with the given block.
+    def bind(signature, *opts, &blk)
+      name, ctype, argtype = parse_signature(signature, @type_alias)
+      h = parse_bind_options(opts)
+      case h[:callback_type]
+      when :bind, nil
+        f = bind_function(name, ctype, argtype, h[:call_type], &blk)
+      else
+        raise(RuntimeError, "unknown callback type: #{h[:callback_type]}")
+      end
+      @func_map[name] = f
+      #define_method(name){|*args,&block| f.call(*args,&block)}
+      begin
+        /^(.+?):(\d+)/ =~ caller.first
+        file, line = $1, $2.to_i
+      rescue
+        file, line = __FILE__, __LINE__+3
+      end
+      module_eval(<<-EOS, file, line)
+        def #{name}(*args,&block)
+          @func_map['#{name}'].call(*args,&block)
+        end
+      EOS
+      module_function(name)
+      f
+    end
+
+    # Creates a class to wrap the C struct described by +signature+.
+    #
+    #   MyStruct = struct ['int i', 'char c']
+    def struct(signature)
+      tys, mems = parse_struct_signature(signature, @type_alias)
+      Fiddle::CStructBuilder.create(CStruct, tys, mems)
+    end
+
+    # Creates a class to wrap the C union described by +signature+.
+    #
+    #   MyUnion = union ['int i', 'char c']
+    def union(signature)
+      tys, mems = parse_struct_signature(signature, @type_alias)
+      Fiddle::CStructBuilder.create(CUnion, tys, mems)
+    end
+
+    # Returns the function mapped to +name+, that was created by either
+    # Fiddle::Importer.extern or Fiddle::Importer.bind
+    def [](name)
+      @func_map[name]
+    end
+
+    # Creates a class to wrap the C struct with the value +ty+
+    #
+    # See also Fiddle::Importer.struct
+    def create_value(ty, val=nil)
+      s = struct([ty + " value"])
+      ptr = s.malloc()
+      if( val )
+        ptr.value = val
+      end
+      return ptr
+    end
+    alias value create_value
+
+    # Returns a new instance of the C struct with the value +ty+ at the +addr+
+    # address.
+    def import_value(ty, addr)
+      s = struct([ty + " value"])
+      ptr = s.new(addr)
+      return ptr
+    end
+
+
+    # The Fiddle::CompositeHandler instance
+    #
+    # Will raise an error if no handlers are open.
+    def handler
+      @handler or raise "call dlload before importing symbols and functions"
+    end
+
+    # Returns a new Fiddle::Pointer instance at the memory address of the given
+    # +name+ symbol.
+    #
+    # Raises a DLError if the +name+ doesn't exist.
+    #
+    # See Fiddle::CompositeHandler.sym and Fiddle::Handle.sym
+    def import_symbol(name)
+      addr = handler.sym(name)
+      if( !addr )
+        raise(DLError, "cannot find the symbol: #{name}")
+      end
+      Pointer.new(addr)
+    end
+
+    # Returns a new Fiddle::Function instance at the memory address of the given
+    # +name+ function.
+    #
+    # Raises a DLError if the +name+ doesn't exist.
+    #
+    # * +argtype+ is an Array of arguments, passed to the +name+ function.
+    # * +ctype+ is the return type of the function
+    # * +call_type+ is the ABI of the function
+    #
+    # See also Fiddle:Function.new
+    #
+    # See Fiddle::CompositeHandler.sym and Fiddle::Handler.sym
+    def import_function(name, ctype, argtype, call_type = nil)
+      addr = handler.sym(name)
+      if( !addr )
+        raise(DLError, "cannot find the function: #{name}()")
+      end
+      Function.new(addr, argtype, ctype, CALL_TYPE_TO_ABI[call_type],
+                   name: name)
+    end
+
+    # Returns a new closure wrapper for the +name+ function.
+    #
+    # * +ctype+ is the return type of the function
+    # * +argtype+ is an Array of arguments, passed to the callback function
+    # * +call_type+ is the abi of the closure
+    # * +block+ is passed to the callback
+    #
+    # See Fiddle::Closure
+    def bind_function(name, ctype, argtype, call_type = nil, &block)
+      abi = CALL_TYPE_TO_ABI[call_type]
+      closure = Class.new(Fiddle::Closure) {
+        define_method(:call, block)
+      }.new(ctype, argtype, abi)
+
+      Function.new(closure, argtype, ctype, abi, name: name)
+    end
+  end
+end