ffi 1.11.1

data/ext/ffi_c/libffi/testsuite/libffi.complex/return_complex1_double.c

@@ -0,0 +1,10 @@
+/* Area:	ffi_call
+   Purpose:	Check return value complex.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<vogt@linux.vnet.ibm.com>.  */
+
+/* { dg-do run } */
+
+#include "complex_defs_double.inc"
+#include "return_complex1.inc"

data/ext/ffi_c/libffi/testsuite/libffi.complex/return_complex1_float.c

@@ -0,0 +1,10 @@
+/* Area:	ffi_call
+   Purpose:	Check return value complex.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<vogt@linux.vnet.ibm.com>.  */
+
+/* { dg-do run } */
+
+#include "complex_defs_float.inc"
+#include "return_complex1.inc"

data/ext/ffi_c/libffi/testsuite/libffi.complex/return_complex1_longdouble.c

@@ -0,0 +1,10 @@
+/* Area:	ffi_call
+   Purpose:	Check return value complex.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<vogt@linux.vnet.ibm.com>.  */
+
+/* { dg-do run } */
+
+#include "complex_defs_longdouble.inc"
+#include "return_complex1.inc"

data/ext/ffi_c/libffi/testsuite/libffi.complex/return_complex2.inc

@@ -0,0 +1,44 @@
+/* -*-c-*- */
+#include "ffitest.h"
+#include <complex.h>
+
+_Complex T_C_TYPE
+return_c(_Complex T_C_TYPE c1, _Complex T_C_TYPE c2,
+	 unsigned int in3, _Complex T_C_TYPE c4)
+{
+  volatile _Complex T_C_TYPE r = c1 + c2 + in3 + c4;
+  return r;
+}
+
+int main (void)
+{
+  ffi_cif cif;
+  ffi_type *args[MAX_ARGS];
+  void *values[MAX_ARGS];
+  _Complex T_C_TYPE c1, c2, c4, rc, rc2;
+  unsigned int in3;
+  args[0] = &T_FFI_TYPE;
+  args[1] = &T_FFI_TYPE;
+  args[2] = &ffi_type_uint;
+  args[3] = &T_FFI_TYPE;
+  values[0] = &c1;
+  values[1] = &c2;
+  values[2] = &in3;
+  values[3] = &c4;
+
+  /* Initialize the cif */
+  CHECK(ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 4,
+		     &T_FFI_TYPE, args) == FFI_OK);
+  c1 = 127.0 + 255.0 * I;
+  c2 = 128.0 + 256.0;
+  in3 = 255;
+  c4 = 512.7 + 1024.1 * I;
+
+  ffi_call(&cif, FFI_FN(return_c), &rc, values);
+  rc2 = return_c(c1, c2, in3, c4);
+  printf ("%f,%fi vs %f,%fi\n",
+	  T_CONV creal (rc), T_CONV cimag (rc),
+	  T_CONV creal (rc2), T_CONV cimag (rc2));
+  CHECK(rc == rc2);
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.complex/return_complex2_double.c

@@ -0,0 +1,10 @@
+/* Area:	ffi_call
+   Purpose:	Check return value complex.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<vogt@linux.vnet.ibm.com>.  */
+
+/* { dg-do run } */
+
+#include "complex_defs_double.inc"
+#include "return_complex2.inc"

data/ext/ffi_c/libffi/testsuite/libffi.complex/return_complex2_float.c

@@ -0,0 +1,10 @@
+/* Area:	ffi_call
+   Purpose:	Check return value complex.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<vogt@linux.vnet.ibm.com>.  */
+
+/* { dg-do run } */
+
+#include "complex_defs_float.inc"
+#include "return_complex2.inc"

data/ext/ffi_c/libffi/testsuite/libffi.complex/return_complex2_longdouble.c

@@ -0,0 +1,10 @@
+/* Area:	ffi_call
+   Purpose:	Check return value complex.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<vogt@linux.vnet.ibm.com>.  */
+
+/* { dg-do run } */
+
+#include "complex_defs_longdouble.inc"
+#include "return_complex2.inc"

data/ext/ffi_c/libffi/testsuite/libffi.complex/return_complex_double.c

@@ -0,0 +1,10 @@
+/* Area:	ffi_call
+   Purpose:	Check return value complex.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<vogt@linux.vnet.ibm.com>.  */
+
+/* { dg-do run } */
+
+#include "complex_defs_double.inc"
+#include "return_complex.inc"

data/ext/ffi_c/libffi/testsuite/libffi.complex/return_complex_float.c

@@ -0,0 +1,10 @@
+/* Area:	ffi_call
+   Purpose:	Check return value complex.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<vogt@linux.vnet.ibm.com>.  */
+
+/* { dg-do run } */
+
+#include "complex_defs_float.inc"
+#include "return_complex.inc"

data/ext/ffi_c/libffi/testsuite/libffi.complex/return_complex_longdouble.c

@@ -0,0 +1,10 @@
+/* Area:	ffi_call
+   Purpose:	Check return value complex.
+   Limitations:	none.
+   PR:		none.
+   Originator:	<vogt@linux.vnet.ibm.com>.  */
+
+/* { dg-do run } */
+
+#include "complex_defs_longdouble.inc"
+#include "return_complex.inc"

data/ext/ffi_c/libffi/testsuite/libffi.go/aa-direct.c

@@ -0,0 +1,34 @@
+/* { dg-do run } */
+
+#include "static-chain.h"
+
+#if defined(__GNUC__) && !defined(__clang__) && defined(STATIC_CHAIN_REG)
+
+#include "ffitest.h"
+
+/* Blatent assumption here that the prologue doesn't clobber the
+   static chain for trivial functions.  If this is not true, don't
+   define STATIC_CHAIN_REG, and we'll test what we can via other tests.  */
+void *doit(void)
+{
+  register void *chain __asm__(STATIC_CHAIN_REG);
+  return chain;
+}
+
+int main()
+{
+  ffi_cif cif;
+  void *result;
+
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 0, &ffi_type_pointer, NULL) == FFI_OK);
+
+  ffi_call_go(&cif, FFI_FN(doit), &result, NULL, &result);
+
+  CHECK(result == &result);
+
+  return 0;
+}
+
+#else /* UNSUPPORTED */
+int main() { return 0; }
+#endif

data/ext/ffi_c/libffi/testsuite/libffi.go/closure1.c

@@ -0,0 +1,28 @@
+/* { dg-do run } */
+
+#include "ffitest.h"
+
+void doit(ffi_cif *cif, void *rvalue, void **avalue, void *closure)
+{
+  (void)cif;
+  (void)avalue;
+  *(void **)rvalue = closure;
+}
+
+typedef void * (*FN)(void);
+
+int main()
+{
+  ffi_cif cif;
+  ffi_go_closure cl;
+  void *result;
+
+  CHECK(ffi_prep_cif(&cif, ABI_NUM, 0, &ffi_type_pointer, NULL) == FFI_OK);
+  CHECK(ffi_prep_go_closure(&cl, &cif, doit) == FFI_OK);
+
+  ffi_call_go(&cif, FFI_FN(*(FN *)&cl), &result, NULL, &cl);
+
+  CHECK(result == &cl);
+
+  exit(0);
+}

data/ext/ffi_c/libffi/testsuite/libffi.go/ffitest.h

@@ -0,0 +1 @@
+#include "../libffi.call/ffitest.h"

data/ext/ffi_c/libffi/testsuite/libffi.go/go.exp

@@ -0,0 +1,36 @@
+# Copyright (C) 2003, 2006, 2009, 2010, 2014 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; see the file COPYING3.  If not see
+# <http://www.gnu.org/licenses/>.
+
+dg-init
+libffi-init
+
+global srcdir subdir
+
+set tlist [lsort [glob -nocomplain -- $srcdir/$subdir/*.{c,cc}]]
+
+if { [libffi_feature_test "#ifdef FFI_GO_CLOSURES"] } {
+    run-many-tests $tlist ""
+} else {
+    foreach test $tlist {
+	unsupported "$test"
+    }
+}
+
+dg-finish
+
+# Local Variables:
+# tcl-indent-level:4
+# End:

data/ext/ffi_c/libffi/testsuite/libffi.go/static-chain.h

@@ -0,0 +1,19 @@
+#ifdef __aarch64__
+# define STATIC_CHAIN_REG  "x18"
+#elif defined(__alpha__)
+# define STATIC_CHAIN_REG  "$1"
+#elif defined(__arm__)
+# define STATIC_CHAIN_REG  "ip"
+#elif defined(__sparc__)
+# if defined(__arch64__) || defined(__sparcv9)
+#  define STATIC_CHAIN_REG "g5"
+# else
+#  define STATIC_CHAIN_REG "g2"
+# endif
+#elif defined(__x86_64__)
+# define STATIC_CHAIN_REG  "r10"
+#elif defined(__i386__)
+# ifndef ABI_NUM
+#  define STATIC_CHAIN_REG  "ecx"	/* FFI_DEFAULT_ABI only */
+# endif
+#endif

data/ext/ffi_c/rbffi.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2008, 2009, Wayne Meissner
+ *
+ * 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 RBFFI_RBFFI_H
+#define	RBFFI_RBFFI_H
+
+#include <ruby.h>
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+#define MAX_PARAMETERS (32)
+
+extern VALUE rbffi_FFIModule;
+    
+extern void rbffi_Type_Init(VALUE ffiModule);
+extern void rbffi_Buffer_Init(VALUE ffiModule);
+extern void rbffi_Invoker_Init(VALUE ffiModule);
+extern void rbffi_Variadic_Init(VALUE ffiModule);
+extern VALUE rbffi_AbstractMemoryClass, rbffi_InvokerClass;
+extern int rbffi_type_size(VALUE type);
+extern void rbffi_Thread_Init(VALUE moduleFFI);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* RBFFI_RBFFI_H */

data/ext/ffi_c/rbffi_endian.h

@@ -0,0 +1,59 @@
+#ifndef JFFI_ENDIAN_H
+#define JFFI_ENDIAN_H
+
+#ifndef _MSC_VER
+#include <sys/param.h>
+#endif
+
+#include <sys/types.h>
+
+#if defined(__linux__) || defined(__CYGWIN__) || defined(__GNU__) || defined(__GLIBC__) || defined(__HAIKU__)
+# include <endian.h>
+# if !defined(LITTLE_ENDIAN) && defined(__LITTLE_ENDIAN)
+#  define LITTLE_ENDIAN __LITTLE_ENDIAN
+# endif
+# if !defined(BIG_ENDIAN) && defined(__BIG_ENDIAN)
+#  define BIG_ENDIAN __BIG_ENDIAN
+# endif
+# if !defined(BYTE_ORDER) && defined(__BYTE_ORDER)
+#  define BYTE_ORDER __BYTE_ORDER
+# endif
+#endif
+
+#ifdef __sun
+# include <sys/byteorder.h>
+# define LITTLE_ENDIAN 1234
+# define BIG_ENDIAN 4321
+# if defined(_BIG_ENDIAN)
+#  define BYTE_ORDER BIG_ENDIAN
+# elif defined(_LITTLE_ENDIAN)
+#  define BYTE_ORDER LITTLE_ENDIAN
+# else
+#  error "Cannot determine endian-ness"
+# endif
+#endif
+
+#if defined(_AIX) && !defined(BYTE_ORDER)
+# define LITTLE_ENDIAN 1234
+# define BIG_ENDIAN 4321
+# if defined(__BIG_ENDIAN__)
+#  define BYTE_ORDER BIG_ENDIAN
+# elif defined(__LITTLE_ENDIAN__)
+#  define BYTE_ORDER LITTLE_ENDIAN
+# else
+#  error "Cannot determine endian-ness"
+# endif
+#endif
+
+#if defined(_WIN32)
+# define LITTLE_ENDIAN 1234
+# define BIG_ENDIAN 4321
+# define BYTE_ORDER LITTLE_ENDIAN
+#endif
+
+#if !defined(BYTE_ORDER) || !defined(LITTLE_ENDIAN) || !defined(BIG_ENDIAN)
+#  error "Cannot determine the endian-ness of this platform"
+#endif
+
+#endif /* JFFI_ENDIAN_H */
+

data/ext/ffi_c/win32/stdbool.h

@@ -0,0 +1,8 @@
+#ifndef FFI_STDBOOL_H
+#define FFI_STDBOOL_H
+
+typedef int bool;
+#define true 1
+#define false 0
+
+#endif /* FFI_STDBOOL_H */

data/ext/ffi_c/win32/stdint.h

@@ -0,0 +1,201 @@
+/* stdint.h standard header */
+#if !defined(_MSC_VER) && !defined(INT8_MIN)
+#pragma once
+#ifndef _STDINT
+#define _STDINT
+#ifndef RC_INVOKED
+#include <yvals.h>
+
+/* NB: assumes
+	byte has 8 bits
+	long is 32 bits
+	pointer can convert to and from long long
+	long long is longest type
+ */
+
+_C_STD_BEGIN
+		/* TYPE DEFINITIONS */
+typedef signed char int8_t;
+typedef short int16_t;
+typedef int int32_t;
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+
+typedef signed char int_least8_t;
+typedef short int_least16_t;
+typedef int int_least32_t;
+
+typedef unsigned char uint_least8_t;
+typedef unsigned short uint_least16_t;
+typedef unsigned int uint_least32_t;
+
+typedef char int_fast8_t;
+typedef int int_fast16_t;
+typedef int int_fast32_t;
+
+typedef unsigned char uint_fast8_t;
+typedef unsigned int uint_fast16_t;
+typedef unsigned int uint_fast32_t;
+
+#ifndef _INTPTR_T_DEFINED
+ #define _INTPTR_T_DEFINED
+ #ifdef _WIN64
+typedef __int64 intptr_t;
+ #else /* _WIN64 */
+typedef _W64 int intptr_t;
+ #endif /* _WIN64 */
+#endif /* _INTPTR_T_DEFINED */
+
+#ifndef _UINTPTR_T_DEFINED
+ #define _UINTPTR_T_DEFINED
+ #ifdef _WIN64
+typedef unsigned __int64 uintptr_t;
+ #else /* _WIN64 */
+typedef _W64 unsigned int uintptr_t;
+ #endif /* _WIN64 */
+#endif /* _UINTPTR_T_DEFINED */
+
+typedef _Longlong int64_t;
+typedef _ULonglong uint64_t;
+
+typedef _Longlong int_least64_t;
+typedef _ULonglong uint_least64_t;
+
+typedef _Longlong int_fast64_t;
+typedef _ULonglong uint_fast64_t;
+
+typedef _Longlong intmax_t;
+typedef _ULonglong uintmax_t;
+
+		/* LIMIT MACROS */
+#define INT8_MIN	(-0x7f - _C2)
+#define INT16_MIN	(-0x7fff - _C2)
+#define INT32_MIN	(-0x7fffffff - _C2)
+
+#define INT8_MAX	0x7f
+#define INT16_MAX	0x7fff
+#define INT32_MAX	0x7fffffff
+#define UINT8_MAX	0xff
+#define UINT16_MAX	0xffff
+#define UINT32_MAX	0xffffffff
+
+#define INT_LEAST8_MIN		(-0x7f - _C2)
+#define INT_LEAST16_MIN		(-0x7fff - _C2)
+#define INT_LEAST32_MIN		(-0x7fffffff - _C2)
+
+#define INT_LEAST8_MAX		0x7f
+#define INT_LEAST16_MAX		0x7fff
+#define INT_LEAST32_MAX		0x7fffffff
+#define UINT_LEAST8_MAX		0xff
+#define UINT_LEAST16_MAX	0xffff
+#define UINT_LEAST32_MAX	0xffffffff
+
+#define INT_FAST8_MIN		(-0x7f - _C2)
+#define INT_FAST16_MIN		(-0x7fff - _C2)
+#define INT_FAST32_MIN		(-0x7fffffff - _C2)
+
+#define INT_FAST8_MAX		0x7f
+#define INT_FAST16_MAX		0x7fff
+#define INT_FAST32_MAX		0x7fffffff
+#define UINT_FAST8_MAX		0xff
+#define UINT_FAST16_MAX		0xffff
+#define UINT_FAST32_MAX		0xffffffff
+
+ #if _INTPTR == 0 || _INTPTR == 1
+#define INTPTR_MAX			0x7fffffff
+#define INTPTR_MIN			(-INTPTR_MAX - _C2)
+#define UINTPTR_MAX			0xffffffff
+
+ #else /* _INTPTR == 2 */
+#define INTPTR_MIN			(-_LLONG_MAX - _C2)
+#define INTPTR_MAX			_LLONG_MAX
+#define UINTPTR_MAX			_ULLONG_MAX
+#endif /* _INTPTR */
+
+#define INT8_C(x)	(x)
+#define INT16_C(x)	(x)
+#define INT32_C(x)	((x) + (INT32_MAX - INT32_MAX))
+
+#define UINT8_C(x)	(x)
+#define UINT16_C(x)	(x)
+#define UINT32_C(x)	((x) + (UINT32_MAX - UINT32_MAX))
+
+#ifdef _WIN64
+ #define PTRDIFF_MIN		INT64_MIN
+ #define PTRDIFF_MAX		INT64_MAX
+#else /* _WIN64 */
+ #define PTRDIFF_MIN		INT32_MIN
+ #define PTRDIFF_MAX		INT32_MAX
+#endif /* _WIN64 */
+
+#define SIG_ATOMIC_MIN	INT32_MIN
+#define SIG_ATOMIC_MAX	INT32_MAX
+
+#ifndef SIZE_MAX
+ #ifdef _WIN64
+  #define SIZE_MAX		UINT64_MAX
+ #else /* _WIN64 */
+  #define SIZE_MAX		UINT32_MAX
+ #endif /* _WIN64 */
+#endif /* SIZE_MAX */
+
+#define WCHAR_MIN	0x0000
+#define WCHAR_MAX	0xffff
+
+#define WINT_MIN	0x0000
+#define WINT_MAX	0xffff
+
+ #define INT64_MIN	(-0x7fffffffffffffff - _C2)
+ #define INT64_MAX	0x7fffffffffffffff
+ #define UINT64_MAX	0xffffffffffffffffU
+
+ #define INT_LEAST64_MIN	(-0x7fffffffffffffff - _C2)
+ #define INT_LEAST64_MAX	0x7fffffffffffffff
+ #define UINT_LEAST64_MAX	0xffffffffffffffffU
+
+ #define INT_FAST64_MIN		(-0x7fffffffffffffff - _C2)
+ #define INT_FAST64_MAX		0x7fffffffffffffff
+ #define UINT_FAST64_MAX	0xffffffffffffffffU
+
+ #define INTMAX_MIN		(-0x7fffffffffffffff - _C2)
+ #define INTMAX_MAX		0x7fffffffffffffff
+ #define UINTMAX_MAX	0xffffffffffffffffU
+
+#define INT64_C(x)		((x) + (INT64_MAX - INT64_MAX))
+#define UINT64_C(x)		((x) + (UINT64_MAX - UINT64_MAX))
+#define INTMAX_C(x)		INT64_C(x)
+#define UINTMAX_C(x)	UINT64_C(x)
+_C_STD_END
+#endif /* RC_INVOKED */
+#endif /* _STDINT */
+
+ #if defined(_STD_USING)
+using _CSTD int8_t; using _CSTD int16_t;
+using _CSTD int32_t; using _CSTD int64_t;
+
+using _CSTD uint8_t; using _CSTD uint16_t;
+using _CSTD uint32_t; using _CSTD uint64_t;
+
+using _CSTD int_least8_t; using _CSTD int_least16_t;
+using _CSTD int_least32_t;  using _CSTD int_least64_t;
+using _CSTD uint_least8_t; using _CSTD uint_least16_t;
+using _CSTD uint_least32_t; using _CSTD uint_least64_t;
+
+using _CSTD intmax_t; using _CSTD uintmax_t;
+
+using _CSTD uintptr_t;
+using _CSTD intptr_t;
+
+using _CSTD int_fast8_t; using _CSTD int_fast16_t;
+using _CSTD int_fast32_t; using _CSTD int_fast64_t;
+using _CSTD uint_fast8_t; using _CSTD uint_fast16_t;
+using _CSTD uint_fast32_t; using _CSTD uint_fast64_t;
+ #endif /* defined(_STD_USING) */
+
+/*
+ * Copyright (c) 1992-2009 by P.J. Plauger.  ALL RIGHTS RESERVED.
+ * Consult your license regarding permissions and restrictions.
+V5.20:0009 */
+#endif /* !defined(_MSC_VER) && !defined(INT8_MIN) */