cloudsmith-api 0.44.4 → 0.49.9

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.12.2/ext/ffi_c/Types.c

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2009, Wayne Meissner
+ * Copyright (c) 2009, Luc Heinrich
+ * 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.
+ */
+
+#include <ruby.h>
+#include "Pointer.h"
+#include "rbffi.h"
+#include "Function.h"
+#include "StructByValue.h"
+#include "Types.h"
+#include "Struct.h"
+#include "MappedType.h"
+#include "MemoryPointer.h"
+#include "LongDouble.h"
+
+static ID id_from_native = 0;
+
+
+VALUE
+rbffi_NativeValue_ToRuby(Type* type, VALUE rbType, const void* ptr)
+{
+    switch (type->nativeType) {
+        case NATIVE_VOID:
+            return Qnil;
+        case NATIVE_INT8:
+          return INT2NUM((signed char) *(ffi_sarg *) ptr);
+        case NATIVE_INT16:
+          return INT2NUM((signed short) *(ffi_sarg *) ptr);
+        case NATIVE_INT32:
+          return INT2NUM((signed int) *(ffi_sarg *) ptr);
+        case NATIVE_LONG:
+            return LONG2NUM((signed long) *(ffi_sarg *) ptr);
+        case NATIVE_INT64:
+            return LL2NUM(*(signed long long *) ptr);
+
+        case NATIVE_UINT8:
+          return UINT2NUM((unsigned char) *(ffi_arg *) ptr);
+        case NATIVE_UINT16:
+          return UINT2NUM((unsigned short) *(ffi_arg *) ptr);
+        case NATIVE_UINT32:
+          return UINT2NUM((unsigned int) *(ffi_arg *) ptr);
+        case NATIVE_ULONG:
+            return ULONG2NUM((unsigned long) *(ffi_arg *) ptr);
+        case NATIVE_UINT64:
+            return ULL2NUM(*(unsigned long long *) ptr);
+
+        case NATIVE_FLOAT32:
+            return rb_float_new(*(float *) ptr);
+        case NATIVE_FLOAT64:
+            return rb_float_new(*(double *) ptr);
+
+        case NATIVE_LONGDOUBLE:
+	  return rbffi_longdouble_new(*(long double *) ptr);
+
+        case NATIVE_STRING:
+            return (*(void **) ptr != NULL) ? rb_str_new2(*(char **) ptr) : Qnil;
+        case NATIVE_POINTER:
+            return rbffi_Pointer_NewInstance(*(void **) ptr);
+        case NATIVE_BOOL:
+            return ((unsigned char) *(ffi_arg *) ptr) ? Qtrue : Qfalse;
+        
+        case NATIVE_FUNCTION:
+        case NATIVE_CALLBACK: {
+            return *(void **) ptr != NULL 
+                    ? rbffi_Function_NewInstance(rbType, rbffi_Pointer_NewInstance(*(void **) ptr))
+                    : Qnil;
+        }
+
+        case NATIVE_STRUCT: {
+            StructByValue* sbv = (StructByValue *)type;
+            AbstractMemory* mem;
+            VALUE rbMemory = rbffi_MemoryPointer_NewInstance(1, sbv->base.ffiType->size, false);
+
+            Data_Get_Struct(rbMemory, AbstractMemory, mem);
+            memcpy(mem->address, ptr, sbv->base.ffiType->size);
+            RB_GC_GUARD(rbMemory);
+            RB_GC_GUARD(rbType);
+
+            return rb_class_new_instance(1, &rbMemory, sbv->rbStructClass);
+        }
+
+        case NATIVE_MAPPED: {
+            /*
+             * For mapped types, first convert to the real native type, then upcall to
+             * ruby to convert to the expected return type
+             */
+            MappedType* m = (MappedType *) type;
+            VALUE values[2], rbReturnValue;
+
+            values[0] = rbffi_NativeValue_ToRuby(m->type, m->rbType, ptr);
+            values[1] = Qnil;
+            
+
+            rbReturnValue = rb_funcall2(m->rbConverter, id_from_native, 2, values);
+            RB_GC_GUARD(values[0]);
+            RB_GC_GUARD(rbType);
+            
+            return rbReturnValue;
+        }
+    
+        default:
+            rb_raise(rb_eRuntimeError, "Unknown type: %d", type->nativeType);
+            return Qnil;
+    }
+}
+
+void
+rbffi_Types_Init(VALUE moduleFFI)
+{
+    id_from_native = rb_intern("from_native");
+}
+

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.12.2/ext/ffi_c/extconf.h

@@ -0,0 +1,12 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#define HAVE_FFI_H 1
+#define HAVE_FFI_CLOSURE_ALLOC 1
+#define HAVE_RB_THREAD_CALL_WITHOUT_GVL 1
+#define HAVE_RUBY_NATIVE_THREAD_P 1
+#define HAVE_RUBY_THREAD_HAS_GVL_P 1
+#define HAVE_FFI_PREP_CIF_VAR 1
+#define HAVE_FFI_RAW_CALL 1
+#define HAVE_FFI_PREP_RAW_CLOSURE 1
+#define HAVE_RAW_API 1
+#endif

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.12.2/ext/ffi_c/extconf.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
+  require 'mkmf'
+  require 'rbconfig'
+
+  def system_libffi_usable?
+    # We need pkg_config or ffi.h
+    libffi_ok = pkg_config("libffi") ||
+        have_header("ffi.h") ||
+        find_header("ffi.h", "/usr/local/include", "/usr/include/ffi")
+
+    # Ensure we can link to ffi_call
+    libffi_ok &&= have_library("ffi", "ffi_call", [ "ffi.h" ]) ||
+                  have_library("libffi", "ffi_call", [ "ffi.h" ])
+
+    # And we need a libffi version recent enough to provide ffi_closure_alloc
+    libffi_ok &&= have_func("ffi_closure_alloc")
+  end
+
+  dir_config("ffi_c")
+
+  # recent versions of ruby add restrictive ansi and warning flags on a whim - kill them all
+  $warnflags = ''
+  $CFLAGS.gsub!(/[\s+]-ansi/, '')
+  $CFLAGS.gsub!(/[\s+]-std=[^\s]+/, '')
+  # solaris 10 needs -c99 for <stdbool.h>
+  $CFLAGS << " -std=c99" if RbConfig::CONFIG['host_os'] =~ /solaris(!?2\.11)/
+
+  # Check whether we use system libffi
+  system_libffi = enable_config('system-libffi', :try)
+
+  if system_libffi == :try
+    system_libffi = ENV['RUBY_CC_VERSION'].nil? && system_libffi_usable?
+  elsif system_libffi
+    abort "system libffi is not usable" unless system_libffi_usable?
+  end
+
+  have_header('shlwapi.h')
+  have_func('rb_thread_call_without_gvl') || abort("Ruby C-API function `rb_thread_call_without_gvl` is missing")
+  have_func('ruby_native_thread_p')
+  if RUBY_VERSION >= "2.3.0"
+    # On OSX and Linux ruby_thread_has_gvl_p() is detected but fails at runtime for ruby < 2.3.0
+    have_func('ruby_thread_has_gvl_p')
+  end
+
+  if system_libffi
+    have_func('ffi_prep_cif_var')
+    $defs << "-DHAVE_RAW_API" if have_func("ffi_raw_call") && have_func("ffi_prep_raw_closure")
+  else
+    $defs << "-DHAVE_FFI_PREP_CIF_VAR"
+    $defs << "-DUSE_INTERNAL_LIBFFI"
+  end
+
+  $defs << "-DHAVE_EXTCONF_H" if $defs.empty? # needed so create_header works
+  $defs << "-DFFI_BUILDING" if RbConfig::CONFIG['host_os'] =~ /mswin/ # for compatibility with newer libffi
+
+  create_header
+
+  $LOCAL_LIBS << " ./libffi/.libs/libffi_convenience.lib" if !system_libffi && RbConfig::CONFIG['host_os'] =~ /mswin/
+
+  create_makefile("ffi_c")
+  unless system_libffi
+    File.open("Makefile", "a") do |mf|
+      mf.puts "LIBFFI_HOST=--host=#{RbConfig::CONFIG['host_alias']}" if RbConfig::CONFIG.has_key?("host_alias")
+      if RbConfig::CONFIG['host_os'].downcase =~ /darwin/
+        mf.puts "include ${srcdir}/libffi.darwin.mk"
+      elsif RbConfig::CONFIG['host_os'].downcase =~ /bsd/
+        mf.puts '.include "${srcdir}/libffi.bsd.mk"'
+      elsif RbConfig::CONFIG['host_os'].downcase =~ /mswin64/
+        mf.puts '!include $(srcdir)/libffi.vc64.mk'
+      elsif RbConfig::CONFIG['host_os'].downcase =~ /mswin32/
+        mf.puts '!include $(srcdir)/libffi.vc.mk'
+      else
+        mf.puts "include ${srcdir}/libffi.mk"
+      end
+    end
+  end
+
+else
+  File.open("Makefile", "w") do |mf|
+    mf.puts "# Dummy makefile for non-mri rubies"
+    mf.puts "all install::\n"
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.12.2/ext/ffi_c/libffi.darwin.mk

@@ -0,0 +1,105 @@
+# -*- makefile -*-
+
+include ${srcdir}/libffi.gnu.mk
+
+CCACHE := $(shell type -p ccache)
+BUILD_DIR := $(shell pwd)
+
+INCFLAGS += -I"$(BUILD_DIR)"
+
+# Work out which arches we need to compile the lib for
+ARCHES :=
+ARCHFLAGS ?= $(filter -arch %, $(CFLAGS))
+
+ifneq ($(findstring -arch ppc,$(ARCHFLAGS)),)
+  ARCHES += ppc
+endif
+
+ifneq ($(findstring -arch i386,$(ARCHFLAGS)),)
+  ARCHES += i386
+endif
+
+ifneq ($(findstring -arch x86_64,$(ARCHFLAGS)),)
+  ARCHES += x86_64
+endif
+
+ifeq ($(strip $(ARCHES)),)
+LIBFFI_BUILD_DIR = $(BUILD_DIR)/libffi-$(arch)
+# Just build the one (default) architecture
+$(LIBFFI):
+	@mkdir -p "$(LIBFFI_BUILD_DIR)" "$(@D)"
+	@if [ ! -f "$(LIBFFI_SRC_DIR)"/configure ]; then \
+		echo "Running autoreconf for libffi"; \
+		cd "$(LIBFFI_SRC_DIR)" && \
+		/bin/sh $(LIBFFI_AUTOGEN) > /dev/null; \
+	fi
+	@if [ ! -f "$(LIBFFI_BUILD_DIR)"/Makefile ]; then \
+		echo "Configuring libffi"; \
+		cd "$(LIBFFI_BUILD_DIR)" && \
+		/usr/bin/env CC="$(CC)" LD="$(LD)" CFLAGS="$(LIBFFI_CFLAGS)" GREP_OPTIONS="" \
+		/bin/sh $(LIBFFI_CONFIGURE) $(LIBFFI_HOST) > /dev/null; \
+	fi
+	cd "$(LIBFFI_BUILD_DIR)" && $(MAKE)
+
+else
+LIBTARGETS = $(foreach arch,$(ARCHES),"$(BUILD_DIR)"/libffi-$(arch)/.libs/libffi_convenience.a)
+
+# Build a fat binary and assemble
+build_ffi = \
+	mkdir -p "$(BUILD_DIR)"/libffi-$(1); \
+	(if [ ! -f "$(LIBFFI_SRC_DIR)"/configure ]; then \
+		echo "Running autoreconf for libffi"; \
+		cd "$(LIBFFI_SRC_DIR)" && \
+		/bin/sh $(LIBFFI_AUTOGEN) > /dev/null; \
+	fi); \
+	(if [ ! -f "$(BUILD_DIR)"/libffi-$(1)/Makefile ]; then \
+	    echo "Configuring libffi for $(1)"; \
+	    cd "$(BUILD_DIR)"/libffi-$(1) && \
+	      env CC="$(CCACHE) $(CC)" CFLAGS="-arch $(1) $(LIBFFI_CFLAGS)" LDFLAGS="-arch $(1)" \
+		$(LIBFFI_CONFIGURE) --host=$(1)-apple-darwin > /dev/null; \
+	fi); \
+	$(MAKE) -C "$(BUILD_DIR)"/libffi-$(1)
+
+target_ffi = "$(BUILD_DIR)"/libffi-$(1)/.libs/libffi_convenience.a:; $(call build_ffi,$(1))
+
+# Work out which arches we need to compile the lib for
+ifneq ($(findstring ppc,$(ARCHES)),)
+  $(call target_ffi,ppc)
+endif
+
+ifneq ($(findstring i386,$(ARCHES)),)
+  $(call target_ffi,i386)
+endif
+
+ifneq ($(findstring x86_64,$(ARCHES)),)
+  $(call target_ffi,x86_64)
+endif
+
+
+$(LIBFFI):	$(LIBTARGETS)
+	# Assemble into a FAT (x86_64, i386, ppc) library
+	@mkdir -p "$(@D)"
+	/usr/bin/libtool -static -o $@ \
+	    $(foreach arch, $(ARCHES),"$(BUILD_DIR)"/libffi-$(arch)/.libs/libffi_convenience.a)
+	@mkdir -p "$(LIBFFI_BUILD_DIR)"/include
+	$(RM) "$(LIBFFI_BUILD_DIR)"/include/ffi.h
+	@( \
+		printf "#if defined(__i386__)\n"; \
+		printf "#include \"libffi-i386/include/ffi.h\"\n"; \
+		printf "#elif defined(__x86_64__)\n"; \
+		printf "#include \"libffi-x86_64/include/ffi.h\"\n";\
+		printf "#elif defined(__ppc__)\n"; \
+		printf "#include \"libffi-ppc/include/ffi.h\"\n";\
+		printf "#endif\n";\
+	) > "$(LIBFFI_BUILD_DIR)"/include/ffi.h
+	@( \
+		printf "#if defined(__i386__)\n"; \
+		printf "#include \"libffi-i386/include/ffitarget.h\"\n"; \
+		printf "#elif defined(__x86_64__)\n"; \
+		printf "#include \"libffi-x86_64/include/ffitarget.h\"\n";\
+		printf "#elif defined(__ppc__)\n"; \
+		printf "#include \"libffi-ppc/include/ffitarget.h\"\n";\
+		printf "#endif\n";\
+	) > "$(LIBFFI_BUILD_DIR)"/include/ffitarget.h
+
+endif

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.12.2/ext/ffi_c/libffi/.appveyor.yml

@@ -0,0 +1,66 @@
+shallow_clone: true
+
+# We're currently only testing libffi built with Microsoft's
+# tools.
+# This matrix should be expanded to include at least:
+#  32- and 64-bit gcc/cygwin
+#  32- and 64-bit gcc/mingw
+#  32- and 64-bit clang/mingw
+#  and perhaps more.
+
+image: Visual Studio 2017
+platform:
+  - x64
+  - x86
+  - arm
+  - arm64
+
+environment:
+  global:
+    CYG_ROOT: C:/cygwin
+    CYG_CACHE: C:/cygwin/var/cache/setup
+    CYG_MIRROR: http://mirrors.kernel.org/sourceware/cygwin/
+  matrix:
+    - VSVER: 15
+
+install:
+  - ps: >-
+      If ($env:Platform -Match "x86") {
+          $env:VCVARS_PLATFORM="x86"
+          $env:BUILD="i686-pc-cygwin"
+          $env:HOST="i686-pc-cygwin"
+          $env:MSVCC="/cygdrive/c/projects/libffi/msvcc.sh"
+          $env:SRC_ARCHITECTURE="x86"
+        } ElseIf ($env:Platform -Match "arm64") {
+          $env:VCVARS_PLATFORM="x86_arm64"
+          $env:BUILD="i686-pc-cygwin"
+          $env:HOST="aarch64-w64-cygwin"
+          $env:MSVCC="/cygdrive/c/projects/libffi/msvcc.sh -marm64"
+          $env:SRC_ARCHITECTURE="aarch64"
+        } ElseIf ($env:Platform -Match "arm") {
+          $env:VCVARS_PLATFORM="x86_arm"
+          $env:BUILD="i686-pc-cygwin"
+          $env:HOST="arm-w32-cygwin"
+          $env:MSVCC="/cygdrive/c/projects/libffi/msvcc.sh -marm"
+          $env:SRC_ARCHITECTURE="arm"
+        } Else {
+          $env:VCVARS_PLATFORM="amd64"
+          $env:BUILD="x86_64-w64-cygwin"
+          $env:HOST="x86_64-w64-cygwin"
+          $env:MSVCC="/cygdrive/c/projects/libffi/msvcc.sh -m64"
+          $env:SRC_ARCHITECTURE="x86"
+      }
+  - 'appveyor DownloadFile https://cygwin.com/setup-x86.exe -FileName setup.exe'
+  - 'setup.exe -qnNdO -R "%CYG_ROOT%" -s "%CYG_MIRROR%" -l "%CYG_CACHE%" -P dejagnu >NUL'
+  - '%CYG_ROOT%/bin/bash -lc "cygcheck -dc cygwin"'
+  - echo call VsDevCmd to set VS150COMNTOOLS
+  - call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\Tools\VsDevCmd.bat"
+  - ps: $env:VSCOMNTOOLS=(Get-Content ("env:VS" + "$env:VSVER" + "0COMNTOOLS"))
+  - echo "Using Visual Studio %VSVER%.0 at %VSCOMNTOOLS%"
+  - call "%VSCOMNTOOLS%..\..\vc\Auxiliary\Build\vcvarsall.bat" %VCVARS_PLATFORM%
+
+build_script:
+  - c:\cygwin\bin\sh -lc "(cd $OLDPWD; ./autogen.sh;)"
+  - c:\cygwin\bin\sh -lc "(cd $OLDPWD; ./configure CC='%MSVCC%' CXX='%MSVCC%' LD='link' CPP='cl -nologo -EP' CXXCPP='cl -nologo -EP' CPPFLAGS='-DFFI_BUILDING_DLL' AR='/cygdrive/c/projects/libffi/.travis/ar-lib lib' NM='dumpbin -symbols' STRIP=':' --build=$BUILD --host=$HOST;)"
+  - c:\cygwin\bin\sh -lc "(cd $OLDPWD; cp src/%SRC_ARCHITECTURE%/ffitarget.h include; make; find .;)"
+  - c:\cygwin\bin\sh -lc "(cd $OLDPWD; cp `find . -name 'libffi-?.dll'` $HOST/testsuite/; make check; cat `find ./ -name libffi.log`)"

data/vendor/bundle/ruby/2.3.0/gems/ffi-1.12.2/ext/ffi_c/libffi/.gitattributes

@@ -0,0 +1,4 @@
+*	text=auto
+
+*.sln	text eol=crlf
+*.vcxproj*	text eol=crlf