/pypy/translator/c/src/libffi_msvc/ffi.h
C++ Header | 315 lines | 191 code | 54 blank | 70 comment | 10 complexity | 5cf163425ad0dc04938c2b41a1109756 MD5 | raw file
- /* -----------------------------------------------------------------*-C-*-
- libffi 2.00-beta - Copyright (c) 1996-2003 Red Hat, Inc.
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- ``Software''), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
- The above copyright notice and this permission notice shall be included
- in all copies or substantial portions of the Software.
- THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
- OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- OTHER DEALINGS IN THE SOFTWARE.
- ----------------------------------------------------------------------- */
- /* -------------------------------------------------------------------
- The basic API is described in the README file.
- The raw API is designed to bypass some of the argument packing
- and unpacking on architectures for which it can be avoided.
- The closure API allows interpreted functions to be packaged up
- inside a C function pointer, so that they can be called as C functions,
- with no understanding on the client side that they are interpreted.
- It can also be used in other cases in which it is necessary to package
- up a user specified parameter and a function pointer as a single
- function pointer.
- The closure API must be implemented in order to get its functionality,
- e.g. for use by gij. Routines are provided to emulate the raw API
- if the underlying platform doesn't allow faster implementation.
- More details on the raw and cloure API can be found in:
- http://gcc.gnu.org/ml/java/1999-q3/msg00138.html
- and
- http://gcc.gnu.org/ml/java/1999-q3/msg00174.html
- -------------------------------------------------------------------- */
- #ifndef LIBFFI_H
- #define LIBFFI_H
- #ifdef __cplusplus
- extern "C" {
- #endif
- /* Specify which architecture libffi is configured for. */
- //XXX #define X86
- /* ---- System configuration information --------------------------------- */
- #include <ffitarget.h>
- #ifndef LIBFFI_ASM
- #include <stddef.h>
- #include <limits.h>
- /* LONG_LONG_MAX is not always defined (not if STRICT_ANSI, for example).
- But we can find it either under the correct ANSI name, or under GNU
- C's internal name. */
- #ifdef LONG_LONG_MAX
- # define FFI_LONG_LONG_MAX LONG_LONG_MAX
- #else
- # ifdef LLONG_MAX
- # define FFI_LONG_LONG_MAX LLONG_MAX
- # else
- # ifdef __GNUC__
- # define FFI_LONG_LONG_MAX __LONG_LONG_MAX__
- # endif
- # ifdef _MSC_VER
- # define FFI_LONG_LONG_MAX _I64_MAX
- # endif
- # endif
- #endif
- #if SCHAR_MAX == 127
- # define ffi_type_uchar ffi_type_uint8
- # define ffi_type_schar ffi_type_sint8
- #else
- #error "char size not supported"
- #endif
- #if SHRT_MAX == 32767
- # define ffi_type_ushort ffi_type_uint16
- # define ffi_type_sshort ffi_type_sint16
- #elif SHRT_MAX == 2147483647
- # define ffi_type_ushort ffi_type_uint32
- # define ffi_type_sshort ffi_type_sint32
- #else
- #error "short size not supported"
- #endif
- #if INT_MAX == 32767
- # define ffi_type_uint ffi_type_uint16
- # define ffi_type_sint ffi_type_sint16
- #elif INT_MAX == 2147483647
- # define ffi_type_uint ffi_type_uint32
- # define ffi_type_sint ffi_type_sint32
- #elif INT_MAX == 9223372036854775807
- # define ffi_type_uint ffi_type_uint64
- # define ffi_type_sint ffi_type_sint64
- #else
- #error "int size not supported"
- #endif
- #define ffi_type_ulong ffi_type_uint64
- #define ffi_type_slong ffi_type_sint64
- #if LONG_MAX == 2147483647
- # if FFI_LONG_LONG_MAX != 9223372036854775807
- #error "no 64-bit data type supported"
- # endif
- #elif LONG_MAX != 9223372036854775807
- #error "long size not supported"
- #endif
- /* The closure code assumes that this works on pointers, i.e. a size_t */
- /* can hold a pointer. */
- typedef struct _ffi_type
- {
- size_t size;
- unsigned short alignment;
- unsigned short type;
- /*@null@*/ struct _ffi_type **elements;
- } ffi_type;
- /* These are defined in types.c */
- extern ffi_type ffi_type_void;
- extern ffi_type ffi_type_uint8;
- extern ffi_type ffi_type_sint8;
- extern ffi_type ffi_type_uint16;
- extern ffi_type ffi_type_sint16;
- extern ffi_type ffi_type_uint32;
- extern ffi_type ffi_type_sint32;
- extern ffi_type ffi_type_uint64;
- extern ffi_type ffi_type_sint64;
- extern ffi_type ffi_type_float;
- extern ffi_type ffi_type_double;
- extern ffi_type ffi_type_longdouble;
- extern ffi_type ffi_type_pointer;
- typedef enum {
- FFI_OK = 0,
- FFI_BAD_TYPEDEF,
- FFI_BAD_ABI
- } ffi_status;
- typedef unsigned FFI_TYPE;
- typedef struct {
- ffi_abi abi;
- unsigned nargs;
- /*@dependent@*/ ffi_type **arg_types;
- /*@dependent@*/ ffi_type *rtype;
- unsigned bytes;
- unsigned flags;
- #ifdef FFI_EXTRA_CIF_FIELDS
- FFI_EXTRA_CIF_FIELDS;
- #endif
- } ffi_cif;
- /* ---- Definitions for the raw API -------------------------------------- */
- #ifdef _WIN64
- #define FFI_SIZEOF_ARG 8
- #else
- #define FFI_SIZEOF_ARG 4
- #endif
- typedef union {
- ffi_sarg sint;
- ffi_arg uint;
- float flt;
- char data[FFI_SIZEOF_ARG];
- void* ptr;
- } ffi_raw;
- void ffi_raw_call (/*@dependent@*/ ffi_cif *cif,
- void (*fn)(),
- /*@out@*/ void *rvalue,
- /*@dependent@*/ ffi_raw *avalue);
- void ffi_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw);
- void ffi_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args);
- size_t ffi_raw_size (ffi_cif *cif);
- /* This is analogous to the raw API, except it uses Java parameter */
- /* packing, even on 64-bit machines. I.e. on 64-bit machines */
- /* longs and doubles are followed by an empty 64-bit word. */
- void ffi_java_raw_call (/*@dependent@*/ ffi_cif *cif,
- void (*fn)(),
- /*@out@*/ void *rvalue,
- /*@dependent@*/ ffi_raw *avalue);
- void ffi_java_ptrarray_to_raw (ffi_cif *cif, void **args, ffi_raw *raw);
- void ffi_java_raw_to_ptrarray (ffi_cif *cif, ffi_raw *raw, void **args);
- size_t ffi_java_raw_size (ffi_cif *cif);
- /* ---- Definitions for closures ----------------------------------------- */
- #if FFI_CLOSURES
- typedef struct {
- char tramp[FFI_TRAMPOLINE_SIZE];
- ffi_cif *cif;
- void (*fun)(ffi_cif*,void*,void**,void*);
- void *user_data;
- } ffi_closure;
- ffi_status
- ffi_prep_closure (ffi_closure*,
- ffi_cif *,
- void (*fun)(ffi_cif*,void*,void**,void*),
- void *user_data);
- typedef struct {
- char tramp[FFI_TRAMPOLINE_SIZE];
- ffi_cif *cif;
- #if !FFI_NATIVE_RAW_API
- /* if this is enabled, then a raw closure has the same layout
- as a regular closure. We use this to install an intermediate
- handler to do the transaltion, void** -> ffi_raw*. */
- void (*translate_args)(ffi_cif*,void*,void**,void*);
- void *this_closure;
- #endif
- void (*fun)(ffi_cif*,void*,ffi_raw*,void*);
- void *user_data;
- } ffi_raw_closure;
- ffi_status
- ffi_prep_raw_closure (ffi_raw_closure*,
- ffi_cif *cif,
- void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
- void *user_data);
- ffi_status
- ffi_prep_java_raw_closure (ffi_raw_closure*,
- ffi_cif *cif,
- void (*fun)(ffi_cif*,void*,ffi_raw*,void*),
- void *user_data);
- #endif /* FFI_CLOSURES */
- /* ---- Public interface definition -------------------------------------- */
- ffi_status ffi_prep_cif(/*@out@*/ /*@partial@*/ ffi_cif *cif,
- ffi_abi abi,
- unsigned int nargs,
- /*@dependent@*/ /*@out@*/ /*@partial@*/ ffi_type *rtype,
- /*@dependent@*/ ffi_type **atypes);
- int
- ffi_call(/*@dependent@*/ ffi_cif *cif,
- void (*fn)(),
- /*@out@*/ void *rvalue,
- /*@dependent@*/ void **avalue);
- /* Useful for eliminating compiler warnings */
- #define FFI_FN(f) ((void (*)())f)
- /* ---- Definitions shared with assembly code ---------------------------- */
- #endif
- /* If these change, update src/mips/ffitarget.h. */
- #define FFI_TYPE_VOID 0
- #define FFI_TYPE_INT 1
- #define FFI_TYPE_FLOAT 2
- #define FFI_TYPE_DOUBLE 3
- #if 1
- #define FFI_TYPE_LONGDOUBLE 4
- #else
- #define FFI_TYPE_LONGDOUBLE FFI_TYPE_DOUBLE
- #endif
- #define FFI_TYPE_UINT8 5
- #define FFI_TYPE_SINT8 6
- #define FFI_TYPE_UINT16 7
- #define FFI_TYPE_SINT16 8
- #define FFI_TYPE_UINT32 9
- #define FFI_TYPE_SINT32 10
- #define FFI_TYPE_UINT64 11
- #define FFI_TYPE_SINT64 12
- #define FFI_TYPE_STRUCT 13
- #define FFI_TYPE_POINTER 14
- /* This should always refer to the last type code (for sanity checks) */
- #define FFI_TYPE_LAST FFI_TYPE_POINTER
- #ifdef __cplusplus
- }
- #endif
- #endif