cloudsmith-api 0.30.7 → 0.44.4

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.25/Rakefile

@@ -1,268 +0,0 @@
-require 'rubygems/tasks'
-require 'rbconfig'
-require 'rake/clean'
-require File.expand_path("./lib/ffi/version")
-
-USE_RAKE_COMPILER = (RUBY_PLATFORM =~ /java/) ? false : true
-if USE_RAKE_COMPILER
-  require 'rake/extensiontask'
-end
-
-require 'date'
-require 'fileutils'
-require 'rbconfig'
-require 'rspec/core/rake_task'
-require 'rubygems/package_task'
-
-LIBEXT = case RbConfig::CONFIG['host_os'].downcase
-  when /darwin/
-    "dylib"
-  when /mswin|mingw/
-    "dll"
-  else
-    RbConfig::CONFIG['DLEXT']
-  end
-
-CPU = case RbConfig::CONFIG['host_cpu'].downcase
-  when /i[3456]86/
-    # Darwin always reports i686, even when running in 64bit mode
-    if RbConfig::CONFIG['host_os'] =~ /darwin/ && 0xfee1deadbeef.is_a?(Fixnum)
-      "x86_64"
-    else
-      "i386"
-    end
-
-  when /amd64|x86_64/
-    "x86_64"
-
-  when /ppc64|powerpc64/
-    "powerpc64"
-
-  when /ppc|powerpc/
-    "powerpc"
-
-  when /^arm/
-    "arm"
-
-  else
-    RbConfig::CONFIG['host_cpu']
-  end
-
-OS = case RbConfig::CONFIG['host_os'].downcase
-  when /linux/
-    "linux"
-  when /darwin/
-    "darwin"
-  when /freebsd/
-    "freebsd"
-  when /openbsd/
-    "openbsd"
-  when /sunos|solaris/
-    "solaris"
-  when /mswin|mingw/
-    "win32"
-  else
-    RbConfig::CONFIG['host_os'].downcase
-  end
-
-def which(name)
-  exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-  ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-    exts.each do |ext|
-      app = File.join(path, name+ext)
-      return app if File.executable? app
-    end
-  end
-  nil
-end
-
-GMAKE = which('gmake').nil? ? 'make' : 'gmake'
-
-LIBTEST = "build/libtest.#{LIBEXT}"
-BUILD_DIR = "build"
-BUILD_EXT_DIR = File.join(BUILD_DIR, "#{RbConfig::CONFIG['arch']}", 'ffi_c', RUBY_VERSION)
-
-def gem_spec
-  @gem_spec ||= Gem::Specification.load('ffi.gemspec')
-end
-
-TEST_DEPS = [ LIBTEST ]
-if RUBY_PLATFORM == "java"
-  RSpec::Core::RakeTask.new(:spec) do |config|
-    config.rspec_opts = YAML.load_file 'spec/spec.opts'
-  end
-else
-  RSpec::Core::RakeTask.new(:spec => :compile) do |config|
-    config.rspec_opts = YAML.load_file 'spec/spec.opts'
-  end
-
-  TEST_DEPS.unshift :compile
-end
-
-desc "Build all packages"
-task :package => %w[ gem:java gem:windows ]
-
-CLOBBER.include 'lib/ffi/types.conf'
-CLOBBER.include 'pkg'
-CLOBBER.include 'log'
-
-CLEAN.include 'build'
-CLEAN.include 'conftest.dSYM'
-CLEAN.include 'spec/ffi/fixtures/libtest.{dylib,so,dll}'
-CLEAN.include 'spec/ffi/fixtures/*.o'
-CLEAN.include "pkg/ffi-*-{mingw32,java}"
-CLEAN.include 'lib/1.*'
-CLEAN.include 'lib/2.*'
-CLEAN.include 'bin'
-
-task :distclean => :clobber
-
-desc "Build the native test lib"
-file "build/libtest.#{LIBEXT}" => FileList['libtest/**/*.[ch]'] do
-  sh %{#{GMAKE} -f libtest/GNUmakefile CPU=#{CPU} OS=#{OS} }
-end
-
-
-desc "Build test helper lib"
-task :libtest => "build/libtest.#{LIBEXT}"
-
-desc "Test the extension"
-task :test => [ :spec ]
-
-
-namespace :bench do
-  ITER = ENV['ITER'] ? ENV['ITER'].to_i : 100000
-  bench_libs = "-Ilib -I#{BUILD_DIR}" unless RUBY_PLATFORM == "java"
-  bench_files = Dir["bench/bench_*.rb"].reject { |f| f == "bench_helper.rb" }
-  bench_files.each do |bench|
-    task File.basename(bench, ".rb")[6..-1] => TEST_DEPS do
-      sh %{#{Gem.ruby} #{bench_libs} #{bench} #{ITER}}
-    end
-  end
-  task :all => TEST_DEPS do
-    bench_files.each do |bench|
-      sh %{#{Gem.ruby} #{bench_libs} #{bench}}
-    end
-  end
-end
-
-task 'spec:run' => TEST_DEPS
-task 'spec:specdoc' => TEST_DEPS
-
-task :default => :spec
-
-namespace 'java' do
-
-  java_gem_spec = Gem::Specification.new do |s|
-    s.name = gem_spec.name
-    s.version = gem_spec.version
-    s.author = gem_spec.author
-    s.email = gem_spec.email
-    s.homepage = gem_spec.homepage
-    s.summary = gem_spec.summary
-    s.description = gem_spec.description
-    s.files = %w(LICENSE COPYING README.md CHANGELOG.md Rakefile)
-    s.has_rdoc = false
-    s.license = gem_spec.license
-    s.platform = 'java'
-  end
-
-  Gem::PackageTask.new(java_gem_spec) do |pkg|
-    pkg.need_zip = true
-    pkg.need_tar = true
-    pkg.package_dir = 'pkg'
-  end
-end
-
-task 'gem:java' => 'java:gem'
-
-
-if USE_RAKE_COMPILER
-  Rake::ExtensionTask.new('ffi_c', gem_spec) do |ext|
-    ext.name = 'ffi_c'                                        # indicate the name of the extension.
-    # ext.lib_dir = BUILD_DIR                                 # put binaries into this folder.
-    ext.tmp_dir = BUILD_DIR                                   # temporary folder used during compilation.
-    ext.cross_compile = true                                  # enable cross compilation (requires cross compile toolchain)
-    ext.cross_platform = %w[i386-mingw32 x64-mingw32]                     # forces the Windows platform instead of the default one
-    ext.cross_compiling do |spec|
-      spec.files.reject! { |path| File.fnmatch?('ext/*', path) }
-    end
-  end
-
-  # To reduce the gem file size strip mingw32 dlls before packaging
-  ENV['RUBY_CC_VERSION'].to_s.split(':').each do |ruby_version|
-    task "build/i386-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so" do |t|
-      sh "i686-w64-mingw32-strip -S build/i386-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so"
-    end
-
-    task "build/x64-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so" do |t|
-      sh "x86_64-w64-mingw32-strip -S build/x64-mingw32/stage/lib/#{ruby_version[/^\d+\.\d+/]}/ffi_c.so"
-    end
-  end
-
-  desc "build a windows gem without all the ceremony."
-  task "gem:windows" do
-    require "rake_compiler_dock"
-    RakeCompilerDock.sh "sudo apt-get update && sudo apt-get install -y libltdl-dev && bundle && rake cross native gem MAKE='nice make -j`nproc`'"
-  end
-end
-
-directory "ext/ffi_c/libffi"
-file "ext/ffi_c/libffi/autogen.sh" => "ext/ffi_c/libffi" do
-  warn "Downloading libffi ..."
-  sh "git submodule update --init --recursive"
-end
-
-LIBFFI_GIT_FILES = `git --git-dir ext/ffi_c/libffi/.git ls-files -z`.split("\x0")
-
-# Generate files in gemspec but not in libffi's git repo by running autogen.sh
-gem_spec.files.select do |f|
-  f =~ /ext\/ffi_c\/libffi\/(.*)/ && !LIBFFI_GIT_FILES.include?($1)
-end.each do |f|
-  file f => "ext/ffi_c/libffi/autogen.sh" do
-    chdir "ext/ffi_c/libffi" do
-      sh "sh ./autogen.sh"
-    end
-    touch f
-    if gem_spec.files != Gem::Specification.load('./ffi.gemspec').files
-      warn "gemspec files have changed -> Please restart rake!"
-      exit 1
-    end
-  end
-end
-
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), 'lib')
-require 'ffi/platform'
-types_conf = File.expand_path(File.join(FFI::Platform::CONF_DIR, 'types.conf'))
-logfile = File.join(File.dirname(__FILE__), 'types_log')
-
-file types_conf => File.join("lib", "ffi", "version.rb") do |task|
-  require 'fileutils'
-  require 'ffi/tools/types_generator'
-  options = {}
-  FileUtils.mkdir_p(File.dirname(task.name), { :mode => 0755 })
-  File.open(task.name, File::CREAT|File::TRUNC|File::RDWR, 0644) do |f|
-    f.puts FFI::TypesGenerator.generate(options)
-  end
-  File.open(logfile, 'w') do |log|
-    log.puts(types_conf)
-  end
-end
-
-task :types_conf => types_conf do
-end
-
-Gem::Tasks.new do |t|
-  t.scm.tag.format = '%s'
-end
-
-begin
-  require 'yard'
-
-  namespace :doc do
-    YARD::Rake::YardocTask.new do |yard|
-    end
-  end
-rescue LoadError
-  warn "[warn] YARD unavailable"
-end

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.25/appveyor.yml

@@ -1,22 +0,0 @@
-install:
-  - SET PATH=C:\Ruby%RUBYVER%\bin;%PATH%
-  - SET RAKEOPT=-rdevkit
-  - ps: |
-      if ($env:RUBYVER -like "*head*") {
-        $(new-object net.webclient).DownloadFile("https://github.com/oneclick/rubyinstaller2/releases/download/rubyinstaller-head/rubyinstaller-$env:RUBYVER.exe", "$pwd/ruby-setup.exe")
-        cmd /c ruby-setup.exe /verysilent /dir=C:/Ruby$env:RUBYVER
-      }
-  - ridk version
-  - gem --version
-  - gem install bundler --quiet --no-ri --no-rdoc
-  - bundle install
-build: off
-build_script:
-  - bundle exec rake compile || bundle exec rake compile
-test_script:
-  - bundle exec rake test
-environment:
-  matrix:
-    - RUBYVER: "head-x64"
-    - RUBYVER: 24
-    - RUBYVER: 25-x64

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.9.25/ext/ffi_c/Call.c

@@ -1,520 +0,0 @@
-/*
- * Copyright (c) 2009, Wayne Meissner
- * Copyright (c) 2009, Luc Heinrich <luc@honk-honk.com>
- * Copyright (c) 2009, Mike Dalessio <mike.dalessio@gmail.com>
- * Copyright (c) 2009, Aman Gupta.
- * Copyright (c) 2008-2013, Ruby FFI project contributors
- * 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 <COPYRIGHT HOLDER> 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.
- */
-
-#ifndef _MSC_VER
-#include <sys/param.h>
-#endif
-#include <sys/types.h>
-#include <stdio.h>
-#ifndef _MSC_VER
-# include <stdint.h>
-# include <stdbool.h>
-#else
-# include "win32/stdbool.h"
-# include "win32/stdint.h"
-#endif
-#include <errno.h>
-#include <ruby.h>
-#if defined(HAVE_RUBY_THREAD_H)
-#include <ruby/thread.h>
-#endif
-#if defined(HAVE_NATIVETHREAD) && (defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)) && !defined(_WIN32)
-#  include <signal.h>
-#  include <pthread.h>
-#endif
-#include <ffi.h>
-#include "extconf.h"
-#include "rbffi.h"
-#include "compat.h"
-#include "AbstractMemory.h"
-#include "Pointer.h"
-#include "Struct.h"
-#include "Function.h"
-#include "Type.h"
-#include "LastError.h"
-#include "Call.h"
-#include "MappedType.h"
-#include "Thread.h"
-#include "LongDouble.h"
-
-#ifdef USE_RAW
-#  ifndef __i386__
-#    error "RAW argument packing only supported on i386"
-#  endif
-
-#define INT8_ADJ (4)
-#define INT16_ADJ (4)
-#define INT32_ADJ (4)
-#define INT64_ADJ (8)
-#define LONG_ADJ (sizeof(long))
-#define FLOAT32_ADJ (4)
-#define FLOAT64_ADJ (8)
-#define ADDRESS_ADJ (sizeof(void *))
-#define LONGDOUBLE_ADJ (ffi_type_longdouble.alignment)
-
-#endif /* USE_RAW */
-
-#ifdef USE_RAW
-#  define ADJ(p, a) ((p) = (FFIStorage*) (((char *) p) + a##_ADJ))
-#else
-#  define ADJ(p, a) (++(p))
-#endif
-
-static void* callback_param(VALUE proc, VALUE cbinfo);
-static inline void* getPointer(VALUE value, int type);
-
-static ID id_to_ptr, id_map_symbol, id_to_native;
-
-void
-rbffi_SetupCallParams(int argc, VALUE* argv, int paramCount, Type** paramTypes,
-        FFIStorage* paramStorage, void** ffiValues,
-        VALUE* callbackParameters, int callbackCount, VALUE enums)
-{
-    VALUE callbackProc = Qnil;
-    FFIStorage* param = &paramStorage[0];
-    int i, argidx, cbidx, argCount;
-
-    if (unlikely(paramCount != -1 && paramCount != argc)) {
-        if (argc == (paramCount - 1) && callbackCount == 1 && rb_block_given_p()) {
-            callbackProc = rb_block_proc();
-        } else {
-            rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, paramCount);
-        }
-    }
-
-    argCount = paramCount != -1 ? paramCount : argc;
-
-    for (i = 0, argidx = 0, cbidx = 0; i < argCount; ++i) {
-        Type* paramType = paramTypes[i];
-        int type;
-
-        
-        if (unlikely(paramType->nativeType == NATIVE_MAPPED)) {
-            VALUE values[] = { argv[argidx], Qnil };
-            argv[argidx] = rb_funcall2(((MappedType *) paramType)->rbConverter, id_to_native, 2, values);
-            paramType = ((MappedType *) paramType)->type;
-        }
-
-        type = argidx < argc ? TYPE(argv[argidx]) : T_NONE;
-        ffiValues[i] = param;
-
-        switch (paramType->nativeType) {
-
-            case NATIVE_INT8:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    param->s8 = NUM2INT(value);
-                } else {
-                    param->s8 = NUM2INT(argv[argidx]);
-                }
-
-                ++argidx;
-                ADJ(param, INT8);
-                break;
-
-            case NATIVE_INT16:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    param->s16 = NUM2INT(value);
-
-                } else {
-                    param->s16 = NUM2INT(argv[argidx]);
-                }
-
-                ++argidx;
-                ADJ(param, INT16);
-                break;
-
-            case NATIVE_INT32:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    param->s32 = NUM2INT(value);
-
-                } else {
-                    param->s32 = NUM2INT(argv[argidx]);
-                }
-
-                ++argidx;
-                ADJ(param, INT32);
-                break;
-
-            case NATIVE_BOOL:
-                if (type != T_TRUE && type != T_FALSE) {
-                    rb_raise(rb_eTypeError, "wrong argument type  (expected a boolean parameter)");
-                }
-                param->s8 = argv[argidx++] == Qtrue;
-                ADJ(param, INT8);
-                break;
-
-            case NATIVE_UINT8:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    param->u8 = NUM2UINT(value);
-                } else {
-                    param->u8 = NUM2UINT(argv[argidx]);
-                }
-
-                ADJ(param, INT8);
-                ++argidx;
-                break;
-
-            case NATIVE_UINT16:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    param->u16 = NUM2UINT(value);
-                } else {
-                    param->u16 = NUM2UINT(argv[argidx]);
-                }
-
-                ADJ(param, INT16);
-                ++argidx;
-                break;
-
-            case NATIVE_UINT32:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    param->u32 = NUM2UINT(value);
-                } else {
-                    param->u32 = NUM2UINT(argv[argidx]);
-                }
-
-                ADJ(param, INT32);
-                ++argidx;
-                break;
-
-            case NATIVE_INT64:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    param->i64 = NUM2LL(value);
-                } else {
-                    param->i64 = NUM2LL(argv[argidx]);
-                }
-
-                ADJ(param, INT64);
-                ++argidx;
-                break;
-
-            case NATIVE_UINT64:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    param->u64 = NUM2ULL(value);
-                } else {
-                    param->u64 = NUM2ULL(argv[argidx]);
-                }
-
-                ADJ(param, INT64);
-                ++argidx;
-                break;
-
-            case NATIVE_LONG:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    *(ffi_sarg *) param = NUM2LONG(value);
-                } else {
-                    *(ffi_sarg *) param = NUM2LONG(argv[argidx]);
-                }
-
-                ADJ(param, LONG);
-                ++argidx;
-                break;
-
-            case NATIVE_ULONG:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    *(ffi_arg *) param = NUM2ULONG(value);
-                } else {
-                    *(ffi_arg *) param = NUM2ULONG(argv[argidx]);
-                }
-
-                ADJ(param, LONG);
-                ++argidx;
-                break;
-
-            case NATIVE_FLOAT32:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    param->f32 = (float) NUM2DBL(value);
-                } else {
-                    param->f32 = (float) NUM2DBL(argv[argidx]);
-                }
-
-                ADJ(param, FLOAT32);
-                ++argidx;
-                break;
-
-            case NATIVE_FLOAT64:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    param->f64 = NUM2DBL(value);
-                } else {
-                    param->f64 = NUM2DBL(argv[argidx]);
-                }
-
-                ADJ(param, FLOAT64);
-                ++argidx;
-                break;
-
-            case NATIVE_LONGDOUBLE:
-                if (unlikely(type == T_SYMBOL && enums != Qnil)) {
-                    VALUE value = rb_funcall(enums, id_map_symbol, 1, argv[argidx]);
-                    param->ld = rbffi_num2longdouble(value);
-                } else {
-                    param->ld = rbffi_num2longdouble(argv[argidx]);
-                }
-
-                ADJ(param, LONGDOUBLE);
-                ++argidx;
-                break;
-
-
-            case NATIVE_STRING:
-                if (type == T_NIL) {
-                    param->ptr = NULL; 
-                
-                } else {
-                    if (rb_safe_level() >= 1 && OBJ_TAINTED(argv[argidx])) {
-                        rb_raise(rb_eSecurityError, "Unsafe string parameter");
-                    }
-
-                    param->ptr = StringValueCStr(argv[argidx]);
-                }
-
-                ADJ(param, ADDRESS);
-                ++argidx;
-                break;
-
-            case NATIVE_POINTER:
-            case NATIVE_BUFFER_IN:
-            case NATIVE_BUFFER_OUT:
-            case NATIVE_BUFFER_INOUT:
-                param->ptr = getPointer(argv[argidx++], type);
-                ADJ(param, ADDRESS);
-                break;
-
-
-            case NATIVE_FUNCTION:
-            case NATIVE_CALLBACK:
-                if (callbackProc != Qnil) {
-                    param->ptr = callback_param(callbackProc, callbackParameters[cbidx++]);
-                } else {
-                    param->ptr = callback_param(argv[argidx], callbackParameters[cbidx++]);
-                    ++argidx;
-                }
-                ADJ(param, ADDRESS);
-                break;
-
-            case NATIVE_STRUCT:
-                ffiValues[i] = getPointer(argv[argidx++], type);
-                break;
-
-            default:
-                rb_raise(rb_eArgError, "Invalid parameter type: %d", paramType->nativeType);
-        }
-    }
-}
-
-static void *
-call_blocking_function(void* data)
-{
-    rbffi_blocking_call_t* b = (rbffi_blocking_call_t *) data;
-    b->frame->has_gvl = false;
-    ffi_call(&b->cif, FFI_FN(b->function), b->retval, b->ffiValues);
-    b->frame->has_gvl = true;
-
-    return NULL;
-}
-
-VALUE
-rbffi_do_blocking_call(void *data)
-{
-    rbffi_thread_blocking_region(call_blocking_function, data, (void *) -1, NULL);
-
-    return Qnil;
-}
-
-VALUE
-rbffi_save_frame_exception(void *data, VALUE exc)
-{
-    rbffi_frame_t* frame = (rbffi_frame_t *) data;
-    frame->exc = exc;
-    return Qnil;
-}
-
-VALUE
-rbffi_CallFunction(int argc, VALUE* argv, void* function, FunctionType* fnInfo)
-{
-    void* retval;
-    void** ffiValues;
-    FFIStorage* params;
-    VALUE rbReturnValue;
-    rbffi_frame_t frame = { 0 };
-    
-    retval = alloca(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
-    
-    if (unlikely(fnInfo->blocking)) {
-        rbffi_blocking_call_t* bc;
-
-        /*
-         * due to the way thread switching works on older ruby variants, we
-         * cannot allocate anything passed to the blocking function on the stack
-         */
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
-        ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
-        params = ALLOCA_N(FFIStorage, fnInfo->parameterCount);
-        bc = ALLOCA_N(rbffi_blocking_call_t, 1);
-        bc->retval = retval;
-#else
-        ffiValues = ALLOC_N(void *, fnInfo->parameterCount);
-        params = ALLOC_N(FFIStorage, fnInfo->parameterCount);
-        bc = ALLOC_N(rbffi_blocking_call_t, 1);
-        bc->retval = xmalloc(MAX(fnInfo->ffi_cif.rtype->size, FFI_SIZEOF_ARG));
-        bc->stkretval = retval;
-#endif
-        bc->cif = fnInfo->ffi_cif;
-        bc->function = function;
-        bc->ffiValues = ffiValues;
-        bc->params = params;
-        bc->frame = &frame;
-
-        rbffi_SetupCallParams(argc, argv,
-            fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
-            fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
-
-        rbffi_frame_push(&frame); 
-        rb_rescue2(rbffi_do_blocking_call, (VALUE) bc, rbffi_save_frame_exception, (VALUE) &frame, rb_eException, (VALUE) 0);
-        rbffi_frame_pop(&frame);
-
-#if !(defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL))
-        memcpy(bc->stkretval, bc->retval, MAX(bc->cif.rtype->size, FFI_SIZEOF_ARG));
-        xfree(bc->params);
-        xfree(bc->ffiValues);
-        xfree(bc->retval);
-        xfree(bc);
-#endif
-    
-    } else {
-
-        ffiValues = ALLOCA_N(void *, fnInfo->parameterCount);
-        params = ALLOCA_N(FFIStorage, fnInfo->parameterCount);
-
-        rbffi_SetupCallParams(argc, argv,
-            fnInfo->parameterCount, fnInfo->parameterTypes, params, ffiValues,
-            fnInfo->callbackParameters, fnInfo->callbackCount, fnInfo->rbEnums);
-
-        rbffi_frame_push(&frame);
-        ffi_call(&fnInfo->ffi_cif, FFI_FN(function), retval, ffiValues);
-        rbffi_frame_pop(&frame);
-    }
-
-    if (unlikely(!fnInfo->ignoreErrno)) {
-        rbffi_save_errno();
-    }    
-
-    if (RTEST(frame.exc) && frame.exc != Qnil) {
-        rb_exc_raise(frame.exc);
-    }
-
-    RB_GC_GUARD(rbReturnValue) = rbffi_NativeValue_ToRuby(fnInfo->returnType, fnInfo->rbReturnType, retval);
-    RB_GC_GUARD(fnInfo->rbReturnType);
-    
-    return rbReturnValue;
-}
-
-static inline void*
-getPointer(VALUE value, int type)
-{
-    if (likely(type == T_DATA && rb_obj_is_kind_of(value, rbffi_AbstractMemoryClass))) {
-
-        return ((AbstractMemory *) DATA_PTR(value))->address;
-
-    } else if (type == T_DATA && rb_obj_is_kind_of(value, rbffi_StructClass)) {
-
-        AbstractMemory* memory = ((Struct *) DATA_PTR(value))->pointer;
-        return memory != NULL ? memory->address : NULL;
-
-    } else if (type == T_STRING) {
-        
-        return StringValuePtr(value);
-
-    } else if (type == T_NIL) {
-
-        return NULL;
-
-    } else if (rb_respond_to(value, id_to_ptr)) {
-
-        VALUE ptr = rb_funcall2(value, id_to_ptr, 0, NULL);
-        if (rb_obj_is_kind_of(ptr, rbffi_AbstractMemoryClass) && TYPE(ptr) == T_DATA) {
-            return ((AbstractMemory *) DATA_PTR(ptr))->address;
-        }
-        rb_raise(rb_eArgError, "to_ptr returned an invalid pointer");
-    }
-
-    rb_raise(rb_eArgError, ":pointer argument is not a valid pointer");
-    return NULL;
-}
-
-Invoker
-rbffi_GetInvoker(FunctionType *fnInfo)
-{
-    return rbffi_CallFunction;
-}
-
-
-static void*
-callback_param(VALUE proc, VALUE cbInfo)
-{
-    VALUE callback ;
-    if (unlikely(proc == Qnil)) {
-        return NULL ;
-    }
-
-    /* Handle Function pointers here */
-    if (rb_obj_is_kind_of(proc, rbffi_FunctionClass)) {
-        AbstractMemory* ptr;
-        Data_Get_Struct(proc, AbstractMemory, ptr);
-        return ptr->address;
-    }
-
-    callback = rbffi_Function_ForProc(cbInfo, proc);
-    RB_GC_GUARD(callback);
-
-    return ((AbstractMemory *) DATA_PTR(callback))->address;
-}
-
-
-void
-rbffi_Call_Init(VALUE moduleFFI)
-{
-    id_to_ptr = rb_intern("to_ptr");
-    id_to_native = rb_intern("to_native");
-    id_map_symbol = rb_intern("__map_symbol");
-}
-