ffi 1.15.5-x64-mingw-ucrt

data/lib/ffi/types.rb

@@ -0,0 +1,194 @@
+#
+# Copyright (C) 2008-2010 Wayne Meissner
+# Copyright (c) 2007, 2008 Evan Phoenix
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+# see {file:README}
+module FFI
+
+  # @param [Type, DataConverter, Symbol] old type definition used by {FFI.find_type}
+  # @param [Symbol] add new type definition's name to add
+  # @return [Type]
+  # Add a definition type to type definitions.
+  def self.typedef(old, add)
+    TypeDefs[add] = self.find_type(old)
+  end
+
+  # (see FFI.typedef)
+  def self.add_typedef(old, add)
+    typedef old, add
+  end
+
+
+  # @param [Type, DataConverter, Symbol] name
+  # @param [Hash] type_map if nil, {FFI::TypeDefs} is used
+  # @return [Type]
+  # Find a type in +type_map+ ({FFI::TypeDefs}, by default) from
+  # a type objet, a type name (symbol). If +name+ is a {DataConverter},
+  # a new {Type::Mapped} is created.
+  def self.find_type(name, type_map = nil)
+    if name.is_a?(Type)
+      name
+
+    elsif type_map && type_map.has_key?(name)
+      type_map[name]
+
+    elsif TypeDefs.has_key?(name)
+      TypeDefs[name]
+
+    elsif name.is_a?(DataConverter)
+      (type_map || TypeDefs)[name] = Type::Mapped.new(name)
+    else
+      raise TypeError, "unable to resolve type '#{name}'"
+    end
+  end
+
+  # List of type definitions
+  TypeDefs.merge!({
+      # The C void type; only useful for function return types
+      :void => Type::VOID,
+
+      # C boolean type
+      :bool => Type::BOOL,
+
+      # C nul-terminated string
+      :string => Type::STRING,
+
+      # C signed char
+      :char => Type::CHAR,
+      # C unsigned char
+      :uchar => Type::UCHAR,
+
+      # C signed short
+      :short => Type::SHORT,
+      # C unsigned short
+      :ushort => Type::USHORT,
+
+      # C signed int
+      :int => Type::INT,
+      # C unsigned int
+      :uint => Type::UINT,
+
+      # C signed long
+      :long => Type::LONG,
+
+      # C unsigned long
+      :ulong => Type::ULONG,
+
+      # C signed long long integer
+      :long_long => Type::LONG_LONG,
+
+      # C unsigned long long integer
+      :ulong_long => Type::ULONG_LONG,
+
+      # C single precision float
+      :float => Type::FLOAT,
+
+      # C double precision float
+      :double => Type::DOUBLE,
+
+      # C long double
+      :long_double => Type::LONGDOUBLE,
+
+      # Native memory address
+      :pointer => Type::POINTER,
+
+      # 8 bit signed integer
+      :int8 => Type::INT8,
+      # 8 bit unsigned integer
+      :uint8 => Type::UINT8,
+
+      # 16 bit signed integer
+      :int16 => Type::INT16,
+      # 16 bit unsigned integer
+      :uint16 => Type::UINT16,
+
+      # 32 bit signed integer
+      :int32 => Type::INT32,
+      # 32 bit unsigned integer
+      :uint32 => Type::UINT32,
+
+      # 64 bit signed integer
+      :int64 => Type::INT64,
+      # 64 bit unsigned integer
+      :uint64 => Type::UINT64,
+
+      :buffer_in => Type::BUFFER_IN,
+      :buffer_out => Type::BUFFER_OUT,
+      :buffer_inout => Type::BUFFER_INOUT,
+
+      # Used in function prototypes to indicate the arguments are variadic
+      :varargs => Type::VARARGS,
+  })
+
+  # This will convert a pointer to a Ruby string (just like `:string`), but
+  # also allow to work with the pointer itself. This is useful when you want
+  # a Ruby string already containing a copy of the data, but also the pointer
+  # to the data for you to do something with it, like freeing it, in case the
+  # library handed the memory off to the caller (Ruby-FFI).
+  #
+  # It's {typedef}'d as +:strptr+.
+  class StrPtrConverter
+    extend DataConverter
+    native_type Type::POINTER
+
+    # @param [Pointer] val
+    # @param ctx not used
+    # @return [Array(String, Pointer)]
+    # Returns a [ String, Pointer ] tuple so the C memory for the string can be freed
+    def self.from_native(val, ctx)
+      [ val.null? ? nil : val.get_string(0), val ]
+    end
+  end
+
+  typedef(StrPtrConverter, :strptr)
+
+  # @param type +type+ is an instance of class accepted by {FFI.find_type}
+  # @return [Numeric]
+  # Get +type+ size, in bytes.
+  def self.type_size(type)
+    find_type(type).size
+  end
+
+  # Load all the platform dependent types
+  begin
+    File.open(File.join(Platform::CONF_DIR, 'types.conf'), "r") do |f|
+      prefix = "rbx.platform.typedef."
+      f.each_line { |line|
+        if line.index(prefix) == 0
+          new_type, orig_type = line.chomp.slice(prefix.length..-1).split(/\s*=\s*/)
+          typedef(orig_type.to_sym, new_type.to_sym)
+        end
+      }
+    end
+    typedef :pointer, :caddr_t
+  rescue Errno::ENOENT
+  end
+end

data/lib/ffi/union.rb

@@ -0,0 +1,43 @@
+#
+# Copyright (C) 2009 Andrea Fazzi <andrea.fazzi@alcacoop.it>
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+require 'ffi/struct'
+
+module FFI
+
+  class Union < FFI::Struct
+    def self.builder
+      b = StructLayoutBuilder.new
+      b.union = true
+      b
+    end
+  end
+end

data/lib/ffi/variadic.rb

@@ -0,0 +1,69 @@
+#
+# Copyright (C) 2008, 2009 Wayne Meissner
+# Copyright (C) 2009 Luc Heinrich
+#
+# This file is part of ruby-ffi.
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Ruby FFI project nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+module FFI
+  class VariadicInvoker
+    def call(*args, &block)
+      param_types = Array.new(@fixed)
+      param_values = Array.new
+      @fixed.each_with_index do |t, i|
+        param_values << args[i]
+      end
+      i = @fixed.length
+      while i < args.length
+        param_types << FFI.find_type(args[i], @type_map)
+        param_values << args[i + 1]
+        i += 2
+      end
+      invoke(param_types, param_values, &block)
+    end
+
+    #
+    # Attach the invoker to module +mod+ as +mname+
+    #
+    def attach(mod, mname)
+      invoker = self
+      params = "*args"
+      call = "call"
+      mod.module_eval <<-code
+      @@#{mname} = invoker
+      def self.#{mname}(#{params})
+        @@#{mname}.#{call}(#{params})
+      end
+      def #{mname}(#{params})
+        @@#{mname}.#{call}(#{params})
+      end
+      code
+      invoker
+    end
+  end
+end

data/lib/ffi/version.rb

@@ -0,0 +1,3 @@
+module FFI
+  VERSION = '1.15.5'
+end

data/lib/ffi.rb

@@ -0,0 +1,27 @@
+if RUBY_ENGINE == 'ruby'
+  begin
+    require RUBY_VERSION.split('.')[0, 2].join('.') + '/ffi_c'
+  rescue Exception
+    require 'ffi_c'
+  end
+
+  require 'ffi/ffi'
+
+elsif RUBY_ENGINE == 'jruby' && (RUBY_ENGINE_VERSION.split('.').map(&:to_i) <=> [9, 2, 20]) >= 0
+  JRuby::Util.load_ext("org.jruby.ext.ffi.FFIService")
+  require 'ffi/ffi'
+
+elsif RUBY_ENGINE == 'truffleruby' && (RUBY_ENGINE_VERSION.split('.').map(&:to_i) <=> [20, 1, 0]) >= 0
+  require 'truffleruby/ffi_backend'
+  require 'ffi/ffi'
+
+else
+  # Remove the ffi gem dir from the load path, then reload the internal ffi implementation
+  $LOAD_PATH.delete(File.dirname(__FILE__))
+  $LOAD_PATH.delete(File.join(File.dirname(__FILE__), 'ffi'))
+  unless $LOADED_FEATURES.nil?
+    $LOADED_FEATURES.delete(__FILE__)
+    $LOADED_FEATURES.delete('ffi.rb')
+  end
+  require 'ffi.rb'
+end

data/rakelib/ffi_gem_helper.rb

@@ -0,0 +1,65 @@
+require 'bundler'
+require 'bundler/gem_helper'
+
+class FfiGemHelper < Bundler::GemHelper
+  attr_accessor :cross_platforms
+
+  def install
+    super
+
+    task "release:guard_clean" => ["release:update_history"]
+
+    task "release:update_history" do
+      update_history
+    end
+
+    task "release:rubygem_push" => ["gem:native", "gem:java"]
+  end
+
+  def hfile
+    "CHANGELOG.md"
+  end
+
+  def headline
+    '([^\w]*)(\d+\.\d+\.\d+(?:\.\w+)?)([^\w]+)([2Y][0Y][0-9Y][0-9Y]-[0-1M][0-9M]-[0-3D][0-9D])([^\w]*|$)'
+  end
+
+  def reldate
+    Time.now.strftime("%Y-%m-%d")
+  end
+
+  def update_history
+    hin = File.read(hfile)
+    hout = hin.sub(/#{headline}/) do
+      raise "#{hfile} isn't up-to-date for version #{version}" unless $2==version.to_s
+      $1 + $2 + $3 + reldate + $5
+    end
+    if hout != hin
+      Bundler.ui.confirm "Updating #{hfile} for release."
+      File.write(hfile, hout)
+      Rake::FileUtilsExt.sh "git", "commit", hfile, "-m", "Update release date in #{hfile}"
+    end
+  end
+
+  def tag_version
+    Bundler.ui.confirm "Tag release with annotation:"
+    m = File.read(hfile).match(/(?<annotation>#{headline}.*?)#{headline}/m) || raise("Unable to find release notes in #{hfile}")
+    Bundler.ui.info(m[:annotation].gsub(/^/, "    "))
+    IO.popen(["git", "tag", "--file=-", version_tag], "w") do |fd|
+      fd.write m[:annotation]
+    end
+    yield if block_given?
+  rescue
+    Bundler.ui.error "Untagging #{version_tag} due to error."
+    sh_with_code "git tag -d #{version_tag}"
+    raise
+  end
+
+  def rubygem_push(path)
+    cross_platforms.each do |ruby_platform|
+      super(path.gsub(/\.gem\z/, "-#{ruby_platform}.gem"))
+    end
+    super(path.gsub(/\.gem\z/, "-java.gem"))
+    super(path)
+  end
+end

data/samples/getlogin.rb

@@ -0,0 +1,8 @@
+require 'ffi'
+
+module Foo
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  attach_function :getlogin, [ ], :string
+end
+puts "getlogin=#{Foo.getlogin}"

data/samples/getpid.rb

@@ -0,0 +1,8 @@
+require 'ffi'
+
+module Foo
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  attach_function :getpid, [ ], :int
+end
+puts "My pid=#{Foo.getpid}"

data/samples/gettimeofday.rb

@@ -0,0 +1,18 @@
+require 'ffi'
+require 'rbconfig'
+
+class Timeval < FFI::Struct
+  layout tv_sec: :ulong, tv_usec: :ulong
+end
+module LibC
+  extend FFI::Library
+  if FFI::Platform.windows?
+    ffi_lib RbConfig::CONFIG["LIBRUBY_SO"]
+  else
+    ffi_lib FFI::Library::LIBC
+  end
+  attach_function :gettimeofday, [ :pointer, :pointer ], :int
+end
+t = Timeval.new
+LibC.gettimeofday(t.pointer, nil)
+puts "t.tv_sec=#{t[:tv_sec]} t.tv_usec=#{t[:tv_usec]}"

data/samples/hello.rb

@@ -0,0 +1,8 @@
+require 'ffi'
+
+module Foo
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  attach_function("cputs", "puts", [ :string ], :int)
+end
+Foo.cputs("Hello, World via libc puts using FFI on MRI ruby")

data/samples/inotify.rb

@@ -0,0 +1,60 @@
+require 'ffi'
+
+module Inotify
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  class Event < FFI::Struct
+    layout \
+      :wd, :int,
+      :mask, :uint,
+      :cookie, :uint,
+      :len, :uint
+  end
+  attach_function :init, :inotify_init, [ ], :int
+  attach_function :add_watch, :inotify_add_watch, [ :int, :string, :uint ], :int
+  attach_function :rm_watch, :inotify_rm_watch, [ :int, :uint ], :int
+  attach_function :read, [ :int, :buffer_out, :uint ], :int
+  IN_ACCESS=0x00000001
+  IN_MODIFY=0x00000002
+  IN_ATTRIB=0x00000004
+  IN_CLOSE_WRITE=0x00000008
+  IN_CLOSE_NOWRITE=0x00000010
+  IN_CLOSE=(IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
+  IN_OPEN=0x00000020
+  IN_MOVED_FROM=0x00000040
+  IN_MOVED_TO=0x00000080
+  IN_MOVE= (IN_MOVED_FROM | IN_MOVED_TO)
+  IN_CREATE=0x00000100
+  IN_DELETE=0x00000200
+  IN_DELETE_SELF=0x00000400
+  IN_MOVE_SELF=0x00000800
+  # Events sent by the kernel.
+  IN_UNMOUNT=0x00002000
+  IN_Q_OVERFLOW=0x00004000
+  IN_IGNORED=0x00008000
+  IN_ONLYDIR=0x01000000
+  IN_DONT_FOLLOW=0x02000000
+  IN_MASK_ADD=0x20000000
+  IN_ISDIR=0x40000000
+  IN_ONESHOT=0x80000000
+  IN_ALL_EVENTS=(IN_ACCESS | IN_MODIFY | IN_ATTRIB | IN_CLOSE_WRITE \
+                          | IN_CLOSE_NOWRITE | IN_OPEN | IN_MOVED_FROM \
+                          | IN_MOVED_TO | IN_CREATE | IN_DELETE \
+                          | IN_DELETE_SELF | IN_MOVE_SELF)
+
+end
+if $0 == __FILE__
+  fd = Inotify.init
+  puts "fd=#{fd}"
+  wd = Inotify.add_watch(fd, "/tmp/", Inotify::IN_ALL_EVENTS)
+  fp = FFI::IO.for_fd(fd)
+  puts "wfp=#{fp}"
+  while true
+    buf = FFI::Buffer.alloc_out(Inotify::Event.size + 4096, 1, false)
+    ev = Inotify::Event.new buf
+    ready = IO.select([ fp ], nil, nil, nil)
+    n = Inotify.read(fd, buf, buf.total)
+    puts "Read #{n} bytes from inotify fd"
+    puts "event.wd=#{ev[:wd]} mask=#{ev[:mask]} len=#{ev[:len]} name=#{ev[:len] > 0 ? buf.get_string(16) : 'unknown'}"
+  end
+end

data/samples/pty.rb

@@ -0,0 +1,75 @@
+require 'ffi'
+
+module PTY
+  private
+  module LibC
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+    attach_function :forkpty, [ :buffer_out, :buffer_out, :buffer_in, :buffer_in ], :int
+    attach_function :openpty, [ :buffer_out, :buffer_out, :buffer_out, :buffer_in, :buffer_in ], :int
+    attach_function :login_tty, [ :int ], :int
+    attach_function :close, [ :int ], :int
+    attach_function :strerror, [ :int ], :string
+    attach_function :fork, [], :int
+    attach_function :execv, [ :string, :buffer_in ], :int
+    attach_function :execvp, [ :string, :buffer_in ], :int
+    attach_function :dup2, [ :int, :int ], :int
+    attach_function :dup, [ :int ], :int
+  end
+  Buffer = FFI::Buffer
+  def self.build_args(args)
+    cmd = args.shift
+    cmd_args = args.map do |arg|
+      MemoryPointer.from_string(arg)
+    end
+    exec_args = MemoryPointer.new(:pointer, 1 + cmd_args.length + 1)
+    exec_cmd = MemoryPointer.from_string(cmd)
+    exec_args[0].put_pointer(0, exec_cmd)
+    cmd_args.each_with_index do |arg, i|
+      exec_args[i + 1].put_pointer(0, arg)
+    end
+    [ cmd, exec_args ]
+  end
+  public
+  def self.getpty(*args)
+    mfdp = Buffer.new :int
+    name = Buffer.new 1024
+    #
+    # All the execv setup is done in the parent, since doing anything other than
+    # execv in the child after fork is really flakey
+    #
+    exec_cmd, exec_args = build_args(args)
+    pid = LibC.forkpty(mfdp, name, nil, nil)
+    raise "forkpty failed: #{LibC.strerror(FFI.errno)}" if pid < 0
+    if pid == 0
+      LibC.execvp(exec_cmd, exec_args)
+      exit 1
+    end
+    masterfd = mfdp.get_int(0)
+    rfp = FFI::IO.for_fd(masterfd, "r")
+    wfp = FFI::IO.for_fd(LibC.dup(masterfd), "w")
+    if block_given?
+      yield rfp, wfp, pid
+      rfp.close unless rfp.closed?
+      wfp.close unless wfp.closed?
+    else
+      [ rfp, wfp, pid ]
+    end
+  end
+  def self.spawn(*args, &block)
+    self.getpty("/bin/sh", "-c", args[0], &block)
+  end
+end
+module LibC
+  extend FFI::Library
+  attach_function :close, [ :int ], :int
+  attach_function :write, [ :int, :buffer_in, :ulong ], :long
+  attach_function :read, [ :int, :buffer_out, :ulong ], :long
+end
+PTY.getpty("/bin/ls", "-alR", "/") { |rfd, wfd, pid|
+#PTY.spawn("ls -laR /") { |rfd, wfd, pid|
+  puts "child pid=#{pid}"
+  while !rfd.eof? && (buf = rfd.gets)
+    puts "child: '#{buf.strip}'"
+  end
+}

data/samples/qsort.rb

@@ -0,0 +1,20 @@
+require 'ffi'
+
+module LibC
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  callback :qsort_cmp, [ :pointer, :pointer ], :int
+  attach_function :qsort, [ :pointer, :ulong, :ulong, :qsort_cmp ], :int
+end
+
+p = FFI::MemoryPointer.new(:int, 2)
+p.put_array_of_int32(0, [ 2, 1 ])
+puts "ptr=#{p.inspect}"
+puts "Before qsort #{p.get_array_of_int32(0, 2).join(', ')}"
+LibC.qsort(p, 2, 4) do |p1, p2|
+  i1 = p1.get_int32(0)
+  i2 = p2.get_int32(0)
+  puts "In block: comparing #{i1} and #{i2}"
+  i1 < i2 ? -1 : i1 > i2 ? 1 : 0
+end
+puts "After qsort #{p.get_array_of_int32(0, 2).join(', ')}"