PyPy error

platcheck_29.c

/* Define on Darwin to activate all library features */
#define _DARWIN_C_SOURCE 1
/* This must be set to 64 on some systems to enable large file support. */
#define _FILE_OFFSET_BITS 64
/* Define on Linux to activate all library features */
#define _GNU_SOURCE 1
/* This must be defined on some systems to enable large file support. */
#define _LARGEFILE_SOURCE 1
/* Define on NetBSD to activate all library features */
#define _NETBSD_SOURCE 1
/* Define to activate features from IEEE Stds 1003.1-2001 */
#ifndef _POSIX_C_SOURCE
#  define _POSIX_C_SOURCE 200112L
#endif
/* Define on FreeBSD to activate all library features */
#define __BSD_VISIBLE 1
#define __XSI_VISIBLE 700
/* Windows: winsock/winsock2 mess */
#define WIN32_LEAN_AND_MEAN
#ifdef _WIN64
   typedef          __int64 Signed;
   typedef unsigned __int64 Unsigned;
#  define SIGNED_MIN LLONG_MIN 
#else
   typedef          long Signed;
   typedef unsigned long Unsigned;
#  define SIGNED_MIN LONG_MIN
#endif

#include <ffi.h>

#include <stdio.h>
#include <stddef.h>   /* for offsetof() */

void dump(char* key, int value) {
    printf("%s: %d\n", key, value);
}


void dump_section_FFI_BAD_TYPEDEF(void) {
	if ((FFI_BAD_TYPEDEF) <= 0) {
	    long long x = (long long)(FFI_BAD_TYPEDEF);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(FFI_BAD_TYPEDEF);
	    printf("value: %llu\n", x);
	}
}

void dump_section_FFI_DEFAULT_ABI(void) {
	if ((FFI_DEFAULT_ABI) <= 0) {
	    long long x = (long long)(FFI_DEFAULT_ABI);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(FFI_DEFAULT_ABI);
	    printf("value: %llu\n", x);
	}
}

void dump_section_FFI_OK(void) {
	if ((FFI_OK) <= 0) {
	    long long x = (long long)(FFI_OK);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(FFI_OK);
	    printf("value: %llu\n", x);
	}
}

void dump_section_FFI_TYPE_STRUCT(void) {
	if ((FFI_TYPE_STRUCT) <= 0) {
	    long long x = (long long)(FFI_TYPE_STRUCT);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(FFI_TYPE_STRUCT);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_abi(void) {
	typedef ffi_abi platcheck_t;

	platcheck_t x;
	dump("size",  sizeof(platcheck_t));
	x = 0; x = ~x;
	dump("unsigned", x > 0);
}

void dump_section_ffi_arg(void) {
	typedef ffi_arg platcheck_t;

	platcheck_t x;
	dump("size",  sizeof(platcheck_t));
	x = 0; x = ~x;
	dump("unsigned", x > 0);
}

void dump_section_ffi_cif(void) {
	typedef ffi_cif platcheck_t;
	typedef struct {
	    char c;
	    platcheck_t s;
	} platcheck2_t;

	platcheck_t s;
	dump("align", offsetof(platcheck2_t, s));
	dump("size",  sizeof(platcheck_t));
}

void dump_section_ffi_closure(void) {
	typedef ffi_closure platcheck_t;
	typedef struct {
	    char c;
	    platcheck_t s;
	} platcheck2_t;

	platcheck_t s;
	dump("align", offsetof(platcheck2_t, s));
	dump("size",  sizeof(platcheck_t));
}

void dump_section_ffi_type(void) {
	typedef ffi_type platcheck_t;
	typedef struct {
	    char c;
	    platcheck_t s;
	} platcheck2_t;

	platcheck_t s;
	dump("align", offsetof(platcheck2_t, s));
	dump("size",  sizeof(platcheck_t));
	dump("fldofs size", offsetof(platcheck_t, size));
	dump("fldsize size",   sizeof(s.size));
	s.size = 0; s.size = ~s.size;
	dump("fldunsigned size", s.size > 0);
	dump("fldofs alignment", offsetof(platcheck_t, alignment));
	dump("fldsize alignment",   sizeof(s.alignment));
	s.alignment = 0; s.alignment = ~s.alignment;
	dump("fldunsigned alignment", s.alignment > 0);
	dump("fldofs type", offsetof(platcheck_t, type));
	dump("fldsize type",   sizeof(s.type));
	s.type = 0; s.type = ~s.type;
	dump("fldunsigned type", s.type > 0);
	dump("fldofs elements", offsetof(platcheck_t, elements));
	dump("fldsize elements",   sizeof(s.elements));
}

void dump_section_ffi_type_double_alignment(void) {
	if ((ffi_type_double.alignment) <= 0) {
	    long long x = (long long)(ffi_type_double.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_double.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_double_size(void) {
	if ((ffi_type_double.size) <= 0) {
	    long long x = (long long)(ffi_type_double.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_double.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_double_type(void) {
	if ((ffi_type_double.type) <= 0) {
	    long long x = (long long)(ffi_type_double.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_double.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_float_alignment(void) {
	if ((ffi_type_float.alignment) <= 0) {
	    long long x = (long long)(ffi_type_float.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_float.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_float_size(void) {
	if ((ffi_type_float.size) <= 0) {
	    long long x = (long long)(ffi_type_float.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_float.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_float_type(void) {
	if ((ffi_type_float.type) <= 0) {
	    long long x = (long long)(ffi_type_float.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_float.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_longdouble_alignment(void) {
	if ((ffi_type_longdouble.alignment) <= 0) {
	    long long x = (long long)(ffi_type_longdouble.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_longdouble.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_longdouble_size(void) {
	if ((ffi_type_longdouble.size) <= 0) {
	    long long x = (long long)(ffi_type_longdouble.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_longdouble.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_longdouble_type(void) {
	if ((ffi_type_longdouble.type) <= 0) {
	    long long x = (long long)(ffi_type_longdouble.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_longdouble.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_pointer_alignment(void) {
	if ((ffi_type_pointer.alignment) <= 0) {
	    long long x = (long long)(ffi_type_pointer.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_pointer.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_pointer_size(void) {
	if ((ffi_type_pointer.size) <= 0) {
	    long long x = (long long)(ffi_type_pointer.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_pointer.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_pointer_type(void) {
	if ((ffi_type_pointer.type) <= 0) {
	    long long x = (long long)(ffi_type_pointer.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_pointer.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_schar_alignment(void) {
	if ((ffi_type_schar.alignment) <= 0) {
	    long long x = (long long)(ffi_type_schar.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_schar.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_schar_size(void) {
	if ((ffi_type_schar.size) <= 0) {
	    long long x = (long long)(ffi_type_schar.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_schar.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_schar_type(void) {
	if ((ffi_type_schar.type) <= 0) {
	    long long x = (long long)(ffi_type_schar.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_schar.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint16_alignment(void) {
	if ((ffi_type_sint16.alignment) <= 0) {
	    long long x = (long long)(ffi_type_sint16.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint16.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint16_size(void) {
	if ((ffi_type_sint16.size) <= 0) {
	    long long x = (long long)(ffi_type_sint16.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint16.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint16_type(void) {
	if ((ffi_type_sint16.type) <= 0) {
	    long long x = (long long)(ffi_type_sint16.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint16.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint32_alignment(void) {
	if ((ffi_type_sint32.alignment) <= 0) {
	    long long x = (long long)(ffi_type_sint32.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint32.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint32_size(void) {
	if ((ffi_type_sint32.size) <= 0) {
	    long long x = (long long)(ffi_type_sint32.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint32.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint32_type(void) {
	if ((ffi_type_sint32.type) <= 0) {
	    long long x = (long long)(ffi_type_sint32.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint32.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint64_alignment(void) {
	if ((ffi_type_sint64.alignment) <= 0) {
	    long long x = (long long)(ffi_type_sint64.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint64.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint64_size(void) {
	if ((ffi_type_sint64.size) <= 0) {
	    long long x = (long long)(ffi_type_sint64.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint64.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint64_type(void) {
	if ((ffi_type_sint64.type) <= 0) {
	    long long x = (long long)(ffi_type_sint64.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint64.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint8_alignment(void) {
	if ((ffi_type_sint8.alignment) <= 0) {
	    long long x = (long long)(ffi_type_sint8.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint8.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint8_size(void) {
	if ((ffi_type_sint8.size) <= 0) {
	    long long x = (long long)(ffi_type_sint8.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint8.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint8_type(void) {
	if ((ffi_type_sint8.type) <= 0) {
	    long long x = (long long)(ffi_type_sint8.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint8.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint_alignment(void) {
	if ((ffi_type_sint.alignment) <= 0) {
	    long long x = (long long)(ffi_type_sint.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint_size(void) {
	if ((ffi_type_sint.size) <= 0) {
	    long long x = (long long)(ffi_type_sint.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sint_type(void) {
	if ((ffi_type_sint.type) <= 0) {
	    long long x = (long long)(ffi_type_sint.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sint.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sshort_alignment(void) {
	if ((ffi_type_sshort.alignment) <= 0) {
	    long long x = (long long)(ffi_type_sshort.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sshort.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sshort_size(void) {
	if ((ffi_type_sshort.size) <= 0) {
	    long long x = (long long)(ffi_type_sshort.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sshort.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_sshort_type(void) {
	if ((ffi_type_sshort.type) <= 0) {
	    long long x = (long long)(ffi_type_sshort.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_sshort.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uchar_alignment(void) {
	if ((ffi_type_uchar.alignment) <= 0) {
	    long long x = (long long)(ffi_type_uchar.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uchar.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uchar_size(void) {
	if ((ffi_type_uchar.size) <= 0) {
	    long long x = (long long)(ffi_type_uchar.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uchar.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uchar_type(void) {
	if ((ffi_type_uchar.type) <= 0) {
	    long long x = (long long)(ffi_type_uchar.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uchar.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint16_alignment(void) {
	if ((ffi_type_uint16.alignment) <= 0) {
	    long long x = (long long)(ffi_type_uint16.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint16.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint16_size(void) {
	if ((ffi_type_uint16.size) <= 0) {
	    long long x = (long long)(ffi_type_uint16.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint16.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint16_type(void) {
	if ((ffi_type_uint16.type) <= 0) {
	    long long x = (long long)(ffi_type_uint16.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint16.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint32_alignment(void) {
	if ((ffi_type_uint32.alignment) <= 0) {
	    long long x = (long long)(ffi_type_uint32.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint32.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint32_size(void) {
	if ((ffi_type_uint32.size) <= 0) {
	    long long x = (long long)(ffi_type_uint32.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint32.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint32_type(void) {
	if ((ffi_type_uint32.type) <= 0) {
	    long long x = (long long)(ffi_type_uint32.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint32.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint64_alignment(void) {
	if ((ffi_type_uint64.alignment) <= 0) {
	    long long x = (long long)(ffi_type_uint64.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint64.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint64_size(void) {
	if ((ffi_type_uint64.size) <= 0) {
	    long long x = (long long)(ffi_type_uint64.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint64.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint64_type(void) {
	if ((ffi_type_uint64.type) <= 0) {
	    long long x = (long long)(ffi_type_uint64.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint64.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint8_alignment(void) {
	if ((ffi_type_uint8.alignment) <= 0) {
	    long long x = (long long)(ffi_type_uint8.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint8.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint8_size(void) {
	if ((ffi_type_uint8.size) <= 0) {
	    long long x = (long long)(ffi_type_uint8.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint8.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint8_type(void) {
	if ((ffi_type_uint8.type) <= 0) {
	    long long x = (long long)(ffi_type_uint8.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint8.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint_alignment(void) {
	if ((ffi_type_uint.alignment) <= 0) {
	    long long x = (long long)(ffi_type_uint.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint_size(void) {
	if ((ffi_type_uint.size) <= 0) {
	    long long x = (long long)(ffi_type_uint.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_uint_type(void) {
	if ((ffi_type_uint.type) <= 0) {
	    long long x = (long long)(ffi_type_uint.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_uint.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_ushort_alignment(void) {
	if ((ffi_type_ushort.alignment) <= 0) {
	    long long x = (long long)(ffi_type_ushort.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_ushort.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_ushort_size(void) {
	if ((ffi_type_ushort.size) <= 0) {
	    long long x = (long long)(ffi_type_ushort.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_ushort.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_ushort_type(void) {
	if ((ffi_type_ushort.type) <= 0) {
	    long long x = (long long)(ffi_type_ushort.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_ushort.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_void_alignment(void) {
	if ((ffi_type_void.alignment) <= 0) {
	    long long x = (long long)(ffi_type_void.alignment);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_void.alignment);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_void_size(void) {
	if ((ffi_type_void.size) <= 0) {
	    long long x = (long long)(ffi_type_void.size);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_void.size);
	    printf("value: %llu\n", x);
	}
}

void dump_section_ffi_type_void_type(void) {
	if ((ffi_type_void.type) <= 0) {
	    long long x = (long long)(ffi_type_void.type);
	    printf("value: %lld\n", x);
	} else {
	    unsigned long long x = (unsigned long long)(ffi_type_void.type);
	    printf("value: %llu\n", x);
	}
}

void dump_section_size_t(void) {
	typedef size_t platcheck_t;

	platcheck_t x;
	dump("size",  sizeof(platcheck_t));
	x = 0; x = ~x;
	dump("unsigned", x > 0);
}

int main(int argc, char *argv[]) {
	printf("-+- FFI_BAD_TYPEDEF\n");
	dump_section_FFI_BAD_TYPEDEF();
	printf("---\n");
	printf("-+- FFI_DEFAULT_ABI\n");
	dump_section_FFI_DEFAULT_ABI();
	printf("---\n");
	printf("-+- FFI_OK\n");
	dump_section_FFI_OK();
	printf("---\n");
	printf("-+- FFI_TYPE_STRUCT\n");
	dump_section_FFI_TYPE_STRUCT();
	printf("---\n");
	printf("-+- ffi_abi\n");
	dump_section_ffi_abi();
	printf("---\n");
	printf("-+- ffi_arg\n");
	dump_section_ffi_arg();
	printf("---\n");
	printf("-+- ffi_cif\n");
	dump_section_ffi_cif();
	printf("---\n");
	printf("-+- ffi_closure\n");
	dump_section_ffi_closure();
	printf("---\n");
	printf("-+- ffi_type\n");
	dump_section_ffi_type();
	printf("---\n");
	printf("-+- ffi_type_double_alignment\n");
	dump_section_ffi_type_double_alignment();
	printf("---\n");
	printf("-+- ffi_type_double_size\n");
	dump_section_ffi_type_double_size();
	printf("---\n");
	printf("-+- ffi_type_double_type\n");
	dump_section_ffi_type_double_type();
	printf("---\n");
	printf("-+- ffi_type_float_alignment\n");
	dump_section_ffi_type_float_alignment();
	printf("---\n");
	printf("-+- ffi_type_float_size\n");
	dump_section_ffi_type_float_size();
	printf("---\n");
	printf("-+- ffi_type_float_type\n");
	dump_section_ffi_type_float_type();
	printf("---\n");
	printf("-+- ffi_type_longdouble_alignment\n");
	dump_section_ffi_type_longdouble_alignment();
	printf("---\n");
	printf("-+- ffi_type_longdouble_size\n");
	dump_section_ffi_type_longdouble_size();
	printf("---\n");
	printf("-+- ffi_type_longdouble_type\n");
	dump_section_ffi_type_longdouble_type();
	printf("---\n");
	printf("-+- ffi_type_pointer_alignment\n");
	dump_section_ffi_type_pointer_alignment();
	printf("---\n");
	printf("-+- ffi_type_pointer_size\n");
	dump_section_ffi_type_pointer_size();
	printf("---\n");
	printf("-+- ffi_type_pointer_type\n");
	dump_section_ffi_type_pointer_type();
	printf("---\n");
	printf("-+- ffi_type_schar_alignment\n");
	dump_section_ffi_type_schar_alignment();
	printf("---\n");
	printf("-+- ffi_type_schar_size\n");
	dump_section_ffi_type_schar_size();
	printf("---\n");
	printf("-+- ffi_type_schar_type\n");
	dump_section_ffi_type_schar_type();
	printf("---\n");
	printf("-+- ffi_type_sint16_alignment\n");
	dump_section_ffi_type_sint16_alignment();
	printf("---\n");
	printf("-+- ffi_type_sint16_size\n");
	dump_section_ffi_type_sint16_size();
	printf("---\n");
	printf("-+- ffi_type_sint16_type\n");
	dump_section_ffi_type_sint16_type();
	printf("---\n");
	printf("-+- ffi_type_sint32_alignment\n");
	dump_section_ffi_type_sint32_alignment();
	printf("---\n");
	printf("-+- ffi_type_sint32_size\n");
	dump_section_ffi_type_sint32_size();
	printf("---\n");
	printf("-+- ffi_type_sint32_type\n");
	dump_section_ffi_type_sint32_type();
	printf("---\n");
	printf("-+- ffi_type_sint64_alignment\n");
	dump_section_ffi_type_sint64_alignment();
	printf("---\n");
	printf("-+- ffi_type_sint64_size\n");
	dump_section_ffi_type_sint64_size();
	printf("---\n");
	printf("-+- ffi_type_sint64_type\n");
	dump_section_ffi_type_sint64_type();
	printf("---\n");
	printf("-+- ffi_type_sint8_alignment\n");
	dump_section_ffi_type_sint8_alignment();
	printf("---\n");
	printf("-+- ffi_type_sint8_size\n");
	dump_section_ffi_type_sint8_size();
	printf("---\n");
	printf("-+- ffi_type_sint8_type\n");
	dump_section_ffi_type_sint8_type();
	printf("---\n");
	printf("-+- ffi_type_sint_alignment\n");
	dump_section_ffi_type_sint_alignment();
	printf("---\n");
	printf("-+- ffi_type_sint_size\n");
	dump_section_ffi_type_sint_size();
	printf("---\n");
	printf("-+- ffi_type_sint_type\n");
	dump_section_ffi_type_sint_type();
	printf("---\n");
	printf("-+- ffi_type_sshort_alignment\n");
	dump_section_ffi_type_sshort_alignment();
	printf("---\n");
	printf("-+- ffi_type_sshort_size\n");
	dump_section_ffi_type_sshort_size();
	printf("---\n");
	printf("-+- ffi_type_sshort_type\n");
	dump_section_ffi_type_sshort_type();
	printf("---\n");
	printf("-+- ffi_type_uchar_alignment\n");
	dump_section_ffi_type_uchar_alignment();
	printf("---\n");
	printf("-+- ffi_type_uchar_size\n");
	dump_section_ffi_type_uchar_size();
	printf("---\n");
	printf("-+- ffi_type_uchar_type\n");
	dump_section_ffi_type_uchar_type();
	printf("---\n");
	printf("-+- ffi_type_uint16_alignment\n");
	dump_section_ffi_type_uint16_alignment();
	printf("---\n");
	printf("-+- ffi_type_uint16_size\n");
	dump_section_ffi_type_uint16_size();
	printf("---\n");
	printf("-+- ffi_type_uint16_type\n");
	dump_section_ffi_type_uint16_type();
	printf("---\n");
	printf("-+- ffi_type_uint32_alignment\n");
	dump_section_ffi_type_uint32_alignment();
	printf("---\n");
	printf("-+- ffi_type_uint32_size\n");
	dump_section_ffi_type_uint32_size();
	printf("---\n");
	printf("-+- ffi_type_uint32_type\n");
	dump_section_ffi_type_uint32_type();
	printf("---\n");
	printf("-+- ffi_type_uint64_alignment\n");
	dump_section_ffi_type_uint64_alignment();
	printf("---\n");
	printf("-+- ffi_type_uint64_size\n");
	dump_section_ffi_type_uint64_size();
	printf("---\n");
	printf("-+- ffi_type_uint64_type\n");
	dump_section_ffi_type_uint64_type();
	printf("---\n");
	printf("-+- ffi_type_uint8_alignment\n");
	dump_section_ffi_type_uint8_alignment();
	printf("---\n");
	printf("-+- ffi_type_uint8_size\n");
	dump_section_ffi_type_uint8_size();
	printf("---\n");
	printf("-+- ffi_type_uint8_type\n");
	dump_section_ffi_type_uint8_type();
	printf("---\n");
	printf("-+- ffi_type_uint_alignment\n");
	dump_section_ffi_type_uint_alignment();
	printf("---\n");
	printf("-+- ffi_type_uint_size\n");
	dump_section_ffi_type_uint_size();
	printf("---\n");
	printf("-+- ffi_type_uint_type\n");
	dump_section_ffi_type_uint_type();
	printf("---\n");
	printf("-+- ffi_type_ushort_alignment\n");
	dump_section_ffi_type_ushort_alignment();
	printf("---\n");
	printf("-+- ffi_type_ushort_size\n");
	dump_section_ffi_type_ushort_size();
	printf("---\n");
	printf("-+- ffi_type_ushort_type\n");
	dump_section_ffi_type_ushort_type();
	printf("---\n");
	printf("-+- ffi_type_void_alignment\n");
	dump_section_ffi_type_void_alignment();
	printf("---\n");
	printf("-+- ffi_type_void_size\n");
	dump_section_ffi_type_void_size();
	printf("---\n");
	printf("-+- ffi_type_void_type\n");
	dump_section_ffi_type_void_type();
	printf("---\n");
	printf("-+- size_t\n");
	dump_section_size_t();
	printf("---\n");
	return 0;
}