�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2F'>ext</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fffi%2F'>ffi</a>/</p><hr><h3>✏️ Editing: ffi.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
   +----------------------------------------------------------------------+
   | Copyright (c) The PHP Group                                          |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | https://www.php.net/license/3_01.txt                                 |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | Author: Dmitry Stogov &lt;dmitry@zend.com&gt;                              |
   +----------------------------------------------------------------------+
*/

#ifdef HAVE_CONFIG_H
# include &quot;config.h&quot;
#endif

#include &quot;php.h&quot;
#include &quot;php_ffi.h&quot;
#include &quot;ext/standard/info.h&quot;
#include &quot;php_scandir.h&quot;
#include &quot;zend_exceptions.h&quot;
#include &quot;zend_closures.h&quot;
#include &quot;zend_weakrefs.h&quot;
#include &quot;main/SAPI.h&quot;
#include &quot;zend_observer.h&quot;

#include &lt;ffi.h&gt;

#include &lt;sys/types.h&gt;
#include &lt;sys/stat.h&gt;
#include &lt;fcntl.h&gt;

#ifdef HAVE_LIBDL
#ifdef PHP_WIN32
#include &quot;win32/param.h&quot;
#include &quot;win32/winutil.h&quot;
#define GET_DL_ERROR()  php_win_err()
#else
#include &lt;sys/param.h&gt;
#define GET_DL_ERROR()  DL_ERROR()
#endif
#endif

#ifdef HAVE_GLOB
#ifdef PHP_WIN32
#include &quot;win32/glob.h&quot;
#else
#include &lt;glob.h&gt;
#endif
#endif

#ifndef __BIGGEST_ALIGNMENT__
/* XXX need something better, perhaps with regard to SIMD, etc. */
# define __BIGGEST_ALIGNMENT__ sizeof(size_t)
#endif

ZEND_DECLARE_MODULE_GLOBALS(ffi)

typedef enum _zend_ffi_tag_kind {
	ZEND_FFI_TAG_ENUM,
	ZEND_FFI_TAG_STRUCT,
	ZEND_FFI_TAG_UNION
} zend_ffi_tag_kind;

static const char *zend_ffi_tag_kind_name[3] = {&quot;enum&quot;, &quot;struct&quot;, &quot;union&quot;};


typedef struct _zend_ffi_tag {
	zend_ffi_tag_kind      kind;
	zend_ffi_type         *type;
} zend_ffi_tag;

typedef enum _zend_ffi_type_kind {
	ZEND_FFI_TYPE_VOID,
	ZEND_FFI_TYPE_FLOAT,
	ZEND_FFI_TYPE_DOUBLE,
#ifdef HAVE_LONG_DOUBLE
	ZEND_FFI_TYPE_LONGDOUBLE,
#endif
	ZEND_FFI_TYPE_UINT8,
	ZEND_FFI_TYPE_SINT8,
	ZEND_FFI_TYPE_UINT16,
	ZEND_FFI_TYPE_SINT16,
	ZEND_FFI_TYPE_UINT32,
	ZEND_FFI_TYPE_SINT32,
	ZEND_FFI_TYPE_UINT64,
	ZEND_FFI_TYPE_SINT64,
	ZEND_FFI_TYPE_ENUM,
	ZEND_FFI_TYPE_BOOL,
	ZEND_FFI_TYPE_CHAR,
	ZEND_FFI_TYPE_POINTER,
	ZEND_FFI_TYPE_FUNC,
	ZEND_FFI_TYPE_ARRAY,
	ZEND_FFI_TYPE_STRUCT,
} zend_ffi_type_kind;

#include &quot;ffi_arginfo.h&quot;

typedef enum _zend_ffi_flags {
	ZEND_FFI_FLAG_CONST      = (1 &lt;&lt; 0),
	ZEND_FFI_FLAG_OWNED      = (1 &lt;&lt; 1),
	ZEND_FFI_FLAG_PERSISTENT = (1 &lt;&lt; 2),
} zend_ffi_flags;

struct _zend_ffi_type {
	zend_ffi_type_kind     kind;
	size_t                 size;
	uint32_t               align;
	uint32_t               attr;
	union {
		struct {
			zend_string        *tag_name;
			zend_ffi_type_kind  kind;
		} enumeration;
		struct {
			zend_ffi_type *type;
			zend_long      length;
		} array;
		struct {
			zend_ffi_type *type;
		} pointer;
		struct {
			zend_string   *tag_name;
			HashTable      fields;
		} record;
		struct {
			zend_ffi_type *ret_type;
			HashTable     *args;
			ffi_abi        abi;
		} func;
	};
};

typedef struct _zend_ffi_field {
	size_t                 offset;
	bool              is_const;
	bool              is_nested; /* part of nested anonymous struct */
	uint8_t                first_bit;
	uint8_t                bits;
	zend_ffi_type         *type;
} zend_ffi_field;

typedef enum _zend_ffi_symbol_kind {
	ZEND_FFI_SYM_TYPE,
	ZEND_FFI_SYM_CONST,
	ZEND_FFI_SYM_VAR,
	ZEND_FFI_SYM_FUNC
} zend_ffi_symbol_kind;

typedef struct _zend_ffi_symbol {
	zend_ffi_symbol_kind   kind;
	bool              is_const;
	zend_ffi_type         *type;
	union {
		void *addr;
		int64_t value;
	};
} zend_ffi_symbol;

typedef struct _zend_ffi_scope {
	HashTable             *symbols;
	HashTable             *tags;
} zend_ffi_scope;

typedef struct _zend_ffi {
	zend_object            std;
	DL_HANDLE              lib;
	HashTable             *symbols;
	HashTable             *tags;
	bool              persistent;
} zend_ffi;

#define ZEND_FFI_TYPE_OWNED        (1&lt;&lt;0)

#define ZEND_FFI_TYPE(t) \
	((zend_ffi_type*)(((uintptr_t)(t)) &amp; ~ZEND_FFI_TYPE_OWNED))

#define ZEND_FFI_TYPE_IS_OWNED(t) \
	(((uintptr_t)(t)) &amp; ZEND_FFI_TYPE_OWNED)

#define ZEND_FFI_TYPE_MAKE_OWNED(t) \
	((zend_ffi_type*)(((uintptr_t)(t)) | ZEND_FFI_TYPE_OWNED))

#define ZEND_FFI_SIZEOF_ARG \
	MAX(FFI_SIZEOF_ARG, sizeof(double))

typedef struct _zend_ffi_cdata {
	zend_object            std;
	zend_ffi_type         *type;
	void                  *ptr;
	void                  *ptr_holder;
	zend_ffi_flags         flags;
} zend_ffi_cdata;

typedef struct _zend_ffi_ctype {
	zend_object            std;
	zend_ffi_type         *type;
} zend_ffi_ctype;

static zend_class_entry *zend_ffi_exception_ce;
static zend_class_entry *zend_ffi_parser_exception_ce;
static zend_class_entry *zend_ffi_ce;
static zend_class_entry *zend_ffi_cdata_ce;
static zend_class_entry *zend_ffi_ctype_ce;

static zend_object_handlers zend_ffi_handlers;
static zend_object_handlers zend_ffi_cdata_handlers;
static zend_object_handlers zend_ffi_cdata_value_handlers;
static zend_object_handlers zend_ffi_cdata_free_handlers;
static zend_object_handlers zend_ffi_ctype_handlers;

static zend_internal_function zend_ffi_new_fn;
static zend_internal_function zend_ffi_cast_fn;
static zend_internal_function zend_ffi_type_fn;

/* forward declarations */
static void _zend_ffi_type_dtor(zend_ffi_type *type);
static void zend_ffi_finalize_type(zend_ffi_dcl *dcl);
static bool zend_ffi_is_same_type(zend_ffi_type *type1, zend_ffi_type *type2);
static zend_ffi_type *zend_ffi_remember_type(zend_ffi_type *type);
static char *zend_ffi_parse_directives(const char *filename, char *code_pos, char **scope_name, char **lib, bool preload);
static ZEND_FUNCTION(ffi_trampoline);
static ZEND_COLD void zend_ffi_return_unsupported(zend_ffi_type *type);
static ZEND_COLD void zend_ffi_pass_unsupported(zend_ffi_type *type);
static ZEND_COLD void zend_ffi_assign_incompatible(zval *arg, zend_ffi_type *type);
static bool zend_ffi_is_compatible_type(zend_ffi_type *dst_type, zend_ffi_type *src_type);

#if FFI_CLOSURES
static void *zend_ffi_create_callback(zend_ffi_type *type, zval *value);
#endif

static zend_always_inline void zend_ffi_type_dtor(zend_ffi_type *type) /* {{{ */
{
	if (UNEXPECTED(ZEND_FFI_TYPE_IS_OWNED(type))) {
		_zend_ffi_type_dtor(type);
		return;
	}
}
/* }}} */

static zend_always_inline void zend_ffi_object_init(zend_object *object, zend_class_entry *ce) /* {{{ */
{
	GC_SET_REFCOUNT(object, 1);
	GC_TYPE_INFO(object) = GC_OBJECT | (IS_OBJ_DESTRUCTOR_CALLED &lt;&lt; GC_FLAGS_SHIFT);
	object-&gt;extra_flags = 0;
	object-&gt;ce = ce;
	object-&gt;handlers = ce-&gt;default_object_handlers;
	object-&gt;properties = NULL;
	zend_objects_store_put(object);
}
/* }}} */

static zend_object *zend_ffi_cdata_new(zend_class_entry *class_type) /* {{{ */
{
	zend_ffi_cdata *cdata;

	cdata = emalloc(sizeof(zend_ffi_cdata));

	zend_ffi_object_init(&amp;cdata-&gt;std, class_type);

	cdata-&gt;type = NULL;
	cdata-&gt;ptr = NULL;
	cdata-&gt;flags = 0;

	return &amp;cdata-&gt;std;
}
/* }}} */

static bool zend_ffi_func_ptr_are_compatible(zend_ffi_type *dst_type, zend_ffi_type *src_type) /* {{{ */
{
	uint32_t dst_argc, src_argc, i;
	zend_ffi_type *dst_arg, *src_arg;

	ZEND_ASSERT(dst_type-&gt;kind == ZEND_FFI_TYPE_FUNC);
	ZEND_ASSERT(src_type-&gt;kind == ZEND_FFI_TYPE_FUNC);

	/* Ensure calling convention matches */
	if (dst_type-&gt;func.abi != src_type-&gt;func.abi) {
		return 0;
	}

	/* Ensure variadic attr matches */
	if ((dst_type-&gt;attr &amp; ZEND_FFI_ATTR_VARIADIC) != (src_type-&gt;attr &amp; ZEND_FFI_ATTR_VARIADIC)) {
		return 0;
	}

	/* Ensure same arg count */
	dst_argc = dst_type-&gt;func.args ? zend_hash_num_elements(dst_type-&gt;func.args) : 0;
	src_argc = src_type-&gt;func.args ? zend_hash_num_elements(src_type-&gt;func.args) : 0;
	if (dst_argc != src_argc) {
		return 0;
	}

	/* Ensure compatible ret_type */
	if (!zend_ffi_is_compatible_type(dst_type-&gt;func.ret_type, src_type-&gt;func.ret_type)) {
		return 0;
	}

	/* Ensure compatible args */
	for (i = 0; i &lt; dst_argc; i++) {
		dst_arg = zend_hash_index_find_ptr(dst_type-&gt;func.args, i);
		src_arg = zend_hash_index_find_ptr(src_type-&gt;func.args, i);
		if (!zend_ffi_is_compatible_type(ZEND_FFI_TYPE(dst_arg), ZEND_FFI_TYPE(src_arg))) {
			return 0;
		}
	}

	return 1;
}
/* }}} */

static bool zend_ffi_is_compatible_type(zend_ffi_type *dst_type, zend_ffi_type *src_type) /* {{{ */
{
	while (1) {
		if (dst_type == src_type) {
			return 1;
		} else if (dst_type-&gt;kind == src_type-&gt;kind) {
			if (dst_type-&gt;kind &lt; ZEND_FFI_TYPE_POINTER) {
				return 1;
			} else if (dst_type-&gt;kind == ZEND_FFI_TYPE_POINTER) {
				dst_type = ZEND_FFI_TYPE(dst_type-&gt;pointer.type);
				src_type = ZEND_FFI_TYPE(src_type-&gt;pointer.type);
				if (dst_type-&gt;kind == ZEND_FFI_TYPE_VOID ||
				    src_type-&gt;kind == ZEND_FFI_TYPE_VOID) {
				    return 1;
				} else if (dst_type-&gt;kind == ZEND_FFI_TYPE_FUNC &amp;&amp;
				           src_type-&gt;kind == ZEND_FFI_TYPE_FUNC) {
				    return zend_ffi_func_ptr_are_compatible(dst_type, src_type);
				}
			} else if (dst_type-&gt;kind == ZEND_FFI_TYPE_ARRAY &amp;&amp;
			           (dst_type-&gt;array.length == src_type-&gt;array.length ||
			            dst_type-&gt;array.length == 0)) {
				dst_type = ZEND_FFI_TYPE(dst_type-&gt;array.type);
				src_type = ZEND_FFI_TYPE(src_type-&gt;array.type);
			} else {
				break;
			}
		} else if (dst_type-&gt;kind == ZEND_FFI_TYPE_POINTER &amp;&amp;
		           src_type-&gt;kind == ZEND_FFI_TYPE_ARRAY) {
			dst_type = ZEND_FFI_TYPE(dst_type-&gt;pointer.type);
			src_type = ZEND_FFI_TYPE(src_type-&gt;array.type);
			if (dst_type-&gt;kind == ZEND_FFI_TYPE_VOID) {
			    return 1;
			}
		} else {
			break;
		}
	}
	return 0;
}
/* }}} */

static ffi_type* zend_ffi_face_struct_add_fields(ffi_type* t, zend_ffi_type *type, int *i, size_t size)
{
	zend_ffi_field *field;

	ZEND_HASH_MAP_FOREACH_PTR(&amp;type-&gt;record.fields, field) {
		switch (ZEND_FFI_TYPE(field-&gt;type)-&gt;kind) {
			case ZEND_FFI_TYPE_FLOAT:
				t-&gt;elements[(*i)++] = &amp;ffi_type_float;
				break;
			case ZEND_FFI_TYPE_DOUBLE:
				t-&gt;elements[(*i)++] = &amp;ffi_type_double;
				break;
#ifdef HAVE_LONG_DOUBLE
			case ZEND_FFI_TYPE_LONGDOUBLE:
				t-&gt;elements[(*i)++] = &amp;ffi_type_longdouble;
				break;
#endif
			case ZEND_FFI_TYPE_SINT8:
			case ZEND_FFI_TYPE_UINT8:
			case ZEND_FFI_TYPE_BOOL:
			case ZEND_FFI_TYPE_CHAR:
				t-&gt;elements[(*i)++] = &amp;ffi_type_uint8;
				break;
			case ZEND_FFI_TYPE_SINT16:
			case ZEND_FFI_TYPE_UINT16:
				t-&gt;elements[(*i)++] = &amp;ffi_type_uint16;
				break;
			case ZEND_FFI_TYPE_SINT32:
			case ZEND_FFI_TYPE_UINT32:
				t-&gt;elements[(*i)++] = &amp;ffi_type_uint32;
				break;
			case ZEND_FFI_TYPE_SINT64:
			case ZEND_FFI_TYPE_UINT64:
				t-&gt;elements[(*i)++] = &amp;ffi_type_uint64;
				break;
			case ZEND_FFI_TYPE_POINTER:
				t-&gt;elements[(*i)++] = &amp;ffi_type_pointer;
				break;
			case ZEND_FFI_TYPE_STRUCT: {
				zend_ffi_type *field_type = ZEND_FFI_TYPE(field-&gt;type);
				/* for unions we use only the first field */
				uint32_t num_fields = !(field_type-&gt;attr &amp; ZEND_FFI_ATTR_UNION) ?
					zend_hash_num_elements(&amp;field_type-&gt;record.fields) : 1;

				if (num_fields &gt; 1) {
					size += sizeof(ffi_type*) * (num_fields - 1);
					t = erealloc(t, size);
					t-&gt;elements = (ffi_type**)(t + 1);
				}
				t = zend_ffi_face_struct_add_fields(t, field_type, i, size);
				break;
			}
			default:
				t-&gt;elements[(*i)++] = &amp;ffi_type_void;
				break;
		}
		if (type-&gt;attr &amp; ZEND_FFI_ATTR_UNION) {
			/* for unions we use only the first field */
			break;
		}
	} ZEND_HASH_FOREACH_END();
	return t;
}

static ffi_type *zend_ffi_make_fake_struct_type(zend_ffi_type *type) /* {{{ */
{
	/* for unions we use only the first field */
	uint32_t num_fields = !(type-&gt;attr &amp; ZEND_FFI_ATTR_UNION) ?
		zend_hash_num_elements(&amp;type-&gt;record.fields) : 1;
	size_t size = sizeof(ffi_type) + sizeof(ffi_type*) * (num_fields + 1);
	ffi_type *t = emalloc(size);
	int i;

	t-&gt;size = type-&gt;size;
	t-&gt;alignment = type-&gt;align;
	t-&gt;type = FFI_TYPE_STRUCT;
	t-&gt;elements = (ffi_type**)(t + 1);
	i = 0;
	t = zend_ffi_face_struct_add_fields(t, type, &amp;i, size);
	t-&gt;elements[i] = NULL;
	return t;
}
/* }}} */

static ffi_type *zend_ffi_get_type(zend_ffi_type *type) /* {{{ */
{
	zend_ffi_type_kind kind = type-&gt;kind;

again:
	switch (kind) {
		case ZEND_FFI_TYPE_FLOAT:
			return &amp;ffi_type_float;
		case ZEND_FFI_TYPE_DOUBLE:
			return &amp;ffi_type_double;
#ifdef HAVE_LONG_DOUBLE
		case ZEND_FFI_TYPE_LONGDOUBLE:
			return &amp;ffi_type_longdouble;
#endif
		case ZEND_FFI_TYPE_UINT8:
			return &amp;ffi_type_uint8;
		case ZEND_FFI_TYPE_SINT8:
			return &amp;ffi_type_sint8;
		case ZEND_FFI_TYPE_UINT16:
			return &amp;ffi_type_uint16;
		case ZEND_FFI_TYPE_SINT16:
			return &amp;ffi_type_sint16;
		case ZEND_FFI_TYPE_UINT32:
			return &amp;ffi_type_uint32;
		case ZEND_FFI_TYPE_SINT32:
			return &amp;ffi_type_sint32;
		case ZEND_FFI_TYPE_UINT64:
			return &amp;ffi_type_uint64;
		case ZEND_FFI_TYPE_SINT64:
			return &amp;ffi_type_sint64;
		case ZEND_FFI_TYPE_POINTER:
			return &amp;ffi_type_pointer;
		case ZEND_FFI_TYPE_VOID:
			return &amp;ffi_type_void;
		case ZEND_FFI_TYPE_BOOL:
			return &amp;ffi_type_uint8;
		case ZEND_FFI_TYPE_CHAR:
			return &amp;ffi_type_sint8;
		case ZEND_FFI_TYPE_ENUM:
			kind = type-&gt;enumeration.kind;
			goto again;
		case ZEND_FFI_TYPE_STRUCT:
			return zend_ffi_make_fake_struct_type(type);
		default:
			break;
	}
	return NULL;
}
/* }}} */

static zend_never_inline zend_ffi_cdata *zend_ffi_cdata_to_zval_slow(void *ptr, zend_ffi_type *type, zend_ffi_flags flags) /* {{{ */
{
	zend_ffi_cdata *cdata = emalloc(sizeof(zend_ffi_cdata));

	zend_ffi_object_init(&amp;cdata-&gt;std, zend_ffi_cdata_ce);
	cdata-&gt;std.handlers =
		(type-&gt;kind &lt; ZEND_FFI_TYPE_POINTER) ?
		&amp;zend_ffi_cdata_value_handlers :
		&amp;zend_ffi_cdata_handlers;
	cdata-&gt;type = type;
	cdata-&gt;flags = flags;
	cdata-&gt;ptr = ptr;
	return cdata;
}
/* }}} */

static zend_never_inline zend_ffi_cdata *zend_ffi_cdata_to_zval_slow_ptr(void *ptr, zend_ffi_type *type, zend_ffi_flags flags) /* {{{ */
{
	zend_ffi_cdata *cdata = emalloc(sizeof(zend_ffi_cdata));

	zend_ffi_object_init(&amp;cdata-&gt;std, zend_ffi_cdata_ce);
	cdata-&gt;type = type;
	cdata-&gt;flags = flags;
	cdata-&gt;ptr = (void*)&amp;cdata-&gt;ptr_holder;
	*(void**)cdata-&gt;ptr = *(void**)ptr;
	return cdata;
}
/* }}} */

static zend_never_inline zend_ffi_cdata *zend_ffi_cdata_to_zval_slow_ret(void *ptr, zend_ffi_type *type, zend_ffi_flags flags) /* {{{ */
{
	zend_ffi_cdata *cdata = emalloc(sizeof(zend_ffi_cdata));

	zend_ffi_object_init(&amp;cdata-&gt;std, zend_ffi_cdata_ce);
	cdata-&gt;std.handlers =
		(type-&gt;kind &lt; ZEND_FFI_TYPE_POINTER) ?
		&amp;zend_ffi_cdata_value_handlers :
		&amp;zend_ffi_cdata_handlers;
	cdata-&gt;type = type;
	cdata-&gt;flags = flags;
	if (type-&gt;kind == ZEND_FFI_TYPE_POINTER) {
		cdata-&gt;ptr = (void*)&amp;cdata-&gt;ptr_holder;
		*(void**)cdata-&gt;ptr = *(void**)ptr;
	} else if (type-&gt;kind == ZEND_FFI_TYPE_STRUCT) {
		cdata-&gt;ptr = emalloc(type-&gt;size);
		cdata-&gt;flags |= ZEND_FFI_FLAG_OWNED;
		memcpy(cdata-&gt;ptr, ptr, type-&gt;size);
	} else {
		cdata-&gt;ptr = ptr;
	}
	return cdata;
}
/* }}} */

static zend_always_inline void zend_ffi_cdata_to_zval(zend_ffi_cdata *cdata, void *ptr, zend_ffi_type *type, int read_type, zval *rv, zend_ffi_flags flags, bool is_ret, bool debug_union) /* {{{ */
{
	if (read_type == BP_VAR_R) {
		zend_ffi_type_kind kind = type-&gt;kind;

again:
	    switch (kind) {
			case ZEND_FFI_TYPE_FLOAT:
				ZVAL_DOUBLE(rv, *(float*)ptr);
				return;
			case ZEND_FFI_TYPE_DOUBLE:
				ZVAL_DOUBLE(rv, *(double*)ptr);
				return;
#ifdef HAVE_LONG_DOUBLE
			case ZEND_FFI_TYPE_LONGDOUBLE:
				ZVAL_DOUBLE(rv, *(long double*)ptr);
				return;
#endif
			case ZEND_FFI_TYPE_UINT8:
				ZVAL_LONG(rv, *(uint8_t*)ptr);
				return;
			case ZEND_FFI_TYPE_SINT8:
				ZVAL_LONG(rv, *(int8_t*)ptr);
				return;
			case ZEND_FFI_TYPE_UINT16:
				ZVAL_LONG(rv, *(uint16_t*)ptr);
				return;
			case ZEND_FFI_TYPE_SINT16:
				ZVAL_LONG(rv, *(int16_t*)ptr);
				return;
			case ZEND_FFI_TYPE_UINT32:
				ZVAL_LONG(rv, *(uint32_t*)ptr);
				return;
			case ZEND_FFI_TYPE_SINT32:
				ZVAL_LONG(rv, *(int32_t*)ptr);
				return;
			case ZEND_FFI_TYPE_UINT64:
				ZVAL_LONG(rv, *(uint64_t*)ptr);
				return;
			case ZEND_FFI_TYPE_SINT64:
				ZVAL_LONG(rv, *(int64_t*)ptr);
				return;
			case ZEND_FFI_TYPE_BOOL:
				ZVAL_BOOL(rv, *(uint8_t*)ptr);
				return;
			case ZEND_FFI_TYPE_CHAR:
				ZVAL_CHAR(rv, *(char*)ptr);
				return;
			case ZEND_FFI_TYPE_ENUM:
				kind = type-&gt;enumeration.kind;
				goto again;
			case ZEND_FFI_TYPE_POINTER:
				if (*(void**)ptr == NULL) {
					ZVAL_NULL(rv);
					return;
				} else if (debug_union) {
					ZVAL_STR(rv, zend_strpprintf(0, &quot;%p&quot;, *(void**)ptr));
					return;
				} else if ((type-&gt;attr &amp; ZEND_FFI_ATTR_CONST) &amp;&amp; ZEND_FFI_TYPE(type-&gt;pointer.type)-&gt;kind == ZEND_FFI_TYPE_CHAR) {
					ZVAL_STRING(rv, *(char**)ptr);
					return;
				}
				if (!cdata) {
					if (is_ret) {
						cdata = zend_ffi_cdata_to_zval_slow_ret(ptr, type, flags);
					} else {
						cdata = zend_ffi_cdata_to_zval_slow_ptr(ptr, type, flags);
					}
				} else {
					GC_ADDREF(&amp;cdata-&gt;std);
				}
				ZVAL_OBJ(rv, &amp;cdata-&gt;std);
				return;
			default:
				break;
		}
	}

	if (!cdata) {
		if (is_ret) {
			cdata = zend_ffi_cdata_to_zval_slow_ret(ptr, type, flags);
		} else {
			cdata = zend_ffi_cdata_to_zval_slow(ptr, type, flags);
		}
	} else {
		GC_ADDREF(&amp;cdata-&gt;std);
	}
	ZVAL_OBJ(rv, &amp;cdata-&gt;std);
}
/* }}} */

static uint64_t zend_ffi_bit_field_read(void *ptr, zend_ffi_field *field) /* {{{ */
{
	size_t bit = field-&gt;first_bit;
	size_t last_bit = bit + field-&gt;bits - 1;
	uint8_t *p = (uint8_t *) ptr + bit / 8;
	uint8_t *last_p = (uint8_t *) ptr + last_bit / 8;
	size_t pos = bit % 8;
	size_t insert_pos = 0;
	uint8_t mask;
	uint64_t val = 0;

	/* Bitfield fits into a single byte */
	if (p == last_p) {
		mask = (1U &lt;&lt; field-&gt;bits) - 1U;
		return (*p &gt;&gt; pos) &amp; mask;
	}

	/* Read partial prefix byte */
	if (pos != 0) {
		size_t num_bits = 8 - pos;
		mask = (1U &lt;&lt; num_bits) - 1U;
		val = (*p++ &gt;&gt; pos) &amp; mask;
		insert_pos += num_bits;
	}

	/* Read full bytes */
	while (p &lt; last_p) {
		val |= (uint64_t) *p++ &lt;&lt; insert_pos;
		insert_pos += 8;
	}

	/* Read partial suffix byte */
	if (p == last_p) {
		size_t num_bits = last_bit % 8 + 1;
		mask = (1U &lt;&lt; num_bits) - 1U;
		val |= (uint64_t) (*p &amp; mask) &lt;&lt; insert_pos;
	}

	return val;
}
/* }}} */

static void zend_ffi_bit_field_to_zval(void *ptr, zend_ffi_field *field, zval *rv) /* {{{ */
{
	uint64_t val = zend_ffi_bit_field_read(ptr, field);
	if (ZEND_FFI_TYPE(field-&gt;type)-&gt;kind == ZEND_FFI_TYPE_CHAR
	 || ZEND_FFI_TYPE(field-&gt;type)-&gt;kind == ZEND_FFI_TYPE_SINT8
	 || ZEND_FFI_TYPE(field-&gt;type)-&gt;kind == ZEND_FFI_TYPE_SINT16
	 || ZEND_FFI_TYPE(field-&gt;type)-&gt;kind == ZEND_FFI_TYPE_SINT32
	 || ZEND_FFI_TYPE(field-&gt;type)-&gt;kind == ZEND_FFI_TYPE_SINT64) {
		/* Sign extend */
		uint64_t shift = 64 - (field-&gt;bits % 64);
		if (shift != 0) {
			val = (int64_t)(val &lt;&lt; shift) &gt;&gt; shift;
		}
	}
	ZVAL_LONG(rv, val);
}
/* }}} */

static void zend_ffi_zval_to_bit_field(void *ptr, zend_ffi_field *field, zval *value) /* {{{ */
{
	uint64_t val = zval_get_long(value);
	size_t bit = field-&gt;first_bit;
	size_t last_bit = bit + field-&gt;bits - 1;
	uint8_t *p = (uint8_t *) ptr + bit / 8;
	uint8_t *last_p = (uint8_t *) ptr + last_bit / 8;
	size_t pos = bit % 8;
	uint8_t mask;

	/* Bitfield fits into a single byte */
	if (p == last_p) {
		mask = ((1U &lt;&lt; field-&gt;bits) - 1U) &lt;&lt; pos;
		*p = (*p &amp; ~mask) | ((val &lt;&lt; pos) &amp; mask);
		return;
	}

	/* Write partial prefix byte */
	if (pos != 0) {
		size_t num_bits = 8 - pos;
		mask = ((1U &lt;&lt; num_bits) - 1U) &lt;&lt; pos;
		*p = (*p &amp; ~mask) | ((val &lt;&lt; pos) &amp; mask);
		p++;
		val &gt;&gt;= num_bits;
	}

	/* Write full bytes */
	while (p &lt; last_p) {
		*p++ = val;
		val &gt;&gt;= 8;
	}

	/* Write partial suffix byte */
	if (p == last_p) {
		size_t num_bits = last_bit % 8 + 1;
		mask = (1U &lt;&lt; num_bits) - 1U;
		*p = (*p &amp; ~mask) | (val &amp; mask);
	}
}
/* }}} */

static zend_always_inline zend_result zend_ffi_zval_to_cdata(void *ptr, zend_ffi_type *type, zval *value) /* {{{ */
{
	zend_long lval;
	double dval;
	zend_string *tmp_str;
	zend_string *str;
	zend_ffi_type_kind kind = type-&gt;kind;

	/* Pointer type has special handling of CData */
	if (kind != ZEND_FFI_TYPE_POINTER &amp;&amp; Z_TYPE_P(value) == IS_OBJECT &amp;&amp; Z_OBJCE_P(value) == zend_ffi_cdata_ce) {
		zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(value);
		if (zend_ffi_is_compatible_type(type, ZEND_FFI_TYPE(cdata-&gt;type)) &amp;&amp;
			type-&gt;size == ZEND_FFI_TYPE(cdata-&gt;type)-&gt;size) {
			memcpy(ptr, cdata-&gt;ptr, type-&gt;size);
			return SUCCESS;
		}
	}

again:
	switch (kind) {
		case ZEND_FFI_TYPE_FLOAT:
			dval = zval_get_double(value);
			*(float*)ptr = dval;
			break;
		case ZEND_FFI_TYPE_DOUBLE:
			dval = zval_get_double(value);
			*(double*)ptr = dval;
			break;
#ifdef HAVE_LONG_DOUBLE
		case ZEND_FFI_TYPE_LONGDOUBLE:
			dval = zval_get_double(value);
			*(long double*)ptr = dval;
			break;
#endif
		case ZEND_FFI_TYPE_UINT8:
			lval = zval_get_long(value);
			*(uint8_t*)ptr = lval;
			break;
		case ZEND_FFI_TYPE_SINT8:
			lval = zval_get_long(value);
			*(int8_t*)ptr = lval;
			break;
		case ZEND_FFI_TYPE_UINT16:
			lval = zval_get_long(value);
			*(uint16_t*)ptr = lval;
			break;
		case ZEND_FFI_TYPE_SINT16:
			lval = zval_get_long(value);
			*(int16_t*)ptr = lval;
			break;
		case ZEND_FFI_TYPE_UINT32:
			lval = zval_get_long(value);
			*(uint32_t*)ptr = lval;
			break;
		case ZEND_FFI_TYPE_SINT32:
			lval = zval_get_long(value);
			*(int32_t*)ptr = lval;
			break;
		case ZEND_FFI_TYPE_UINT64:
			lval = zval_get_long(value);
			*(uint64_t*)ptr = lval;
			break;
		case ZEND_FFI_TYPE_SINT64:
			lval = zval_get_long(value);
			*(int64_t*)ptr = lval;
			break;
		case ZEND_FFI_TYPE_BOOL:
			*(uint8_t*)ptr = zend_is_true(value);
			break;
		case ZEND_FFI_TYPE_CHAR:
			str = zval_get_tmp_string(value, &amp;tmp_str);
			if (ZSTR_LEN(str) == 1) {
				*(char*)ptr = ZSTR_VAL(str)[0];
			} else {
				zend_tmp_string_release(tmp_str);
				zend_ffi_assign_incompatible(value, type);
				return FAILURE;
			}
			zend_tmp_string_release(tmp_str);
			break;
		case ZEND_FFI_TYPE_ENUM:
			kind = type-&gt;enumeration.kind;
			goto again;
		case ZEND_FFI_TYPE_POINTER:
			if (Z_TYPE_P(value) == IS_NULL) {
				*(void**)ptr = NULL;
				break;
			} else if (Z_TYPE_P(value) == IS_OBJECT &amp;&amp; Z_OBJCE_P(value) == zend_ffi_cdata_ce) {
				zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(value);

				if (zend_ffi_is_compatible_type(type, ZEND_FFI_TYPE(cdata-&gt;type))) {
					if (ZEND_FFI_TYPE(cdata-&gt;type)-&gt;kind == ZEND_FFI_TYPE_POINTER) {
						*(void**)ptr = *(void**)cdata-&gt;ptr;
					} else {
						if (cdata-&gt;flags &amp; ZEND_FFI_FLAG_OWNED) {
							zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to perform assign of owned C pointer&quot;);
							return FAILURE;
						}
						*(void**)ptr = cdata-&gt;ptr;
					}
					return SUCCESS;
				/* Allow transparent assignment of not-owned CData to compatible pointers */
				} else if (ZEND_FFI_TYPE(cdata-&gt;type)-&gt;kind != ZEND_FFI_TYPE_POINTER
				 &amp;&amp; zend_ffi_is_compatible_type(ZEND_FFI_TYPE(type-&gt;pointer.type), ZEND_FFI_TYPE(cdata-&gt;type))) {
					if (cdata-&gt;flags &amp; ZEND_FFI_FLAG_OWNED) {
						zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to perform assign pointer to owned C data&quot;);
						return FAILURE;
					}
					*(void**)ptr = cdata-&gt;ptr;
					return SUCCESS;
				}
#if FFI_CLOSURES
			} else if (ZEND_FFI_TYPE(type-&gt;pointer.type)-&gt;kind == ZEND_FFI_TYPE_FUNC) {
				void *callback = zend_ffi_create_callback(ZEND_FFI_TYPE(type-&gt;pointer.type), value);

				if (callback) {
					*(void**)ptr = callback;
					break;
				} else {
					return FAILURE;
				}
#endif
			}
			zend_ffi_assign_incompatible(value, type);
			return FAILURE;
		case ZEND_FFI_TYPE_STRUCT:
		case ZEND_FFI_TYPE_ARRAY:
		default:
			/* Incompatible types, because otherwise the CData check at the entry point would&#039;ve succeeded. */
			zend_ffi_assign_incompatible(value, type);
			return FAILURE;
	}
	return SUCCESS;
}
/* }}} */

#if defined(ZEND_WIN32) &amp;&amp; (defined(HAVE_FFI_FASTCALL) || defined(HAVE_FFI_STDCALL) || defined(HAVE_FFI_VECTORCALL_PARTIAL))
static size_t zend_ffi_arg_size(zend_ffi_type *type) /* {{{ */
{
	zend_ffi_type *arg_type;
	size_t arg_size = 0;

	ZEND_HASH_PACKED_FOREACH_PTR(type-&gt;func.args, arg_type) {
		arg_size += MAX(ZEND_FFI_TYPE(arg_type)-&gt;size, sizeof(size_t));
	} ZEND_HASH_FOREACH_END();
	return arg_size;
}
/* }}} */
#endif

static zend_always_inline zend_string *zend_ffi_mangled_func_name(zend_string *name, zend_ffi_type *type) /* {{{ */
{
#ifdef ZEND_WIN32
	switch (type-&gt;func.abi) {
# ifdef HAVE_FFI_FASTCALL
		case FFI_FASTCALL:
			return strpprintf(0, &quot;@%s@%zu&quot;, ZSTR_VAL(name), zend_ffi_arg_size(type));
# endif
# ifdef HAVE_FFI_STDCALL
		case FFI_STDCALL:
			return strpprintf(0, &quot;_%s@%zu&quot;, ZSTR_VAL(name), zend_ffi_arg_size(type));
# endif
# ifdef HAVE_FFI_VECTORCALL_PARTIAL
		case FFI_VECTORCALL_PARTIAL:
			return strpprintf(0, &quot;%s@@%zu&quot;, ZSTR_VAL(name), zend_ffi_arg_size(type));
# endif
	}
#endif
	return zend_string_copy(name);
}
/* }}} */

#if FFI_CLOSURES
typedef struct _zend_ffi_callback_data {
	zend_fcall_info_cache  fcc;
	zend_ffi_type         *type;
	void                  *code;
	void                  *callback;
	ffi_cif                cif;
	uint32_t               arg_count;
	ffi_type              *ret_type;
	ffi_type              *arg_types[] ZEND_ELEMENT_COUNT(arg_count);
} zend_ffi_callback_data;

static void zend_ffi_callback_hash_dtor(zval *zv) /* {{{ */
{
	zend_ffi_callback_data *callback_data = Z_PTR_P(zv);

	ffi_closure_free(callback_data-&gt;callback);
	if (callback_data-&gt;fcc.function_handler-&gt;common.fn_flags &amp; ZEND_ACC_CLOSURE) {
		OBJ_RELEASE(ZEND_CLOSURE_OBJECT(callback_data-&gt;fcc.function_handler));
	}
	for (int i = 0; i &lt; callback_data-&gt;arg_count; ++i) {
		if (callback_data-&gt;arg_types[i]-&gt;type == FFI_TYPE_STRUCT) {
			efree(callback_data-&gt;arg_types[i]);
		}
	}
	if (callback_data-&gt;ret_type-&gt;type == FFI_TYPE_STRUCT) {
		efree(callback_data-&gt;ret_type);
	}
	efree(callback_data);
}
/* }}} */

static void zend_ffi_callback_trampoline(ffi_cif* cif, void* ret, void** args, void* data) /* {{{ */
{
	zend_ffi_callback_data *callback_data = (zend_ffi_callback_data*)data;
	zend_fcall_info fci;
	zend_ffi_type *ret_type;
	zval retval;
	ALLOCA_FLAG(use_heap)

	fci.size = sizeof(zend_fcall_info);
	ZVAL_UNDEF(&amp;fci.function_name);
	fci.retval = &amp;retval;
	fci.params = do_alloca(sizeof(zval) *callback_data-&gt;arg_count, use_heap);
	fci.object = NULL;
	fci.param_count = callback_data-&gt;arg_count;
	fci.named_params = NULL;

	if (callback_data-&gt;type-&gt;func.args) {
		int n = 0;
		zend_ffi_type *arg_type;

		ZEND_HASH_PACKED_FOREACH_PTR(callback_data-&gt;type-&gt;func.args, arg_type) {
			arg_type = ZEND_FFI_TYPE(arg_type);
			zend_ffi_cdata_to_zval(NULL, args[n], arg_type, BP_VAR_R, &amp;fci.params[n], (zend_ffi_flags)(arg_type-&gt;attr &amp; ZEND_FFI_ATTR_CONST), 0, 0);
			n++;
		} ZEND_HASH_FOREACH_END();
	}

	ZVAL_UNDEF(&amp;retval);
	if (zend_call_function(&amp;fci, &amp;callback_data-&gt;fcc) != SUCCESS) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Cannot call callback&quot;);
	}

	if (callback_data-&gt;arg_count) {
		int n = 0;

		for (n = 0; n &lt; callback_data-&gt;arg_count; n++) {
			zval_ptr_dtor(&amp;fci.params[n]);
		}
	}
	free_alloca(fci.params, use_heap);

	if (EG(exception)) {
		zend_error_noreturn(E_ERROR, &quot;Throwing from FFI callbacks is not allowed&quot;);
	}

	ret_type = ZEND_FFI_TYPE(callback_data-&gt;type-&gt;func.ret_type);
	if (ret_type-&gt;kind != ZEND_FFI_TYPE_VOID) {
		zend_ffi_zval_to_cdata(ret, ret_type, &amp;retval);

#ifdef WORDS_BIGENDIAN
		if (ret_type-&gt;size &lt; sizeof(ffi_arg)
		 &amp;&amp; ret_type-&gt;kind &gt;= ZEND_FFI_TYPE_UINT8
		 &amp;&amp; ret_type-&gt;kind &lt; ZEND_FFI_TYPE_POINTER) {
			/* We need to widen the value (zero extend) */
			switch (ret_type-&gt;size) {
				case 1:
					*(ffi_arg*)ret = *(uint8_t*)ret;
					break;
				case 2:
					*(ffi_arg*)ret = *(uint16_t*)ret;
					break;
				case 4:
					*(ffi_arg*)ret = *(uint32_t*)ret;
					break;
				default:
					break;
			}
		}
#endif
	}

	zval_ptr_dtor(&amp;retval);
}
/* }}} */

static void *zend_ffi_create_callback(zend_ffi_type *type, zval *value) /* {{{ */
{
	zend_fcall_info_cache fcc;
	char *error = NULL;
	uint32_t arg_count;
	void *code;
	void *callback;
	zend_ffi_callback_data *callback_data;

	if (type-&gt;attr &amp; ZEND_FFI_ATTR_VARIADIC) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Variadic function closures are not supported&quot;);
		return NULL;
	}

	if (!zend_is_callable_ex(value, NULL, 0, NULL, &amp;fcc, &amp;error)) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to assign an invalid callback, %s&quot;, error);
		return NULL;
	}

	arg_count = type-&gt;func.args ? zend_hash_num_elements(type-&gt;func.args) : 0;
	if (arg_count &lt; fcc.function_handler-&gt;common.required_num_args) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to assign an invalid callback, insufficient number of arguments&quot;);
		return NULL;
	}

	callback = ffi_closure_alloc(sizeof(ffi_closure), &amp;code);
	if (!callback) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Cannot allocate callback&quot;);
		return NULL;
	}

	callback_data = emalloc(sizeof(zend_ffi_callback_data) + sizeof(ffi_type*) * arg_count);
	memcpy(&amp;callback_data-&gt;fcc, &amp;fcc, sizeof(zend_fcall_info_cache));
	callback_data-&gt;type = type;
	callback_data-&gt;callback = callback;
	callback_data-&gt;code = code;
	callback_data-&gt;arg_count = arg_count;

	if (type-&gt;func.args) {
		int n = 0;
		zend_ffi_type *arg_type;

		ZEND_HASH_PACKED_FOREACH_PTR(type-&gt;func.args, arg_type) {
			arg_type = ZEND_FFI_TYPE(arg_type);
			callback_data-&gt;arg_types[n] = zend_ffi_get_type(arg_type);
			if (!callback_data-&gt;arg_types[n]) {
				zend_ffi_pass_unsupported(arg_type);
				for (int i = 0; i &lt; n; ++i) {
					if (callback_data-&gt;arg_types[i]-&gt;type == FFI_TYPE_STRUCT) {
						efree(callback_data-&gt;arg_types[i]);
					}
				}
				efree(callback_data);
				ffi_closure_free(callback);
				return NULL;
			}
			n++;
		} ZEND_HASH_FOREACH_END();
	}
	callback_data-&gt;ret_type = zend_ffi_get_type(ZEND_FFI_TYPE(type-&gt;func.ret_type));
	if (!callback_data-&gt;ret_type) {
		zend_ffi_return_unsupported(type-&gt;func.ret_type);
		for (int i = 0; i &lt; callback_data-&gt;arg_count; ++i) {
			if (callback_data-&gt;arg_types[i]-&gt;type == FFI_TYPE_STRUCT) {
				efree(callback_data-&gt;arg_types[i]);
			}
		}
		efree(callback_data);
		ffi_closure_free(callback);
		return NULL;
	}

	if (ffi_prep_cif(&amp;callback_data-&gt;cif, type-&gt;func.abi, callback_data-&gt;arg_count, callback_data-&gt;ret_type, callback_data-&gt;arg_types) != FFI_OK) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Cannot prepare callback CIF&quot;);
		goto free_on_failure;
	}

	if (ffi_prep_closure_loc(callback, &amp;callback_data-&gt;cif, zend_ffi_callback_trampoline, callback_data, code) != FFI_OK) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Cannot prepare callback&quot;);
free_on_failure: ;
		for (int i = 0; i &lt; callback_data-&gt;arg_count; ++i) {
			if (callback_data-&gt;arg_types[i]-&gt;type == FFI_TYPE_STRUCT) {
				efree(callback_data-&gt;arg_types[i]);
			}
		}
		if (callback_data-&gt;ret_type-&gt;type == FFI_TYPE_STRUCT) {
			efree(callback_data-&gt;ret_type);
		}
		efree(callback_data);
		ffi_closure_free(callback);
		return NULL;
	}

	if (!FFI_G(callbacks)) {
		FFI_G(callbacks) = emalloc(sizeof(HashTable));
		zend_hash_init(FFI_G(callbacks), 0, NULL, zend_ffi_callback_hash_dtor, 0);
	}
	zend_hash_next_index_insert_ptr(FFI_G(callbacks), callback_data);

	if (fcc.function_handler-&gt;common.fn_flags &amp; ZEND_ACC_CLOSURE) {
		GC_ADDREF(ZEND_CLOSURE_OBJECT(fcc.function_handler));
	}

	return code;
}
/* }}} */
#endif

static zval *zend_ffi_cdata_get(zend_object *obj, zend_string *member, int read_type, void **cache_slot, zval *rv) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)obj;
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);

#if 0
	if (UNEXPECTED(!cdata-&gt;ptr)) {
		zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
		return &amp;EG(uninitialized_zval);
	}
#endif

	if (UNEXPECTED(!zend_string_equals_literal(member, &quot;cdata&quot;))) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Only &#039;cdata&#039; property may be read&quot;);
		return &amp;EG(uninitialized_zval);
	}

	zend_ffi_cdata_to_zval(cdata, cdata-&gt;ptr, type, BP_VAR_R, rv, 0, 0, 0);
	return rv;
}
/* }}} */

static zval *zend_ffi_cdata_set(zend_object *obj, zend_string *member, zval *value, void **cache_slot) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)obj;
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);

#if 0
	if (UNEXPECTED(!cdata-&gt;ptr)) {
		zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
		return &amp;EG(uninitialized_zval);
	}
#endif

	if (UNEXPECTED(!zend_string_equals_literal(member, &quot;cdata&quot;))) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Only &#039;cdata&#039; property may be set&quot;);
		return &amp;EG(uninitialized_zval);
	}

	zend_ffi_zval_to_cdata(cdata-&gt;ptr, type, value);

	return value;
}
/* }}} */

static zend_result zend_ffi_cdata_cast_object(zend_object *readobj, zval *writeobj, int type) /* {{{ */
{
	if (type == IS_STRING) {
		zend_ffi_cdata *cdata = (zend_ffi_cdata*)readobj;
		zend_ffi_type  *ctype = ZEND_FFI_TYPE(cdata-&gt;type);
		void           *ptr = cdata-&gt;ptr;
		zend_ffi_type_kind kind = ctype-&gt;kind;

again:
	    switch (kind) {
			case ZEND_FFI_TYPE_FLOAT:
				ZVAL_DOUBLE(writeobj, *(float*)ptr);
				break;
			case ZEND_FFI_TYPE_DOUBLE:
				ZVAL_DOUBLE(writeobj, *(double*)ptr);
				break;
#ifdef HAVE_LONG_DOUBLE
			case ZEND_FFI_TYPE_LONGDOUBLE:
				ZVAL_DOUBLE(writeobj, *(long double*)ptr);
				break;
#endif
			case ZEND_FFI_TYPE_UINT8:
				ZVAL_LONG(writeobj, *(uint8_t*)ptr);
				break;
			case ZEND_FFI_TYPE_SINT8:
				ZVAL_LONG(writeobj, *(int8_t*)ptr);
				break;
			case ZEND_FFI_TYPE_UINT16:
				ZVAL_LONG(writeobj, *(uint16_t*)ptr);
				break;
			case ZEND_FFI_TYPE_SINT16:
				ZVAL_LONG(writeobj, *(int16_t*)ptr);
				break;
			case ZEND_FFI_TYPE_UINT32:
				ZVAL_LONG(writeobj, *(uint32_t*)ptr);
				break;
			case ZEND_FFI_TYPE_SINT32:
				ZVAL_LONG(writeobj, *(int32_t*)ptr);
				break;
			case ZEND_FFI_TYPE_UINT64:
				ZVAL_LONG(writeobj, *(uint64_t*)ptr);
				break;
			case ZEND_FFI_TYPE_SINT64:
				ZVAL_LONG(writeobj, *(int64_t*)ptr);
				break;
			case ZEND_FFI_TYPE_BOOL:
				ZVAL_BOOL(writeobj, *(uint8_t*)ptr);
				break;
			case ZEND_FFI_TYPE_CHAR:
				ZVAL_CHAR(writeobj, *(char*)ptr);
				return SUCCESS;
			case ZEND_FFI_TYPE_ENUM:
				kind = ctype-&gt;enumeration.kind;
				goto again;
			case ZEND_FFI_TYPE_POINTER:
				if (*(void**)ptr == NULL) {
					ZVAL_NULL(writeobj);
					break;
				} else if ((ctype-&gt;attr &amp; ZEND_FFI_ATTR_CONST) &amp;&amp; ZEND_FFI_TYPE(ctype-&gt;pointer.type)-&gt;kind == ZEND_FFI_TYPE_CHAR) {
					ZVAL_STRING(writeobj, *(char**)ptr);
					return SUCCESS;
				}
				return FAILURE;
			default:
				return FAILURE;
		}
		convert_to_string(writeobj);
		return SUCCESS;
	} else if (type == _IS_BOOL) {
		ZVAL_TRUE(writeobj);
		return SUCCESS;
	}

	return FAILURE;
}
/* }}} */

static zval *zend_ffi_cdata_read_field(zend_object *obj, zend_string *field_name, int read_type, void **cache_slot, zval *rv) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)obj;
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);
	void           *ptr = cdata-&gt;ptr;
	zend_ffi_field *field;

	if (cache_slot &amp;&amp; *cache_slot == type) {
		field = *(cache_slot + 1);
	} else {
		if (type-&gt;kind == ZEND_FFI_TYPE_POINTER) {
			type = ZEND_FFI_TYPE(type-&gt;pointer.type);
		}
		if (UNEXPECTED(type-&gt;kind != ZEND_FFI_TYPE_STRUCT)) {
			if (UNEXPECTED(type-&gt;kind != ZEND_FFI_TYPE_STRUCT)) {
				zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to read field &#039;%s&#039; of non C struct/union&quot;, ZSTR_VAL(field_name));
				return &amp;EG(uninitialized_zval);
			}
		}

		field = zend_hash_find_ptr(&amp;type-&gt;record.fields, field_name);
		if (UNEXPECTED(!field)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to read undefined field &#039;%s&#039; of C struct/union&quot;, ZSTR_VAL(field_name));
			return &amp;EG(uninitialized_zval);
		}

		if (cache_slot) {
			*cache_slot = type;
			*(cache_slot + 1) = field;
		}
	}

	if (ZEND_FFI_TYPE(cdata-&gt;type)-&gt;kind == ZEND_FFI_TYPE_POINTER) {
		/* transparently dereference the pointer */
		if (UNEXPECTED(!ptr)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
			return &amp;EG(uninitialized_zval);
		}
		ptr = (void*)(*(char**)ptr);
		if (UNEXPECTED(!ptr)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
			return &amp;EG(uninitialized_zval);
		}
		type = ZEND_FFI_TYPE(type-&gt;pointer.type);
	}

#if 0
	if (UNEXPECTED(!ptr)) {
		zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
		return &amp;EG(uninitialized_zval);
	}
#endif

	if (EXPECTED(!field-&gt;bits)) {
		zend_ffi_type *field_type = field-&gt;type;

		if (ZEND_FFI_TYPE_IS_OWNED(field_type)) {
			field_type = ZEND_FFI_TYPE(field_type);
			if (!(field_type-&gt;attr &amp; ZEND_FFI_ATTR_STORED)
			 &amp;&amp; field_type-&gt;kind == ZEND_FFI_TYPE_POINTER) {
				field-&gt;type = field_type = zend_ffi_remember_type(field_type);
			}
		}
		ptr = (void*)(((char*)ptr) + field-&gt;offset);
		zend_ffi_cdata_to_zval(NULL, ptr, field_type, read_type, rv, (cdata-&gt;flags &amp; ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)field-&gt;is_const, 0, 0);
	} else {
		zend_ffi_bit_field_to_zval(ptr, field, rv);
	}

	return rv;
}
/* }}} */

static zval *zend_ffi_cdata_write_field(zend_object *obj, zend_string *field_name, zval *value, void **cache_slot) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)obj;
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);
	void           *ptr = cdata-&gt;ptr;
	zend_ffi_field *field;

	if (cache_slot &amp;&amp; *cache_slot == type) {
		field = *(cache_slot + 1);
	} else {
		if (UNEXPECTED(type == NULL)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to assign field &#039;%s&#039; to uninitialized FFI\\CData object&quot;, ZSTR_VAL(field_name));
			return value;
		}
		if (type-&gt;kind == ZEND_FFI_TYPE_POINTER) {
			type = ZEND_FFI_TYPE(type-&gt;pointer.type);
		}
		if (UNEXPECTED(type-&gt;kind != ZEND_FFI_TYPE_STRUCT)) {
			if (UNEXPECTED(type-&gt;kind != ZEND_FFI_TYPE_STRUCT)) {
				zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to assign field &#039;%s&#039; of non C struct/union&quot;, ZSTR_VAL(field_name));
				return value;
			}
		}

		field = zend_hash_find_ptr(&amp;type-&gt;record.fields, field_name);
		if (UNEXPECTED(!field)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to assign undefined field &#039;%s&#039; of C struct/union&quot;, ZSTR_VAL(field_name));
			return value;
		}

		if (cache_slot) {
			*cache_slot = type;
			*(cache_slot + 1) = field;
		}
	}

	if (ZEND_FFI_TYPE(cdata-&gt;type)-&gt;kind == ZEND_FFI_TYPE_POINTER) {
		/* transparently dereference the pointer */
		if (UNEXPECTED(!ptr)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
			return value;
		}
		ptr = (void*)(*(char**)ptr);
		if (UNEXPECTED(!ptr)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
			return value;
		}
	}

#if 0
	if (UNEXPECTED(!ptr)) {
		zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
		return value;
	}
#endif

	if (UNEXPECTED(cdata-&gt;flags &amp; ZEND_FFI_FLAG_CONST)) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to assign read-only location&quot;);
		return value;
	} else if (UNEXPECTED(field-&gt;is_const)) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to assign read-only field &#039;%s&#039;&quot;, ZSTR_VAL(field_name));
		return value;
	}

	if (EXPECTED(!field-&gt;bits)) {
		ptr = (void*)(((char*)ptr) + field-&gt;offset);
		zend_ffi_zval_to_cdata(ptr, ZEND_FFI_TYPE(field-&gt;type), value);
	} else {
		zend_ffi_zval_to_bit_field(ptr, field, value);
	}
	return value;
}
/* }}} */

static zval *zend_ffi_cdata_read_dim(zend_object *obj, zval *offset, int read_type, zval *rv) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)obj;
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);
	zend_long       dim = zval_get_long(offset);
	zend_ffi_type  *dim_type;
	void           *ptr;
	zend_ffi_flags  is_const;

	if (EXPECTED(type-&gt;kind == ZEND_FFI_TYPE_ARRAY)) {
		if (UNEXPECTED((zend_ulong)(dim) &gt;= (zend_ulong)type-&gt;array.length)
		 &amp;&amp; (UNEXPECTED(dim &lt; 0) || UNEXPECTED(type-&gt;array.length != 0))) {
			zend_throw_error(zend_ffi_exception_ce, &quot;C array index out of bounds&quot;);
			return &amp;EG(uninitialized_zval);
		}

		is_const = (cdata-&gt;flags &amp; ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)(type-&gt;attr &amp; ZEND_FFI_ATTR_CONST);

		dim_type = type-&gt;array.type;
		if (ZEND_FFI_TYPE_IS_OWNED(dim_type)) {
			dim_type = ZEND_FFI_TYPE(dim_type);
			if (!(dim_type-&gt;attr &amp; ZEND_FFI_ATTR_STORED)
			 &amp;&amp; dim_type-&gt;kind == ZEND_FFI_TYPE_POINTER) {
				type-&gt;array.type = dim_type = zend_ffi_remember_type(dim_type);
			}
		}
#if 0
		if (UNEXPECTED(!cdata-&gt;ptr)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
			return &amp;EG(uninitialized_zval);
		}
#endif
		ptr = (void*)(((char*)cdata-&gt;ptr) + dim_type-&gt;size * dim);
	} else if (EXPECTED(type-&gt;kind == ZEND_FFI_TYPE_POINTER)) {
		is_const = (cdata-&gt;flags &amp; ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)(type-&gt;attr &amp; ZEND_FFI_ATTR_CONST);
		dim_type = type-&gt;pointer.type;
		if (ZEND_FFI_TYPE_IS_OWNED(dim_type)) {
			dim_type = ZEND_FFI_TYPE(dim_type);
			if (!(dim_type-&gt;attr &amp; ZEND_FFI_ATTR_STORED)
			 &amp;&amp; dim_type-&gt;kind == ZEND_FFI_TYPE_POINTER) {
				type-&gt;pointer.type = dim_type = zend_ffi_remember_type(dim_type);
			}
		}
		if (UNEXPECTED(!cdata-&gt;ptr)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
			return &amp;EG(uninitialized_zval);
		}
		ptr = (void*)((*(char**)cdata-&gt;ptr) + dim_type-&gt;size * dim);
	} else {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to read element of non C array&quot;);
		return &amp;EG(uninitialized_zval);
	}

	zend_ffi_cdata_to_zval(NULL, ptr, dim_type, read_type, rv, is_const, 0, 0);
	return rv;
}
/* }}} */

static void zend_ffi_cdata_write_dim(zend_object *obj, zval *offset, zval *value) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)obj;
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);
	zend_long       dim;
	void           *ptr;
	zend_ffi_flags  is_const;

	if (offset == NULL) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Cannot add next element to object of type FFI\\CData&quot;);
		return;
	}

	dim = zval_get_long(offset);
	if (EXPECTED(type-&gt;kind == ZEND_FFI_TYPE_ARRAY)) {
		if (UNEXPECTED((zend_ulong)(dim) &gt;= (zend_ulong)type-&gt;array.length)
		 &amp;&amp; (UNEXPECTED(dim &lt; 0) || UNEXPECTED(type-&gt;array.length != 0))) {
			zend_throw_error(zend_ffi_exception_ce, &quot;C array index out of bounds&quot;);
			return;
		}

		is_const = (cdata-&gt;flags &amp; ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)(type-&gt;attr &amp; ZEND_FFI_ATTR_CONST);
		type = ZEND_FFI_TYPE(type-&gt;array.type);
#if 0
		if (UNEXPECTED(!cdata-&gt;ptr)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
			return;
		}
#endif
		ptr = (void*)(((char*)cdata-&gt;ptr) + type-&gt;size * dim);
	} else if (EXPECTED(type-&gt;kind == ZEND_FFI_TYPE_POINTER)) {
		is_const = (cdata-&gt;flags &amp; ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)(type-&gt;attr &amp; ZEND_FFI_ATTR_CONST);
		type = ZEND_FFI_TYPE(type-&gt;pointer.type);
		if (UNEXPECTED(!cdata-&gt;ptr)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
			return;
		}
		ptr = (void*)((*(char**)cdata-&gt;ptr) + type-&gt;size * dim);
	} else {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to assign element of non C array&quot;);
		return;
	}

	if (UNEXPECTED(is_const)) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to assign read-only location&quot;);
		return;
	}

	zend_ffi_zval_to_cdata(ptr, type, value);
}
/* }}} */

#define MAX_TYPE_NAME_LEN 256

typedef struct _zend_ffi_ctype_name_buf {
	char *start;
	char *end;
	char buf[MAX_TYPE_NAME_LEN];
} zend_ffi_ctype_name_buf;

static bool zend_ffi_ctype_name_prepend(zend_ffi_ctype_name_buf *buf, const char *str, size_t len) /* {{{ */
{
	buf-&gt;start -= len;
	if (buf-&gt;start &lt; buf-&gt;buf) {
		return 0;
	}
	memcpy(buf-&gt;start, str, len);
	return 1;
}
/* }}} */

static bool zend_ffi_ctype_name_append(zend_ffi_ctype_name_buf *buf, const char *str, size_t len) /* {{{ */
{
	if (buf-&gt;end + len &gt; buf-&gt;buf + MAX_TYPE_NAME_LEN) {
		return 0;
	}
	buf-&gt;end = zend_mempcpy(buf-&gt;end, str, len);
	return 1;
}
/* }}} */

static bool zend_ffi_ctype_name(zend_ffi_ctype_name_buf *buf, const zend_ffi_type *type) /* {{{ */
{
	const char *name = NULL;
	bool is_ptr = 0;

	while (1) {
		switch (type-&gt;kind) {
			case ZEND_FFI_TYPE_VOID:
				name = &quot;void&quot;;
				break;
			case ZEND_FFI_TYPE_FLOAT:
				name = &quot;float&quot;;
				break;
			case ZEND_FFI_TYPE_DOUBLE:
				name = &quot;double&quot;;
				break;
#ifdef HAVE_LONG_DOUBLE
			case ZEND_FFI_TYPE_LONGDOUBLE:
				name = &quot;long double&quot;;
				break;
#endif
			case ZEND_FFI_TYPE_UINT8:
				name = &quot;uint8_t&quot;;
				break;
			case ZEND_FFI_TYPE_SINT8:
				name = &quot;int8_t&quot;;
				break;
			case ZEND_FFI_TYPE_UINT16:
				name = &quot;uint16_t&quot;;
				break;
			case ZEND_FFI_TYPE_SINT16:
				name = &quot;int16_t&quot;;
				break;
			case ZEND_FFI_TYPE_UINT32:
				name = &quot;uint32_t&quot;;
				break;
			case ZEND_FFI_TYPE_SINT32:
				name = &quot;int32_t&quot;;
				break;
			case ZEND_FFI_TYPE_UINT64:
				name = &quot;uint64_t&quot;;
				break;
			case ZEND_FFI_TYPE_SINT64:
				name = &quot;int64_t&quot;;
				break;
			case ZEND_FFI_TYPE_ENUM:
				if (type-&gt;enumeration.tag_name) {
					zend_ffi_ctype_name_prepend(buf, ZSTR_VAL(type-&gt;enumeration.tag_name), ZSTR_LEN(type-&gt;enumeration.tag_name));
				} else {
					zend_ffi_ctype_name_prepend(buf, &quot;&lt;anonymous&gt;&quot;, sizeof(&quot;&lt;anonymous&gt;&quot;)-1);
				}
				name = &quot;enum &quot;;
				break;
			case ZEND_FFI_TYPE_BOOL:
				name = &quot;bool&quot;;
				break;
			case ZEND_FFI_TYPE_CHAR:
				name = &quot;char&quot;;
				break;
			case ZEND_FFI_TYPE_POINTER:
				if (!zend_ffi_ctype_name_prepend(buf, &quot;*&quot;, 1)) {
					return 0;
				}
				is_ptr = 1;
				type = ZEND_FFI_TYPE(type-&gt;pointer.type);
				break;
			case ZEND_FFI_TYPE_FUNC:
				if (is_ptr) {
					is_ptr = 0;
					if (!zend_ffi_ctype_name_prepend(buf, &quot;(&quot;, 1)
					 || !zend_ffi_ctype_name_append(buf, &quot;)&quot;, 1)) {
						return 0;
					}
				}
				if (!zend_ffi_ctype_name_append(buf, &quot;(&quot;, 1)
				 || !zend_ffi_ctype_name_append(buf, &quot;)&quot;, 1)) {
					return 0;
				}
				type = ZEND_FFI_TYPE(type-&gt;func.ret_type);
				break;
			case ZEND_FFI_TYPE_ARRAY:
				if (is_ptr) {
					is_ptr = 0;
					if (!zend_ffi_ctype_name_prepend(buf, &quot;(&quot;, 1)
					 || !zend_ffi_ctype_name_append(buf, &quot;)&quot;, 1)) {
						return 0;
					}
				}
				if (!zend_ffi_ctype_name_append(buf, &quot;[&quot;, 1)) {
					return 0;
				}
				if (type-&gt;attr &amp; ZEND_FFI_ATTR_VLA) {
					if (!zend_ffi_ctype_name_append(buf, &quot;*&quot;, 1)) {
						return 0;
					}
				} else if (!(type-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_ARRAY)) {
					char str[MAX_LENGTH_OF_LONG + 1];
					char *s = zend_print_long_to_buf(str + sizeof(str) - 1, type-&gt;array.length);

					if (!zend_ffi_ctype_name_append(buf, s, strlen(s))) {
						return 0;
					}
				}
				if (!zend_ffi_ctype_name_append(buf, &quot;]&quot;, 1)) {
					return 0;
				}
				type = ZEND_FFI_TYPE(type-&gt;array.type);
				break;
			case ZEND_FFI_TYPE_STRUCT:
				if (type-&gt;attr &amp; ZEND_FFI_ATTR_UNION) {
					if (type-&gt;record.tag_name) {
						zend_ffi_ctype_name_prepend(buf, ZSTR_VAL(type-&gt;record.tag_name), ZSTR_LEN(type-&gt;record.tag_name));
					} else {
						zend_ffi_ctype_name_prepend(buf, &quot;&lt;anonymous&gt;&quot;, sizeof(&quot;&lt;anonymous&gt;&quot;)-1);
					}
					name = &quot;union &quot;;
				} else {
					if (type-&gt;record.tag_name) {
						zend_ffi_ctype_name_prepend(buf, ZSTR_VAL(type-&gt;record.tag_name), ZSTR_LEN(type-&gt;record.tag_name));
					} else {
						zend_ffi_ctype_name_prepend(buf, &quot;&lt;anonymous&gt;&quot;, sizeof(&quot;&lt;anonymous&gt;&quot;)-1);
					}
					name = &quot;struct &quot;;
				}
				break;
			default:
				ZEND_UNREACHABLE();
		}
		if (name) {
			break;
		}
	}

//	if (buf-&gt;start != buf-&gt;end &amp;&amp; *buf-&gt;start != &#039;[&#039;) {
//		if (!zend_ffi_ctype_name_prepend(buf, &quot; &quot;, 1)) {
//			return 0;
//		}
//	}
	return zend_ffi_ctype_name_prepend(buf, name, strlen(name));
}
/* }}} */

static ZEND_COLD void zend_ffi_return_unsupported(zend_ffi_type *type) /* {{{ */
{
	type = ZEND_FFI_TYPE(type);
	if (type-&gt;kind == ZEND_FFI_TYPE_STRUCT) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI return struct/union is not implemented&quot;);
	} else if (type-&gt;kind == ZEND_FFI_TYPE_ARRAY) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI return array is not implemented&quot;);
	} else {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI internal error. Unsupported return type&quot;);
	}
}
/* }}} */

static ZEND_COLD void zend_ffi_pass_unsupported(zend_ffi_type *type) /* {{{ */
{
	type = ZEND_FFI_TYPE(type);
	if (type-&gt;kind == ZEND_FFI_TYPE_STRUCT) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI passing struct/union is not implemented&quot;);
	} else if (type-&gt;kind == ZEND_FFI_TYPE_ARRAY) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI passing array is not implemented&quot;);
	} else {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI internal error. Unsupported parameter type&quot;);
	}
}
/* }}} */

static ZEND_COLD void zend_ffi_pass_incompatible(zval *arg, zend_ffi_type *type, uint32_t n, zend_execute_data *execute_data) /* {{{ */
{
	zend_ffi_ctype_name_buf buf1, buf2;

	buf1.start = buf1.end = buf1.buf + ((MAX_TYPE_NAME_LEN * 3) / 4);
	if (!zend_ffi_ctype_name(&amp;buf1, type)) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Passing incompatible argument %d of C function &#039;%s&#039;&quot;, n + 1, ZSTR_VAL(EX(func)-&gt;internal_function.function_name));
	} else {
		*buf1.end = 0;
		if (Z_TYPE_P(arg) == IS_OBJECT &amp;&amp; Z_OBJCE_P(arg) == zend_ffi_cdata_ce) {
			zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(arg);

			type = ZEND_FFI_TYPE(cdata-&gt;type);
			buf2.start = buf2.end = buf2.buf + ((MAX_TYPE_NAME_LEN * 3) / 4);
			if (!zend_ffi_ctype_name(&amp;buf2, type)) {
				zend_throw_error(zend_ffi_exception_ce, &quot;Passing incompatible argument %d of C function &#039;%s&#039;, expecting &#039;%s&#039;&quot;, n + 1, ZSTR_VAL(EX(func)-&gt;internal_function.function_name), buf1.start);
			} else {
				*buf2.end = 0;
				zend_throw_error(zend_ffi_exception_ce, &quot;Passing incompatible argument %d of C function &#039;%s&#039;, expecting &#039;%s&#039;, found &#039;%s&#039;&quot;, n + 1, ZSTR_VAL(EX(func)-&gt;internal_function.function_name), buf1.start, buf2.start);
			}
		} else {
			zend_throw_error(zend_ffi_exception_ce, &quot;Passing incompatible argument %d of C function &#039;%s&#039;, expecting &#039;%s&#039;, found PHP &#039;%s&#039;&quot;, n + 1, ZSTR_VAL(EX(func)-&gt;internal_function.function_name), buf1.start, zend_zval_value_name(arg));
		}
	}
}
/* }}} */

static ZEND_COLD void zend_ffi_assign_incompatible(zval *arg, zend_ffi_type *type) /* {{{ */
{
	zend_ffi_ctype_name_buf buf1, buf2;

	buf1.start = buf1.end = buf1.buf + ((MAX_TYPE_NAME_LEN * 3) / 4);
	if (!zend_ffi_ctype_name(&amp;buf1, type)) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Incompatible types when assigning&quot;);
	} else {
		*buf1.end = 0;
		if (Z_TYPE_P(arg) == IS_OBJECT &amp;&amp; Z_OBJCE_P(arg) == zend_ffi_cdata_ce) {
			zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(arg);

			type = ZEND_FFI_TYPE(cdata-&gt;type);
			buf2.start = buf2.end = buf2.buf + ((MAX_TYPE_NAME_LEN * 3) / 4);
			if (!zend_ffi_ctype_name(&amp;buf2, type)) {
				zend_throw_error(zend_ffi_exception_ce, &quot;Incompatible types when assigning to type &#039;%s&#039;&quot;, buf1.start);
			} else {
				*buf2.end = 0;
				zend_throw_error(zend_ffi_exception_ce, &quot;Incompatible types when assigning to type &#039;%s&#039; from type &#039;%s&#039;&quot;, buf1.start, buf2.start);
			}
		} else {
			zend_throw_error(zend_ffi_exception_ce, &quot;Incompatible types when assigning to type &#039;%s&#039; from PHP &#039;%s&#039;&quot;, buf1.start, zend_zval_value_name(arg));
		}
	}
}
/* }}} */

static zend_string *zend_ffi_get_class_name(zend_string *prefix, const zend_ffi_type *type) /* {{{ */
{
	zend_ffi_ctype_name_buf buf;

	buf.start = buf.end = buf.buf + ((MAX_TYPE_NAME_LEN * 3) / 4);
	if (!zend_ffi_ctype_name(&amp;buf, type)) {
		return zend_string_copy(prefix);
	} else {
		return zend_string_concat3(
			ZSTR_VAL(prefix), ZSTR_LEN(prefix), &quot;:&quot;, 1, buf.start, buf.end - buf.start);
	}
}
/* }}} */

static zend_string *zend_ffi_cdata_get_class_name(const zend_object *zobj) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)zobj;

	return zend_ffi_get_class_name(zobj-&gt;ce-&gt;name, ZEND_FFI_TYPE(cdata-&gt;type));
}
/* }}} */

static int zend_ffi_cdata_compare_objects(zval *o1, zval *o2) /* {{{ */
{
	if (Z_TYPE_P(o1) == IS_OBJECT &amp;&amp; Z_OBJCE_P(o1) == zend_ffi_cdata_ce &amp;&amp;
	    Z_TYPE_P(o2) == IS_OBJECT &amp;&amp; Z_OBJCE_P(o2) == zend_ffi_cdata_ce) {
		zend_ffi_cdata *cdata1 = (zend_ffi_cdata*)Z_OBJ_P(o1);
		zend_ffi_cdata *cdata2 = (zend_ffi_cdata*)Z_OBJ_P(o2);
		zend_ffi_type *type1 = ZEND_FFI_TYPE(cdata1-&gt;type);
		zend_ffi_type *type2 = ZEND_FFI_TYPE(cdata2-&gt;type);

		if (type1-&gt;kind == ZEND_FFI_TYPE_POINTER &amp;&amp; type2-&gt;kind == ZEND_FFI_TYPE_POINTER) {
			void *ptr1 = *(void**)cdata1-&gt;ptr;
			void *ptr2 = *(void**)cdata2-&gt;ptr;

			if (!ptr1 || !ptr2) {
				zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
				return 0;
			}
			return ptr1 == ptr2 ? 0 : (ptr1 &lt; ptr2 ? -1 : 1);
		}
	}
	zend_throw_error(zend_ffi_exception_ce, &quot;Comparison of incompatible C types&quot;);
	return 0;
}
/* }}} */

static zend_result zend_ffi_cdata_count_elements(zend_object *obj, zend_long *count) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)obj;
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);

	if (type-&gt;kind != ZEND_FFI_TYPE_ARRAY) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to count() on non C array&quot;);
		return FAILURE;
	} else {
		*count = type-&gt;array.length;
		return SUCCESS;
	}
}
/* }}} */

static zend_object* zend_ffi_add(zend_ffi_cdata *base_cdata, zend_ffi_type *base_type, zend_long offset) /* {{{ */
{
	char *ptr;
	zend_ffi_type *ptr_type;
	zend_ffi_cdata *cdata =
		(zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);

	if (base_type-&gt;kind == ZEND_FFI_TYPE_POINTER) {
		if (ZEND_FFI_TYPE_IS_OWNED(base_cdata-&gt;type)) {
			if (!(base_type-&gt;attr &amp; ZEND_FFI_ATTR_STORED)) {
				if (GC_REFCOUNT(&amp;base_cdata-&gt;std) == 1) {
					/* transfer type ownership */
					base_cdata-&gt;type = base_type;
					base_type = ZEND_FFI_TYPE_MAKE_OWNED(base_type);
				} else {
					base_cdata-&gt;type = base_type = zend_ffi_remember_type(base_type);
				}
			}
		}
		cdata-&gt;type = base_type;
		ptr = (char*)(*(void**)base_cdata-&gt;ptr);
		ptr_type = ZEND_FFI_TYPE(base_type)-&gt;pointer.type;
	} else {
		zend_ffi_type *new_type = emalloc(sizeof(zend_ffi_type));

		new_type-&gt;kind = ZEND_FFI_TYPE_POINTER;
		new_type-&gt;attr = 0;
		new_type-&gt;size = sizeof(void*);
		new_type-&gt;align = _Alignof(void*);

		ptr_type = base_type-&gt;array.type;
		if (ZEND_FFI_TYPE_IS_OWNED(ptr_type)) {
			ptr_type = ZEND_FFI_TYPE(ptr_type);
			if (!(ptr_type-&gt;attr &amp; ZEND_FFI_ATTR_STORED)) {
				if (GC_REFCOUNT(&amp;base_cdata-&gt;std) == 1) {
					/* transfer type ownership */
					base_type-&gt;array.type = ptr_type;
					ptr_type = ZEND_FFI_TYPE_MAKE_OWNED(ptr_type);
				} else {
					base_type-&gt;array.type = ptr_type = zend_ffi_remember_type(ptr_type);
				}
			}
		}
		new_type-&gt;pointer.type = ptr_type;

		cdata-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(new_type);
		ptr = (char*)base_cdata-&gt;ptr;
	}
	cdata-&gt;ptr = &amp;cdata-&gt;ptr_holder;
	cdata-&gt;ptr_holder = ptr +
		(ptrdiff_t) (offset * ZEND_FFI_TYPE(ptr_type)-&gt;size);
	cdata-&gt;flags = base_cdata-&gt;flags &amp; ZEND_FFI_FLAG_CONST;
	return &amp;cdata-&gt;std;
}
/* }}} */

static zend_result zend_ffi_cdata_do_operation(uint8_t opcode, zval *result, zval *op1, zval *op2) /* {{{ */
{
	zend_long offset;

	ZVAL_DEREF(op1);
	ZVAL_DEREF(op2);
	if (Z_TYPE_P(op1) == IS_OBJECT &amp;&amp; Z_OBJCE_P(op1) == zend_ffi_cdata_ce) {
		zend_ffi_cdata *cdata1 = (zend_ffi_cdata*)Z_OBJ_P(op1);
		zend_ffi_type *type1 = ZEND_FFI_TYPE(cdata1-&gt;type);

		if (type1-&gt;kind == ZEND_FFI_TYPE_POINTER || type1-&gt;kind == ZEND_FFI_TYPE_ARRAY) {
			if (opcode == ZEND_ADD) {
				offset = zval_get_long(op2);
				ZVAL_OBJ(result, zend_ffi_add(cdata1, type1, offset));
				if (result == op1) {
					OBJ_RELEASE(&amp;cdata1-&gt;std);
				}
				return SUCCESS;
			} else if (opcode == ZEND_SUB) {
				if (Z_TYPE_P(op2) == IS_OBJECT &amp;&amp; Z_OBJCE_P(op2) == zend_ffi_cdata_ce) {
					zend_ffi_cdata *cdata2 = (zend_ffi_cdata*)Z_OBJ_P(op2);
					zend_ffi_type *type2 = ZEND_FFI_TYPE(cdata2-&gt;type);

					if (type2-&gt;kind == ZEND_FFI_TYPE_POINTER || type2-&gt;kind == ZEND_FFI_TYPE_ARRAY) {
						zend_ffi_type *t1, *t2;
						char *p1, *p2;

						if (type1-&gt;kind == ZEND_FFI_TYPE_POINTER) {
							t1 = ZEND_FFI_TYPE(type1-&gt;pointer.type);
							p1 = (char*)(*(void**)cdata1-&gt;ptr);
						} else {
							t1 = ZEND_FFI_TYPE(type1-&gt;array.type);
							p1 = cdata1-&gt;ptr;
						}
						if (type2-&gt;kind == ZEND_FFI_TYPE_POINTER) {
							t2 = ZEND_FFI_TYPE(type2-&gt;pointer.type);
							p2 = (char*)(*(void**)cdata2-&gt;ptr);
						} else {
							t2 = ZEND_FFI_TYPE(type2-&gt;array.type);
							p2 = cdata2-&gt;ptr;
						}
						if (zend_ffi_is_same_type(t1, t2)) {
							ZVAL_LONG(result,
								(zend_long)(p1 - p2) / (zend_long)t1-&gt;size);
							return SUCCESS;
						}
					}
				}
				offset = zval_get_long(op2);
				ZVAL_OBJ(result, zend_ffi_add(cdata1, type1, -offset));
				if (result == op1) {
					OBJ_RELEASE(&amp;cdata1-&gt;std);
				}
				return SUCCESS;
			}
		}
	} else if (Z_TYPE_P(op2) == IS_OBJECT &amp;&amp; Z_OBJCE_P(op2) == zend_ffi_cdata_ce) {
		zend_ffi_cdata *cdata2 = (zend_ffi_cdata*)Z_OBJ_P(op2);
		zend_ffi_type *type2 = ZEND_FFI_TYPE(cdata2-&gt;type);

		if (type2-&gt;kind == ZEND_FFI_TYPE_POINTER || type2-&gt;kind == ZEND_FFI_TYPE_ARRAY) {
			if (opcode == ZEND_ADD) {
				offset = zval_get_long(op1);
				ZVAL_OBJ(result, zend_ffi_add(cdata2, type2, offset));
				return SUCCESS;
			}
		}
	}

	return FAILURE;
}
/* }}} */

typedef struct _zend_ffi_cdata_iterator {
	zend_object_iterator it;
	zend_long key;
	zval value;
	bool by_ref;
} zend_ffi_cdata_iterator;

static void zend_ffi_cdata_it_dtor(zend_object_iterator *iter) /* {{{ */
{
	zval_ptr_dtor(&amp;((zend_ffi_cdata_iterator*)iter)-&gt;value);
	zval_ptr_dtor(&amp;iter-&gt;data);
}
/* }}} */

static zend_result zend_ffi_cdata_it_valid(zend_object_iterator *it) /* {{{ */
{
	zend_ffi_cdata_iterator *iter = (zend_ffi_cdata_iterator*)it;
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ(iter-&gt;it.data);
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);

	return (iter-&gt;key &gt;= 0 &amp;&amp; iter-&gt;key &lt; type-&gt;array.length) ? SUCCESS : FAILURE;
}
/* }}} */

static zval *zend_ffi_cdata_it_get_current_data(zend_object_iterator *it) /* {{{ */
{
	zend_ffi_cdata_iterator *iter = (zend_ffi_cdata_iterator*)it;
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ(iter-&gt;it.data);
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);
	zend_ffi_type  *dim_type;
	void *ptr;

	if (!cdata-&gt;ptr) {
		zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
		return &amp;EG(uninitialized_zval);
	}
	dim_type = type-&gt;array.type;
	if (ZEND_FFI_TYPE_IS_OWNED(dim_type)) {
		dim_type = ZEND_FFI_TYPE(dim_type);
		if (!(dim_type-&gt;attr &amp; ZEND_FFI_ATTR_STORED)
		 &amp;&amp; dim_type-&gt;kind == ZEND_FFI_TYPE_POINTER) {
			type-&gt;array.type = dim_type = zend_ffi_remember_type(dim_type);
		}
	}
	ptr = (void*)((char*)cdata-&gt;ptr + dim_type-&gt;size * iter-&gt;it.index);

	zval_ptr_dtor(&amp;iter-&gt;value);
	zend_ffi_cdata_to_zval(NULL, ptr, dim_type, iter-&gt;by_ref ? BP_VAR_RW : BP_VAR_R, &amp;iter-&gt;value, (cdata-&gt;flags &amp; ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)(type-&gt;attr &amp; ZEND_FFI_ATTR_CONST), 0, 0);
	return &amp;iter-&gt;value;
}
/* }}} */

static void zend_ffi_cdata_it_get_current_key(zend_object_iterator *it, zval *key) /* {{{ */
{
	zend_ffi_cdata_iterator *iter = (zend_ffi_cdata_iterator*)it;
	ZVAL_LONG(key, iter-&gt;key);
}
/* }}} */

static void zend_ffi_cdata_it_move_forward(zend_object_iterator *it) /* {{{ */
{
	zend_ffi_cdata_iterator *iter = (zend_ffi_cdata_iterator*)it;
	iter-&gt;key++;
}
/* }}} */

static void zend_ffi_cdata_it_rewind(zend_object_iterator *it) /* {{{ */
{
	zend_ffi_cdata_iterator *iter = (zend_ffi_cdata_iterator*)it;
	iter-&gt;key = 0;
}
/* }}} */

static const zend_object_iterator_funcs zend_ffi_cdata_it_funcs = {
	zend_ffi_cdata_it_dtor,
	zend_ffi_cdata_it_valid,
	zend_ffi_cdata_it_get_current_data,
	zend_ffi_cdata_it_get_current_key,
	zend_ffi_cdata_it_move_forward,
	zend_ffi_cdata_it_rewind,
	NULL,
	NULL, /* get_gc */
};

static zend_object_iterator *zend_ffi_cdata_get_iterator(zend_class_entry *ce, zval *object, int by_ref) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(object);
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);
	zend_ffi_cdata_iterator *iter;

	if (type-&gt;kind != ZEND_FFI_TYPE_ARRAY) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to iterate on non C array&quot;);
		return NULL;
	}

	iter = emalloc(sizeof(zend_ffi_cdata_iterator));

	zend_iterator_init(&amp;iter-&gt;it);

	Z_ADDREF_P(object);
	ZVAL_OBJ(&amp;iter-&gt;it.data, Z_OBJ_P(object));
	iter-&gt;it.funcs = &amp;zend_ffi_cdata_it_funcs;
	iter-&gt;key = 0;
	iter-&gt;by_ref = by_ref;
	ZVAL_UNDEF(&amp;iter-&gt;value);

	return &amp;iter-&gt;it;
}
/* }}} */

static HashTable *zend_ffi_cdata_get_debug_info(zend_object *obj, int *is_temp) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)obj;
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);
	void           *ptr = cdata-&gt;ptr;
	HashTable      *ht = NULL;
	zend_string    *key;
	zend_ffi_field *f;
	zend_long       n;
	zval            tmp;

	if (!cdata-&gt;ptr) {
		zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
		return NULL;
	}

	switch (type-&gt;kind) {
		case ZEND_FFI_TYPE_VOID:
			return NULL;
		case ZEND_FFI_TYPE_BOOL:
		case ZEND_FFI_TYPE_CHAR:
		case ZEND_FFI_TYPE_ENUM:
		case ZEND_FFI_TYPE_FLOAT:
		case ZEND_FFI_TYPE_DOUBLE:
#ifdef HAVE_LONG_DOUBLE
		case ZEND_FFI_TYPE_LONGDOUBLE:
#endif
		case ZEND_FFI_TYPE_UINT8:
		case ZEND_FFI_TYPE_SINT8:
		case ZEND_FFI_TYPE_UINT16:
		case ZEND_FFI_TYPE_SINT16:
		case ZEND_FFI_TYPE_UINT32:
		case ZEND_FFI_TYPE_SINT32:
		case ZEND_FFI_TYPE_UINT64:
		case ZEND_FFI_TYPE_SINT64:
			zend_ffi_cdata_to_zval(cdata, ptr, type, BP_VAR_R, &amp;tmp, ZEND_FFI_FLAG_CONST, 0, 0);
			ht = zend_new_array(1);
			zend_hash_str_add(ht, &quot;cdata&quot;, sizeof(&quot;cdata&quot;)-1, &amp;tmp);
			*is_temp = 1;
			return ht;
			break;
		case ZEND_FFI_TYPE_POINTER:
			if (*(void**)ptr == NULL) {
				ZVAL_NULL(&amp;tmp);
				ht = zend_new_array(1);
				zend_hash_index_add_new(ht, 0, &amp;tmp);
				*is_temp = 1;
				return ht;
			} else if (ZEND_FFI_TYPE(type-&gt;pointer.type)-&gt;kind == ZEND_FFI_TYPE_VOID) {
				ZVAL_LONG(&amp;tmp, (uintptr_t)*(void**)ptr);
				ht = zend_new_array(1);
				zend_hash_index_add_new(ht, 0, &amp;tmp);
				*is_temp = 1;
				return ht;
			} else {
				zend_ffi_cdata_to_zval(NULL, *(void**)ptr, ZEND_FFI_TYPE(type-&gt;pointer.type), BP_VAR_R, &amp;tmp, ZEND_FFI_FLAG_CONST, 0, 0);
				ht = zend_new_array(1);
				zend_hash_index_add_new(ht, 0, &amp;tmp);
				*is_temp = 1;
				return ht;
			}
			break;
		case ZEND_FFI_TYPE_STRUCT:
			ht = zend_new_array(zend_hash_num_elements(&amp;type-&gt;record.fields));
			ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&amp;type-&gt;record.fields, key, f) {
				if (key) {
					if (!f-&gt;bits) {
						void *f_ptr = (void*)(((char*)ptr) + f-&gt;offset);
						zend_ffi_cdata_to_zval(NULL, f_ptr, ZEND_FFI_TYPE(f-&gt;type), BP_VAR_R, &amp;tmp, ZEND_FFI_FLAG_CONST, 0, type-&gt;attr &amp; ZEND_FFI_ATTR_UNION);
						zend_hash_add(ht, key, &amp;tmp);
					} else {
						zend_ffi_bit_field_to_zval(ptr, f, &amp;tmp);
						zend_hash_add(ht, key, &amp;tmp);
					}
				}
			} ZEND_HASH_FOREACH_END();
			*is_temp = 1;
			return ht;
		case ZEND_FFI_TYPE_ARRAY:
			ht = zend_new_array(type-&gt;array.length);
			for (n = 0; n &lt; type-&gt;array.length; n++) {
				zend_ffi_cdata_to_zval(NULL, ptr, ZEND_FFI_TYPE(type-&gt;array.type), BP_VAR_R, &amp;tmp, ZEND_FFI_FLAG_CONST, 0, 0);
				zend_hash_index_add(ht, n, &amp;tmp);
				ptr = (void*)(((char*)ptr) + ZEND_FFI_TYPE(type-&gt;array.type)-&gt;size);
			}
			*is_temp = 1;
			return ht;
		case ZEND_FFI_TYPE_FUNC:
			ht = zend_new_array(0);
			// TODO: function name ???
			*is_temp = 1;
			return ht;
			break;
		default:
			ZEND_UNREACHABLE();
			break;
	}
	return NULL;
}
/* }}} */

static zend_result zend_ffi_cdata_get_closure(zend_object *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zend_object **obj_ptr, bool check_only) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)obj;
	zend_ffi_type  *type = ZEND_FFI_TYPE(cdata-&gt;type);
	zend_function  *func;

	if (type-&gt;kind != ZEND_FFI_TYPE_POINTER) {
		if (!check_only) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to call non C function pointer&quot;);
		}
		return FAILURE;
	}
	type = ZEND_FFI_TYPE(type-&gt;pointer.type);
	if (type-&gt;kind != ZEND_FFI_TYPE_FUNC) {
		if (!check_only) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to call non C function pointer&quot;);
		}
		return FAILURE;
	}
	if (!cdata-&gt;ptr) {
		if (!check_only) {
			zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
		}
		return FAILURE;
	}

	if (EXPECTED(EG(trampoline).common.function_name == NULL)) {
		func = &amp;EG(trampoline);
	} else {
		func = ecalloc(1, sizeof(zend_internal_function));
	}
	func-&gt;type = ZEND_INTERNAL_FUNCTION;
	func-&gt;common.arg_flags[0] = 0;
	func-&gt;common.arg_flags[1] = 0;
	func-&gt;common.arg_flags[2] = 0;
	func-&gt;common.fn_flags = ZEND_ACC_CALL_VIA_TRAMPOLINE;
	func-&gt;common.function_name = ZSTR_KNOWN(ZEND_STR_MAGIC_INVOKE);
	/* set to 0 to avoid arg_info[] allocation, because all values are passed by value anyway */
	func-&gt;common.num_args = 0;
	func-&gt;common.required_num_args = type-&gt;func.args ? zend_hash_num_elements(type-&gt;func.args) : 0;
	func-&gt;common.scope = NULL;
	func-&gt;common.prototype = NULL;
	func-&gt;common.arg_info = NULL;
	func-&gt;internal_function.handler = ZEND_FN(ffi_trampoline);
	func-&gt;internal_function.module = NULL;
	func-&gt;internal_function.doc_comment = NULL;

	func-&gt;internal_function.reserved[0] = type;
	func-&gt;internal_function.reserved[1] = *(void**)cdata-&gt;ptr;

	*ce_ptr = NULL;
	*fptr_ptr= func;
	*obj_ptr = NULL;

	return SUCCESS;
}
/* }}} */

static zend_object *zend_ffi_ctype_new(zend_class_entry *class_type) /* {{{ */
{
	zend_ffi_ctype *ctype;

	ctype = emalloc(sizeof(zend_ffi_ctype));

	zend_ffi_object_init(&amp;ctype-&gt;std, class_type);

	ctype-&gt;type = NULL;

	return &amp;ctype-&gt;std;
}
/* }}} */

static void zend_ffi_ctype_free_obj(zend_object *object) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)object;

	zend_ffi_type_dtor(ctype-&gt;type);

    if (UNEXPECTED(GC_FLAGS(object) &amp; IS_OBJ_WEAKLY_REFERENCED)) {
        zend_weakrefs_notify(object);
    }
}
/* }}} */

static bool zend_ffi_is_same_type(zend_ffi_type *type1, zend_ffi_type *type2) /* {{{ */
{
	while (1) {
		if (type1 == type2) {
			return 1;
		} else if (type1-&gt;kind == type2-&gt;kind) {
			if (type1-&gt;kind &lt; ZEND_FFI_TYPE_POINTER) {
				return 1;
			} else if (type1-&gt;kind == ZEND_FFI_TYPE_POINTER) {
				type1 = ZEND_FFI_TYPE(type1-&gt;pointer.type);
				type2 = ZEND_FFI_TYPE(type2-&gt;pointer.type);
				if (type1-&gt;kind == ZEND_FFI_TYPE_VOID ||
				    type2-&gt;kind == ZEND_FFI_TYPE_VOID) {
				    return 1;
				}
			} else if (type1-&gt;kind == ZEND_FFI_TYPE_ARRAY &amp;&amp;
			           type1-&gt;array.length == type2-&gt;array.length) {
				type1 = ZEND_FFI_TYPE(type1-&gt;array.type);
				type2 = ZEND_FFI_TYPE(type2-&gt;array.type);
			} else {
				break;
			}
		} else {
			break;
		}
	}
	return 0;
}
/* }}} */

static zend_string *zend_ffi_ctype_get_class_name(const zend_object *zobj) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)zobj;

	return zend_ffi_get_class_name(zobj-&gt;ce-&gt;name, ZEND_FFI_TYPE(ctype-&gt;type));
}
/* }}} */

static int zend_ffi_ctype_compare_objects(zval *o1, zval *o2) /* {{{ */
{
	if (Z_TYPE_P(o1) == IS_OBJECT &amp;&amp; Z_OBJCE_P(o1) == zend_ffi_ctype_ce &amp;&amp;
	    Z_TYPE_P(o2) == IS_OBJECT &amp;&amp; Z_OBJCE_P(o2) == zend_ffi_ctype_ce) {
		zend_ffi_ctype *ctype1 = (zend_ffi_ctype*)Z_OBJ_P(o1);
		zend_ffi_ctype *ctype2 = (zend_ffi_ctype*)Z_OBJ_P(o2);
		zend_ffi_type *type1 = ZEND_FFI_TYPE(ctype1-&gt;type);
		zend_ffi_type *type2 = ZEND_FFI_TYPE(ctype2-&gt;type);

		if (zend_ffi_is_same_type(type1, type2)) {
			return 0;
		} else {
			return 1;
		}
	}
	zend_throw_error(zend_ffi_exception_ce, &quot;Comparison of incompatible C types&quot;);
	return 0;
}
/* }}} */

static HashTable *zend_ffi_ctype_get_debug_info(zend_object *obj, int *is_temp) /* {{{ */
{
	return NULL;
}
/* }}} */

static zend_object *zend_ffi_new(zend_class_entry *class_type) /* {{{ */
{
	zend_ffi *ffi;

	ffi = emalloc(sizeof(zend_ffi));

	zend_ffi_object_init(&amp;ffi-&gt;std, class_type);

	ffi-&gt;lib = NULL;
	ffi-&gt;symbols = NULL;
	ffi-&gt;tags = NULL;
	ffi-&gt;persistent = 0;

	return &amp;ffi-&gt;std;
}
/* }}} */

static void _zend_ffi_type_dtor(zend_ffi_type *type) /* {{{ */
{
	type = ZEND_FFI_TYPE(type);

	switch (type-&gt;kind) {
		case ZEND_FFI_TYPE_ENUM:
			if (type-&gt;enumeration.tag_name) {
				zend_string_release(type-&gt;enumeration.tag_name);
			}
			break;
		case ZEND_FFI_TYPE_STRUCT:
			if (type-&gt;record.tag_name) {
				zend_string_release(type-&gt;record.tag_name);
			}
			zend_hash_destroy(&amp;type-&gt;record.fields);
			break;
		case ZEND_FFI_TYPE_POINTER:
			zend_ffi_type_dtor(type-&gt;pointer.type);
			break;
		case ZEND_FFI_TYPE_ARRAY:
			zend_ffi_type_dtor(type-&gt;array.type);
			break;
		case ZEND_FFI_TYPE_FUNC:
			if (type-&gt;func.args) {
				zend_hash_destroy(type-&gt;func.args);
				pefree(type-&gt;func.args, type-&gt;attr &amp; ZEND_FFI_ATTR_PERSISTENT);
			}
			zend_ffi_type_dtor(type-&gt;func.ret_type);
			break;
		default:
			break;
	}
	pefree(type, type-&gt;attr &amp; ZEND_FFI_ATTR_PERSISTENT);
}
/* }}} */

static void zend_ffi_type_hash_dtor(zval *zv) /* {{{ */
{
	zend_ffi_type *type = Z_PTR_P(zv);
	zend_ffi_type_dtor(type);
}
/* }}} */

static void zend_ffi_field_hash_dtor(zval *zv) /* {{{ */
{
	zend_ffi_field *field = Z_PTR_P(zv);
	zend_ffi_type_dtor(field-&gt;type);
	efree(field);
}
/* }}} */

static void zend_ffi_field_hash_persistent_dtor(zval *zv) /* {{{ */
{
	zend_ffi_field *field = Z_PTR_P(zv);
	zend_ffi_type_dtor(field-&gt;type);
	free(field);
}
/* }}} */

static void zend_ffi_symbol_hash_dtor(zval *zv) /* {{{ */
{
	zend_ffi_symbol *sym = Z_PTR_P(zv);
	zend_ffi_type_dtor(sym-&gt;type);
	efree(sym);
}
/* }}} */

static void zend_ffi_symbol_hash_persistent_dtor(zval *zv) /* {{{ */
{
	zend_ffi_symbol *sym = Z_PTR_P(zv);
	zend_ffi_type_dtor(sym-&gt;type);
	free(sym);
}
/* }}} */

static void zend_ffi_tag_hash_dtor(zval *zv) /* {{{ */
{
	zend_ffi_tag *tag = Z_PTR_P(zv);
	zend_ffi_type_dtor(tag-&gt;type);
	efree(tag);
}
/* }}} */

static void zend_ffi_tag_hash_persistent_dtor(zval *zv) /* {{{ */
{
	zend_ffi_tag *tag = Z_PTR_P(zv);
	zend_ffi_type_dtor(tag-&gt;type);
	free(tag);
}
/* }}} */

static void zend_ffi_cdata_dtor(zend_ffi_cdata *cdata) /* {{{ */
{
	zend_ffi_type_dtor(cdata-&gt;type);
	if (cdata-&gt;flags &amp; ZEND_FFI_FLAG_OWNED) {
		if (cdata-&gt;ptr != (void*)&amp;cdata-&gt;ptr_holder) {
			pefree(cdata-&gt;ptr, cdata-&gt;flags &amp; ZEND_FFI_FLAG_PERSISTENT);
		} else {
			pefree(cdata-&gt;ptr_holder, cdata-&gt;flags &amp; ZEND_FFI_FLAG_PERSISTENT);
		}
	}
}
/* }}} */

static void zend_ffi_scope_hash_dtor(zval *zv) /* {{{ */
{
	zend_ffi_scope *scope = Z_PTR_P(zv);
	if (scope-&gt;symbols) {
		zend_hash_destroy(scope-&gt;symbols);
		free(scope-&gt;symbols);
	}
	if (scope-&gt;tags) {
		zend_hash_destroy(scope-&gt;tags);
		free(scope-&gt;tags);
	}
	free(scope);
}
/* }}} */

static void zend_ffi_free_obj(zend_object *object) /* {{{ */
{
	zend_ffi *ffi = (zend_ffi*)object;

	if (ffi-&gt;persistent) {
		return;
	}

	if (ffi-&gt;lib) {
		DL_UNLOAD(ffi-&gt;lib);
		ffi-&gt;lib = NULL;
	}

	if (ffi-&gt;symbols) {
		zend_hash_destroy(ffi-&gt;symbols);
		efree(ffi-&gt;symbols);
	}

	if (ffi-&gt;tags) {
		zend_hash_destroy(ffi-&gt;tags);
		efree(ffi-&gt;tags);
	}

    if (UNEXPECTED(GC_FLAGS(object) &amp; IS_OBJ_WEAKLY_REFERENCED)) {
        zend_weakrefs_notify(object);
    }
}
/* }}} */

static void zend_ffi_cdata_free_obj(zend_object *object) /* {{{ */
{
	zend_ffi_cdata *cdata = (zend_ffi_cdata*)object;

	zend_ffi_cdata_dtor(cdata);

    if (UNEXPECTED(GC_FLAGS(object) &amp; IS_OBJ_WEAKLY_REFERENCED)) {
        zend_weakrefs_notify(object);
    }
}
/* }}} */

static zend_object *zend_ffi_cdata_clone_obj(zend_object *obj) /* {{{ */
{
	zend_ffi_cdata *old_cdata = (zend_ffi_cdata*)obj;
	zend_ffi_type *type = ZEND_FFI_TYPE(old_cdata-&gt;type);
	zend_ffi_cdata *new_cdata;

	new_cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
	if (type-&gt;kind &lt; ZEND_FFI_TYPE_POINTER) {
		new_cdata-&gt;std.handlers = &amp;zend_ffi_cdata_value_handlers;
	}
	new_cdata-&gt;type = type;
	new_cdata-&gt;ptr = emalloc(type-&gt;size);
	memcpy(new_cdata-&gt;ptr, old_cdata-&gt;ptr, type-&gt;size);
	new_cdata-&gt;flags |= ZEND_FFI_FLAG_OWNED;

	return &amp;new_cdata-&gt;std;
}
/* }}} */

static zval *zend_ffi_read_var(zend_object *obj, zend_string *var_name, int read_type, void **cache_slot, zval *rv) /* {{{ */
{
	zend_ffi        *ffi = (zend_ffi*)obj;
	zend_ffi_symbol *sym = NULL;

	if (ffi-&gt;symbols) {
		sym = zend_hash_find_ptr(ffi-&gt;symbols, var_name);
		if (sym &amp;&amp; sym-&gt;kind != ZEND_FFI_SYM_VAR &amp;&amp; sym-&gt;kind != ZEND_FFI_SYM_CONST &amp;&amp; sym-&gt;kind != ZEND_FFI_SYM_FUNC) {
			sym = NULL;
		}
	}
	if (!sym) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to read undefined C variable &#039;%s&#039;&quot;, ZSTR_VAL(var_name));
		return &amp;EG(uninitialized_zval);
	}

	if (sym-&gt;kind == ZEND_FFI_SYM_VAR) {
		zend_ffi_cdata_to_zval(NULL, sym-&gt;addr, ZEND_FFI_TYPE(sym-&gt;type), read_type, rv, (zend_ffi_flags)sym-&gt;is_const, 0, 0);
	} else if (sym-&gt;kind == ZEND_FFI_SYM_FUNC) {
		zend_ffi_cdata *cdata;
		zend_ffi_type *new_type = emalloc(sizeof(zend_ffi_type));

		new_type-&gt;kind = ZEND_FFI_TYPE_POINTER;
		new_type-&gt;attr = 0;
		new_type-&gt;size = sizeof(void*);
		new_type-&gt;align = _Alignof(void*);
		new_type-&gt;pointer.type = ZEND_FFI_TYPE(sym-&gt;type);

		cdata = emalloc(sizeof(zend_ffi_cdata));
		zend_ffi_object_init(&amp;cdata-&gt;std, zend_ffi_cdata_ce);
		cdata-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(new_type);
		cdata-&gt;flags = ZEND_FFI_FLAG_CONST;
		cdata-&gt;ptr_holder = sym-&gt;addr;
		cdata-&gt;ptr = &amp;cdata-&gt;ptr_holder;
		ZVAL_OBJ(rv, &amp;cdata-&gt;std);
	} else {
		ZVAL_LONG(rv, sym-&gt;value);
	}

	return rv;
}
/* }}} */

static zval *zend_ffi_write_var(zend_object *obj, zend_string *var_name, zval *value, void **cache_slot) /* {{{ */
{
	zend_ffi        *ffi = (zend_ffi*)obj;
	zend_ffi_symbol *sym = NULL;

	if (ffi-&gt;symbols) {
		sym = zend_hash_find_ptr(ffi-&gt;symbols, var_name);
		if (sym &amp;&amp; sym-&gt;kind != ZEND_FFI_SYM_VAR) {
			sym = NULL;
		}
	}
	if (!sym) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to assign undefined C variable &#039;%s&#039;&quot;, ZSTR_VAL(var_name));
		return value;
	}

	if (sym-&gt;is_const) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to assign read-only C variable &#039;%s&#039;&quot;, ZSTR_VAL(var_name));
		return value;
	}

	zend_ffi_zval_to_cdata(sym-&gt;addr, ZEND_FFI_TYPE(sym-&gt;type), value);
	return value;
}
/* }}} */

static zend_result zend_ffi_pass_arg(zval *arg, zend_ffi_type *type, ffi_type **pass_type, void **arg_values, uint32_t n, zend_execute_data *execute_data) /* {{{ */
{
	zend_long lval;
	double dval;
	zend_string *str, *tmp_str;
	zend_ffi_type_kind kind = type-&gt;kind;

	ZVAL_DEREF(arg);

again:
	switch (kind) {
		case ZEND_FFI_TYPE_FLOAT:
			dval = zval_get_double(arg);
			*pass_type = &amp;ffi_type_float;
			*(float*)arg_values[n] = (float)dval;
			break;
		case ZEND_FFI_TYPE_DOUBLE:
			dval = zval_get_double(arg);
			*pass_type = &amp;ffi_type_double;
			*(double*)arg_values[n] = dval;
			break;
#ifdef HAVE_LONG_DOUBLE
		case ZEND_FFI_TYPE_LONGDOUBLE:
			dval = zval_get_double(arg);
			*pass_type = &amp;ffi_type_double;
			*(long double*)arg_values[n] = (long double)dval;
			break;
#endif
		case ZEND_FFI_TYPE_UINT8:
			lval = zval_get_long(arg);
			*pass_type = &amp;ffi_type_uint8;
			*(uint8_t*)arg_values[n] = (uint8_t)lval;
			break;
		case ZEND_FFI_TYPE_SINT8:
			lval = zval_get_long(arg);
			*pass_type = &amp;ffi_type_sint8;
			*(int8_t*)arg_values[n] = (int8_t)lval;
			break;
		case ZEND_FFI_TYPE_UINT16:
			lval = zval_get_long(arg);
			*pass_type = &amp;ffi_type_uint16;
			*(uint16_t*)arg_values[n] = (uint16_t)lval;
			break;
		case ZEND_FFI_TYPE_SINT16:
			lval = zval_get_long(arg);
			*pass_type = &amp;ffi_type_sint16;
			*(int16_t*)arg_values[n] = (int16_t)lval;
			break;
		case ZEND_FFI_TYPE_UINT32:
			lval = zval_get_long(arg);
			*pass_type = &amp;ffi_type_uint32;
			*(uint32_t*)arg_values[n] = (uint32_t)lval;
			break;
		case ZEND_FFI_TYPE_SINT32:
			lval = zval_get_long(arg);
			*pass_type = &amp;ffi_type_sint32;
			*(int32_t*)arg_values[n] = (int32_t)lval;
			break;
		case ZEND_FFI_TYPE_UINT64:
			lval = zval_get_long(arg);
			*pass_type = &amp;ffi_type_uint64;
			*(uint64_t*)arg_values[n] = (uint64_t)lval;
			break;
		case ZEND_FFI_TYPE_SINT64:
			lval = zval_get_long(arg);
			*pass_type = &amp;ffi_type_sint64;
			*(int64_t*)arg_values[n] = (int64_t)lval;
			break;
		case ZEND_FFI_TYPE_POINTER:
			*pass_type = &amp;ffi_type_pointer;
			if (Z_TYPE_P(arg) == IS_NULL) {
				*(void**)arg_values[n] = NULL;
				return SUCCESS;
			} else if (Z_TYPE_P(arg) == IS_STRING
			        &amp;&amp; ((ZEND_FFI_TYPE(type-&gt;pointer.type)-&gt;kind == ZEND_FFI_TYPE_CHAR)
			         || (ZEND_FFI_TYPE(type-&gt;pointer.type)-&gt;kind == ZEND_FFI_TYPE_VOID))) {
				*(void**)arg_values[n] = Z_STRVAL_P(arg);
				return SUCCESS;
			} else if (Z_TYPE_P(arg) == IS_OBJECT &amp;&amp; Z_OBJCE_P(arg) == zend_ffi_cdata_ce) {
				zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(arg);

				if (zend_ffi_is_compatible_type(type, ZEND_FFI_TYPE(cdata-&gt;type))) {
					if (ZEND_FFI_TYPE(cdata-&gt;type)-&gt;kind == ZEND_FFI_TYPE_POINTER) {
						if (!cdata-&gt;ptr) {
							zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
							return FAILURE;
						}
						*(void**)arg_values[n] = *(void**)cdata-&gt;ptr;
					} else {
						*(void**)arg_values[n] = cdata-&gt;ptr;
					}
					return SUCCESS;
				}
#if FFI_CLOSURES
			} else if (ZEND_FFI_TYPE(type-&gt;pointer.type)-&gt;kind == ZEND_FFI_TYPE_FUNC) {
				void *callback = zend_ffi_create_callback(ZEND_FFI_TYPE(type-&gt;pointer.type), arg);

				if (callback) {
					*(void**)arg_values[n] = callback;
					break;
				} else {
					return FAILURE;
				}
#endif
			}
			zend_ffi_pass_incompatible(arg, type, n, execute_data);
			return FAILURE;
		case ZEND_FFI_TYPE_BOOL:
			*pass_type = &amp;ffi_type_uint8;
			*(uint8_t*)arg_values[n] = zend_is_true(arg);
			break;
		case ZEND_FFI_TYPE_CHAR:
			str = zval_get_tmp_string(arg, &amp;tmp_str);
			*pass_type = &amp;ffi_type_sint8;
			*(char*)arg_values[n] = ZSTR_VAL(str)[0];
			if (ZSTR_LEN(str) != 1) {
				zend_ffi_pass_incompatible(arg, type, n, execute_data);
			}
			zend_tmp_string_release(tmp_str);
			break;
		case ZEND_FFI_TYPE_ENUM:
			kind = type-&gt;enumeration.kind;
			goto again;
		case ZEND_FFI_TYPE_STRUCT:
			if (Z_TYPE_P(arg) == IS_OBJECT &amp;&amp; Z_OBJCE_P(arg) == zend_ffi_cdata_ce) {
				zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(arg);

				if (zend_ffi_is_compatible_type(type, ZEND_FFI_TYPE(cdata-&gt;type))) {
					*pass_type = zend_ffi_make_fake_struct_type(type);
					arg_values[n] = cdata-&gt;ptr;
					break;
				}
			}
			zend_ffi_pass_incompatible(arg, type, n, execute_data);
			return FAILURE;
		default:
			zend_ffi_pass_unsupported(type);
			return FAILURE;
	}
	return SUCCESS;
}
/* }}} */

static zend_result zend_ffi_pass_var_arg(zval *arg, ffi_type **pass_type, void **arg_values, uint32_t n, zend_execute_data *execute_data) /* {{{ */
{
	ZVAL_DEREF(arg);
	switch (Z_TYPE_P(arg)) {
		case IS_NULL:
			*pass_type = &amp;ffi_type_pointer;
			*(void**)arg_values[n] = NULL;
			break;
		case IS_FALSE:
			*pass_type = &amp;ffi_type_uint8;
			*(uint8_t*)arg_values[n] = 0;
			break;
		case IS_TRUE:
			*pass_type = &amp;ffi_type_uint8;
			*(uint8_t*)arg_values[n] = 1;
			break;
		case IS_LONG:
			if (sizeof(zend_long) == 4) {
				*pass_type = &amp;ffi_type_sint32;
				*(int32_t*)arg_values[n] = Z_LVAL_P(arg);
			} else {
				*pass_type = &amp;ffi_type_sint64;
				*(int64_t*)arg_values[n] = Z_LVAL_P(arg);
			}
			break;
		case IS_DOUBLE:
			*pass_type = &amp;ffi_type_double;
			*(double*)arg_values[n] = Z_DVAL_P(arg);
			break;
		case IS_STRING:
			*pass_type = &amp;ffi_type_pointer;
			*(char**)arg_values[n] = Z_STRVAL_P(arg);
			break;
		case IS_OBJECT:
			if (Z_OBJCE_P(arg) == zend_ffi_cdata_ce) {
				zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(arg);
				zend_ffi_type *type = ZEND_FFI_TYPE(cdata-&gt;type);

				return zend_ffi_pass_arg(arg, type, pass_type, arg_values, n, execute_data);
			}
			ZEND_FALLTHROUGH;
		default:
			zend_throw_error(zend_ffi_exception_ce, &quot;Unsupported argument type&quot;);
			return FAILURE;
	}
	return SUCCESS;
}
/* }}} */

static ZEND_FUNCTION(ffi_trampoline) /* {{{ */
{
	zend_ffi_type *type = EX(func)-&gt;internal_function.reserved[0];
	void *addr = EX(func)-&gt;internal_function.reserved[1];
	ffi_cif cif;
	ffi_type *ret_type = NULL;
	ffi_type **arg_types = NULL;
	void **arg_values = NULL;
	uint32_t n, arg_count;
	void *ret;
	zend_ffi_type *arg_type;
	ALLOCA_FLAG(arg_types_use_heap = 0)
	ALLOCA_FLAG(arg_values_use_heap = 0)
	ALLOCA_FLAG(ret_use_heap = 0)

	ZEND_ASSERT(type-&gt;kind == ZEND_FFI_TYPE_FUNC);
	arg_count = type-&gt;func.args ? zend_hash_num_elements(type-&gt;func.args) : 0;
	if (type-&gt;attr &amp; ZEND_FFI_ATTR_VARIADIC) {
		if (arg_count &gt; EX_NUM_ARGS()) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Incorrect number of arguments for C function &#039;%s&#039;, expecting at least %d parameter%s&quot;, ZSTR_VAL(EX(func)-&gt;internal_function.function_name), arg_count, (arg_count != 1) ? &quot;s&quot; : &quot;&quot;);
			goto exit;
		}
		if (EX_NUM_ARGS()) {
			arg_types = do_alloca(
				sizeof(ffi_type*) * EX_NUM_ARGS(), arg_types_use_heap);
			arg_values = do_alloca(
				(sizeof(void*) + ZEND_FFI_SIZEOF_ARG) * EX_NUM_ARGS(), arg_values_use_heap);
			n = 0;
			if (type-&gt;func.args) {
				ZEND_HASH_PACKED_FOREACH_PTR(type-&gt;func.args, arg_type) {
					arg_type = ZEND_FFI_TYPE(arg_type);
					arg_values[n] = ((char*)arg_values) + (sizeof(void*) * EX_NUM_ARGS()) + (ZEND_FFI_SIZEOF_ARG * n);
					if (zend_ffi_pass_arg(EX_VAR_NUM(n), arg_type, &amp;arg_types[n], arg_values, n, execute_data) == FAILURE) {
						free_alloca(arg_types, arg_types_use_heap);
						free_alloca(arg_values, arg_values_use_heap);
						goto exit;
					}
					n++;
				} ZEND_HASH_FOREACH_END();
			}
			for (; n &lt; EX_NUM_ARGS(); n++) {
				arg_values[n] = ((char*)arg_values) + (sizeof(void*) * EX_NUM_ARGS()) + (ZEND_FFI_SIZEOF_ARG * n);
				if (zend_ffi_pass_var_arg(EX_VAR_NUM(n), &amp;arg_types[n], arg_values, n, execute_data) == FAILURE) {
					free_alloca(arg_types, arg_types_use_heap);
					free_alloca(arg_values, arg_values_use_heap);
					goto exit;
				}
			}
		}
		ret_type = zend_ffi_get_type(ZEND_FFI_TYPE(type-&gt;func.ret_type));
		if (!ret_type) {
			zend_ffi_return_unsupported(type-&gt;func.ret_type);
			free_alloca(arg_types, arg_types_use_heap);
			free_alloca(arg_values, arg_values_use_heap);
			goto exit;
		}
		if (ffi_prep_cif_var(&amp;cif, type-&gt;func.abi, arg_count, EX_NUM_ARGS(), ret_type, arg_types) != FFI_OK) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Cannot prepare callback CIF&quot;);
			free_alloca(arg_types, arg_types_use_heap);
			free_alloca(arg_values, arg_values_use_heap);
			goto exit;
		}
	} else {
		if (arg_count != EX_NUM_ARGS()) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Incorrect number of arguments for C function &#039;%s&#039;, expecting exactly %d parameter%s&quot;, ZSTR_VAL(EX(func)-&gt;internal_function.function_name), arg_count, (arg_count != 1) ? &quot;s&quot; : &quot;&quot;);
			goto exit;
		}
		if (EX_NUM_ARGS()) {
			arg_types = do_alloca(
				(sizeof(ffi_type*) + sizeof(ffi_type)) * EX_NUM_ARGS(), arg_types_use_heap);
			arg_values = do_alloca(
				(sizeof(void*) + ZEND_FFI_SIZEOF_ARG) * EX_NUM_ARGS(), arg_values_use_heap);
			n = 0;
			if (type-&gt;func.args) {
				ZEND_HASH_PACKED_FOREACH_PTR(type-&gt;func.args, arg_type) {
					arg_type = ZEND_FFI_TYPE(arg_type);
					arg_values[n] = ((char*)arg_values) + (sizeof(void*) * EX_NUM_ARGS()) + (ZEND_FFI_SIZEOF_ARG * n);
					if (zend_ffi_pass_arg(EX_VAR_NUM(n), arg_type, &amp;arg_types[n], arg_values, n, execute_data) == FAILURE) {
						free_alloca(arg_types, arg_types_use_heap);
						free_alloca(arg_values, arg_values_use_heap);
						goto exit;
					}
					n++;
				} ZEND_HASH_FOREACH_END();
			}
		}
		ret_type = zend_ffi_get_type(ZEND_FFI_TYPE(type-&gt;func.ret_type));
		if (!ret_type) {
			zend_ffi_return_unsupported(type-&gt;func.ret_type);
			free_alloca(arg_types, arg_types_use_heap);
			free_alloca(arg_values, arg_values_use_heap);
			goto exit;
		}
		if (ffi_prep_cif(&amp;cif, type-&gt;func.abi, arg_count, ret_type, arg_types) != FFI_OK) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Cannot prepare callback CIF&quot;);
			free_alloca(arg_types, arg_types_use_heap);
			free_alloca(arg_values, arg_values_use_heap);
			goto exit;
		}
	}

	ret = do_alloca(MAX(ret_type-&gt;size, sizeof(ffi_arg)), ret_use_heap);
	ffi_call(&amp;cif, addr, ret, arg_values);

	for (n = 0; n &lt; arg_count; n++) {
		if (arg_types[n]-&gt;type == FFI_TYPE_STRUCT) {
			efree(arg_types[n]);
		}
	}
	if (ret_type-&gt;type == FFI_TYPE_STRUCT) {
		efree(ret_type);
	}

	if (EX_NUM_ARGS()) {
		free_alloca(arg_types, arg_types_use_heap);
		free_alloca(arg_values, arg_values_use_heap);
	}

	if (ZEND_FFI_TYPE(type-&gt;func.ret_type)-&gt;kind != ZEND_FFI_TYPE_VOID) {
		zend_ffi_type *func_ret_type = ZEND_FFI_TYPE(type-&gt;func.ret_type);

#ifdef WORDS_BIGENDIAN
		if (func_ret_type-&gt;size &lt; sizeof(ffi_arg)
		 &amp;&amp; func_ret_type-&gt;kind &gt;= ZEND_FFI_TYPE_UINT8
		 &amp;&amp; func_ret_type-&gt;kind &lt; ZEND_FFI_TYPE_POINTER) {

			/* We need to narrow the value (truncate) */
			switch (func_ret_type-&gt;size) {
				case 1:
					*(uint8_t*)ret = *(ffi_arg*)ret;
					break;
				case 2:
					*(uint16_t*)ret = *(ffi_arg*)ret;
					break;
				case 4:
					*(uint32_t*)ret = *(ffi_arg*)ret;
					break;
				default:
					break;
			}
		}
#endif

		zend_ffi_cdata_to_zval(NULL, ret, func_ret_type, BP_VAR_R, return_value, 0, 1, 0);
	} else {
		ZVAL_NULL(return_value);
	}
	free_alloca(ret, ret_use_heap);

exit:
	zend_string_release(EX(func)-&gt;common.function_name);
	if (EX(func)-&gt;common.fn_flags &amp; ZEND_ACC_CALL_VIA_TRAMPOLINE) {
		zend_free_trampoline(EX(func));
		EX(func) = NULL;
	}
}
/* }}} */

static zend_function *zend_ffi_get_func(zend_object **obj, zend_string *name, const zval *key) /* {{{ */
{
	zend_ffi        *ffi = (zend_ffi*)*obj;
	zend_ffi_symbol *sym = NULL;
	zend_function   *func;
	zend_ffi_type   *type;

	if (ZSTR_LEN(name) == sizeof(&quot;new&quot;) -1
	 &amp;&amp; (ZSTR_VAL(name)[0] == &#039;n&#039; || ZSTR_VAL(name)[0] == &#039;N&#039;)
	 &amp;&amp; (ZSTR_VAL(name)[1] == &#039;e&#039; || ZSTR_VAL(name)[1] == &#039;E&#039;)
	 &amp;&amp; (ZSTR_VAL(name)[2] == &#039;w&#039; || ZSTR_VAL(name)[2] == &#039;W&#039;)) {
		return (zend_function*)&amp;zend_ffi_new_fn;
	} else if (ZSTR_LEN(name) == sizeof(&quot;cast&quot;) -1
	 &amp;&amp; (ZSTR_VAL(name)[0] == &#039;c&#039; || ZSTR_VAL(name)[0] == &#039;C&#039;)
	 &amp;&amp; (ZSTR_VAL(name)[1] == &#039;a&#039; || ZSTR_VAL(name)[1] == &#039;A&#039;)
	 &amp;&amp; (ZSTR_VAL(name)[2] == &#039;s&#039; || ZSTR_VAL(name)[2] == &#039;S&#039;)
	 &amp;&amp; (ZSTR_VAL(name)[3] == &#039;t&#039; || ZSTR_VAL(name)[3] == &#039;T&#039;)) {
		return (zend_function*)&amp;zend_ffi_cast_fn;
	} else if (ZSTR_LEN(name) == sizeof(&quot;type&quot;) -1
	 &amp;&amp; (ZSTR_VAL(name)[0] == &#039;t&#039; || ZSTR_VAL(name)[0] == &#039;T&#039;)
	 &amp;&amp; (ZSTR_VAL(name)[1] == &#039;y&#039; || ZSTR_VAL(name)[1] == &#039;Y&#039;)
	 &amp;&amp; (ZSTR_VAL(name)[2] == &#039;p&#039; || ZSTR_VAL(name)[2] == &#039;P&#039;)
	 &amp;&amp; (ZSTR_VAL(name)[3] == &#039;e&#039; || ZSTR_VAL(name)[3] == &#039;E&#039;)) {
		return (zend_function*)&amp;zend_ffi_type_fn;
	}

	if (ffi-&gt;symbols) {
		sym = zend_hash_find_ptr(ffi-&gt;symbols, name);
		if (sym &amp;&amp; sym-&gt;kind != ZEND_FFI_SYM_FUNC) {
			sym = NULL;
		}
	}
	if (!sym) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to call undefined C function &#039;%s&#039;&quot;, ZSTR_VAL(name));
		return NULL;
	}

	type = ZEND_FFI_TYPE(sym-&gt;type);
	ZEND_ASSERT(type-&gt;kind == ZEND_FFI_TYPE_FUNC);

	if (EXPECTED(EG(trampoline).common.function_name == NULL)) {
		func = &amp;EG(trampoline);
	} else {
		func = ecalloc(1, sizeof(zend_internal_function));
	}
	func-&gt;common.type = ZEND_INTERNAL_FUNCTION;
	func-&gt;common.arg_flags[0] = 0;
	func-&gt;common.arg_flags[1] = 0;
	func-&gt;common.arg_flags[2] = 0;
	func-&gt;common.fn_flags = ZEND_ACC_CALL_VIA_TRAMPOLINE;
	func-&gt;common.function_name = zend_string_copy(name);
	/* set to 0 to avoid arg_info[] allocation, because all values are passed by value anyway */
	func-&gt;common.num_args = 0;
	func-&gt;common.required_num_args = type-&gt;func.args ? zend_hash_num_elements(type-&gt;func.args) : 0;
	func-&gt;common.scope = NULL;
	func-&gt;common.prototype = NULL;
	func-&gt;common.arg_info = NULL;
	func-&gt;internal_function.handler = ZEND_FN(ffi_trampoline);
	func-&gt;internal_function.module = NULL;
	func-&gt;internal_function.doc_comment = NULL;

	func-&gt;internal_function.reserved[0] = type;
	func-&gt;internal_function.reserved[1] = sym-&gt;addr;

	return func;
}
/* }}} */

static int zend_fake_compare_objects(zval *o1, zval *o2)
{
	zend_throw_error(zend_ffi_exception_ce, &quot;Cannot compare FFI objects&quot;);
	return ZEND_UNCOMPARABLE;
}

static zend_never_inline int zend_ffi_disabled(void) /* {{{ */
{
	zend_throw_error(zend_ffi_exception_ce, &quot;FFI API is restricted by \&quot;ffi.enable\&quot; configuration directive&quot;);
	return 0;
}
/* }}} */

static zend_always_inline bool zend_ffi_validate_api_restriction(zend_execute_data *execute_data) /* {{{ */
{
	if (EXPECTED(FFI_G(restriction) &gt; ZEND_FFI_ENABLED)) {
		ZEND_ASSERT(FFI_G(restriction) == ZEND_FFI_PRELOAD);
		if (FFI_G(is_cli)
		 || (execute_data-&gt;prev_execute_data
		  &amp;&amp; (execute_data-&gt;prev_execute_data-&gt;func-&gt;common.fn_flags &amp; ZEND_ACC_PRELOADED))
		 || (CG(compiler_options) &amp; ZEND_COMPILE_PRELOAD)) {
			return 1;
		}
	} else if (EXPECTED(FFI_G(restriction) == ZEND_FFI_ENABLED)) {
		return 1;
	}
	return zend_ffi_disabled();
}
/* }}} */

#define ZEND_FFI_VALIDATE_API_RESTRICTION() do { \
		if (UNEXPECTED(!zend_ffi_validate_api_restriction(execute_data))) { \
			RETURN_THROWS(); \
		} \
	} while (0)

ZEND_METHOD(FFI, cdef) /* {{{ */
{
	zend_string *code = NULL;
	zend_string *lib = NULL;
	zend_ffi *ffi = NULL;
	DL_HANDLE handle = NULL;
	char *err;
	void *addr;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(0, 2)
		Z_PARAM_OPTIONAL
		Z_PARAM_STR(code)
		Z_PARAM_STR_OR_NULL(lib)
	ZEND_PARSE_PARAMETERS_END();

	if (lib) {
		handle = DL_LOAD(ZSTR_VAL(lib));
		if (!handle) {
			err = GET_DL_ERROR();
#ifdef PHP_WIN32
			if (err &amp;&amp; err[0]) {
				zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039; (%s)&quot;, ZSTR_VAL(lib), err);
				php_win32_error_msg_free(err);
			} else {
				zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039; (Unknown reason)&quot;, ZSTR_VAL(lib));
			}
#else
			zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039; (%s)&quot;, ZSTR_VAL(lib), err);
			GET_DL_ERROR(); /* free the buffer storing the error */
#endif
			RETURN_THROWS();
		}

#ifdef RTLD_DEFAULT
	} else if (1) {
		// TODO: this might need to be disabled or protected ???
		handle = RTLD_DEFAULT;
#endif
	}

	FFI_G(symbols) = NULL;
	FFI_G(tags) = NULL;

	if (code &amp;&amp; ZSTR_LEN(code)) {
		/* Parse C definitions */
		FFI_G(default_type_attr) = ZEND_FFI_ATTR_STORED;

		if (zend_ffi_parse_decl(ZSTR_VAL(code), ZSTR_LEN(code)) == FAILURE) {
			if (FFI_G(symbols)) {
				zend_hash_destroy(FFI_G(symbols));
				efree(FFI_G(symbols));
				FFI_G(symbols) = NULL;
			}
			if (FFI_G(tags)) {
				zend_hash_destroy(FFI_G(tags));
				efree(FFI_G(tags));
				FFI_G(tags) = NULL;
			}
			RETURN_THROWS();
		}

		if (FFI_G(symbols)) {
			zend_string *name;
			zend_ffi_symbol *sym;

			ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(FFI_G(symbols), name, sym) {
				if (sym-&gt;kind == ZEND_FFI_SYM_VAR) {
					addr = DL_FETCH_SYMBOL(handle, ZSTR_VAL(name));
					if (!addr) {
						zend_throw_error(zend_ffi_exception_ce, &quot;Failed resolving C variable &#039;%s&#039;&quot;, ZSTR_VAL(name));
						RETURN_THROWS();
					}
					sym-&gt;addr = addr;
				} else if (sym-&gt;kind == ZEND_FFI_SYM_FUNC) {
					zend_string *mangled_name = zend_ffi_mangled_func_name(name, ZEND_FFI_TYPE(sym-&gt;type));

					addr = DL_FETCH_SYMBOL(handle, ZSTR_VAL(mangled_name));
					zend_string_release(mangled_name);
					if (!addr) {
						zend_throw_error(zend_ffi_exception_ce, &quot;Failed resolving C function &#039;%s&#039;&quot;, ZSTR_VAL(name));
						RETURN_THROWS();
					}
					sym-&gt;addr = addr;
				}
			} ZEND_HASH_FOREACH_END();
		}
	}

	ffi = (zend_ffi*)zend_ffi_new(zend_ffi_ce);
	ffi-&gt;lib = handle;
	ffi-&gt;symbols = FFI_G(symbols);
	ffi-&gt;tags = FFI_G(tags);

	FFI_G(symbols) = NULL;
	FFI_G(tags) = NULL;

	RETURN_OBJ(&amp;ffi-&gt;std);
}
/* }}} */

static bool zend_ffi_same_types(zend_ffi_type *old, zend_ffi_type *type) /* {{{ */
{
	if (old == type) {
		return 1;
	}

	if (old-&gt;kind != type-&gt;kind
	 || old-&gt;size != type-&gt;size
	 || old-&gt;align != type-&gt;align
	 || old-&gt;attr != type-&gt;attr) {
		return 0;
	}

	switch (old-&gt;kind) {
		case ZEND_FFI_TYPE_ENUM:
			return old-&gt;enumeration.kind == type-&gt;enumeration.kind;
		case ZEND_FFI_TYPE_ARRAY:
			return old-&gt;array.length == type-&gt;array.length
			 &amp;&amp;	zend_ffi_same_types(ZEND_FFI_TYPE(old-&gt;array.type), ZEND_FFI_TYPE(type-&gt;array.type));
		case ZEND_FFI_TYPE_POINTER:
			return zend_ffi_same_types(ZEND_FFI_TYPE(old-&gt;pointer.type), ZEND_FFI_TYPE(type-&gt;pointer.type));
		case ZEND_FFI_TYPE_STRUCT:
			if (zend_hash_num_elements(&amp;old-&gt;record.fields) != zend_hash_num_elements(&amp;type-&gt;record.fields)) {
				return 0;
			} else {
				zend_ffi_field *old_field, *field;
				zend_string *key;
				Bucket *b = type-&gt;record.fields.arData;

				ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&amp;old-&gt;record.fields, key, old_field) {
					while (Z_TYPE(b-&gt;val) == IS_UNDEF) {
						b++;
					}
					if (key) {
						if (!b-&gt;key
						 || !zend_string_equals(key, b-&gt;key)) {
							return 0;
						}
					} else if (b-&gt;key) {
						return 0;
					}
					field = Z_PTR(b-&gt;val);
					if (old_field-&gt;offset != field-&gt;offset
					 || old_field-&gt;is_const != field-&gt;is_const
					 || old_field-&gt;is_nested != field-&gt;is_nested
					 || old_field-&gt;first_bit != field-&gt;first_bit
					 || old_field-&gt;bits != field-&gt;bits
					 || !zend_ffi_same_types(ZEND_FFI_TYPE(old_field-&gt;type), ZEND_FFI_TYPE(field-&gt;type))) {
						return 0;
					}
					b++;
				} ZEND_HASH_FOREACH_END();
			}
			break;
		case ZEND_FFI_TYPE_FUNC:
			if (old-&gt;func.abi != type-&gt;func.abi
			 || ((old-&gt;func.args ? zend_hash_num_elements(old-&gt;func.args) : 0) != (type-&gt;func.args ? zend_hash_num_elements(type-&gt;func.args) : 0))
			 || !zend_ffi_same_types(ZEND_FFI_TYPE(old-&gt;func.ret_type), ZEND_FFI_TYPE(type-&gt;func.ret_type))) {
				return 0;
			} else if (old-&gt;func.args) {
				zend_ffi_type *arg_type;
				zval *zv = type-&gt;func.args-&gt;arPacked;

				ZEND_HASH_PACKED_FOREACH_PTR(old-&gt;func.args, arg_type) {
					while (Z_TYPE_P(zv) == IS_UNDEF) {
						zv++;
					}
					if (!zend_ffi_same_types(ZEND_FFI_TYPE(arg_type), ZEND_FFI_TYPE(Z_PTR_P(zv)))) {
						return 0;
					}
					zv++;
				} ZEND_HASH_FOREACH_END();
			}
			break;
		default:
			break;
	}

	return 1;
}
/* }}} */

static bool zend_ffi_same_symbols(zend_ffi_symbol *old, zend_ffi_symbol *sym) /* {{{ */
{
	if (old-&gt;kind != sym-&gt;kind || old-&gt;is_const != sym-&gt;is_const) {
		return 0;
	}

	if (old-&gt;kind == ZEND_FFI_SYM_CONST) {
		if (old-&gt;value != sym-&gt;value) {
			return 0;
		}
	}

	return zend_ffi_same_types(ZEND_FFI_TYPE(old-&gt;type), ZEND_FFI_TYPE(sym-&gt;type));
}
/* }}} */

static bool zend_ffi_same_tags(zend_ffi_tag *old, zend_ffi_tag *tag) /* {{{ */
{
	if (old-&gt;kind != tag-&gt;kind) {
		return 0;
	}

	return zend_ffi_same_types(ZEND_FFI_TYPE(old-&gt;type), ZEND_FFI_TYPE(tag-&gt;type));
}
/* }}} */

static bool zend_ffi_subst_old_type(zend_ffi_type **dcl, zend_ffi_type *old, zend_ffi_type *type) /* {{{ */
{
	zend_ffi_type *dcl_type;
	zend_ffi_field *field;

	if (ZEND_FFI_TYPE(*dcl) == type) {
		*dcl = old;
		return 1;
	}
	dcl_type = *dcl;
	switch (dcl_type-&gt;kind) {
		case ZEND_FFI_TYPE_POINTER:
			return zend_ffi_subst_old_type(&amp;dcl_type-&gt;pointer.type, old, type);
		case ZEND_FFI_TYPE_ARRAY:
			return zend_ffi_subst_old_type(&amp;dcl_type-&gt;array.type, old, type);
		case ZEND_FFI_TYPE_FUNC:
			if (zend_ffi_subst_old_type(&amp;dcl_type-&gt;func.ret_type, old, type)) {
				return 1;
			}
			if (dcl_type-&gt;func.args) {
				zval *zv;

				ZEND_HASH_PACKED_FOREACH_VAL(dcl_type-&gt;func.args, zv) {
					if (zend_ffi_subst_old_type((zend_ffi_type**)&amp;Z_PTR_P(zv), old, type)) {
						return 1;
					}
				} ZEND_HASH_FOREACH_END();
			}
			break;
		case ZEND_FFI_TYPE_STRUCT:
			ZEND_HASH_MAP_FOREACH_PTR(&amp;dcl_type-&gt;record.fields, field) {
				if (zend_ffi_subst_old_type(&amp;field-&gt;type, old, type)) {
					return 1;
				}
			} ZEND_HASH_FOREACH_END();
			break;
		default:
			break;
	}
	return 0;
} /* }}} */

static void zend_ffi_cleanup_type(zend_ffi_type *old, zend_ffi_type *type) /* {{{ */
{
	zend_ffi_symbol *sym;
	zend_ffi_tag *tag;

	if (FFI_G(symbols)) {
		ZEND_HASH_MAP_FOREACH_PTR(FFI_G(symbols), sym) {
			zend_ffi_subst_old_type(&amp;sym-&gt;type, old, type);
		} ZEND_HASH_FOREACH_END();
	}
	if (FFI_G(tags)) {
		ZEND_HASH_MAP_FOREACH_PTR(FFI_G(tags), tag) {
			zend_ffi_subst_old_type(&amp;tag-&gt;type, old, type);
		} ZEND_HASH_FOREACH_END();
	}
}
/* }}} */

static zend_ffi_type *zend_ffi_remember_type(zend_ffi_type *type) /* {{{ */
{
	if (!FFI_G(weak_types)) {
		FFI_G(weak_types) = emalloc(sizeof(HashTable));
		zend_hash_init(FFI_G(weak_types), 0, NULL, zend_ffi_type_hash_dtor, 0);
	}
	// TODO: avoid dups ???
	type-&gt;attr |= ZEND_FFI_ATTR_STORED;
	zend_hash_next_index_insert_ptr(FFI_G(weak_types), ZEND_FFI_TYPE_MAKE_OWNED(type));
	return type;
}
/* }}} */

static zend_ffi *zend_ffi_load(const char *filename, bool preload) /* {{{ */
{
	struct stat buf;
	int fd;
	char *code, *code_pos, *scope_name, *lib, *err;
	size_t code_size, scope_name_len;
	zend_ffi *ffi;
	DL_HANDLE handle = NULL;
	zend_ffi_scope *scope = NULL;
	zend_string *name;
	zend_ffi_symbol *sym;
	zend_ffi_tag *tag;
	void *addr;

	if (stat(filename, &amp;buf) != 0) {
		if (preload) {
			zend_error(E_WARNING, &quot;FFI: failed pre-loading &#039;%s&#039;, file doesn&#039;t exist&quot;, filename);
		} else {
			zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039;, file doesn&#039;t exist&quot;, filename);
		}
		return NULL;
	}

	if ((buf.st_mode &amp; S_IFMT) != S_IFREG) {
		if (preload) {
			zend_error(E_WARNING, &quot;FFI: failed pre-loading &#039;%s&#039;, not a regular file&quot;, filename);
		} else {
			zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039;, not a regular file&quot;, filename);
		}
		return NULL;
	}

	code_size = buf.st_size;
	code = emalloc(code_size + 1);
	int open_flags = O_RDONLY;
#ifdef PHP_WIN32
	open_flags |= _O_BINARY;
#endif
	fd = open(filename, open_flags, 0);
	if (fd &lt; 0 || read(fd, code, code_size) != code_size) {
		if (preload) {
			zend_error(E_WARNING, &quot;FFI: Failed pre-loading &#039;%s&#039;, cannot read_file&quot;, filename);
		} else {
			zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039;, cannot read_file&quot;, filename);
		}
		efree(code);
		close(fd);
		return NULL;
	}
	close(fd);
	code[code_size] = 0;

	FFI_G(symbols) = NULL;
	FFI_G(tags) = NULL;
	FFI_G(persistent) = preload;
	FFI_G(default_type_attr) = preload ?
		ZEND_FFI_ATTR_STORED | ZEND_FFI_ATTR_PERSISTENT :
		ZEND_FFI_ATTR_STORED;

	scope_name = NULL;
	scope_name_len = 0;
	lib = NULL;
	code_pos = zend_ffi_parse_directives(filename, code, &amp;scope_name, &amp;lib, preload);
	if (!code_pos) {
		efree(code);
		FFI_G(persistent) = 0;
		return NULL;
	}
	code_size -= code_pos - code;

	if (zend_ffi_parse_decl(code_pos, code_size) == FAILURE) {
		if (preload) {
			zend_error(E_WARNING, &quot;FFI: failed pre-loading &#039;%s&#039;&quot;, filename);
		} else {
			zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039;&quot;, filename);
		}
		goto cleanup;
	}

	if (lib) {
		handle = DL_LOAD(lib);
		if (!handle) {
			if (preload) {
				zend_error(E_WARNING, &quot;FFI: Failed pre-loading &#039;%s&#039;&quot;, lib);
			} else {
				err = GET_DL_ERROR();
#ifdef PHP_WIN32
				if (err &amp;&amp; err[0]) {
					zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039; (%s)&quot;, lib, err);
					php_win32_error_msg_free(err);
				} else {
					zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039; (Unknown reason)&quot;, lib);
				}
#else
				zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039; (%s)&quot;, lib, err);
				GET_DL_ERROR(); /* free the buffer storing the error */
#endif
			}
			goto cleanup;
		}
#ifdef RTLD_DEFAULT
	} else if (1) {
		// TODO: this might need to be disabled or protected ???
		handle = RTLD_DEFAULT;
#endif
	}

	if (preload) {
		if (!scope_name) {
			scope_name = &quot;C&quot;;
		}
		scope_name_len = strlen(scope_name);
		if (FFI_G(scopes)) {
			scope = zend_hash_str_find_ptr(FFI_G(scopes), scope_name, scope_name_len);
		}
	}

	if (FFI_G(symbols)) {
		ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(FFI_G(symbols), name, sym) {
			if (sym-&gt;kind == ZEND_FFI_SYM_VAR) {
				addr = DL_FETCH_SYMBOL(handle, ZSTR_VAL(name));
				if (!addr) {
					if (preload) {
						zend_error(E_WARNING, &quot;FFI: failed pre-loading &#039;%s&#039;, cannot resolve C variable &#039;%s&#039;&quot;, filename, ZSTR_VAL(name));
					} else {
						zend_throw_error(zend_ffi_exception_ce, &quot;Failed resolving C variable &#039;%s&#039;&quot;, ZSTR_VAL(name));
					}
					if (lib) {
						DL_UNLOAD(handle);
					}
					goto cleanup;
				}
				sym-&gt;addr = addr;
			} else if (sym-&gt;kind == ZEND_FFI_SYM_FUNC) {
				zend_string *mangled_name = zend_ffi_mangled_func_name(name, ZEND_FFI_TYPE(sym-&gt;type));

				addr = DL_FETCH_SYMBOL(handle, ZSTR_VAL(mangled_name));
				zend_string_release(mangled_name);
				if (!addr) {
					if (preload) {
						zend_error(E_WARNING, &quot;failed pre-loading &#039;%s&#039;, cannot resolve C function &#039;%s&#039;&quot;, filename, ZSTR_VAL(name));
					} else {
						zend_throw_error(zend_ffi_exception_ce, &quot;Failed resolving C function &#039;%s&#039;&quot;, ZSTR_VAL(name));
					}
					if (lib) {
						DL_UNLOAD(handle);
					}
					goto cleanup;
				}
				sym-&gt;addr = addr;
			}
			if (scope &amp;&amp; scope-&gt;symbols) {
				zend_ffi_symbol *old_sym = zend_hash_find_ptr(scope-&gt;symbols, name);

				if (old_sym) {
					if (zend_ffi_same_symbols(old_sym, sym)) {
						if (ZEND_FFI_TYPE_IS_OWNED(sym-&gt;type)
						 &amp;&amp; ZEND_FFI_TYPE(old_sym-&gt;type) != ZEND_FFI_TYPE(sym-&gt;type)) {
							zend_ffi_type *type = ZEND_FFI_TYPE(sym-&gt;type);
							zend_ffi_cleanup_type(ZEND_FFI_TYPE(old_sym-&gt;type), ZEND_FFI_TYPE(type));
							zend_ffi_type_dtor(type);
						}
					} else {
						zend_error(E_WARNING, &quot;FFI: failed pre-loading &#039;%s&#039;, redefinition of &#039;%s&#039;&quot;, filename, ZSTR_VAL(name));
						if (lib) {
							DL_UNLOAD(handle);
						}
						goto cleanup;
					}
				}
			}
		} ZEND_HASH_FOREACH_END();
	}

	if (preload) {
		if (scope &amp;&amp; scope-&gt;tags &amp;&amp; FFI_G(tags)) {
			ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(FFI_G(tags), name, tag) {
				zend_ffi_tag *old_tag = zend_hash_find_ptr(scope-&gt;tags, name);

				if (old_tag) {
					if (zend_ffi_same_tags(old_tag, tag)) {
						if (ZEND_FFI_TYPE_IS_OWNED(tag-&gt;type)
						 &amp;&amp; ZEND_FFI_TYPE(old_tag-&gt;type) != ZEND_FFI_TYPE(tag-&gt;type)) {
							zend_ffi_type *type = ZEND_FFI_TYPE(tag-&gt;type);
							zend_ffi_cleanup_type(ZEND_FFI_TYPE(old_tag-&gt;type), ZEND_FFI_TYPE(type));
							zend_ffi_type_dtor(type);
						}
					} else {
						zend_error(E_WARNING, &quot;FFI: failed pre-loading &#039;%s&#039;, redefinition of &#039;%s %s&#039;&quot;, filename, zend_ffi_tag_kind_name[tag-&gt;kind], ZSTR_VAL(name));
						if (lib) {
							DL_UNLOAD(handle);
						}
						goto cleanup;
					}
				}
			} ZEND_HASH_FOREACH_END();
		}

		if (!scope) {
			scope = malloc(sizeof(zend_ffi_scope));
			scope-&gt;symbols = FFI_G(symbols);
			scope-&gt;tags = FFI_G(tags);

			if (!FFI_G(scopes)) {
				FFI_G(scopes) = malloc(sizeof(HashTable));
				zend_hash_init(FFI_G(scopes), 0, NULL, zend_ffi_scope_hash_dtor, 1);
			}

			zend_hash_str_add_ptr(FFI_G(scopes), scope_name, scope_name_len, scope);
		} else {
			if (FFI_G(symbols)) {
				if (!scope-&gt;symbols) {
					scope-&gt;symbols = FFI_G(symbols);
					FFI_G(symbols) = NULL;
				} else {
					ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(FFI_G(symbols), name, sym) {
						if (!zend_hash_add_ptr(scope-&gt;symbols, name, sym)) {
							zend_ffi_type_dtor(sym-&gt;type);
							free(sym);
						}
					} ZEND_HASH_FOREACH_END();
					FFI_G(symbols)-&gt;pDestructor = NULL;
					zend_hash_destroy(FFI_G(symbols));
				}
			}
			if (FFI_G(tags)) {
				if (!scope-&gt;tags) {
					scope-&gt;tags = FFI_G(tags);
					FFI_G(tags) = NULL;
				} else {
					ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(FFI_G(tags), name, tag) {
						if (!zend_hash_add_ptr(scope-&gt;tags, name, tag)) {
							zend_ffi_type_dtor(tag-&gt;type);
							free(tag);
						}
					} ZEND_HASH_FOREACH_END();
					FFI_G(tags)-&gt;pDestructor = NULL;
					zend_hash_destroy(FFI_G(tags));
				}
			}
		}

		if (EG(objects_store).object_buckets) {
			ffi = (zend_ffi*)zend_ffi_new(zend_ffi_ce);
		} else {
			ffi = ecalloc(1, sizeof(zend_ffi));
		}
		ffi-&gt;symbols = scope-&gt;symbols;
		ffi-&gt;tags = scope-&gt;tags;
		ffi-&gt;persistent = 1;
	} else {
		ffi = (zend_ffi*)zend_ffi_new(zend_ffi_ce);
		ffi-&gt;lib = handle;
		ffi-&gt;symbols = FFI_G(symbols);
		ffi-&gt;tags = FFI_G(tags);
	}

	efree(code);
	FFI_G(symbols) = NULL;
	FFI_G(tags) = NULL;
	FFI_G(persistent) = 0;

	return ffi;

cleanup:
	efree(code);
	if (FFI_G(symbols)) {
		zend_hash_destroy(FFI_G(symbols));
		pefree(FFI_G(symbols), preload);
		FFI_G(symbols) = NULL;
	}
	if (FFI_G(tags)) {
		zend_hash_destroy(FFI_G(tags));
		pefree(FFI_G(tags), preload);
		FFI_G(tags) = NULL;
	}
	FFI_G(persistent) = 0;
	return NULL;
}
/* }}} */

ZEND_METHOD(FFI, load) /* {{{ */
{
	zend_string *fn;
	zend_ffi *ffi;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_STR(fn)
	ZEND_PARSE_PARAMETERS_END();

	if (CG(compiler_options) &amp; ZEND_COMPILE_PRELOAD_IN_CHILD) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI::load() doesn&#039;t work in conjunction with \&quot;opcache.preload_user\&quot;. Use \&quot;ffi.preload\&quot; instead.&quot;);
		RETURN_THROWS();
	}

	ffi = zend_ffi_load(ZSTR_VAL(fn), (CG(compiler_options) &amp; ZEND_COMPILE_PRELOAD) != 0);

	if (ffi) {
		RETURN_OBJ(&amp;ffi-&gt;std);
	}
}
/* }}} */

ZEND_METHOD(FFI, scope) /* {{{ */
{
	zend_string *scope_name;
	zend_ffi_scope *scope = NULL;
	zend_ffi *ffi;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_STR(scope_name)
	ZEND_PARSE_PARAMETERS_END();

	if (FFI_G(scopes)) {
		scope = zend_hash_find_ptr(FFI_G(scopes), scope_name);
	}

	if (!scope) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading scope &#039;%s&#039;&quot;, ZSTR_VAL(scope_name));
		RETURN_THROWS();
	}

	ffi = (zend_ffi*)zend_ffi_new(zend_ffi_ce);

	ffi-&gt;symbols = scope-&gt;symbols;
	ffi-&gt;tags = scope-&gt;tags;
	ffi-&gt;persistent = 1;

	RETURN_OBJ(&amp;ffi-&gt;std);
}
/* }}} */

void zend_ffi_cleanup_dcl(zend_ffi_dcl *dcl) /* {{{ */
{
	if (dcl) {
		zend_ffi_type_dtor(dcl-&gt;type);
		dcl-&gt;type = NULL;
	}
}
/* }}} */

static void zend_ffi_throw_parser_error(const char *format, ...) /* {{{ */
{
	va_list va;
	char *message = NULL;

	va_start(va, format);
	zend_vspprintf(&amp;message, 0, format, va);

	if (EG(current_execute_data)) {
		zend_throw_exception(zend_ffi_parser_exception_ce, message, 0);
	} else {
		zend_error(E_WARNING, &quot;FFI Parser: %s&quot;, message);
	}

	efree(message);
	va_end(va);
}
/* }}} */

static zend_result zend_ffi_validate_vla(zend_ffi_type *type) /* {{{ */
{
	if (!FFI_G(allow_vla) &amp;&amp; (type-&gt;attr &amp; ZEND_FFI_ATTR_VLA)) {
		zend_ffi_throw_parser_error(&quot;\&quot;[*]\&quot; is not allowed in other than function prototype scope at line %d&quot;, FFI_G(line));
		return FAILURE;
	}
	return SUCCESS;
}
/* }}} */

static zend_result zend_ffi_validate_incomplete_type(zend_ffi_type *type, bool allow_incomplete_tag, bool allow_incomplete_array) /* {{{ */
{
	if (!allow_incomplete_tag &amp;&amp; (type-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_TAG)) {
		if (FFI_G(tags)) {
			zend_string *key;
			zend_ffi_tag *tag;

			ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(FFI_G(tags), key, tag) {
				if (ZEND_FFI_TYPE(tag-&gt;type) == type) {
					if (type-&gt;kind == ZEND_FFI_TYPE_ENUM) {
						zend_ffi_throw_parser_error(&quot;Incomplete enum \&quot;%s\&quot; at line %d&quot;, ZSTR_VAL(key), FFI_G(line));
					} else if (type-&gt;attr &amp; ZEND_FFI_ATTR_UNION) {
						zend_ffi_throw_parser_error(&quot;Incomplete union \&quot;%s\&quot; at line %d&quot;, ZSTR_VAL(key), FFI_G(line));
					} else {
						zend_ffi_throw_parser_error(&quot;Incomplete struct \&quot;%s\&quot; at line %d&quot;, ZSTR_VAL(key), FFI_G(line));
					}
					return FAILURE;
				}
			} ZEND_HASH_FOREACH_END();
		}
		if (FFI_G(symbols)) {
			zend_string *key;
			zend_ffi_symbol *sym;

			ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(FFI_G(symbols), key, sym) {
				if (type == ZEND_FFI_TYPE(sym-&gt;type)) {
					zend_ffi_throw_parser_error(&quot;Incomplete C type %s at line %d&quot;, ZSTR_VAL(key), FFI_G(line));
					return FAILURE;
				}
			} ZEND_HASH_FOREACH_END();
		}
		zend_ffi_throw_parser_error(&quot;Incomplete type at line %d&quot;, FFI_G(line));
		return FAILURE;
	} else if (!allow_incomplete_array &amp;&amp; (type-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_ARRAY)) {
		zend_ffi_throw_parser_error(&quot;\&quot;[]\&quot; is not allowed at line %d&quot;, FFI_G(line));
		return FAILURE;
	} else if (!FFI_G(allow_vla) &amp;&amp; (type-&gt;attr &amp; ZEND_FFI_ATTR_VLA)) {
		zend_ffi_throw_parser_error(&quot;\&quot;[*]\&quot; is not allowed in other than function prototype scope at line %d&quot;, FFI_G(line));
		return FAILURE;
	}
	return SUCCESS;
}
/* }}} */

static zend_result zend_ffi_validate_type(zend_ffi_type *type, bool allow_incomplete_tag, bool allow_incomplete_array) /* {{{ */
{
	if (type-&gt;kind == ZEND_FFI_TYPE_VOID) {
		zend_ffi_throw_parser_error(&quot;void type is not allowed at line %d&quot;, FFI_G(line));
		return FAILURE;
	}
	return zend_ffi_validate_incomplete_type(type, allow_incomplete_tag, allow_incomplete_array);
}
/* }}} */

static zend_result zend_ffi_validate_var_type(zend_ffi_type *type, bool allow_incomplete_array) /* {{{ */
{
	if (type-&gt;kind == ZEND_FFI_TYPE_FUNC) {
		zend_ffi_throw_parser_error(&quot;function type is not allowed at line %d&quot;, FFI_G(line));
		return FAILURE;
	}
	return zend_ffi_validate_type(type, 0, allow_incomplete_array);
}
/* }}} */

void zend_ffi_validate_type_name(zend_ffi_dcl *dcl) /* {{{ */
{
	zend_ffi_finalize_type(dcl);
	if (zend_ffi_validate_var_type(ZEND_FFI_TYPE(dcl-&gt;type), 0) == FAILURE) {
		zend_ffi_cleanup_dcl(dcl);
		LONGJMP(FFI_G(bailout), FAILURE);
	}
}
/* }}} */

static bool zend_ffi_subst_type(zend_ffi_type **dcl, zend_ffi_type *type) /* {{{ */
{
	zend_ffi_type *dcl_type;
	zend_ffi_field *field;

	if (*dcl == type) {
		*dcl = ZEND_FFI_TYPE_MAKE_OWNED(type);
		return 1;
	}
	dcl_type = *dcl;
	switch (dcl_type-&gt;kind) {
		case ZEND_FFI_TYPE_POINTER:
			return zend_ffi_subst_type(&amp;dcl_type-&gt;pointer.type, type);
		case ZEND_FFI_TYPE_ARRAY:
			return zend_ffi_subst_type(&amp;dcl_type-&gt;array.type, type);
		case ZEND_FFI_TYPE_FUNC:
			if (zend_ffi_subst_type(&amp;dcl_type-&gt;func.ret_type, type)) {
				return 1;
			}
			if (dcl_type-&gt;func.args) {
				zval *zv;

				ZEND_HASH_PACKED_FOREACH_VAL(dcl_type-&gt;func.args, zv) {
					if (zend_ffi_subst_type((zend_ffi_type**)&amp;Z_PTR_P(zv), type)) {
						return 1;
					}
				} ZEND_HASH_FOREACH_END();
			}
			break;
		case ZEND_FFI_TYPE_STRUCT:
			ZEND_HASH_MAP_FOREACH_PTR(&amp;dcl_type-&gt;record.fields, field) {
				if (zend_ffi_subst_type(&amp;field-&gt;type, type)) {
					return 1;
				}
			} ZEND_HASH_FOREACH_END();
			break;
		default:
			break;
	}
	return 0;
} /* }}} */

static void zend_ffi_tags_cleanup(zend_ffi_dcl *dcl) /* {{{ */
{
	zend_ffi_tag *tag;
	ZEND_HASH_MAP_FOREACH_PTR(FFI_G(tags), tag) {
		if (ZEND_FFI_TYPE_IS_OWNED(tag-&gt;type)) {
			zend_ffi_type *type = ZEND_FFI_TYPE(tag-&gt;type);
			zend_ffi_subst_type(&amp;dcl-&gt;type, type);
			tag-&gt;type = type;
		}
	} ZEND_HASH_FOREACH_END();
	zend_hash_destroy(FFI_G(tags));
	efree(FFI_G(tags));
}
/* }}} */

ZEND_METHOD(FFI, new) /* {{{ */
{
	zend_string *type_def = NULL;
	zend_object *type_obj = NULL;
	zend_ffi_type *type, *type_ptr;
	zend_ffi_cdata *cdata;
	void *ptr;
	bool owned = 1;
	bool persistent = 0;
	bool is_const = 0;
	bool is_static_call = Z_TYPE(EX(This)) != IS_OBJECT;
	zend_ffi_flags flags = ZEND_FFI_FLAG_OWNED;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(1, 3)
		Z_PARAM_OBJ_OF_CLASS_OR_STR(type_obj, zend_ffi_ctype_ce, type_def)
		Z_PARAM_OPTIONAL
		Z_PARAM_BOOL(owned)
		Z_PARAM_BOOL(persistent)
	ZEND_PARSE_PARAMETERS_END();

	if (is_static_call) {
		zend_error(E_DEPRECATED, &quot;Calling FFI::new() statically is deprecated&quot;);
		if (EG(exception)) {
			RETURN_THROWS();
		}
	}

	if (!owned) {
		flags &amp;= ~ZEND_FFI_FLAG_OWNED;
	}

	if (persistent) {
		flags |= ZEND_FFI_FLAG_PERSISTENT;
	}

	if (type_def) {
		zend_ffi_dcl dcl = ZEND_FFI_ATTR_INIT;

		if (!is_static_call) {
			zend_ffi *ffi = (zend_ffi*)Z_OBJ(EX(This));
			FFI_G(symbols) = ffi-&gt;symbols;
			FFI_G(tags) = ffi-&gt;tags;
		} else {
			FFI_G(symbols) = NULL;
			FFI_G(tags) = NULL;
		}
		bool clean_symbols = FFI_G(symbols) == NULL;
		bool clean_tags = FFI_G(tags) == NULL;

		FFI_G(default_type_attr) = 0;

		if (zend_ffi_parse_type(ZSTR_VAL(type_def), ZSTR_LEN(type_def), &amp;dcl) == FAILURE) {
			zend_ffi_type_dtor(dcl.type);
			if (clean_tags &amp;&amp; FFI_G(tags)) {
				zend_hash_destroy(FFI_G(tags));
				efree(FFI_G(tags));
				FFI_G(tags) = NULL;
			}
			if (clean_symbols &amp;&amp; FFI_G(symbols)) {
				zend_hash_destroy(FFI_G(symbols));
				efree(FFI_G(symbols));
				FFI_G(symbols) = NULL;
			}
			return;
		}

		type = ZEND_FFI_TYPE(dcl.type);
		if (dcl.attr &amp; ZEND_FFI_ATTR_CONST) {
			is_const = 1;
		}

		if (clean_tags &amp;&amp; FFI_G(tags)) {
			zend_ffi_tags_cleanup(&amp;dcl);
		}
		if (clean_symbols &amp;&amp; FFI_G(symbols)) {
			zend_hash_destroy(FFI_G(symbols));
			efree(FFI_G(symbols));
			FFI_G(symbols) = NULL;
		}
		FFI_G(symbols) = NULL;
		FFI_G(tags) = NULL;

		type_ptr = dcl.type;
	} else {
		zend_ffi_ctype *ctype = (zend_ffi_ctype*) type_obj;

		type_ptr = type = ctype-&gt;type;
		if (ZEND_FFI_TYPE_IS_OWNED(type)) {
			type = ZEND_FFI_TYPE(type);
			if (!(type-&gt;attr &amp; ZEND_FFI_ATTR_STORED)) {
				if (GC_REFCOUNT(&amp;ctype-&gt;std) == 1) {
					/* transfer type ownership */
					ctype-&gt;type = type;
				} else {
					ctype-&gt;type = type_ptr = type = zend_ffi_remember_type(type);
				}
			}
		}
	}

	if (type-&gt;size == 0) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Cannot instantiate FFI\\CData of zero size&quot;);
		zend_ffi_type_dtor(type_ptr);
		return;
	}

	ptr = pemalloc(type-&gt;size, flags &amp; ZEND_FFI_FLAG_PERSISTENT);
	memset(ptr, 0, type-&gt;size);

	cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
	if (type-&gt;kind &lt; ZEND_FFI_TYPE_POINTER) {
		cdata-&gt;std.handlers = &amp;zend_ffi_cdata_value_handlers;
	}
	cdata-&gt;type = type_ptr;
	cdata-&gt;ptr = ptr;
	cdata-&gt;flags = flags;
	if (is_const) {
		cdata-&gt;flags |= ZEND_FFI_FLAG_CONST;
	}

	RETURN_OBJ(&amp;cdata-&gt;std);
}
/* }}} */

ZEND_METHOD(FFI, free) /* {{{ */
{
	zval *zv;
	zend_ffi_cdata *cdata;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_OBJECT_OF_CLASS_EX(zv, zend_ffi_cdata_ce, 0, 1);
	ZEND_PARSE_PARAMETERS_END();

	cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);

	if (ZEND_FFI_TYPE(cdata-&gt;type)-&gt;kind == ZEND_FFI_TYPE_POINTER) {
		if (!cdata-&gt;ptr) {
			zend_throw_error(zend_ffi_exception_ce, &quot;NULL pointer dereference&quot;);
			RETURN_THROWS();
		}
		if (cdata-&gt;ptr != (void*)&amp;cdata-&gt;ptr_holder) {
			pefree(*(void**)cdata-&gt;ptr, cdata-&gt;flags &amp; ZEND_FFI_FLAG_PERSISTENT);
		} else {
			pefree(cdata-&gt;ptr_holder, (cdata-&gt;flags &amp; ZEND_FFI_FLAG_PERSISTENT) || !is_zend_ptr(cdata-&gt;ptr_holder));
		}
		*(void**)cdata-&gt;ptr = NULL;
	} else if (!(cdata-&gt;flags &amp; ZEND_FFI_FLAG_OWNED)) {
		pefree(cdata-&gt;ptr, cdata-&gt;flags &amp; ZEND_FFI_FLAG_PERSISTENT);
		cdata-&gt;ptr = NULL;
		cdata-&gt;flags &amp;= ~(ZEND_FFI_FLAG_OWNED|ZEND_FFI_FLAG_PERSISTENT);
		cdata-&gt;std.handlers = &amp;zend_ffi_cdata_free_handlers;
	} else {
		zend_throw_error(zend_ffi_exception_ce, &quot;free() non a C pointer&quot;);
	}
}
/* }}} */

ZEND_METHOD(FFI, cast) /* {{{ */
{
	zend_string *type_def = NULL;
	zend_object *ztype = NULL;
	zend_ffi_type *old_type, *type, *type_ptr;
	zend_ffi_cdata *old_cdata, *cdata;
	bool is_const = 0;
	bool is_static_call = Z_TYPE(EX(This)) != IS_OBJECT;
	zval *zv, *arg;
	void *ptr;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(2, 2)
		Z_PARAM_OBJ_OF_CLASS_OR_STR(ztype, zend_ffi_ctype_ce, type_def)
		Z_PARAM_ZVAL(zv)
	ZEND_PARSE_PARAMETERS_END();

	if (is_static_call) {
		zend_error(E_DEPRECATED, &quot;Calling FFI::cast() statically is deprecated&quot;);
		if (EG(exception)) {
			RETURN_THROWS();
		}
	}

	arg = zv;
	ZVAL_DEREF(zv);

	if (type_def) {
		zend_ffi_dcl dcl = ZEND_FFI_ATTR_INIT;

		if (!is_static_call) {
			zend_ffi *ffi = (zend_ffi*)Z_OBJ(EX(This));
			FFI_G(symbols) = ffi-&gt;symbols;
			FFI_G(tags) = ffi-&gt;tags;
		} else {
			FFI_G(symbols) = NULL;
			FFI_G(tags) = NULL;
		}
		bool clean_symbols = FFI_G(symbols) == NULL;
		bool clean_tags = FFI_G(tags) == NULL;

		FFI_G(default_type_attr) = 0;

		if (zend_ffi_parse_type(ZSTR_VAL(type_def), ZSTR_LEN(type_def), &amp;dcl) == FAILURE) {
			zend_ffi_type_dtor(dcl.type);
			if (clean_tags &amp;&amp; FFI_G(tags)) {
				zend_hash_destroy(FFI_G(tags));
				efree(FFI_G(tags));
				FFI_G(tags) = NULL;
			}
			if (clean_symbols &amp;&amp; FFI_G(symbols)) {
				zend_hash_destroy(FFI_G(symbols));
				efree(FFI_G(symbols));
				FFI_G(symbols) = NULL;
			}
			return;
		}

		type = ZEND_FFI_TYPE(dcl.type);
		if (dcl.attr &amp; ZEND_FFI_ATTR_CONST) {
			is_const = 1;
		}

		if (clean_tags &amp;&amp; FFI_G(tags)) {
			zend_ffi_tags_cleanup(&amp;dcl);
		}
		if (clean_symbols &amp;&amp; FFI_G(symbols)) {
			zend_hash_destroy(FFI_G(symbols));
			efree(FFI_G(symbols));
			FFI_G(symbols) = NULL;
		}
		FFI_G(symbols) = NULL;
		FFI_G(tags) = NULL;

		type_ptr = dcl.type;
	} else {
		zend_ffi_ctype *ctype = (zend_ffi_ctype*) ztype;

		type_ptr = type = ctype-&gt;type;
		if (ZEND_FFI_TYPE_IS_OWNED(type)) {
			type = ZEND_FFI_TYPE(type);
			if (!(type-&gt;attr &amp; ZEND_FFI_ATTR_STORED)) {
				if (GC_REFCOUNT(&amp;ctype-&gt;std) == 1) {
					/* transfer type ownership */
					ctype-&gt;type = type;
				} else {
					ctype-&gt;type = type_ptr = type = zend_ffi_remember_type(type);
				}
			}
		}
	}

	if (Z_TYPE_P(zv) != IS_OBJECT || Z_OBJCE_P(zv) != zend_ffi_cdata_ce) {
		if (type-&gt;kind &lt; ZEND_FFI_TYPE_POINTER &amp;&amp; Z_TYPE_P(zv) &lt; IS_STRING) {
			/* numeric conversion */
			cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
			cdata-&gt;std.handlers = &amp;zend_ffi_cdata_value_handlers;
			cdata-&gt;type = type_ptr;
			cdata-&gt;ptr = emalloc(type-&gt;size);
			zend_ffi_zval_to_cdata(cdata-&gt;ptr, type, zv);
			cdata-&gt;flags = ZEND_FFI_FLAG_OWNED;
			if (is_const) {
				cdata-&gt;flags |= ZEND_FFI_FLAG_CONST;
			}
			RETURN_OBJ(&amp;cdata-&gt;std);
		} else if (type-&gt;kind == ZEND_FFI_TYPE_POINTER &amp;&amp; Z_TYPE_P(zv) == IS_LONG) {
			/* number to pointer conversion */
			cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
			cdata-&gt;type = type_ptr;
			cdata-&gt;ptr = &amp;cdata-&gt;ptr_holder;
			cdata-&gt;ptr_holder = (void*)(intptr_t)Z_LVAL_P(zv);
			if (is_const) {
				cdata-&gt;flags |= ZEND_FFI_FLAG_CONST;
			}
			RETURN_OBJ(&amp;cdata-&gt;std);
		} else if (type-&gt;kind == ZEND_FFI_TYPE_POINTER &amp;&amp; Z_TYPE_P(zv) == IS_NULL) {
			/* null -&gt; pointer */
			cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
			cdata-&gt;type = type_ptr;
			cdata-&gt;ptr = &amp;cdata-&gt;ptr_holder;
			cdata-&gt;ptr_holder = NULL;
			if (is_const) {
				cdata-&gt;flags |= ZEND_FFI_FLAG_CONST;
			}
			RETURN_OBJ(&amp;cdata-&gt;std);
		} else {
			zend_wrong_parameter_class_error(2, &quot;FFI\\CData&quot;, zv);
			RETURN_THROWS();
		}
	}

	old_cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
	old_type = ZEND_FFI_TYPE(old_cdata-&gt;type);
	ptr = old_cdata-&gt;ptr;

	cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
	if (type-&gt;kind &lt; ZEND_FFI_TYPE_POINTER) {
		cdata-&gt;std.handlers = &amp;zend_ffi_cdata_value_handlers;
	}
	cdata-&gt;type = type_ptr;

	if (old_type-&gt;kind == ZEND_FFI_TYPE_POINTER
	 &amp;&amp; type-&gt;kind != ZEND_FFI_TYPE_POINTER
	 &amp;&amp; ZEND_FFI_TYPE(old_type-&gt;pointer.type)-&gt;kind == ZEND_FFI_TYPE_VOID) {
		/* automatically dereference void* pointers ??? */
		cdata-&gt;ptr = *(void**)ptr;
	} else if (old_type-&gt;kind == ZEND_FFI_TYPE_ARRAY
	 &amp;&amp; type-&gt;kind == ZEND_FFI_TYPE_POINTER
	 &amp;&amp; zend_ffi_is_compatible_type(ZEND_FFI_TYPE(old_type-&gt;array.type), ZEND_FFI_TYPE(type-&gt;pointer.type))) {		cdata-&gt;ptr = &amp;cdata-&gt;ptr_holder;
 		cdata-&gt;ptr = &amp;cdata-&gt;ptr_holder;
 		cdata-&gt;ptr_holder = old_cdata-&gt;ptr;
	} else if (old_type-&gt;kind == ZEND_FFI_TYPE_POINTER
	 &amp;&amp; type-&gt;kind == ZEND_FFI_TYPE_ARRAY
	 &amp;&amp; zend_ffi_is_compatible_type(ZEND_FFI_TYPE(old_type-&gt;pointer.type), ZEND_FFI_TYPE(type-&gt;array.type))) {
		cdata-&gt;ptr = old_cdata-&gt;ptr_holder;
	} else if (type-&gt;size &gt; old_type-&gt;size) {
		zend_object_release(&amp;cdata-&gt;std);
		zend_throw_error(zend_ffi_exception_ce, &quot;attempt to cast to larger type&quot;);
		RETURN_THROWS();
	} else if (ptr != &amp;old_cdata-&gt;ptr_holder) {
		cdata-&gt;ptr = ptr;
	} else {
		cdata-&gt;ptr = &amp;cdata-&gt;ptr_holder;
		cdata-&gt;ptr_holder = old_cdata-&gt;ptr_holder;
	}
	if (is_const) {
		cdata-&gt;flags |= ZEND_FFI_FLAG_CONST;
	}

	if (old_cdata-&gt;flags &amp; ZEND_FFI_FLAG_OWNED) {
		if (GC_REFCOUNT(&amp;old_cdata-&gt;std) == 1 &amp;&amp; Z_REFCOUNT_P(arg) == 1) {
			/* transfer ownership */
			old_cdata-&gt;flags &amp;= ~ZEND_FFI_FLAG_OWNED;
			cdata-&gt;flags |= ZEND_FFI_FLAG_OWNED;
		} else {
			//???zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to cast owned C pointer&quot;);
		}
	}

	RETURN_OBJ(&amp;cdata-&gt;std);
}
/* }}} */

ZEND_METHOD(FFI, type) /* {{{ */
{
	zend_ffi_ctype *ctype;
	zend_ffi_dcl dcl = ZEND_FFI_ATTR_INIT;
	zend_string *type_def;
	bool is_static_call = Z_TYPE(EX(This)) != IS_OBJECT;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_STR(type_def);
	ZEND_PARSE_PARAMETERS_END();

	if (is_static_call) {
		zend_error(E_DEPRECATED, &quot;Calling FFI::type() statically is deprecated&quot;);
		if (EG(exception)) {
			RETURN_THROWS();
		}
	}

	if (!is_static_call) {
		zend_ffi *ffi = (zend_ffi*)Z_OBJ(EX(This));
		FFI_G(symbols) = ffi-&gt;symbols;
		FFI_G(tags) = ffi-&gt;tags;
	} else {
		FFI_G(symbols) = NULL;
		FFI_G(tags) = NULL;
	}
	bool clean_symbols = FFI_G(symbols) == NULL;
	bool clean_tags = FFI_G(tags) == NULL;

	FFI_G(default_type_attr) = 0;

	if (zend_ffi_parse_type(ZSTR_VAL(type_def), ZSTR_LEN(type_def), &amp;dcl) == FAILURE) {
		zend_ffi_type_dtor(dcl.type);
		if (clean_tags &amp;&amp; FFI_G(tags)) {
			zend_hash_destroy(FFI_G(tags));
			efree(FFI_G(tags));
			FFI_G(tags) = NULL;
		}
		if (clean_symbols &amp;&amp; FFI_G(symbols)) {
			zend_hash_destroy(FFI_G(symbols));
			efree(FFI_G(symbols));
			FFI_G(symbols) = NULL;
		}
		return;
	}

	if (clean_tags &amp;&amp; FFI_G(tags)) {
		zend_ffi_tags_cleanup(&amp;dcl);
	}
	if (clean_symbols &amp;&amp; FFI_G(symbols)) {
		zend_hash_destroy(FFI_G(symbols));
		efree(FFI_G(symbols));
		FFI_G(symbols) = NULL;
	}
	FFI_G(symbols) = NULL;
	FFI_G(tags) = NULL;

	ctype = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
	ctype-&gt;type = dcl.type;

	RETURN_OBJ(&amp;ctype-&gt;std);
}
/* }}} */

ZEND_METHOD(FFI, typeof) /* {{{ */
{
	zval *zv, *arg;
	zend_ffi_ctype *ctype;
	zend_ffi_type *type;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_ZVAL(zv);
	ZEND_PARSE_PARAMETERS_END();

	arg = zv;
	ZVAL_DEREF(zv);
	if (Z_TYPE_P(zv) == IS_OBJECT &amp;&amp; Z_OBJCE_P(zv) == zend_ffi_cdata_ce) {
		zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);

		type = cdata-&gt;type;
		if (ZEND_FFI_TYPE_IS_OWNED(type)) {
			type = ZEND_FFI_TYPE(type);
			if (!(type-&gt;attr &amp; ZEND_FFI_ATTR_STORED)) {
				if (GC_REFCOUNT(&amp;cdata-&gt;std) == 1 &amp;&amp; Z_REFCOUNT_P(arg) == 1) {
					/* transfer type ownership */
					cdata-&gt;type = type;
					type = ZEND_FFI_TYPE_MAKE_OWNED(type);
				} else {
					cdata-&gt;type = type = zend_ffi_remember_type(type);
				}
			}
		}
	} else {
		zend_wrong_parameter_class_error(1, &quot;FFI\\CData&quot;, zv);
		RETURN_THROWS();
	}

	ctype = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
	ctype-&gt;type = type;

	RETURN_OBJ(&amp;ctype-&gt;std);
}
/* }}} */

ZEND_METHOD(FFI, arrayType) /* {{{ */
{
	zval *ztype;
	zend_ffi_ctype *ctype;
	zend_ffi_type *type;
	HashTable *dims;
	zval *val;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(2, 2)
		Z_PARAM_OBJECT_OF_CLASS(ztype, zend_ffi_ctype_ce)
		Z_PARAM_ARRAY_HT(dims)
	ZEND_PARSE_PARAMETERS_END();

	ctype = (zend_ffi_ctype*)Z_OBJ_P(ztype);
	type = ZEND_FFI_TYPE(ctype-&gt;type);

	if (type-&gt;kind == ZEND_FFI_TYPE_FUNC) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Array of functions is not allowed&quot;);
		RETURN_THROWS();
	} else if (type-&gt;kind == ZEND_FFI_TYPE_ARRAY &amp;&amp; (type-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_ARRAY)) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Only the leftmost array can be undimensioned&quot;);
		RETURN_THROWS();
	} else if (type-&gt;kind == ZEND_FFI_TYPE_VOID) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Array of void type is not allowed&quot;);
		RETURN_THROWS();
	} else if (type-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_TAG) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Array of incomplete type is not allowed&quot;);
		RETURN_THROWS();
	}

	if (ZEND_FFI_TYPE_IS_OWNED(ctype-&gt;type)) {
		if (!(type-&gt;attr &amp; ZEND_FFI_ATTR_STORED)) {
			if (GC_REFCOUNT(&amp;ctype-&gt;std) == 1) {
				/* transfer type ownership */
				ctype-&gt;type = type;
				type = ZEND_FFI_TYPE_MAKE_OWNED(type);
			} else {
				ctype-&gt;type = type = zend_ffi_remember_type(type);
			}
		}
	}

	ZEND_HASH_REVERSE_FOREACH_VAL(dims, val) {
		zend_long n = zval_get_long(val);
		zend_ffi_type *new_type;

		if (n &lt; 0) {
			zend_throw_error(zend_ffi_exception_ce, &quot;negative array index&quot;);
			zend_ffi_type_dtor(type);
			RETURN_THROWS();
		} else if (ZEND_FFI_TYPE(type)-&gt;kind == ZEND_FFI_TYPE_ARRAY &amp;&amp; (ZEND_FFI_TYPE(type)-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_ARRAY)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;only the leftmost array can be undimensioned&quot;);
			zend_ffi_type_dtor(type);
			RETURN_THROWS();
		}

		new_type = emalloc(sizeof(zend_ffi_type));
		new_type-&gt;kind = ZEND_FFI_TYPE_ARRAY;
		new_type-&gt;attr = 0;
		new_type-&gt;size = n * ZEND_FFI_TYPE(type)-&gt;size;
		new_type-&gt;align = ZEND_FFI_TYPE(type)-&gt;align;
		new_type-&gt;array.type = type;
		new_type-&gt;array.length = n;

		if (n == 0) {
			new_type-&gt;attr |= ZEND_FFI_ATTR_INCOMPLETE_ARRAY;
		}

		type = ZEND_FFI_TYPE_MAKE_OWNED(new_type);
	} ZEND_HASH_FOREACH_END();

	ctype = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
	ctype-&gt;type = type;

	RETURN_OBJ(&amp;ctype-&gt;std);
}
/* }}} */

ZEND_METHOD(FFI, addr) /* {{{ */
{
	zend_ffi_type *type, *new_type;
	zend_ffi_cdata *cdata, *new_cdata;
	zval *zv, *arg;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_ZVAL(zv)
	ZEND_PARSE_PARAMETERS_END();

	arg = zv;
	ZVAL_DEREF(zv);
	if (Z_TYPE_P(zv) != IS_OBJECT || Z_OBJCE_P(zv) != zend_ffi_cdata_ce) {
		zend_wrong_parameter_class_error(1, &quot;FFI\\CData&quot;, zv);
		RETURN_THROWS();
	}

	cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
	type = ZEND_FFI_TYPE(cdata-&gt;type);

	if (GC_REFCOUNT(&amp;cdata-&gt;std) == 1 &amp;&amp; Z_REFCOUNT_P(arg) == 1 &amp;&amp; type-&gt;kind == ZEND_FFI_TYPE_POINTER
	 &amp;&amp; cdata-&gt;ptr == &amp;cdata-&gt;ptr_holder) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI::addr() cannot create a reference to a temporary pointer&quot;);
		RETURN_THROWS();
	}

	new_type = emalloc(sizeof(zend_ffi_type));
	new_type-&gt;kind = ZEND_FFI_TYPE_POINTER;
	new_type-&gt;attr = 0;
	new_type-&gt;size = sizeof(void*);
	new_type-&gt;align = _Alignof(void*);
	/* life-time (source must relive the resulting pointer) ??? */
	new_type-&gt;pointer.type = type;

	new_cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
	new_cdata-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(new_type);
	new_cdata-&gt;ptr_holder = cdata-&gt;ptr;
	new_cdata-&gt;ptr = &amp;new_cdata-&gt;ptr_holder;

	if (GC_REFCOUNT(&amp;cdata-&gt;std) == 1 &amp;&amp; Z_REFCOUNT_P(arg) == 1) {
		if (ZEND_FFI_TYPE_IS_OWNED(cdata-&gt;type)) {
			/* transfer type ownership */
			cdata-&gt;type = type;
			new_type-&gt;pointer.type = ZEND_FFI_TYPE_MAKE_OWNED(type);
		}
		if (cdata-&gt;flags &amp; ZEND_FFI_FLAG_OWNED) {
			/* transfer ownership */
			cdata-&gt;flags &amp;= ~ZEND_FFI_FLAG_OWNED;
			new_cdata-&gt;flags |= ZEND_FFI_FLAG_OWNED;
		}
	}

	RETURN_OBJ(&amp;new_cdata-&gt;std);
}
/* }}} */

ZEND_METHOD(FFI, sizeof) /* {{{ */
{
	zval *zv;
	zend_ffi_type *type;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_ZVAL(zv);
	ZEND_PARSE_PARAMETERS_END();

	ZVAL_DEREF(zv);
	if (Z_TYPE_P(zv) == IS_OBJECT &amp;&amp; Z_OBJCE_P(zv) == zend_ffi_cdata_ce) {
		zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
		type = ZEND_FFI_TYPE(cdata-&gt;type);
	} else if (Z_TYPE_P(zv) == IS_OBJECT &amp;&amp; Z_OBJCE_P(zv) == zend_ffi_ctype_ce) {
		zend_ffi_ctype *ctype = (zend_ffi_ctype*)Z_OBJ_P(zv);
		type = ZEND_FFI_TYPE(ctype-&gt;type);
	} else {
		zend_wrong_parameter_class_error(1, &quot;FFI\\CData or FFI\\CType&quot;, zv);
		RETURN_THROWS();
	}

	RETURN_LONG(type-&gt;size);
}
/* }}} */

ZEND_METHOD(FFI, alignof) /* {{{ */
{
	zval *zv;
	zend_ffi_type *type;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_ZVAL(zv);
	ZEND_PARSE_PARAMETERS_END();

	ZVAL_DEREF(zv);
	if (Z_TYPE_P(zv) == IS_OBJECT &amp;&amp; Z_OBJCE_P(zv) == zend_ffi_cdata_ce) {
		zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
		type = ZEND_FFI_TYPE(cdata-&gt;type);
	} else if (Z_TYPE_P(zv) == IS_OBJECT &amp;&amp; Z_OBJCE_P(zv) == zend_ffi_ctype_ce) {
		zend_ffi_ctype *ctype = (zend_ffi_ctype*)Z_OBJ_P(zv);
		type = ZEND_FFI_TYPE(ctype-&gt;type);
	} else {
		zend_wrong_parameter_class_error(1, &quot;FFI\\CData or FFI\\CType&quot;, zv);
		RETURN_THROWS();
	}

	RETURN_LONG(type-&gt;align);
}
/* }}} */

ZEND_METHOD(FFI, memcpy) /* {{{ */
{
	zval *zv1, *zv2;
	zend_ffi_cdata *cdata1, *cdata2;
	zend_ffi_type *type1, *type2;
	void *ptr1, *ptr2;
	zend_long size;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(3, 3)
		Z_PARAM_OBJECT_OF_CLASS_EX(zv1, zend_ffi_cdata_ce, 0, 1);
		Z_PARAM_ZVAL(zv2)
		Z_PARAM_LONG(size)
	ZEND_PARSE_PARAMETERS_END();

	cdata1 = (zend_ffi_cdata*)Z_OBJ_P(zv1);
	type1 = ZEND_FFI_TYPE(cdata1-&gt;type);
	if (type1-&gt;kind == ZEND_FFI_TYPE_POINTER) {
		ptr1 = *(void**)cdata1-&gt;ptr;
	} else {
		ptr1 = cdata1-&gt;ptr;
		if (type1-&gt;kind != ZEND_FFI_TYPE_POINTER &amp;&amp; size &gt; type1-&gt;size) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to write over data boundary&quot;);
			RETURN_THROWS();
		}
	}

	ZVAL_DEREF(zv2);
	if (Z_TYPE_P(zv2) == IS_STRING) {
		ptr2 = Z_STRVAL_P(zv2);
		if (size &gt; Z_STRLEN_P(zv2)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to read over string boundary&quot;);
			RETURN_THROWS();
		}
	} else if (Z_TYPE_P(zv2) == IS_OBJECT &amp;&amp; Z_OBJCE_P(zv2) == zend_ffi_cdata_ce) {
		cdata2 = (zend_ffi_cdata*)Z_OBJ_P(zv2);
		type2 = ZEND_FFI_TYPE(cdata2-&gt;type);
		if (type2-&gt;kind == ZEND_FFI_TYPE_POINTER) {
			ptr2 = *(void**)cdata2-&gt;ptr;
		} else {
			ptr2 = cdata2-&gt;ptr;
			if (type2-&gt;kind != ZEND_FFI_TYPE_POINTER &amp;&amp; size &gt; type2-&gt;size) {
				zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to read over data boundary&quot;);
				RETURN_THROWS();
			}
		}
	} else {
		zend_wrong_parameter_class_error(2, &quot;FFI\\CData or string&quot;, zv2);
		RETURN_THROWS();
	}

	memcpy(ptr1, ptr2, size);
}
/* }}} */

ZEND_METHOD(FFI, memcmp) /* {{{ */
{
	zval *zv1, *zv2;
	zend_ffi_cdata *cdata1, *cdata2;
	zend_ffi_type *type1, *type2;
	void *ptr1, *ptr2;
	zend_long size;
	int ret;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(3, 3)
		Z_PARAM_ZVAL(zv1);
		Z_PARAM_ZVAL(zv2);
		Z_PARAM_LONG(size)
	ZEND_PARSE_PARAMETERS_END();

	ZVAL_DEREF(zv1);
	if (Z_TYPE_P(zv1) == IS_STRING) {
		ptr1 = Z_STRVAL_P(zv1);
		if (size &gt; Z_STRLEN_P(zv1)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;attempt to read over string boundary&quot;);
			RETURN_THROWS();
		}
	} else if (Z_TYPE_P(zv1) == IS_OBJECT &amp;&amp; Z_OBJCE_P(zv1) == zend_ffi_cdata_ce) {
		cdata1 = (zend_ffi_cdata*)Z_OBJ_P(zv1);
		type1 = ZEND_FFI_TYPE(cdata1-&gt;type);
		if (type1-&gt;kind == ZEND_FFI_TYPE_POINTER) {
			ptr1 = *(void**)cdata1-&gt;ptr;
		} else {
			ptr1 = cdata1-&gt;ptr;
			if (type1-&gt;kind != ZEND_FFI_TYPE_POINTER &amp;&amp; size &gt; type1-&gt;size) {
				zend_throw_error(zend_ffi_exception_ce, &quot;attempt to read over data boundary&quot;);
				RETURN_THROWS();
			}
		}
	} else {
		zend_wrong_parameter_class_error(1, &quot;FFI\\CData or string&quot;, zv1);
		RETURN_THROWS();
	}

	ZVAL_DEREF(zv2);
	if (Z_TYPE_P(zv2) == IS_STRING) {
		ptr2 = Z_STRVAL_P(zv2);
		if (size &gt; Z_STRLEN_P(zv2)) {
			zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to read over string boundary&quot;);
			RETURN_THROWS();
		}
	} else if (Z_TYPE_P(zv2) == IS_OBJECT &amp;&amp; Z_OBJCE_P(zv2) == zend_ffi_cdata_ce) {
		cdata2 = (zend_ffi_cdata*)Z_OBJ_P(zv2);
		type2 = ZEND_FFI_TYPE(cdata2-&gt;type);
		if (type2-&gt;kind == ZEND_FFI_TYPE_POINTER) {
			ptr2 = *(void**)cdata2-&gt;ptr;
		} else {
			ptr2 = cdata2-&gt;ptr;
			if (type2-&gt;kind != ZEND_FFI_TYPE_POINTER &amp;&amp; size &gt; type2-&gt;size) {
				zend_throw_error(zend_ffi_exception_ce, &quot;Attempt to read over data boundary&quot;);
				RETURN_THROWS();
			}
		}
	} else {
		zend_wrong_parameter_class_error(2, &quot;FFI\\CData or string&quot;, zv2);
		RETURN_THROWS();
	}

	ret = memcmp(ptr1, ptr2, size);
	if (ret == 0) {
		RETVAL_LONG(0);
	} else if (ret &lt; 0) {
		RETVAL_LONG(-1);
	} else {
		RETVAL_LONG(1);
	}
}
/* }}} */

ZEND_METHOD(FFI, memset) /* {{{ */
{
	zval *zv;
	zend_ffi_cdata *cdata;
	zend_ffi_type *type;
	void *ptr;
	zend_long ch, size;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(3, 3)
		Z_PARAM_OBJECT_OF_CLASS_EX(zv, zend_ffi_cdata_ce, 0, 1);
		Z_PARAM_LONG(ch)
		Z_PARAM_LONG(size)
	ZEND_PARSE_PARAMETERS_END();

	cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
	type = ZEND_FFI_TYPE(cdata-&gt;type);
	if (type-&gt;kind == ZEND_FFI_TYPE_POINTER) {
		ptr = *(void**)cdata-&gt;ptr;
	} else {
		ptr = cdata-&gt;ptr;
		if (type-&gt;kind != ZEND_FFI_TYPE_POINTER &amp;&amp; size &gt; type-&gt;size) {
			zend_throw_error(zend_ffi_exception_ce, &quot;attempt to write over data boundary&quot;);
			RETURN_THROWS();
		}
	}

	memset(ptr, ch, size);
}
/* }}} */

ZEND_METHOD(FFI, string) /* {{{ */
{
	zval *zv;
	zend_ffi_cdata *cdata;
	zend_ffi_type *type;
	void *ptr;
	zend_long size;
	bool size_is_null = 1;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(1, 2)
		Z_PARAM_OBJECT_OF_CLASS_EX(zv, zend_ffi_cdata_ce, 0, 1);
		Z_PARAM_OPTIONAL
		Z_PARAM_LONG_OR_NULL(size, size_is_null)
	ZEND_PARSE_PARAMETERS_END();

	cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
	type = ZEND_FFI_TYPE(cdata-&gt;type);
	if (!size_is_null) {
		if (type-&gt;kind == ZEND_FFI_TYPE_POINTER) {
			ptr = *(void**)cdata-&gt;ptr;
		} else {
			ptr = cdata-&gt;ptr;
			if (type-&gt;kind != ZEND_FFI_TYPE_POINTER &amp;&amp; size &gt; type-&gt;size) {
				zend_throw_error(zend_ffi_exception_ce, &quot;attempt to read over data boundary&quot;);
				RETURN_THROWS();
			}
		}
		RETURN_STRINGL((char*)ptr, size);
	} else {
		if (type-&gt;kind == ZEND_FFI_TYPE_POINTER &amp;&amp; ZEND_FFI_TYPE(type-&gt;pointer.type)-&gt;kind == ZEND_FFI_TYPE_CHAR) {
			ptr = *(void**)cdata-&gt;ptr;
		} else if (type-&gt;kind == ZEND_FFI_TYPE_ARRAY &amp;&amp; ZEND_FFI_TYPE(type-&gt;array.type)-&gt;kind == ZEND_FFI_TYPE_CHAR) {
			ptr = cdata-&gt;ptr;
		} else {
			zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\Cdata is not a C string&quot;);
			RETURN_THROWS();
		}
		RETURN_STRING((char*)ptr);
	}
}
/* }}} */

ZEND_METHOD(FFI, isNull) /* {{{ */
{
	zval *zv;
	zend_ffi_cdata *cdata;
	zend_ffi_type *type;

	ZEND_FFI_VALIDATE_API_RESTRICTION();
	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_ZVAL(zv);
	ZEND_PARSE_PARAMETERS_END();

	ZVAL_DEREF(zv);
	if (Z_TYPE_P(zv) != IS_OBJECT || Z_OBJCE_P(zv) != zend_ffi_cdata_ce) {
		zend_wrong_parameter_class_error(1, &quot;FFI\\CData&quot;, zv);
		RETURN_THROWS();
	}

	cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
	type = ZEND_FFI_TYPE(cdata-&gt;type);

	if (type-&gt;kind != ZEND_FFI_TYPE_POINTER){
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\Cdata is not a pointer&quot;);
		RETURN_THROWS();
	}

	RETURN_BOOL(*(void**)cdata-&gt;ptr == NULL);
}
/* }}} */


ZEND_METHOD(FFI_CType, getName) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	zend_ffi_ctype_name_buf buf;

	buf.start = buf.end = buf.buf + ((MAX_TYPE_NAME_LEN * 3) / 4);
	if (!zend_ffi_ctype_name(&amp;buf, ZEND_FFI_TYPE(ctype-&gt;type))) {
		RETURN_STR_COPY(Z_OBJ_P(ZEND_THIS)-&gt;ce-&gt;name);
	} else {
		size_t len = buf.end - buf.start;
		zend_string *res = zend_string_init(buf.start, len, 0);
		RETURN_STR(res);
	}
}
/* }}} */

ZEND_METHOD(FFI_CType, getKind) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	RETURN_LONG(type-&gt;kind);
}
/* }}} */

ZEND_METHOD(FFI_CType, getSize) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	RETURN_LONG(type-&gt;size);
}
/* }}} */

ZEND_METHOD(FFI_CType, getAlignment) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	RETURN_LONG(type-&gt;align);
}
/* }}} */

ZEND_METHOD(FFI_CType, getAttributes) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	RETURN_LONG(type-&gt;attr);
}
/* }}} */

ZEND_METHOD(FFI_CType, getEnumKind) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	if (type-&gt;kind != ZEND_FFI_TYPE_ENUM) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\CType is not an enumeration&quot;);
		RETURN_THROWS();
	}
	RETURN_LONG(type-&gt;enumeration.kind);
}
/* }}} */

ZEND_METHOD(FFI_CType, getArrayElementType) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;
	zend_ffi_ctype *ret;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	if (type-&gt;kind != ZEND_FFI_TYPE_ARRAY) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\CType is not an array&quot;);
		RETURN_THROWS();
	}

	ret = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
	ret-&gt;type = ZEND_FFI_TYPE(type-&gt;array.type);
	RETURN_OBJ(&amp;ret-&gt;std);
}
/* }}} */

ZEND_METHOD(FFI_CType, getArrayLength) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	if (type-&gt;kind != ZEND_FFI_TYPE_ARRAY) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\CType is not an array&quot;);
		RETURN_THROWS();
	}
	RETURN_LONG(type-&gt;array.length);
}
/* }}} */

ZEND_METHOD(FFI_CType, getPointerType) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_ctype *ret;
	zend_ffi_type *type;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	if (type-&gt;kind != ZEND_FFI_TYPE_POINTER) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\CType is not a pointer&quot;);
		RETURN_THROWS();
	}

	ret = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
	ret-&gt;type = ZEND_FFI_TYPE(type-&gt;pointer.type);
	RETURN_OBJ(&amp;ret-&gt;std);
}
/* }}} */

ZEND_METHOD(FFI_CType, getStructFieldNames) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;
	HashTable *ht;
	zend_string* name;
	zval zv;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	if (type-&gt;kind != ZEND_FFI_TYPE_STRUCT) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\CType is not a structure&quot;);
		RETURN_THROWS();
	}

	ht = zend_new_array(zend_hash_num_elements(&amp;type-&gt;record.fields));
	RETVAL_ARR(ht);
	ZEND_HASH_MAP_FOREACH_STR_KEY(&amp;type-&gt;record.fields, name) {
		ZVAL_STR_COPY(&amp;zv, name);
		zend_hash_next_index_insert_new(ht, &amp;zv);
	} ZEND_HASH_FOREACH_END();
}
/* }}} */

ZEND_METHOD(FFI_CType, getStructFieldOffset) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;
	zend_string *name;
	zend_ffi_field *ptr;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_STR(name)
	ZEND_PARSE_PARAMETERS_END();

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	if (type-&gt;kind != ZEND_FFI_TYPE_STRUCT) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\CType is not a structure&quot;);
		RETURN_THROWS();
	}

	ptr = zend_hash_find_ptr(&amp;type-&gt;record.fields, name);
	if (!ptr) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Wrong field name&quot;);
		RETURN_THROWS();
	}
	RETURN_LONG(ptr-&gt;offset);
}
/* }}} */

ZEND_METHOD(FFI_CType, getStructFieldType) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;
	zend_string *name;
	zend_ffi_field *ptr;
	zend_ffi_ctype *ret;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_STR(name)
	ZEND_PARSE_PARAMETERS_END();

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	if (type-&gt;kind != ZEND_FFI_TYPE_STRUCT) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\CType is not a structure&quot;);
		RETURN_THROWS();
	}

	ptr = zend_hash_find_ptr(&amp;type-&gt;record.fields, name);
	if (!ptr) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Wrong field name&quot;);
		RETURN_THROWS();
	}

	ret = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
	ret-&gt;type = ZEND_FFI_TYPE(ptr-&gt;type);
	RETURN_OBJ(&amp;ret-&gt;std);
}
/* }}} */

ZEND_METHOD(FFI_CType, getFuncABI) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	if (type-&gt;kind != ZEND_FFI_TYPE_FUNC) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\CType is not a function&quot;);
		RETURN_THROWS();
	}
	RETURN_LONG(type-&gt;func.abi);
}
/* }}} */

ZEND_METHOD(FFI_CType, getFuncReturnType) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_ctype *ret;
	zend_ffi_type *type;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	if (type-&gt;kind != ZEND_FFI_TYPE_FUNC) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\CType is not a function&quot;);
		RETURN_THROWS();
	}

	ret = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
	ret-&gt;type = ZEND_FFI_TYPE(type-&gt;func.ret_type);
	RETURN_OBJ(&amp;ret-&gt;std);
}
/* }}} */

ZEND_METHOD(FFI_CType, getFuncParameterCount) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_THROWS();
	}

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	if (type-&gt;kind != ZEND_FFI_TYPE_FUNC) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\CType is not a function&quot;);
		RETURN_THROWS();
	}
	RETURN_LONG(type-&gt;func.args ? zend_hash_num_elements(type-&gt;func.args) : 0);
}
/* }}} */

ZEND_METHOD(FFI_CType, getFuncParameterType) /* {{{ */
{
	zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
	zend_ffi_type *type, *ptr;
	zend_long n;
	zend_ffi_ctype *ret;

	ZEND_PARSE_PARAMETERS_START(1, 1)
		Z_PARAM_LONG(n)
	ZEND_PARSE_PARAMETERS_END();

	type = ZEND_FFI_TYPE(ctype-&gt;type);
	if (type-&gt;kind != ZEND_FFI_TYPE_FUNC) {
		zend_throw_error(zend_ffi_exception_ce, &quot;FFI\\CType is not a function&quot;);
		RETURN_THROWS();
	}

	if (!type-&gt;func.args) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Wrong argument number&quot;);
		RETURN_THROWS();
	}

	ptr = zend_hash_index_find_ptr(type-&gt;func.args, n);
	if (!ptr) {
		zend_throw_error(zend_ffi_exception_ce, &quot;Wrong argument number&quot;);
		RETURN_THROWS();
	}

	ret = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
	ret-&gt;type = ZEND_FFI_TYPE(ptr);
	RETURN_OBJ(&amp;ret-&gt;std);
}
/* }}} */

static char *zend_ffi_skip_ws_and_comments(char *p, bool allow_standalone_newline)
{
	while (true) {
		if (*p == &#039; &#039; || *p == &#039;\t&#039;) {
			p++;
		} else if (allow_standalone_newline &amp;&amp; (*p == &#039;\r&#039; || *p == &#039;\n&#039; || *p == &#039;\f&#039; || *p == &#039;\v&#039;)) {
			p++;
		} else if (allow_standalone_newline &amp;&amp; *p == &#039;/&#039; &amp;&amp; p[1] == &#039;/&#039;) {
			p += 2;
			while (*p &amp;&amp; *p != &#039;\r&#039; &amp;&amp; *p != &#039;\n&#039;) {
				p++;
			}
		} else if (*p == &#039;/&#039; &amp;&amp; p[1] == &#039;*&#039;) {
			p += 2;
			while (*p &amp;&amp; (*p != &#039;*&#039; || p[1] != &#039;/&#039;)) {
				p++;
			}
			if (*p == &#039;*&#039;) {
				p++;
				if (*p == &#039;/&#039;) {
					p++;
				}
			}
		} else {
			break;
		}
	}

	return p;
}

static char *zend_ffi_parse_directives(const char *filename, char *code_pos, char **scope_name, char **lib, bool preload) /* {{{ */
{
	char *p;

	code_pos = zend_ffi_skip_ws_and_comments(code_pos, true);

	*scope_name = NULL;
	*lib = NULL;
	while (*code_pos == &#039;#&#039;) {
		if (strncmp(code_pos, ZEND_STRL(&quot;#define&quot;)) == 0) {
			p = zend_ffi_skip_ws_and_comments(code_pos + sizeof(&quot;#define&quot;) - 1, false);

			char **target = NULL;
			const char *target_name = NULL;
			if (strncmp(p, ZEND_STRL(&quot;FFI_SCOPE&quot;)) == 0) {
				p = zend_ffi_skip_ws_and_comments(p + sizeof(&quot;FFI_SCOPE&quot;) - 1, false);
				target = scope_name;
				target_name = &quot;FFI_SCOPE&quot;;
			} else if (strncmp(p, ZEND_STRL(&quot;FFI_LIB&quot;)) == 0) {
				p = zend_ffi_skip_ws_and_comments(p + sizeof(&quot;FFI_LIB&quot;) - 1, false);
				target = lib;
				target_name = &quot;FFI_LIB&quot;;
			} else {
				while (*p &amp;&amp; *p != &#039;\n&#039; &amp;&amp; *p != &#039;\r&#039;) {
					p++;
				}
				code_pos = zend_ffi_skip_ws_and_comments(p, true);
				continue;
			}

			if (*p != &#039;&quot;&#039;) {
				if (preload) {
					zend_error(E_WARNING, &quot;FFI: failed pre-loading &#039;%s&#039;, bad %s define&quot;, filename, target_name);
				} else {
					zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039;, bad %s define&quot;, filename, target_name);
				}
				return NULL;
			}
			p++;
			if (*target) {
				if (preload) {
					zend_error(E_WARNING, &quot;FFI: failed pre-loading &#039;%s&#039;, %s defined twice&quot;, filename, target_name);
				} else {
					zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039;, %s defined twice&quot;, filename, target_name);
				}
				return NULL;
			}
			*target = p;
			while (1) {
				if (*p == &#039;\&quot;&#039;) {
					*p = 0;
					p++;
					break;
				} else if (*p &lt;= &#039; &#039;) {
					if (preload) {
						zend_error(E_WARNING, &quot;FFI: failed pre-loading &#039;%s&#039;, bad %s define&quot;, filename, target_name);
					} else {
						zend_throw_error(zend_ffi_exception_ce, &quot;Failed loading &#039;%s&#039;, bad %s define&quot;, filename, target_name);
					}
					return NULL;
				}
				p++;
			}

			code_pos = zend_ffi_skip_ws_and_comments(p, true);
		} else {
			break;
		}
	}
	return code_pos;
}
/* }}} */

static ZEND_COLD zend_function *zend_fake_get_constructor(zend_object *object) /* {{{ */
{
	zend_throw_error(NULL, &quot;Instantiation of %s is not allowed&quot;, ZSTR_VAL(object-&gt;ce-&gt;name));
	return NULL;
}
/* }}} */

static ZEND_COLD zend_never_inline void zend_bad_array_access(zend_class_entry *ce) /* {{{ */
{
	zend_throw_error(NULL, &quot;Cannot use object of type %s as array&quot;, ZSTR_VAL(ce-&gt;name));
}
/* }}} */

static ZEND_COLD zval *zend_fake_read_dimension(zend_object *obj, zval *offset, int type, zval *rv) /* {{{ */
{
	zend_bad_array_access(obj-&gt;ce);
	return NULL;
}
/* }}} */

static ZEND_COLD void zend_fake_write_dimension(zend_object *obj, zval *offset, zval *value) /* {{{ */
{
	zend_bad_array_access(obj-&gt;ce);
}
/* }}} */

static ZEND_COLD int zend_fake_has_dimension(zend_object *obj, zval *offset, int check_empty) /* {{{ */
{
	zend_bad_array_access(obj-&gt;ce);
	return 0;
}
/* }}} */

static ZEND_COLD void zend_fake_unset_dimension(zend_object *obj, zval *offset) /* {{{ */
{
	zend_bad_array_access(obj-&gt;ce);
}
/* }}} */

static ZEND_COLD zend_never_inline void zend_bad_property_access(zend_class_entry *ce) /* {{{ */
{
	zend_throw_error(NULL, &quot;Cannot access property of object of type %s&quot;, ZSTR_VAL(ce-&gt;name));
}
/* }}} */

static ZEND_COLD zval *zend_fake_read_property(zend_object *obj, zend_string *member, int type, void **cache_slot, zval *rv) /* {{{ */
{
	zend_bad_property_access(obj-&gt;ce);
	return &amp;EG(uninitialized_zval);
}
/* }}} */

static ZEND_COLD zval *zend_fake_write_property(zend_object *obj, zend_string *member, zval *value, void **cache_slot) /* {{{ */
{
	zend_bad_array_access(obj-&gt;ce);
	return value;
}
/* }}} */

static ZEND_COLD int zend_fake_has_property(zend_object *obj, zend_string *member, int has_set_exists, void **cache_slot) /* {{{ */
{
	zend_bad_array_access(obj-&gt;ce);
	return 0;
}
/* }}} */

static ZEND_COLD void zend_fake_unset_property(zend_object *obj, zend_string *member, void **cache_slot) /* {{{ */
{
	zend_bad_array_access(obj-&gt;ce);
}
/* }}} */

static zval *zend_fake_get_property_ptr_ptr(zend_object *obj, zend_string *member, int type, void **cache_slot) /* {{{ */
{
	return NULL;
}
/* }}} */

static ZEND_COLD zend_function *zend_fake_get_method(zend_object **obj_ptr, zend_string *method_name, const zval *key) /* {{{ */
{
	zend_class_entry *ce = (*obj_ptr)-&gt;ce;
	zend_throw_error(NULL, &quot;Object of type %s does not support method calls&quot;, ZSTR_VAL(ce-&gt;name));
	return NULL;
}
/* }}} */

static HashTable *zend_fake_get_properties(zend_object *obj) /* {{{ */
{
	return (HashTable*)&amp;zend_empty_array;
}
/* }}} */

static HashTable *zend_fake_get_gc(zend_object *ob, zval **table, int *n) /* {{{ */
{
	*table = NULL;
	*n = 0;
	return NULL;
}
/* }}} */

static zend_result zend_fake_cast_object(zend_object *obj, zval *result, int type)
{
	switch (type) {
		case _IS_BOOL:
			ZVAL_TRUE(result);
			return SUCCESS;
		default:
			return FAILURE;
	}
}

static ZEND_COLD zend_never_inline void zend_ffi_use_after_free(void) /* {{{ */
{
	zend_throw_error(zend_ffi_exception_ce, &quot;Use after free()&quot;);
}
/* }}} */

static zend_object *zend_ffi_free_clone_obj(zend_object *obj) /* {{{ */
{
	zend_ffi_use_after_free();
	return NULL;
}
/* }}} */

static ZEND_COLD zval *zend_ffi_free_read_dimension(zend_object *obj, zval *offset, int type, zval *rv) /* {{{ */
{
	zend_ffi_use_after_free();
	return NULL;
}
/* }}} */

static ZEND_COLD void zend_ffi_free_write_dimension(zend_object *obj, zval *offset, zval *value) /* {{{ */
{
	zend_ffi_use_after_free();
}
/* }}} */

static ZEND_COLD int zend_ffi_free_has_dimension(zend_object *obj, zval *offset, int check_empty) /* {{{ */
{
	zend_ffi_use_after_free();
	return 0;
}
/* }}} */

static ZEND_COLD void zend_ffi_free_unset_dimension(zend_object *obj, zval *offset) /* {{{ */
{
	zend_ffi_use_after_free();
}
/* }}} */

static ZEND_COLD zval *zend_ffi_free_read_property(zend_object *obj, zend_string *member, int type, void **cache_slot, zval *rv) /* {{{ */
{
	zend_ffi_use_after_free();
	return &amp;EG(uninitialized_zval);
}
/* }}} */

static ZEND_COLD zval *zend_ffi_free_write_property(zend_object *obj, zend_string *member, zval *value, void **cache_slot) /* {{{ */
{
	zend_ffi_use_after_free();
	return value;
}
/* }}} */

static ZEND_COLD int zend_ffi_free_has_property(zend_object *obj, zend_string *member, int has_set_exists, void **cache_slot) /* {{{ */
{
	zend_ffi_use_after_free();
	return 0;
}
/* }}} */

static ZEND_COLD void zend_ffi_free_unset_property(zend_object *obj, zend_string *member, void **cache_slot) /* {{{ */
{
	zend_ffi_use_after_free();
}
/* }}} */

static HashTable *zend_ffi_free_get_debug_info(zend_object *obj, int *is_temp) /* {{{ */
{
	zend_ffi_use_after_free();
	return NULL;
}
/* }}} */

static ZEND_INI_MH(OnUpdateFFIEnable) /* {{{ */
{
	if (zend_string_equals_literal_ci(new_value, &quot;preload&quot;)) {
		FFI_G(restriction) = ZEND_FFI_PRELOAD;
	} else {
		FFI_G(restriction) = (zend_ffi_api_restriction)zend_ini_parse_bool(new_value);
	}
	return SUCCESS;
}
/* }}} */

static ZEND_INI_DISP(zend_ffi_enable_displayer_cb) /* {{{ */
{
	if (FFI_G(restriction) == ZEND_FFI_PRELOAD) {
		ZEND_PUTS(&quot;preload&quot;);
	} else if (FFI_G(restriction) == ZEND_FFI_ENABLED) {
		ZEND_PUTS(&quot;On&quot;);
	} else {
		ZEND_PUTS(&quot;Off&quot;);
	}
}
/* }}} */

ZEND_INI_BEGIN()
	ZEND_INI_ENTRY_EX(&quot;ffi.enable&quot;, &quot;preload&quot;, ZEND_INI_SYSTEM, OnUpdateFFIEnable, zend_ffi_enable_displayer_cb)
	STD_ZEND_INI_ENTRY(&quot;ffi.preload&quot;, NULL, ZEND_INI_SYSTEM, OnUpdateString, preload, zend_ffi_globals, ffi_globals)
ZEND_INI_END()

static zend_result zend_ffi_preload_glob(const char *filename) /* {{{ */
{
#ifdef HAVE_GLOB
	glob_t globbuf;
	int    ret;
	unsigned int i;

	memset(&amp;globbuf, 0, sizeof(glob_t));

	ret = glob(filename, 0, NULL, &amp;globbuf);
#ifdef GLOB_NOMATCH
	if (ret == GLOB_NOMATCH || !globbuf.gl_pathc) {
#else
	if (!globbuf.gl_pathc) {
#endif
		/* pass */
	} else {
		for(i=0 ; i&lt;globbuf.gl_pathc; i++) {
			zend_ffi *ffi = zend_ffi_load(globbuf.gl_pathv[i], 1);
			if (!ffi) {
				globfree(&amp;globbuf);
				return FAILURE;
			}
			efree(ffi);
		}
		globfree(&amp;globbuf);
	}
#else
	zend_ffi *ffi = zend_ffi_load(filename, 1);
	if (!ffi) {
		return FAILURE;
	}
	efree(ffi);
#endif

	return SUCCESS;
}
/* }}} */

static zend_result zend_ffi_preload(char *preload) /* {{{ */
{
	zend_ffi *ffi;
	char *s = NULL, *e, *filename;
	bool is_glob = 0;

	e = preload;
	while (*e) {
		switch (*e) {
			case ZEND_PATHS_SEPARATOR:
				if (s) {
					filename = estrndup(s, e-s);
					s = NULL;
					if (!is_glob) {
						ffi = zend_ffi_load(filename, 1);
						efree(filename);
						if (!ffi) {
							return FAILURE;
						}
						efree(ffi);
					} else {
						zend_result ret = zend_ffi_preload_glob(filename);

						efree(filename);
						if (ret == FAILURE) {
							return FAILURE;
						}
						is_glob = 0;
					}
				}
				break;
			case &#039;*&#039;:
			case &#039;?&#039;:
			case &#039;[&#039;:
				is_glob = 1;
				break;
			default:
				if (!s) {
					s = e;
				}
				break;
		}
		e++;
	}
	if (s) {
		filename = estrndup(s, e-s);
		if (!is_glob) {
			ffi = zend_ffi_load(filename, 1);
			efree(filename);
			if (!ffi) {
				return FAILURE;
			}
			efree(ffi);
		} else {
			zend_result ret = zend_ffi_preload_glob(filename);
			efree(filename);
			if (ret == FAILURE) {
				return FAILURE;
			}
		}
	}

	return SUCCESS;
}
/* }}} */

/* The startup code for observers adds a temporary to each function for internal use.
 * The &quot;new&quot;, &quot;cast&quot;, and &quot;type&quot; functions in FFI are both static and non-static.
 * Only the static versions are in the function table and the non-static versions are not.
 * This means the non-static versions will be skipped by the observers startup code.
 * This function fixes that by incrementing the temporary count for the non-static versions.
 */
static zend_result (*prev_zend_post_startup_cb)(void);
static zend_result ffi_fixup_temporaries(void) {
	if (ZEND_OBSERVER_ENABLED) {
		++zend_ffi_new_fn.T;
		++zend_ffi_cast_fn.T;
		++zend_ffi_type_fn.T;
	}
#ifndef ZTS
	ZEND_MAP_PTR(zend_ffi_new_fn.run_time_cache) = ZEND_MAP_PTR(((zend_internal_function *)zend_hash_str_find_ptr(&amp;zend_ffi_ce-&gt;function_table, &quot;new&quot;, sizeof(&quot;new&quot;)-1))-&gt;run_time_cache);
	ZEND_MAP_PTR(zend_ffi_cast_fn.run_time_cache) = ZEND_MAP_PTR(((zend_internal_function *)zend_hash_str_find_ptr(&amp;zend_ffi_ce-&gt;function_table, &quot;cast&quot;, sizeof(&quot;cast&quot;)-1))-&gt;run_time_cache);
	ZEND_MAP_PTR(zend_ffi_type_fn.run_time_cache) = ZEND_MAP_PTR(((zend_internal_function *)zend_hash_str_find_ptr(&amp;zend_ffi_ce-&gt;function_table, &quot;type&quot;, sizeof(&quot;type&quot;)-1))-&gt;run_time_cache);
#endif
	if (prev_zend_post_startup_cb) {
		return prev_zend_post_startup_cb();
	}
	return SUCCESS;
}

/* {{{ ZEND_MINIT_FUNCTION */
ZEND_MINIT_FUNCTION(ffi)
{
	REGISTER_INI_ENTRIES();

	FFI_G(is_cli) = strcmp(sapi_module.name, &quot;cli&quot;) == 0;

	zend_ffi_exception_ce = register_class_FFI_Exception(zend_ce_error);

	zend_ffi_parser_exception_ce = register_class_FFI_ParserException(zend_ffi_exception_ce);

	zend_ffi_ce = register_class_FFI();
	zend_ffi_ce-&gt;create_object = zend_ffi_new;
	zend_ffi_ce-&gt;default_object_handlers = &amp;zend_ffi_handlers;

	memcpy(&amp;zend_ffi_new_fn, zend_hash_str_find_ptr(&amp;zend_ffi_ce-&gt;function_table, &quot;new&quot;, sizeof(&quot;new&quot;)-1), sizeof(zend_internal_function));
	zend_ffi_new_fn.fn_flags &amp;= ~ZEND_ACC_STATIC;
	memcpy(&amp;zend_ffi_cast_fn, zend_hash_str_find_ptr(&amp;zend_ffi_ce-&gt;function_table, &quot;cast&quot;, sizeof(&quot;cast&quot;)-1), sizeof(zend_internal_function));
	zend_ffi_cast_fn.fn_flags &amp;= ~ZEND_ACC_STATIC;
	memcpy(&amp;zend_ffi_type_fn, zend_hash_str_find_ptr(&amp;zend_ffi_ce-&gt;function_table, &quot;type&quot;, sizeof(&quot;type&quot;)-1), sizeof(zend_internal_function));
	zend_ffi_type_fn.fn_flags &amp;= ~ZEND_ACC_STATIC;

	prev_zend_post_startup_cb = zend_post_startup_cb;
	zend_post_startup_cb = ffi_fixup_temporaries;

	memcpy(&amp;zend_ffi_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	zend_ffi_handlers.get_constructor      = zend_fake_get_constructor;
	zend_ffi_handlers.free_obj             = zend_ffi_free_obj;
	zend_ffi_handlers.clone_obj            = NULL;
	zend_ffi_handlers.read_property        = zend_ffi_read_var;
	zend_ffi_handlers.write_property       = zend_ffi_write_var;
	zend_ffi_handlers.read_dimension       = zend_fake_read_dimension;
	zend_ffi_handlers.write_dimension      = zend_fake_write_dimension;
	zend_ffi_handlers.get_property_ptr_ptr = zend_fake_get_property_ptr_ptr;
	zend_ffi_handlers.has_property         = zend_fake_has_property;
	zend_ffi_handlers.unset_property       = zend_fake_unset_property;
	zend_ffi_handlers.has_dimension        = zend_fake_has_dimension;
	zend_ffi_handlers.unset_dimension      = zend_fake_unset_dimension;
	zend_ffi_handlers.get_method           = zend_ffi_get_func;
	zend_ffi_handlers.compare              = zend_fake_compare_objects;
	zend_ffi_handlers.cast_object          = zend_fake_cast_object;
	zend_ffi_handlers.get_debug_info       = NULL;
	zend_ffi_handlers.get_closure          = NULL;
	zend_ffi_handlers.get_properties       = zend_fake_get_properties;
	zend_ffi_handlers.get_gc               = zend_fake_get_gc;

	zend_ffi_cdata_ce = register_class_FFI_CData();
	zend_ffi_cdata_ce-&gt;create_object = zend_ffi_cdata_new;
	zend_ffi_cdata_ce-&gt;default_object_handlers = &amp;zend_ffi_cdata_handlers;
	zend_ffi_cdata_ce-&gt;get_iterator = zend_ffi_cdata_get_iterator;

	memcpy(&amp;zend_ffi_cdata_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	zend_ffi_cdata_handlers.get_constructor      = zend_fake_get_constructor;
	zend_ffi_cdata_handlers.free_obj             = zend_ffi_cdata_free_obj;
	zend_ffi_cdata_handlers.clone_obj            = zend_ffi_cdata_clone_obj;
	zend_ffi_cdata_handlers.read_property        = zend_ffi_cdata_read_field;
	zend_ffi_cdata_handlers.write_property       = zend_ffi_cdata_write_field;
	zend_ffi_cdata_handlers.read_dimension       = zend_ffi_cdata_read_dim;
	zend_ffi_cdata_handlers.write_dimension      = zend_ffi_cdata_write_dim;
	zend_ffi_cdata_handlers.get_property_ptr_ptr = zend_fake_get_property_ptr_ptr;
	zend_ffi_cdata_handlers.has_property         = zend_fake_has_property;
	zend_ffi_cdata_handlers.unset_property       = zend_fake_unset_property;
	zend_ffi_cdata_handlers.has_dimension        = zend_fake_has_dimension;
	zend_ffi_cdata_handlers.unset_dimension      = zend_fake_unset_dimension;
	zend_ffi_cdata_handlers.get_method           = zend_fake_get_method;
	zend_ffi_cdata_handlers.get_class_name       = zend_ffi_cdata_get_class_name;
	zend_ffi_cdata_handlers.do_operation         = zend_ffi_cdata_do_operation;
	zend_ffi_cdata_handlers.compare              = zend_ffi_cdata_compare_objects;
	zend_ffi_cdata_handlers.cast_object          = zend_ffi_cdata_cast_object;
	zend_ffi_cdata_handlers.count_elements       = zend_ffi_cdata_count_elements;
	zend_ffi_cdata_handlers.get_debug_info       = zend_ffi_cdata_get_debug_info;
	zend_ffi_cdata_handlers.get_closure          = zend_ffi_cdata_get_closure;
	zend_ffi_cdata_handlers.get_properties       = zend_fake_get_properties;
	zend_ffi_cdata_handlers.get_gc               = zend_fake_get_gc;

	memcpy(&amp;zend_ffi_cdata_value_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	zend_ffi_cdata_value_handlers.get_constructor      = zend_fake_get_constructor;
	zend_ffi_cdata_value_handlers.free_obj             = zend_ffi_cdata_free_obj;
	zend_ffi_cdata_value_handlers.clone_obj            = zend_ffi_cdata_clone_obj;
	zend_ffi_cdata_value_handlers.read_property        = zend_ffi_cdata_get;
	zend_ffi_cdata_value_handlers.write_property       = zend_ffi_cdata_set;
	zend_ffi_cdata_value_handlers.read_dimension       = zend_fake_read_dimension;
	zend_ffi_cdata_value_handlers.write_dimension      = zend_fake_write_dimension;
	zend_ffi_cdata_value_handlers.get_property_ptr_ptr = zend_fake_get_property_ptr_ptr;
	zend_ffi_cdata_value_handlers.has_property         = zend_fake_has_property;
	zend_ffi_cdata_value_handlers.unset_property       = zend_fake_unset_property;
	zend_ffi_cdata_value_handlers.has_dimension        = zend_fake_has_dimension;
	zend_ffi_cdata_value_handlers.unset_dimension      = zend_fake_unset_dimension;
	zend_ffi_cdata_value_handlers.get_method           = zend_fake_get_method;
	zend_ffi_cdata_value_handlers.get_class_name       = zend_ffi_cdata_get_class_name;
	zend_ffi_cdata_value_handlers.compare              = zend_ffi_cdata_compare_objects;
	zend_ffi_cdata_value_handlers.cast_object          = zend_ffi_cdata_cast_object;
	zend_ffi_cdata_value_handlers.count_elements       = NULL;
	zend_ffi_cdata_value_handlers.get_debug_info       = zend_ffi_cdata_get_debug_info;
	zend_ffi_cdata_value_handlers.get_closure          = NULL;
	zend_ffi_cdata_value_handlers.get_properties       = zend_fake_get_properties;
	zend_ffi_cdata_value_handlers.get_gc               = zend_fake_get_gc;

	memcpy(&amp;zend_ffi_cdata_free_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	zend_ffi_cdata_free_handlers.get_constructor      = zend_fake_get_constructor;
	zend_ffi_cdata_free_handlers.free_obj             = zend_ffi_cdata_free_obj;
	zend_ffi_cdata_free_handlers.clone_obj            = zend_ffi_free_clone_obj;
	zend_ffi_cdata_free_handlers.read_property        = zend_ffi_free_read_property;
	zend_ffi_cdata_free_handlers.write_property       = zend_ffi_free_write_property;
	zend_ffi_cdata_free_handlers.read_dimension       = zend_ffi_free_read_dimension;
	zend_ffi_cdata_free_handlers.write_dimension      = zend_ffi_free_write_dimension;
	zend_ffi_cdata_free_handlers.get_property_ptr_ptr = zend_fake_get_property_ptr_ptr;
	zend_ffi_cdata_free_handlers.has_property         = zend_ffi_free_has_property;
	zend_ffi_cdata_free_handlers.unset_property       = zend_ffi_free_unset_property;
	zend_ffi_cdata_free_handlers.has_dimension        = zend_ffi_free_has_dimension;
	zend_ffi_cdata_free_handlers.unset_dimension      = zend_ffi_free_unset_dimension;
	zend_ffi_cdata_free_handlers.get_method           = zend_fake_get_method;
	zend_ffi_cdata_free_handlers.get_class_name       = zend_ffi_cdata_get_class_name;
	zend_ffi_cdata_free_handlers.compare              = zend_ffi_cdata_compare_objects;
	zend_ffi_cdata_free_handlers.cast_object          = zend_fake_cast_object;
	zend_ffi_cdata_free_handlers.count_elements       = NULL;
	zend_ffi_cdata_free_handlers.get_debug_info       = zend_ffi_free_get_debug_info;
	zend_ffi_cdata_free_handlers.get_closure          = NULL;
	zend_ffi_cdata_free_handlers.get_properties       = zend_fake_get_properties;
	zend_ffi_cdata_free_handlers.get_gc               = zend_fake_get_gc;

	zend_ffi_ctype_ce = register_class_FFI_CType();
	zend_ffi_ctype_ce-&gt;create_object = zend_ffi_ctype_new;
	zend_ffi_ctype_ce-&gt;default_object_handlers = &amp;zend_ffi_ctype_handlers;

	memcpy(&amp;zend_ffi_ctype_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
	zend_ffi_ctype_handlers.get_constructor      = zend_fake_get_constructor;
	zend_ffi_ctype_handlers.free_obj             = zend_ffi_ctype_free_obj;
	zend_ffi_ctype_handlers.clone_obj            = NULL;
	zend_ffi_ctype_handlers.read_property        = zend_fake_read_property;
	zend_ffi_ctype_handlers.write_property       = zend_fake_write_property;
	zend_ffi_ctype_handlers.read_dimension       = zend_fake_read_dimension;
	zend_ffi_ctype_handlers.write_dimension      = zend_fake_write_dimension;
	zend_ffi_ctype_handlers.get_property_ptr_ptr = zend_fake_get_property_ptr_ptr;
	zend_ffi_ctype_handlers.has_property         = zend_fake_has_property;
	zend_ffi_ctype_handlers.unset_property       = zend_fake_unset_property;
	zend_ffi_ctype_handlers.has_dimension        = zend_fake_has_dimension;
	zend_ffi_ctype_handlers.unset_dimension      = zend_fake_unset_dimension;
	//zend_ffi_ctype_handlers.get_method           = zend_fake_get_method;
	zend_ffi_ctype_handlers.get_class_name       = zend_ffi_ctype_get_class_name;
	zend_ffi_ctype_handlers.compare              = zend_ffi_ctype_compare_objects;
	zend_ffi_ctype_handlers.cast_object          = zend_fake_cast_object;
	zend_ffi_ctype_handlers.count_elements       = NULL;
	zend_ffi_ctype_handlers.get_debug_info       = zend_ffi_ctype_get_debug_info;
	zend_ffi_ctype_handlers.get_closure          = NULL;
	zend_ffi_ctype_handlers.get_properties       = zend_fake_get_properties;
	zend_ffi_ctype_handlers.get_gc               = zend_fake_get_gc;

	if (FFI_G(preload)) {
		return zend_ffi_preload(FFI_G(preload));
	}

	return SUCCESS;
}
/* }}} */

/* {{{ ZEND_RSHUTDOWN_FUNCTION */
ZEND_RSHUTDOWN_FUNCTION(ffi)
{
	if (FFI_G(callbacks)) {
		zend_hash_destroy(FFI_G(callbacks));
		efree(FFI_G(callbacks));
		FFI_G(callbacks) = NULL;
	}
	if (FFI_G(weak_types)) {
#if 0
		fprintf(stderr, &quot;WeakTypes: %d\n&quot;, zend_hash_num_elements(FFI_G(weak_types)));
#endif
		zend_hash_destroy(FFI_G(weak_types));
		efree(FFI_G(weak_types));
		FFI_G(weak_types) = NULL;
	}
	return SUCCESS;
}
/* }}} */

/* {{{ ZEND_MINFO_FUNCTION */
ZEND_MINFO_FUNCTION(ffi)
{
	php_info_print_table_start();
	php_info_print_table_row(2, &quot;FFI support&quot;, &quot;enabled&quot;);
	php_info_print_table_end();

	DISPLAY_INI_ENTRIES();
}
/* }}} */

static const zend_ffi_type zend_ffi_type_void = {.kind=ZEND_FFI_TYPE_VOID, .size=1, .align=1};
static const zend_ffi_type zend_ffi_type_char = {.kind=ZEND_FFI_TYPE_CHAR, .size=1, .align=_Alignof(char)};
static const zend_ffi_type zend_ffi_type_bool = {.kind=ZEND_FFI_TYPE_BOOL, .size=1, .align=_Alignof(uint8_t)};
static const zend_ffi_type zend_ffi_type_sint8 = {.kind=ZEND_FFI_TYPE_SINT8, .size=1, .align=_Alignof(int8_t)};
static const zend_ffi_type zend_ffi_type_uint8 = {.kind=ZEND_FFI_TYPE_UINT8, .size=1, .align=_Alignof(uint8_t)};
static const zend_ffi_type zend_ffi_type_sint16 = {.kind=ZEND_FFI_TYPE_SINT16, .size=2, .align=_Alignof(int16_t)};
static const zend_ffi_type zend_ffi_type_uint16 = {.kind=ZEND_FFI_TYPE_UINT16, .size=2, .align=_Alignof(uint16_t)};
static const zend_ffi_type zend_ffi_type_sint32 = {.kind=ZEND_FFI_TYPE_SINT32, .size=4, .align=_Alignof(int32_t)};
static const zend_ffi_type zend_ffi_type_uint32 = {.kind=ZEND_FFI_TYPE_UINT32, .size=4, .align=_Alignof(uint32_t)};
static const zend_ffi_type zend_ffi_type_sint64 = {.kind=ZEND_FFI_TYPE_SINT64, .size=8, .align=_Alignof(int64_t)};
static const zend_ffi_type zend_ffi_type_uint64 = {.kind=ZEND_FFI_TYPE_UINT64, .size=8, .align=_Alignof(uint64_t)};
static const zend_ffi_type zend_ffi_type_float = {.kind=ZEND_FFI_TYPE_FLOAT, .size=sizeof(float), .align=_Alignof(float)};
static const zend_ffi_type zend_ffi_type_double = {.kind=ZEND_FFI_TYPE_DOUBLE, .size=sizeof(double), .align=_Alignof(double)};

#ifdef HAVE_LONG_DOUBLE
static const zend_ffi_type zend_ffi_type_long_double = {.kind=ZEND_FFI_TYPE_LONGDOUBLE, .size=sizeof(long double), .align=_Alignof(long double)};
#endif

static const zend_ffi_type zend_ffi_type_ptr = {.kind=ZEND_FFI_TYPE_POINTER, .size=sizeof(void*), .align=_Alignof(void*), .pointer.type = (zend_ffi_type*)&amp;zend_ffi_type_void};

static const struct {
	const char *name;
	const zend_ffi_type *type;
} zend_ffi_types[] = {
	{&quot;void&quot;,        &amp;zend_ffi_type_void},
	{&quot;char&quot;,        &amp;zend_ffi_type_char},
	{&quot;bool&quot;,        &amp;zend_ffi_type_bool},
	{&quot;int8_t&quot;,      &amp;zend_ffi_type_sint8},
	{&quot;uint8_t&quot;,     &amp;zend_ffi_type_uint8},
	{&quot;int16_t&quot;,     &amp;zend_ffi_type_sint16},
	{&quot;uint16_t&quot;,    &amp;zend_ffi_type_uint16},
	{&quot;int32_t&quot;,     &amp;zend_ffi_type_sint32},
	{&quot;uint32_t&quot;,    &amp;zend_ffi_type_uint32},
	{&quot;int64_t&quot;,     &amp;zend_ffi_type_sint64},
	{&quot;uint64_t&quot;,    &amp;zend_ffi_type_uint64},
	{&quot;float&quot;,       &amp;zend_ffi_type_float},
	{&quot;double&quot;,      &amp;zend_ffi_type_double},
#ifdef HAVE_LONG_DOUBLE
	{&quot;long double&quot;, &amp;zend_ffi_type_long_double},
#endif
#if SIZEOF_SIZE_T == 4
	{&quot;uintptr_t&quot;,  &amp;zend_ffi_type_uint32},
	{&quot;intptr_t&quot;,   &amp;zend_ffi_type_sint32},
	{&quot;size_t&quot;,     &amp;zend_ffi_type_uint32},
	{&quot;ssize_t&quot;,    &amp;zend_ffi_type_sint32},
	{&quot;ptrdiff_t&quot;,  &amp;zend_ffi_type_sint32},
#else
	{&quot;uintptr_t&quot;,  &amp;zend_ffi_type_uint64},
	{&quot;intptr_t&quot;,   &amp;zend_ffi_type_sint64},
	{&quot;size_t&quot;,     &amp;zend_ffi_type_uint64},
	{&quot;ssize_t&quot;,    &amp;zend_ffi_type_sint64},
	{&quot;ptrdiff_t&quot;,  &amp;zend_ffi_type_sint64},
#endif
#if SIZEOF_OFF_T == 4
	{&quot;off_t&quot;,      &amp;zend_ffi_type_sint32},
#else
	{&quot;off_t&quot;,      &amp;zend_ffi_type_sint64},
#endif

	{&quot;va_list&quot;,           &amp;zend_ffi_type_ptr},
	{&quot;__builtin_va_list&quot;, &amp;zend_ffi_type_ptr},
	{&quot;__gnuc_va_list&quot;,    &amp;zend_ffi_type_ptr},
};

/* {{{ ZEND_GINIT_FUNCTION */
static ZEND_GINIT_FUNCTION(ffi)
{
	size_t i;

#if defined(COMPILE_DL_FFI) &amp;&amp; defined(ZTS)
	ZEND_TSRMLS_CACHE_UPDATE();
#endif
	memset(ffi_globals, 0, sizeof(*ffi_globals));
	zend_hash_init(&amp;ffi_globals-&gt;types, 0, NULL, NULL, 1);
	for (i = 0; i &lt; sizeof(zend_ffi_types)/sizeof(zend_ffi_types[0]); i++) {
		zend_hash_str_add_new_ptr(&amp;ffi_globals-&gt;types, zend_ffi_types[i].name, strlen(zend_ffi_types[i].name), (void*)zend_ffi_types[i].type);
	}
}
/* }}} */

/* {{{ ZEND_GINIT_FUNCTION */
static ZEND_GSHUTDOWN_FUNCTION(ffi)
{
	if (ffi_globals-&gt;scopes) {
		zend_hash_destroy(ffi_globals-&gt;scopes);
		free(ffi_globals-&gt;scopes);
	}
	zend_hash_destroy(&amp;ffi_globals-&gt;types);
}
/* }}} */

/* {{{ ffi_module_entry */
zend_module_entry ffi_module_entry = {
	STANDARD_MODULE_HEADER,
	&quot;FFI&quot;,					/* Extension name */
	NULL,					/* zend_function_entry */
	ZEND_MINIT(ffi),		/* ZEND_MINIT - Module initialization */
	NULL,					/* ZEND_MSHUTDOWN - Module shutdown */
	NULL,					/* ZEND_RINIT - Request initialization */
	ZEND_RSHUTDOWN(ffi),	/* ZEND_RSHUTDOWN - Request shutdown */
	ZEND_MINFO(ffi),		/* ZEND_MINFO - Module info */
	PHP_VERSION,			/* Version */
	ZEND_MODULE_GLOBALS(ffi),
	ZEND_GINIT(ffi),
	ZEND_GSHUTDOWN(ffi),
	NULL,
	STANDARD_MODULE_PROPERTIES_EX
};
/* }}} */

#ifdef COMPILE_DL_FFI
# ifdef ZTS
ZEND_TSRMLS_CACHE_DEFINE()
# endif
ZEND_GET_MODULE(ffi)
#endif

/* parser callbacks */
void zend_ffi_parser_error(const char *format, ...) /* {{{ */
{
	va_list va;
	char *message = NULL;

	va_start(va, format);
	zend_vspprintf(&amp;message, 0, format, va);

	if (EG(current_execute_data)) {
		zend_throw_exception(zend_ffi_parser_exception_ce, message, 0);
	} else {
		zend_error(E_WARNING, &quot;FFI Parser: %s&quot;, message);
	}

	efree(message);
	va_end(va);

	LONGJMP(FFI_G(bailout), FAILURE);
}
/* }}} */

static void zend_ffi_finalize_type(zend_ffi_dcl *dcl) /* {{{ */
{
	if (!dcl-&gt;type) {
		switch (dcl-&gt;flags &amp; ZEND_FFI_DCL_TYPE_SPECIFIERS) {
			case ZEND_FFI_DCL_VOID:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_void;
				break;
			case ZEND_FFI_DCL_CHAR:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_char;
				break;
			case ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_SIGNED:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_sint8;
				break;
			case ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_UNSIGNED:
			case ZEND_FFI_DCL_BOOL:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_uint8;
				break;
			case ZEND_FFI_DCL_SHORT:
			case ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_SIGNED:
			case ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_INT:
			case ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_SIGNED|ZEND_FFI_DCL_INT:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_sint16;
				break;
			case ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_UNSIGNED:
			case ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_UNSIGNED|ZEND_FFI_DCL_INT:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_uint16;
				break;
			case ZEND_FFI_DCL_INT:
			case ZEND_FFI_DCL_SIGNED:
			case ZEND_FFI_DCL_SIGNED|ZEND_FFI_DCL_INT:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_sint32;
				break;
			case ZEND_FFI_DCL_UNSIGNED:
			case ZEND_FFI_DCL_UNSIGNED|ZEND_FFI_DCL_INT:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_uint32;
				break;
			case ZEND_FFI_DCL_LONG:
			case ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_SIGNED:
			case ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_INT:
			case ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_SIGNED|ZEND_FFI_DCL_INT:
				if (sizeof(long) == 4) {
					dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_sint32;
				} else {
					dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_sint64;
				}
				break;
			case ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_UNSIGNED:
			case ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_UNSIGNED|ZEND_FFI_DCL_INT:
				if (sizeof(long) == 4) {
					dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_uint32;
				} else {
					dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_uint64;
				}
				break;
			case ZEND_FFI_DCL_LONG_LONG|ZEND_FFI_DCL_LONG:
			case ZEND_FFI_DCL_LONG_LONG|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_SIGNED:
			case ZEND_FFI_DCL_LONG_LONG|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_INT:
			case ZEND_FFI_DCL_LONG_LONG|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_SIGNED|ZEND_FFI_DCL_INT:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_sint64;
				break;
			case ZEND_FFI_DCL_LONG_LONG|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_UNSIGNED:
			case ZEND_FFI_DCL_LONG_LONG|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_UNSIGNED|ZEND_FFI_DCL_INT:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_uint64;
				break;
			case ZEND_FFI_DCL_FLOAT:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_float;
				break;
			case ZEND_FFI_DCL_DOUBLE:
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_double;
				break;
			case ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_DOUBLE:
#ifdef _WIN32
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_double;
#else
				dcl-&gt;type = (zend_ffi_type*)&amp;zend_ffi_type_long_double;
#endif
				break;
			case ZEND_FFI_DCL_FLOAT|ZEND_FFI_DCL_COMPLEX:
			case ZEND_FFI_DCL_DOUBLE|ZEND_FFI_DCL_COMPLEX:
			case ZEND_FFI_DCL_DOUBLE|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_COMPLEX:
				zend_ffi_parser_error(&quot;Unsupported type _Complex at line %d&quot;, FFI_G(line));
				break;
			default:
				zend_ffi_parser_error(&quot;Unsupported type specifier combination at line %d&quot;, FFI_G(line));
				break;
		}
		dcl-&gt;flags &amp;= ~ZEND_FFI_DCL_TYPE_SPECIFIERS;
		dcl-&gt;flags |= ZEND_FFI_DCL_TYPEDEF_NAME;
	}
}
/* }}} */

bool zend_ffi_is_typedef_name(const char *name, size_t name_len) /* {{{ */
{
	zend_ffi_symbol *sym;
	zend_ffi_type *type;

	if (FFI_G(symbols)) {
		sym = zend_hash_str_find_ptr(FFI_G(symbols), name, name_len);
		if (sym) {
			return (sym-&gt;kind == ZEND_FFI_SYM_TYPE);
		}
	}
	type = zend_hash_str_find_ptr(&amp;FFI_G(types), name, name_len);
	if (type) {
		return 1;
	}
	return 0;
}
/* }}} */

void zend_ffi_resolve_typedef(const char *name, size_t name_len, zend_ffi_dcl *dcl) /* {{{ */
{
	zend_ffi_symbol *sym;
	zend_ffi_type *type;

	if (FFI_G(symbols)) {
		sym = zend_hash_str_find_ptr(FFI_G(symbols), name, name_len);
		if (sym &amp;&amp; sym-&gt;kind == ZEND_FFI_SYM_TYPE) {
			dcl-&gt;type = ZEND_FFI_TYPE(sym-&gt;type);
			if (sym-&gt;is_const) {
				dcl-&gt;attr |= ZEND_FFI_ATTR_CONST;
			}
			return;
		}
	}
	type = zend_hash_str_find_ptr(&amp;FFI_G(types), name, name_len);
	if (type) {
		dcl-&gt;type = type;
		return;
	}
	zend_ffi_parser_error(&quot;Undefined C type \&quot;%.*s\&quot; at line %d&quot;, name_len, name, FFI_G(line));
}
/* }}} */

void zend_ffi_resolve_const(const char *name, size_t name_len, zend_ffi_val *val) /* {{{ */
{
	zend_ffi_symbol *sym;

	if (UNEXPECTED(FFI_G(attribute_parsing))) {
		val-&gt;kind = ZEND_FFI_VAL_NAME;
		val-&gt;str = name;
		val-&gt;len = name_len;
		return;
	} else if (FFI_G(symbols)) {
		sym = zend_hash_str_find_ptr(FFI_G(symbols), name, name_len);
		if (sym &amp;&amp; sym-&gt;kind == ZEND_FFI_SYM_CONST) {
			val-&gt;i64 = sym-&gt;value;
			switch (sym-&gt;type-&gt;kind) {
				case ZEND_FFI_TYPE_SINT8:
				case ZEND_FFI_TYPE_SINT16:
				case ZEND_FFI_TYPE_SINT32:
					val-&gt;kind = ZEND_FFI_VAL_INT32;
					break;
				case ZEND_FFI_TYPE_SINT64:
					val-&gt;kind = ZEND_FFI_VAL_INT64;
					break;
				case ZEND_FFI_TYPE_UINT8:
				case ZEND_FFI_TYPE_UINT16:
				case ZEND_FFI_TYPE_UINT32:
					val-&gt;kind = ZEND_FFI_VAL_UINT32;
					break;
				case ZEND_FFI_TYPE_UINT64:
					val-&gt;kind = ZEND_FFI_VAL_UINT64;
					break;
				default:
					ZEND_UNREACHABLE();
			}
			return;
		}
	}
	val-&gt;kind = ZEND_FFI_VAL_ERROR;
}
/* }}} */

void zend_ffi_make_enum_type(zend_ffi_dcl *dcl) /* {{{ */
{
	zend_ffi_type *type = pemalloc(sizeof(zend_ffi_type), FFI_G(persistent));
	type-&gt;kind = ZEND_FFI_TYPE_ENUM;
	type-&gt;attr = FFI_G(default_type_attr) | (dcl-&gt;attr &amp; ZEND_FFI_ENUM_ATTRS);
	type-&gt;enumeration.tag_name = NULL;
	if (type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED) {
		type-&gt;size = zend_ffi_type_uint8.size;
		type-&gt;align = zend_ffi_type_uint8.align;
		type-&gt;enumeration.kind = ZEND_FFI_TYPE_UINT8;
	} else {
		type-&gt;size = zend_ffi_type_uint32.size;
		type-&gt;align = zend_ffi_type_uint32.align;
		type-&gt;enumeration.kind = ZEND_FFI_TYPE_UINT32;
	}
	dcl-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(type);
	dcl-&gt;attr &amp;= ~ZEND_FFI_ENUM_ATTRS;
}
/* }}} */

void zend_ffi_add_enum_val(zend_ffi_dcl *enum_dcl, const char *name, size_t name_len, zend_ffi_val *val, int64_t *min, int64_t *max, int64_t *last) /* {{{ */
{
	zend_ffi_symbol *sym;
	const zend_ffi_type *sym_type;
	int64_t value;
	zend_ffi_type *enum_type = ZEND_FFI_TYPE(enum_dcl-&gt;type);
	bool overflow = 0;
	bool is_signed =
		(enum_type-&gt;enumeration.kind == ZEND_FFI_TYPE_SINT8 ||
		 enum_type-&gt;enumeration.kind == ZEND_FFI_TYPE_SINT16 ||
		 enum_type-&gt;enumeration.kind == ZEND_FFI_TYPE_SINT32 ||
		 enum_type-&gt;enumeration.kind == ZEND_FFI_TYPE_SINT64);

	ZEND_ASSERT(enum_type &amp;&amp; enum_type-&gt;kind == ZEND_FFI_TYPE_ENUM);
	if (val-&gt;kind == ZEND_FFI_VAL_EMPTY) {
		if (is_signed) {
			if (*last == 0x7FFFFFFFFFFFFFFFLL) {
				overflow = 1;
			}
		} else {
			if ((*min != 0 || *max != 0)
			 &amp;&amp; (uint64_t)*last == 0xFFFFFFFFFFFFFFFFULL) {
				overflow = 1;
			}
		}
		value = *last + 1;
	} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
		if (!is_signed &amp;&amp; val-&gt;ch &lt; 0) {
			if ((uint64_t)*max &gt; 0x7FFFFFFFFFFFFFFFULL) {
				overflow = 1;
			} else {
				is_signed = 1;
			}
		}
		value = val-&gt;ch;
	} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
		if (!is_signed &amp;&amp; val-&gt;i64 &lt; 0) {
			if ((uint64_t)*max &gt; 0x7FFFFFFFFFFFFFFFULL) {
				overflow = 1;
			} else {
				is_signed = 1;
			}
		}
		value = val-&gt;i64;
	} else if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) {
		if (is_signed &amp;&amp; val-&gt;u64 &gt; 0x7FFFFFFFFFFFFFFFULL) {
			overflow = 1;
		}
		value = val-&gt;u64;
	} else {
		zend_ffi_parser_error(&quot;Enumerator value \&quot;%.*s\&quot; must be an integer at line %d&quot;, name_len, name, FFI_G(line));
		return;
	}

	if (overflow) {
		zend_ffi_parser_error(&quot;Overflow in enumeration values \&quot;%.*s\&quot; at line %d&quot;, name_len, name, FFI_G(line));
		return;
	}

	if (is_signed) {
		*min = MIN(*min, value);
		*max = MAX(*max, value);
		if ((enum_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED)
		 &amp;&amp; *min &gt;= -0x7FLL-1 &amp;&amp; *max &lt;= 0x7FLL) {
			sym_type = &amp;zend_ffi_type_sint8;
		} else if ((enum_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED)
		 &amp;&amp; *min &gt;= -0x7FFFLL-1 &amp;&amp; *max &lt;= 0x7FFFLL) {
			sym_type = &amp;zend_ffi_type_sint16;
		} else if (*min &gt;= -0x7FFFFFFFLL-1 &amp;&amp; *max &lt;= 0x7FFFFFFFLL) {
			sym_type = &amp;zend_ffi_type_sint32;
		} else {
			sym_type = &amp;zend_ffi_type_sint64;
		}
	} else {
		*min = MIN((uint64_t)*min, (uint64_t)value);
		*max = MAX((uint64_t)*max, (uint64_t)value);
		if ((enum_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED)
		 &amp;&amp; (uint64_t)*max &lt;= 0xFFULL) {
			sym_type = &amp;zend_ffi_type_uint8;
		} else if ((enum_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED)
		 &amp;&amp; (uint64_t)*max &lt;= 0xFFFFULL) {
			sym_type = &amp;zend_ffi_type_uint16;
		} else if ((uint64_t)*max &lt;= 0xFFFFFFFFULL) {
			sym_type = &amp;zend_ffi_type_uint32;
		} else {
			sym_type = &amp;zend_ffi_type_uint64;
		}
	}
	enum_type-&gt;enumeration.kind = sym_type-&gt;kind;
	enum_type-&gt;size = sym_type-&gt;size;
	enum_type-&gt;align = sym_type-&gt;align;
	*last = value;

	if (!FFI_G(symbols)) {
		FFI_G(symbols) = pemalloc(sizeof(HashTable), FFI_G(persistent));
		zend_hash_init(FFI_G(symbols), 0, NULL, FFI_G(persistent) ? zend_ffi_symbol_hash_persistent_dtor : zend_ffi_symbol_hash_dtor, FFI_G(persistent));
	}
	sym = zend_hash_str_find_ptr(FFI_G(symbols), name, name_len);
	if (sym) {
		zend_ffi_parser_error(&quot;Redeclaration of \&quot;%.*s\&quot; at line %d&quot;, name_len, name, FFI_G(line));
	} else {
		sym = pemalloc(sizeof(zend_ffi_symbol), FFI_G(persistent));
		sym-&gt;kind  = ZEND_FFI_SYM_CONST;
		sym-&gt;type  = (zend_ffi_type*)sym_type;
		sym-&gt;value = value;
		zend_hash_str_add_new_ptr(FFI_G(symbols), name, name_len, sym);
	}
}
/* }}} */

void zend_ffi_make_struct_type(zend_ffi_dcl *dcl) /* {{{ */
{
	zend_ffi_type *type = pemalloc(sizeof(zend_ffi_type), FFI_G(persistent));
	type-&gt;kind = ZEND_FFI_TYPE_STRUCT;
	type-&gt;attr = FFI_G(default_type_attr) | (dcl-&gt;attr &amp; ZEND_FFI_STRUCT_ATTRS);
	type-&gt;size = 0;
	type-&gt;align = dcl-&gt;align &gt; 1 ? dcl-&gt;align : 1;
	if (dcl-&gt;flags &amp; ZEND_FFI_DCL_UNION) {
		type-&gt;attr |= ZEND_FFI_ATTR_UNION;
	}
	dcl-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(type);
	type-&gt;record.tag_name = NULL;
	zend_hash_init(&amp;type-&gt;record.fields, 0, NULL, FFI_G(persistent) ? zend_ffi_field_hash_persistent_dtor :zend_ffi_field_hash_dtor, FFI_G(persistent));
	dcl-&gt;attr &amp;= ~ZEND_FFI_STRUCT_ATTRS;
	dcl-&gt;align = 0;
}
/* }}} */

static zend_result zend_ffi_validate_prev_field_type(zend_ffi_type *struct_type) /* {{{ */
{
	if (zend_hash_num_elements(&amp;struct_type-&gt;record.fields) &gt; 0) {
		zend_ffi_field *field = NULL;

		ZEND_HASH_MAP_REVERSE_FOREACH_PTR(&amp;struct_type-&gt;record.fields, field) {
			break;
		} ZEND_HASH_FOREACH_END();
		if (ZEND_FFI_TYPE(field-&gt;type)-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_ARRAY) {
			zend_ffi_throw_parser_error(&quot;Flexible array member not at end of struct at line %d&quot;, FFI_G(line));
			return FAILURE;
		}
	}
	return SUCCESS;
}
/* }}} */

static zend_result zend_ffi_validate_field_type(zend_ffi_type *type, zend_ffi_type *struct_type) /* {{{ */
{
	if (type == struct_type) {
		zend_ffi_throw_parser_error(&quot;Struct/union can&#039;t contain an instance of itself at line %d&quot;, FFI_G(line));
		return FAILURE;
	} else if (zend_ffi_validate_var_type(type, 1) == FAILURE) {
		return FAILURE;
	} else if (struct_type-&gt;attr &amp; ZEND_FFI_ATTR_UNION) {
		if (type-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_ARRAY) {
			zend_ffi_throw_parser_error(&quot;Flexible array member in union at line %d&quot;, FFI_G(line));
			return FAILURE;
		}
	}
	return zend_ffi_validate_prev_field_type(struct_type);
}
/* }}} */

void zend_ffi_add_field(zend_ffi_dcl *struct_dcl, const char *name, size_t name_len, zend_ffi_dcl *field_dcl) /* {{{ */
{
	zend_ffi_field *field;
	zend_ffi_type *struct_type = ZEND_FFI_TYPE(struct_dcl-&gt;type);
	zend_ffi_type *field_type;

	ZEND_ASSERT(struct_type &amp;&amp; struct_type-&gt;kind == ZEND_FFI_TYPE_STRUCT);
	zend_ffi_finalize_type(field_dcl);
	field_type = ZEND_FFI_TYPE(field_dcl-&gt;type);
	if (zend_ffi_validate_field_type(field_type, struct_type) == FAILURE) {
		zend_ffi_cleanup_dcl(field_dcl);
		LONGJMP(FFI_G(bailout), FAILURE);
	}

	field = pemalloc(sizeof(zend_ffi_field), FFI_G(persistent));
	if (!(struct_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED) &amp;&amp; !(field_dcl-&gt;attr &amp; ZEND_FFI_ATTR_PACKED)) {
		struct_type-&gt;align = MAX(struct_type-&gt;align, MAX(field_type-&gt;align, field_dcl-&gt;align));
	}
	if (struct_type-&gt;attr &amp; ZEND_FFI_ATTR_UNION) {
		field-&gt;offset = 0;
		struct_type-&gt;size = MAX(struct_type-&gt;size, field_type-&gt;size);
	} else {
		if (!(struct_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED) &amp;&amp; !(field_dcl-&gt;attr &amp; ZEND_FFI_ATTR_PACKED)) {
			uint32_t field_align = MAX(field_type-&gt;align, field_dcl-&gt;align);
			struct_type-&gt;size = ((struct_type-&gt;size + (field_align - 1)) / field_align) * field_align;
		}
		field-&gt;offset = struct_type-&gt;size;
		struct_type-&gt;size += field_type-&gt;size;
	}
	field-&gt;type = field_dcl-&gt;type;
	field-&gt;is_const = (bool)(field_dcl-&gt;attr &amp; ZEND_FFI_ATTR_CONST);
	field-&gt;is_nested = 0;
	field-&gt;first_bit = 0;
	field-&gt;bits = 0;
	field_dcl-&gt;type = field_type; /* reset &quot;owned&quot; flag */

	if (!zend_hash_str_add_ptr(&amp;struct_type-&gt;record.fields, name, name_len, field)) {
		zend_ffi_type_dtor(field-&gt;type);
		pefree(field, FFI_G(persistent));
		zend_ffi_parser_error(&quot;Duplicate field name \&quot;%.*s\&quot; at line %d&quot;, name_len, name, FFI_G(line));
	}
}
/* }}} */

void zend_ffi_add_anonymous_field(zend_ffi_dcl *struct_dcl, zend_ffi_dcl *field_dcl) /* {{{ */
{
	zend_ffi_type *struct_type = ZEND_FFI_TYPE(struct_dcl-&gt;type);
	zend_ffi_type *field_type;
	zend_ffi_field *field;
	zend_string *key;

	ZEND_ASSERT(struct_type &amp;&amp; struct_type-&gt;kind == ZEND_FFI_TYPE_STRUCT);
	zend_ffi_finalize_type(field_dcl);
	field_type = ZEND_FFI_TYPE(field_dcl-&gt;type);
	if (field_type-&gt;kind != ZEND_FFI_TYPE_STRUCT) {
		zend_ffi_cleanup_dcl(field_dcl);
		zend_ffi_parser_error(&quot;Declaration does not declare anything at line %d&quot;, FFI_G(line));
		return;
	}

	if (!(struct_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED) &amp;&amp; !(field_dcl-&gt;attr &amp; ZEND_FFI_ATTR_PACKED)) {
		struct_type-&gt;align = MAX(struct_type-&gt;align, MAX(field_type-&gt;align, field_dcl-&gt;align));
	}
	if (!(struct_type-&gt;attr &amp; ZEND_FFI_ATTR_UNION)) {
		if (zend_ffi_validate_prev_field_type(struct_type) == FAILURE) {
			zend_ffi_cleanup_dcl(field_dcl);
			LONGJMP(FFI_G(bailout), FAILURE);
		}
		if (!(struct_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED) &amp;&amp; !(field_dcl-&gt;attr &amp; ZEND_FFI_ATTR_PACKED)) {
			uint32_t field_align = MAX(field_type-&gt;align, field_dcl-&gt;align);
			struct_type-&gt;size = ((struct_type-&gt;size + (field_align - 1)) / field_align) * field_align;
		}
	}

	ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&amp;field_type-&gt;record.fields, key, field) {
		zend_ffi_field *new_field = pemalloc(sizeof(zend_ffi_field), FFI_G(persistent));

		if (struct_type-&gt;attr &amp; ZEND_FFI_ATTR_UNION) {
			new_field-&gt;offset = field-&gt;offset;
		} else {
			new_field-&gt;offset = struct_type-&gt;size + field-&gt;offset;
		}
		new_field-&gt;type = field-&gt;type;
		new_field-&gt;is_const = field-&gt;is_const;
		new_field-&gt;is_nested = 1;
		new_field-&gt;first_bit = field-&gt;first_bit;
		new_field-&gt;bits = field-&gt;bits;
		field-&gt;type = ZEND_FFI_TYPE(field-&gt;type); /* reset &quot;owned&quot; flag */

		if (key) {
			if (!zend_hash_add_ptr(&amp;struct_type-&gt;record.fields, key, new_field)) {
				zend_ffi_type_dtor(new_field-&gt;type);
				pefree(new_field, FFI_G(persistent));
				zend_ffi_parser_error(&quot;Duplicate field name \&quot;%s\&quot; at line %d&quot;, ZSTR_VAL(key), FFI_G(line));
				return;
			}
		} else {
			zend_hash_next_index_insert_ptr(&amp;struct_type-&gt;record.fields, field);
		}
	} ZEND_HASH_FOREACH_END();

	if (struct_type-&gt;attr &amp; ZEND_FFI_ATTR_UNION) {
		struct_type-&gt;size = MAX(struct_type-&gt;size, field_type-&gt;size);
	} else {
		struct_type-&gt;size += field_type-&gt;size;
	}

	zend_ffi_type_dtor(field_dcl-&gt;type);
	field_dcl-&gt;type = NULL;
}
/* }}} */

void zend_ffi_add_bit_field(zend_ffi_dcl *struct_dcl, const char *name, size_t name_len, zend_ffi_dcl *field_dcl, zend_ffi_val *bits) /* {{{ */
{
	zend_ffi_type *struct_type = ZEND_FFI_TYPE(struct_dcl-&gt;type);
	zend_ffi_type *field_type;
	zend_ffi_field *field;

	ZEND_ASSERT(struct_type &amp;&amp; struct_type-&gt;kind == ZEND_FFI_TYPE_STRUCT);
	zend_ffi_finalize_type(field_dcl);
	field_type = ZEND_FFI_TYPE(field_dcl-&gt;type);
	if (zend_ffi_validate_field_type(field_type, struct_type) == FAILURE) {
		zend_ffi_cleanup_dcl(field_dcl);
		LONGJMP(FFI_G(bailout), FAILURE);
	}

	if (field_type-&gt;kind &lt; ZEND_FFI_TYPE_UINT8 || field_type-&gt;kind &gt; ZEND_FFI_TYPE_BOOL) {
		zend_ffi_cleanup_dcl(field_dcl);
		zend_ffi_parser_error(&quot;Wrong type of bit field \&quot;%.*s\&quot; at line %d&quot;, name ? name_len : sizeof(&quot;&lt;anonymous&gt;&quot;)-1, name ? name : &quot;&lt;anonymous&gt;&quot;, FFI_G(line));
	}

	if (bits-&gt;kind == ZEND_FFI_VAL_INT32 || bits-&gt;kind == ZEND_FFI_VAL_INT64) {
		if (bits-&gt;i64 &lt; 0) {
			zend_ffi_cleanup_dcl(field_dcl);
			zend_ffi_parser_error(&quot;Negative width in bit-field \&quot;%.*s\&quot; at line %d&quot;, name ? name_len : sizeof(&quot;&lt;anonymous&gt;&quot;)-1, name ? name : &quot;&lt;anonymous&gt;&quot;, FFI_G(line));
		} else if (bits-&gt;i64 == 0) {
			zend_ffi_cleanup_dcl(field_dcl);
			if (name) {
				zend_ffi_parser_error(&quot;Zero width in bit-field \&quot;%.*s\&quot; at line %d&quot;, name ? name_len : sizeof(&quot;&lt;anonymous&gt;&quot;)-1, name ? name : &quot;&lt;anonymous&gt;&quot;, FFI_G(line));
			}
			return;
		} else if (bits-&gt;i64 &gt; field_type-&gt;size * 8) {
			zend_ffi_cleanup_dcl(field_dcl);
			zend_ffi_parser_error(&quot;Width of \&quot;%.*s\&quot; exceeds its type at line %d&quot;, name ? name_len : sizeof(&quot;&lt;anonymous&gt;&quot;)-1, name ? name : &quot;&lt;anonymous&gt;&quot;, FFI_G(line));
		}
	} else if (bits-&gt;kind == ZEND_FFI_VAL_UINT32 || bits-&gt;kind == ZEND_FFI_VAL_UINT64) {
		if (bits-&gt;u64 == 0) {
			zend_ffi_cleanup_dcl(field_dcl);
			if (name) {
				zend_ffi_parser_error(&quot;Zero width in bit-field \&quot;%.*s\&quot; at line %d&quot;, name ? name_len : sizeof(&quot;&lt;anonymous&gt;&quot;)-1, name ? name : &quot;&lt;anonymous&gt;&quot;, FFI_G(line));
			}
			return;
		} else if (bits-&gt;u64 &gt; field_type-&gt;size * 8) {
			zend_ffi_cleanup_dcl(field_dcl);
			zend_ffi_parser_error(&quot;Width of \&quot;%.*s\&quot; exceeds its type at line %d&quot;, name ? name_len : sizeof(&quot;&lt;anonymous&gt;&quot;)-1, name ? name : &quot;&lt;anonymous&gt;&quot;, FFI_G(line));
		}
	} else {
		zend_ffi_cleanup_dcl(field_dcl);
		zend_ffi_parser_error(&quot;Bit field \&quot;%.*s\&quot; width not an integer constant at line %d&quot;, name ? name_len : sizeof(&quot;&lt;anonymous&gt;&quot;)-1, name ? name : &quot;&lt;anonymous&gt;&quot;, FFI_G(line));
	}

	field = pemalloc(sizeof(zend_ffi_field), FFI_G(persistent));
	if (!(struct_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED)) {
		struct_type-&gt;align = MAX(struct_type-&gt;align, sizeof(uint32_t));
	}
	if (struct_type-&gt;attr &amp; ZEND_FFI_ATTR_UNION) {
		field-&gt;offset = 0;
		field-&gt;first_bit = 0;
		field-&gt;bits = bits-&gt;u64;
		if (struct_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED) {
			struct_type-&gt;size = MAX(struct_type-&gt;size, (bits-&gt;u64 + 7) / 8);
		} else {
			struct_type-&gt;size = MAX(struct_type-&gt;size, ((bits-&gt;u64 + 31) / 32) * 4);
		}
	} else {
		zend_ffi_field *prev_field = NULL;

		if (zend_hash_num_elements(&amp;struct_type-&gt;record.fields) &gt; 0) {
			ZEND_HASH_MAP_REVERSE_FOREACH_PTR(&amp;struct_type-&gt;record.fields, prev_field) {
				break;
			} ZEND_HASH_FOREACH_END();
		}
		if (prev_field &amp;&amp; prev_field-&gt;bits) {
			field-&gt;offset = prev_field-&gt;offset;
			field-&gt;first_bit = prev_field-&gt;first_bit + prev_field-&gt;bits;
			field-&gt;bits = bits-&gt;u64;
		} else {
			field-&gt;offset = struct_type-&gt;size;
			field-&gt;first_bit = 0;
			field-&gt;bits = bits-&gt;u64;
		}
		if (struct_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED) {
			struct_type-&gt;size = field-&gt;offset + ((field-&gt;first_bit + field-&gt;bits) + 7) / 8;
		} else {
			struct_type-&gt;size = field-&gt;offset + (((field-&gt;first_bit + field-&gt;bits) + 31) / 32) * 4;
		}
	}
	field-&gt;type = field_dcl-&gt;type;
	field-&gt;is_const = (bool)(field_dcl-&gt;attr &amp; ZEND_FFI_ATTR_CONST);
	field-&gt;is_nested = 0;
	field_dcl-&gt;type = field_type; /* reset &quot;owned&quot; flag */

	if (name) {
		if (!zend_hash_str_add_ptr(&amp;struct_type-&gt;record.fields, name, name_len, field)) {
			zend_ffi_type_dtor(field-&gt;type);
			pefree(field, FFI_G(persistent));
			zend_ffi_parser_error(&quot;Duplicate field name \&quot;%.*s\&quot; at line %d&quot;, name_len, name, FFI_G(line));
		}
	} else {
		zend_hash_next_index_insert_ptr(&amp;struct_type-&gt;record.fields, field);
	}
}
/* }}} */

void zend_ffi_adjust_struct_size(zend_ffi_dcl *dcl) /* {{{ */
{
	zend_ffi_type *struct_type = ZEND_FFI_TYPE(dcl-&gt;type);

	ZEND_ASSERT(struct_type-&gt;kind == ZEND_FFI_TYPE_STRUCT);
	if (dcl-&gt;align &gt; struct_type-&gt;align) {
		struct_type-&gt;align = dcl-&gt;align;
	}
	if (!(struct_type-&gt;attr &amp; ZEND_FFI_ATTR_PACKED)) {
		struct_type-&gt;size = ((struct_type-&gt;size + (struct_type-&gt;align - 1)) / struct_type-&gt;align) * struct_type-&gt;align;
	}
	dcl-&gt;align = 0;
}
/* }}} */

void zend_ffi_make_pointer_type(zend_ffi_dcl *dcl) /* {{{ */
{
	zend_ffi_type *type = pemalloc(sizeof(zend_ffi_type), FFI_G(persistent));
	type-&gt;kind = ZEND_FFI_TYPE_POINTER;
	type-&gt;attr = FFI_G(default_type_attr) | (dcl-&gt;attr &amp; ZEND_FFI_POINTER_ATTRS);
	type-&gt;size = sizeof(void*);
	type-&gt;align = _Alignof(void*);
	zend_ffi_finalize_type(dcl);
	if (zend_ffi_validate_vla(ZEND_FFI_TYPE(dcl-&gt;type)) == FAILURE) {
		zend_ffi_cleanup_dcl(dcl);
		LONGJMP(FFI_G(bailout), FAILURE);
	}
	type-&gt;pointer.type = dcl-&gt;type;
	dcl-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(type);
	dcl-&gt;flags &amp;= ~ZEND_FFI_DCL_TYPE_QUALIFIERS;
	dcl-&gt;attr &amp;= ~ZEND_FFI_POINTER_ATTRS;
	dcl-&gt;align = 0;
}
/* }}} */

static zend_result zend_ffi_validate_array_element_type(zend_ffi_type *type) /* {{{ */
{
	if (type-&gt;kind == ZEND_FFI_TYPE_FUNC) {
		zend_ffi_throw_parser_error(&quot;Array of functions is not allowed at line %d&quot;, FFI_G(line));
		return FAILURE;
	} else if (type-&gt;kind == ZEND_FFI_TYPE_ARRAY &amp;&amp; (type-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_ARRAY)) {
		zend_ffi_throw_parser_error(&quot;Only the leftmost array can be undimensioned at line %d&quot;, FFI_G(line));
		return FAILURE;
	}
	return zend_ffi_validate_type(type, 0, 1);
}
/* }}} */

void zend_ffi_make_array_type(zend_ffi_dcl *dcl, zend_ffi_val *len) /* {{{ */
{
	int length = 0;
	zend_ffi_type *element_type;
	zend_ffi_type *type;

	zend_ffi_finalize_type(dcl);
	element_type = ZEND_FFI_TYPE(dcl-&gt;type);

	if (len-&gt;kind == ZEND_FFI_VAL_EMPTY) {
		length = 0;
	} else if (len-&gt;kind == ZEND_FFI_VAL_UINT32 || len-&gt;kind == ZEND_FFI_VAL_UINT64) {
		length = len-&gt;u64;
	} else if (len-&gt;kind == ZEND_FFI_VAL_INT32 || len-&gt;kind == ZEND_FFI_VAL_INT64) {
		length = len-&gt;i64;
	} else if (len-&gt;kind == ZEND_FFI_VAL_CHAR) {
		length = len-&gt;ch;
	} else {
		zend_ffi_cleanup_dcl(dcl);
		zend_ffi_parser_error(&quot;Unsupported array index type at line %d&quot;, FFI_G(line));
		return;
	}
	if (length &lt; 0) {
		zend_ffi_cleanup_dcl(dcl);
		zend_ffi_parser_error(&quot;Negative array index at line %d&quot;, FFI_G(line));
		return;
	}

	if (zend_ffi_validate_array_element_type(element_type) == FAILURE) {
		zend_ffi_cleanup_dcl(dcl);
		LONGJMP(FFI_G(bailout), FAILURE);
	}

	type = pemalloc(sizeof(zend_ffi_type), FFI_G(persistent));
	type-&gt;kind = ZEND_FFI_TYPE_ARRAY;
	type-&gt;attr = FFI_G(default_type_attr) | (dcl-&gt;attr &amp; ZEND_FFI_ARRAY_ATTRS);
	type-&gt;size = length * element_type-&gt;size;
	type-&gt;align = element_type-&gt;align;
	type-&gt;array.type = dcl-&gt;type;
	type-&gt;array.length = length;
	dcl-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(type);
	dcl-&gt;flags &amp;= ~ZEND_FFI_DCL_TYPE_QUALIFIERS;
	dcl-&gt;attr &amp;= ~ZEND_FFI_ARRAY_ATTRS;
	dcl-&gt;align = 0;
}
/* }}} */

static zend_result zend_ffi_validate_func_ret_type(zend_ffi_type *type) /* {{{ */
{
	if (type-&gt;kind == ZEND_FFI_TYPE_FUNC) {
		zend_ffi_throw_parser_error(&quot;Function returning function is not allowed at line %d&quot;, FFI_G(line));
		return FAILURE;
	 } else if (type-&gt;kind == ZEND_FFI_TYPE_ARRAY) {
		zend_ffi_throw_parser_error(&quot;Function returning array is not allowed at line %d&quot;, FFI_G(line));
		return FAILURE;
	}
	return zend_ffi_validate_incomplete_type(type, 1, 0);
}
/* }}} */

void zend_ffi_make_func_type(zend_ffi_dcl *dcl, HashTable *args, zend_ffi_dcl *nested_dcl) /* {{{ */
{
	zend_ffi_type *type;
	zend_ffi_type *ret_type;

	zend_ffi_finalize_type(dcl);
	ret_type = ZEND_FFI_TYPE(dcl-&gt;type);

	if (args) {
		int no_args = 0;
		zend_ffi_type *arg_type;

		ZEND_HASH_PACKED_FOREACH_PTR(args, arg_type) {
			arg_type = ZEND_FFI_TYPE(arg_type);
			if (arg_type-&gt;kind == ZEND_FFI_TYPE_VOID) {
				if (zend_hash_num_elements(args) != 1) {
					zend_ffi_cleanup_dcl(nested_dcl);
					zend_ffi_cleanup_dcl(dcl);
					zend_hash_destroy(args);
					pefree(args, FFI_G(persistent));
					zend_ffi_parser_error(&quot;void type is not allowed at line %d&quot;, FFI_G(line));
					return;
				} else {
					no_args = 1;
				}
			}
		} ZEND_HASH_FOREACH_END();
		if (no_args) {
			zend_hash_destroy(args);
			pefree(args, FFI_G(persistent));
			args = NULL;
		}
	}

#ifdef HAVE_FFI_VECTORCALL_PARTIAL
	if (dcl-&gt;abi == ZEND_FFI_ABI_VECTORCALL &amp;&amp; args) {
		zend_ulong i;
		zend_ffi_type *arg_type;

		ZEND_HASH_PACKED_FOREACH_KEY_PTR(args, i, arg_type) {
			arg_type = ZEND_FFI_TYPE(arg_type);
# ifdef _WIN64
			if (i &gt;= 4 &amp;&amp; i &lt;= 5 &amp;&amp; (arg_type-&gt;kind == ZEND_FFI_TYPE_FLOAT || arg_type-&gt;kind == ZEND_FFI_TYPE_DOUBLE)) {
# else
			if (i &lt; 6 &amp;&amp; (arg_type-&gt;kind == ZEND_FFI_TYPE_FLOAT || arg_type-&gt;kind == ZEND_FFI_TYPE_DOUBLE)) {
# endif
				zend_ffi_cleanup_dcl(nested_dcl);
				zend_ffi_cleanup_dcl(dcl);
				zend_hash_destroy(args);
				pefree(args, FFI_G(persistent));
				zend_ffi_parser_error(&quot;Type float/double is not allowed at position &quot; ZEND_ULONG_FMT &quot; with __vectorcall at line %d&quot;, i+1, FFI_G(line));
				return;
			}
		} ZEND_HASH_FOREACH_END();
	}
#endif

	if (zend_ffi_validate_func_ret_type(ret_type) == FAILURE) {
		zend_ffi_cleanup_dcl(nested_dcl);
		zend_ffi_cleanup_dcl(dcl);
		if (args) {
			zend_hash_destroy(args);
			pefree(args, FFI_G(persistent));
		}
		LONGJMP(FFI_G(bailout), FAILURE);
	}

	type = pemalloc(sizeof(zend_ffi_type), FFI_G(persistent));
	type-&gt;kind = ZEND_FFI_TYPE_FUNC;
	type-&gt;attr = FFI_G(default_type_attr) | (dcl-&gt;attr &amp; ZEND_FFI_FUNC_ATTRS);
	type-&gt;size = sizeof(void*);
	type-&gt;align = 1;
	type-&gt;func.ret_type = dcl-&gt;type;
	switch (dcl-&gt;abi) {
		case ZEND_FFI_ABI_DEFAULT:
		case ZEND_FFI_ABI_CDECL:
			type-&gt;func.abi = FFI_DEFAULT_ABI;
			break;
#ifdef HAVE_FFI_FASTCALL
		case ZEND_FFI_ABI_FASTCALL:
			type-&gt;func.abi = FFI_FASTCALL;
			break;
#endif
#ifdef HAVE_FFI_THISCALL
		case ZEND_FFI_ABI_THISCALL:
			type-&gt;func.abi = FFI_THISCALL;
			break;
#endif
#ifdef HAVE_FFI_STDCALL
		case ZEND_FFI_ABI_STDCALL:
			type-&gt;func.abi = FFI_STDCALL;
			break;
#endif
#ifdef HAVE_FFI_PASCAL
		case ZEND_FFI_ABI_PASCAL:
			type-&gt;func.abi = FFI_PASCAL;
			break;
#endif
#ifdef HAVE_FFI_REGISTER
		case ZEND_FFI_ABI_REGISTER:
			type-&gt;func.abi = FFI_REGISTER;
			break;
#endif
#ifdef HAVE_FFI_MS_CDECL
		case ZEND_FFI_ABI_MS:
			type-&gt;func.abi = FFI_MS_CDECL;
			break;
#endif
#ifdef HAVE_FFI_SYSV
		case ZEND_FFI_ABI_SYSV:
			type-&gt;func.abi = FFI_SYSV;
			break;
#endif
#ifdef HAVE_FFI_VECTORCALL_PARTIAL
		case ZEND_FFI_ABI_VECTORCALL:
			type-&gt;func.abi = FFI_VECTORCALL_PARTIAL;
			break;
#endif
		default:
			type-&gt;func.abi = FFI_DEFAULT_ABI;
			zend_ffi_cleanup_dcl(nested_dcl);
			if (args) {
				zend_hash_destroy(args);
				pefree(args, FFI_G(persistent));
			}
			type-&gt;func.args = NULL;
			_zend_ffi_type_dtor(type);
			zend_ffi_parser_error(&quot;Unsupported calling convention line %d&quot;, FFI_G(line));
			break;
	}
	type-&gt;func.args = args;
	dcl-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(type);
	dcl-&gt;attr &amp;= ~ZEND_FFI_FUNC_ATTRS;
	dcl-&gt;align = 0;
	dcl-&gt;abi = 0;
}
/* }}} */

void zend_ffi_add_arg(HashTable **args, const char *name, size_t name_len, zend_ffi_dcl *arg_dcl) /* {{{ */
{
	zend_ffi_type *type;

	if (!*args) {
		*args = pemalloc(sizeof(HashTable), FFI_G(persistent));
		zend_hash_init(*args, 0, NULL, zend_ffi_type_hash_dtor, FFI_G(persistent));
	}
	zend_ffi_finalize_type(arg_dcl);
	type = ZEND_FFI_TYPE(arg_dcl-&gt;type);
	if (type-&gt;kind == ZEND_FFI_TYPE_ARRAY) {
		if (ZEND_FFI_TYPE_IS_OWNED(arg_dcl-&gt;type)) {
			type-&gt;kind = ZEND_FFI_TYPE_POINTER;
			type-&gt;size = sizeof(void*);
		} else {
			zend_ffi_type *new_type = pemalloc(sizeof(zend_ffi_type), FFI_G(persistent));
			new_type-&gt;kind = ZEND_FFI_TYPE_POINTER;
			new_type-&gt;attr = FFI_G(default_type_attr) | (type-&gt;attr &amp; ZEND_FFI_POINTER_ATTRS);
			new_type-&gt;size = sizeof(void*);
			new_type-&gt;align = _Alignof(void*);
			new_type-&gt;pointer.type = ZEND_FFI_TYPE(type-&gt;array.type);
			arg_dcl-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(new_type);
		}
	} else if (type-&gt;kind == ZEND_FFI_TYPE_FUNC) {
		zend_ffi_type *new_type = pemalloc(sizeof(zend_ffi_type), FFI_G(persistent));
		new_type-&gt;kind = ZEND_FFI_TYPE_POINTER;
		new_type-&gt;attr = FFI_G(default_type_attr);
		new_type-&gt;size = sizeof(void*);
		new_type-&gt;align = _Alignof(void*);
		new_type-&gt;pointer.type = arg_dcl-&gt;type;
		arg_dcl-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(new_type);
	}
	if (zend_ffi_validate_incomplete_type(type, 1, 1) == FAILURE) {
		zend_ffi_cleanup_dcl(arg_dcl);
		zend_hash_destroy(*args);
		pefree(*args, FFI_G(persistent));
		*args = NULL;
		LONGJMP(FFI_G(bailout), FAILURE);
	}
	zend_hash_next_index_insert_ptr(*args, (void*)arg_dcl-&gt;type);
}
/* }}} */

void zend_ffi_declare(const char *name, size_t name_len, zend_ffi_dcl *dcl) /* {{{ */
{
	zend_ffi_symbol *sym;

	if (!FFI_G(symbols)) {
		FFI_G(symbols) = pemalloc(sizeof(HashTable), FFI_G(persistent));
		zend_hash_init(FFI_G(symbols), 0, NULL, FFI_G(persistent) ? zend_ffi_symbol_hash_persistent_dtor : zend_ffi_symbol_hash_dtor, FFI_G(persistent));
	}
	zend_ffi_finalize_type(dcl);
	sym = zend_hash_str_find_ptr(FFI_G(symbols), name, name_len);
	if (sym) {
		if ((dcl-&gt;flags &amp; ZEND_FFI_DCL_STORAGE_CLASS) == ZEND_FFI_DCL_TYPEDEF
		 &amp;&amp; sym-&gt;kind == ZEND_FFI_SYM_TYPE
		 &amp;&amp; zend_ffi_is_same_type(ZEND_FFI_TYPE(sym-&gt;type), ZEND_FFI_TYPE(dcl-&gt;type))
		 &amp;&amp; sym-&gt;is_const == (bool)(dcl-&gt;attr &amp; ZEND_FFI_ATTR_CONST)) {
			/* allowed redeclaration */
			zend_ffi_type_dtor(dcl-&gt;type);
			return;
		} else if ((dcl-&gt;flags &amp; ZEND_FFI_DCL_STORAGE_CLASS) == 0
		 || (dcl-&gt;flags &amp; ZEND_FFI_DCL_STORAGE_CLASS) == ZEND_FFI_DCL_EXTERN) {
			zend_ffi_type *type = ZEND_FFI_TYPE(dcl-&gt;type);

			if (type-&gt;kind == ZEND_FFI_TYPE_FUNC) {
				if (sym-&gt;kind == ZEND_FFI_SYM_FUNC
				 &amp;&amp; zend_ffi_same_types(ZEND_FFI_TYPE(sym-&gt;type), type)) {
					/* allowed redeclaration */
					zend_ffi_type_dtor(dcl-&gt;type);
					return;
				}
			} else {
				if (sym-&gt;kind == ZEND_FFI_SYM_VAR
				 &amp;&amp; zend_ffi_is_same_type(ZEND_FFI_TYPE(sym-&gt;type), type)
				 &amp;&amp; sym-&gt;is_const == (bool)(dcl-&gt;attr &amp; ZEND_FFI_ATTR_CONST)) {
					/* allowed redeclaration */
					zend_ffi_type_dtor(dcl-&gt;type);
					return;
				}
			}
		}
		zend_ffi_parser_error(&quot;Redeclaration of \&quot;%.*s\&quot; at line %d&quot;, name_len, name, FFI_G(line));
	} else {
		if ((dcl-&gt;flags &amp; ZEND_FFI_DCL_STORAGE_CLASS) == ZEND_FFI_DCL_TYPEDEF) {
			if (zend_ffi_validate_vla(ZEND_FFI_TYPE(dcl-&gt;type)) == FAILURE) {
				zend_ffi_cleanup_dcl(dcl);
				LONGJMP(FFI_G(bailout), FAILURE);
			}
			if (dcl-&gt;align &amp;&amp; dcl-&gt;align &gt; ZEND_FFI_TYPE(dcl-&gt;type)-&gt;align) {
				if (ZEND_FFI_TYPE_IS_OWNED(dcl-&gt;type)) {
					ZEND_FFI_TYPE(dcl-&gt;type)-&gt;align = dcl-&gt;align;
				} else {
					zend_ffi_type *type = pemalloc(sizeof(zend_ffi_type), FFI_G(persistent));

					memcpy(type, ZEND_FFI_TYPE(dcl-&gt;type), sizeof(zend_ffi_type));
					type-&gt;attr |= FFI_G(default_type_attr);
					type-&gt;align = dcl-&gt;align;
					dcl-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(type);
				}
			}
			sym = pemalloc(sizeof(zend_ffi_symbol), FFI_G(persistent));
			sym-&gt;kind = ZEND_FFI_SYM_TYPE;
			sym-&gt;type = dcl-&gt;type;
			sym-&gt;is_const = (bool)(dcl-&gt;attr &amp; ZEND_FFI_ATTR_CONST);
			dcl-&gt;type = ZEND_FFI_TYPE(dcl-&gt;type); /* reset &quot;owned&quot; flag */
			zend_hash_str_add_new_ptr(FFI_G(symbols), name, name_len, sym);
		} else {
			zend_ffi_type *type;

			type = ZEND_FFI_TYPE(dcl-&gt;type);
			if (zend_ffi_validate_type(type, (dcl-&gt;flags &amp; ZEND_FFI_DCL_STORAGE_CLASS) == ZEND_FFI_DCL_EXTERN, 1) == FAILURE) {
				zend_ffi_cleanup_dcl(dcl);
				LONGJMP(FFI_G(bailout), FAILURE);
			}
			if ((dcl-&gt;flags &amp; ZEND_FFI_DCL_STORAGE_CLASS) == 0 ||
			    (dcl-&gt;flags &amp; ZEND_FFI_DCL_STORAGE_CLASS) == ZEND_FFI_DCL_EXTERN) {
				sym = pemalloc(sizeof(zend_ffi_symbol), FFI_G(persistent));
				sym-&gt;kind = (type-&gt;kind == ZEND_FFI_TYPE_FUNC) ? ZEND_FFI_SYM_FUNC : ZEND_FFI_SYM_VAR;
				sym-&gt;type = dcl-&gt;type;
				sym-&gt;is_const = (bool)(dcl-&gt;attr &amp; ZEND_FFI_ATTR_CONST);
				dcl-&gt;type = type; /* reset &quot;owned&quot; flag */
				zend_hash_str_add_new_ptr(FFI_G(symbols), name, name_len, sym);
			} else {
				/* useless declaration */
				zend_ffi_type_dtor(dcl-&gt;type);
			}
		}
	}
}
/* }}} */

void zend_ffi_declare_tag(const char *name, size_t name_len, zend_ffi_dcl *dcl, bool incomplete) /* {{{ */
{
	zend_ffi_tag *tag;
	zend_ffi_type *type;

	if (!FFI_G(tags)) {
		FFI_G(tags) = pemalloc(sizeof(HashTable), FFI_G(persistent));
		zend_hash_init(FFI_G(tags), 0, NULL, FFI_G(persistent) ? zend_ffi_tag_hash_persistent_dtor : zend_ffi_tag_hash_dtor, FFI_G(persistent));
	}
	tag = zend_hash_str_find_ptr(FFI_G(tags), name, name_len);
	if (tag) {
		zend_ffi_type *type = ZEND_FFI_TYPE(tag-&gt;type);

		if (dcl-&gt;flags &amp; ZEND_FFI_DCL_STRUCT) {
			if (tag-&gt;kind != ZEND_FFI_TAG_STRUCT) {
				zend_ffi_parser_error(&quot;\&quot;%.*s\&quot; defined as wrong kind of tag at line %d&quot;, name_len, name, FFI_G(line));
				return;
			} else if (!incomplete &amp;&amp; !(type-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_TAG)) {
				zend_ffi_parser_error(&quot;Redefinition of \&quot;struct %.*s\&quot; at line %d&quot;, name_len, name, FFI_G(line));
				return;
			}
		} else if (dcl-&gt;flags &amp; ZEND_FFI_DCL_UNION) {
			if (tag-&gt;kind != ZEND_FFI_TAG_UNION) {
				zend_ffi_parser_error(&quot;\&quot;%.*s\&quot; defined as wrong kind of tag at line %d&quot;, name_len, name, FFI_G(line));
				return;
			} else if (!incomplete &amp;&amp; !(type-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_TAG)) {
				zend_ffi_parser_error(&quot;Redefinition of \&quot;union %.*s\&quot; at line %d&quot;, name_len, name, FFI_G(line));
				return;
			}
		} else if (dcl-&gt;flags &amp; ZEND_FFI_DCL_ENUM) {
			if (tag-&gt;kind != ZEND_FFI_TAG_ENUM) {
				zend_ffi_parser_error(&quot;\&quot;%.*s\&quot; defined as wrong kind of tag at line %d&quot;, name_len, name, FFI_G(line));
				return;
			} else if (!incomplete &amp;&amp; !(type-&gt;attr &amp; ZEND_FFI_ATTR_INCOMPLETE_TAG)) {
				zend_ffi_parser_error(&quot;Redefinition of \&quot;enum %.*s\&quot; at line %d&quot;, name_len, name, FFI_G(line));
				return;
			}
		} else {
			ZEND_UNREACHABLE();
			return;
		}
		dcl-&gt;type = type;
		if (!incomplete) {
			type-&gt;attr &amp;= ~ZEND_FFI_ATTR_INCOMPLETE_TAG;
		}
	} else {
		zend_ffi_tag *tag = pemalloc(sizeof(zend_ffi_tag), FFI_G(persistent));
		zend_string *tag_name = zend_string_init(name, name_len, FFI_G(persistent));

		if (dcl-&gt;flags &amp; ZEND_FFI_DCL_STRUCT) {
			tag-&gt;kind = ZEND_FFI_TAG_STRUCT;
			zend_ffi_make_struct_type(dcl);
			type = ZEND_FFI_TYPE(dcl-&gt;type);
			type-&gt;record.tag_name = zend_string_copy(tag_name);
		} else if (dcl-&gt;flags &amp; ZEND_FFI_DCL_UNION) {
			tag-&gt;kind = ZEND_FFI_TAG_UNION;
			zend_ffi_make_struct_type(dcl);
			type = ZEND_FFI_TYPE(dcl-&gt;type);
			type-&gt;record.tag_name = zend_string_copy(tag_name);
		} else if (dcl-&gt;flags &amp; ZEND_FFI_DCL_ENUM) {
			tag-&gt;kind = ZEND_FFI_TAG_ENUM;
			zend_ffi_make_enum_type(dcl);
			type = ZEND_FFI_TYPE(dcl-&gt;type);
			type-&gt;enumeration.tag_name = zend_string_copy(tag_name);
		} else {
			ZEND_UNREACHABLE();
		}
		tag-&gt;type = ZEND_FFI_TYPE_MAKE_OWNED(dcl-&gt;type);
		dcl-&gt;type = ZEND_FFI_TYPE(dcl-&gt;type);
		if (incomplete) {
			dcl-&gt;type-&gt;attr |= ZEND_FFI_ATTR_INCOMPLETE_TAG;
		}
		zend_hash_add_new_ptr(FFI_G(tags), tag_name, tag);
		zend_string_release(tag_name);
	}
}
/* }}} */

void zend_ffi_set_abi(zend_ffi_dcl *dcl, uint16_t abi) /* {{{ */
{
	if (dcl-&gt;abi != ZEND_FFI_ABI_DEFAULT) {
		zend_ffi_parser_error(&quot;Multiple calling convention specifiers at line %d&quot;, FFI_G(line));
	} else {
		dcl-&gt;abi = abi;
	}
}
/* }}} */

#define SIMPLE_ATTRIBUTES(_) \
	_(cdecl) \
	_(fastcall) \
	_(thiscall) \
	_(stdcall) \
	_(ms_abi) \
	_(sysv_abi) \
	_(vectorcall) \
	_(aligned) \
	_(packed) \
	_(ms_struct) \
	_(gcc_struct) \
	_(const) \
	_(malloc) \
	_(deprecated) \
	_(nothrow) \
	_(leaf) \
	_(pure) \
	_(noreturn) \
	_(warn_unused_result)

#define ATTR_ID(name)   attr_ ## name,
#define ATTR_NAME(name) {sizeof(#name)-1, #name},

void zend_ffi_add_attribute(zend_ffi_dcl *dcl, const char *name, size_t name_len) /* {{{ */
{
	enum {
		SIMPLE_ATTRIBUTES(ATTR_ID)
		attr_unsupported
	};
	static const struct {
		size_t len;
		const char * const name;
	} names[] = {
		SIMPLE_ATTRIBUTES(ATTR_NAME)
		{0, NULL}
	};
	int id;

	if (name_len &gt; 4
	 &amp;&amp; name[0] == &#039;_&#039;
	 &amp;&amp; name[1] == &#039;_&#039;
	 &amp;&amp; name[name_len-2] == &#039;_&#039;
	 &amp;&amp; name[name_len-1] == &#039;_&#039;) {
		name += 2;
		name_len -= 4;
	}
	for (id = 0; names[id].len != 0; id++) {
		if (name_len == names[id].len) {
			if (memcmp(name, names[id].name, name_len) == 0) {
				break;
			}
		}
	}
	switch (id) {
		case attr_cdecl:
			zend_ffi_set_abi(dcl, ZEND_FFI_ABI_CDECL);
			break;
		case attr_fastcall:
			zend_ffi_set_abi(dcl, ZEND_FFI_ABI_FASTCALL);
			break;
		case attr_thiscall:
			zend_ffi_set_abi(dcl, ZEND_FFI_ABI_THISCALL);
			break;
		case attr_stdcall:
			zend_ffi_set_abi(dcl, ZEND_FFI_ABI_STDCALL);
			break;
		case attr_ms_abi:
			zend_ffi_set_abi(dcl, ZEND_FFI_ABI_MS);
			break;
		case attr_sysv_abi:
			zend_ffi_set_abi(dcl, ZEND_FFI_ABI_SYSV);
			break;
		case attr_vectorcall:
			zend_ffi_set_abi(dcl, ZEND_FFI_ABI_VECTORCALL);
			break;
		case attr_aligned:
			dcl-&gt;align = __BIGGEST_ALIGNMENT__;
			break;
		case attr_packed:
			dcl-&gt;attr |= ZEND_FFI_ATTR_PACKED;
			break;
		case attr_ms_struct:
			dcl-&gt;attr |= ZEND_FFI_ATTR_MS_STRUCT;
			break;
		case attr_gcc_struct:
			dcl-&gt;attr |= ZEND_FFI_ATTR_GCC_STRUCT;
			break;
		case attr_unsupported:
			zend_ffi_parser_error(&quot;Unsupported attribute \&quot;%.*s\&quot; at line %d&quot;, name_len, name, FFI_G(line));
			break;
		default:
			/* ignore */
			break;
	}
}
/* }}} */

#define VALUE_ATTRIBUTES(_) \
	_(regparam) \
	_(aligned) \
	_(mode) \
	_(nonnull) \
	_(alloc_size) \
	_(format) \
	_(deprecated)

void zend_ffi_add_attribute_value(zend_ffi_dcl *dcl, const char *name, size_t name_len, int n, zend_ffi_val *val) /* {{{ */
{
	enum {
		VALUE_ATTRIBUTES(ATTR_ID)
		attr_unsupported
	};
	static const struct {
		size_t len;
		const char * const name;
	} names[] = {
		VALUE_ATTRIBUTES(ATTR_NAME)
		{0, NULL}
	};
	int id;

	if (name_len &gt; 4
	 &amp;&amp; name[0] == &#039;_&#039;
	 &amp;&amp; name[1] == &#039;_&#039;
	 &amp;&amp; name[name_len-2] == &#039;_&#039;
	 &amp;&amp; name[name_len-1] == &#039;_&#039;) {
		name += 2;
		name_len -= 4;
	}
	for (id = 0; names[id].len != 0; id++) {
		if (name_len == names[id].len) {
			if (memcmp(name, names[id].name, name_len) == 0) {
				break;
			}
		}
	}
	switch (id) {
		case attr_regparam:
			if (n == 0
			 &amp;&amp; (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_INT64 || val-&gt;kind == ZEND_FFI_VAL_UINT64)
			 &amp;&amp; val-&gt;i64 == 3) {
				zend_ffi_set_abi(dcl, ZEND_FFI_ABI_REGISTER);
			} else {
				zend_ffi_parser_error(&quot;Incorrect \&quot;regparam\&quot; value at line %d&quot;, FFI_G(line));
			}
			break;
		case attr_aligned:
			if (n == 0
			 &amp;&amp; (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_INT64 || val-&gt;kind == ZEND_FFI_VAL_UINT64)
			 &amp;&amp; val-&gt;i64 &gt; 0 &amp;&amp; val-&gt;i64 &lt;= 0x80000000 &amp;&amp; (val-&gt;i64 &amp; (val-&gt;i64 - 1)) == 0) {
				dcl-&gt;align = val-&gt;i64;
			} else {
				zend_ffi_parser_error(&quot;Incorrect \&quot;alignment\&quot; value at line %d&quot;, FFI_G(line));
			}
			break;
		case attr_mode:
			if (n == 0
			 &amp;&amp; (val-&gt;kind == ZEND_FFI_VAL_NAME)) {
				const char *str = val-&gt;str;
				size_t len = val-&gt;len;
				if (len &gt; 4
				 &amp;&amp; str[0] == &#039;_&#039;
				 &amp;&amp; str[1] == &#039;_&#039;
				 &amp;&amp; str[len-2] == &#039;_&#039;
				 &amp;&amp; str[len-1] == &#039;_&#039;) {
					str += 2;
					len -= 4;
				}
				// TODO: Add support for vector type &#039;VnXX&#039; ???
				if (len == 2) {
					if (str[1] == &#039;I&#039;) {
						if (dcl-&gt;flags &amp; (ZEND_FFI_DCL_TYPE_SPECIFIERS-(ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_INT|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_LONG_LONG|ZEND_FFI_DCL_SIGNED|ZEND_FFI_DCL_UNSIGNED))) {
							/* inappropriate type */
						} else if (str[0] == &#039;Q&#039;) {
							dcl-&gt;flags &amp;= ~(ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_INT|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_LONG_LONG);
							dcl-&gt;flags |= ZEND_FFI_DCL_CHAR;
							break;
						} else if (str[0] == &#039;H&#039;) {
							dcl-&gt;flags &amp;= ~(ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_INT|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_LONG_LONG);
							dcl-&gt;flags |= ZEND_FFI_DCL_SHORT;
							break;
						} else if (str[0] == &#039;S&#039;) {
							dcl-&gt;flags &amp;= ~(ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_INT|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_LONG_LONG);
							dcl-&gt;flags |= ZEND_FFI_DCL_INT;
							break;
						} else if (str[0] == &#039;D&#039;) {
							dcl-&gt;flags &amp;= ~(ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_INT|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_LONG_LONG);
							if (sizeof(long) == 8) {
								dcl-&gt;flags |= ZEND_FFI_DCL_LONG;
							} else {
								dcl-&gt;flags |= ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_LONG_LONG;
							}
							break;
						}
					} else if (str[1] == &#039;F&#039;) {
						if (dcl-&gt;flags &amp; (ZEND_FFI_DCL_TYPE_SPECIFIERS-(ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_FLOAT|ZEND_FFI_DCL_DOUBLE))) {
							/* inappropriate type */
						} else if (str[0] == &#039;S&#039;) {
							dcl-&gt;flags &amp;= ~(ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_FLOAT|ZEND_FFI_DCL_DOUBLE);
							dcl-&gt;flags |= ZEND_FFI_DCL_FLOAT;
							break;
						} else if (str[0] == &#039;D&#039;) {
							dcl-&gt;flags &amp;= ~(ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_FLOAT|ZEND_FFI_DCL_DOUBLE);
							dcl-&gt;flags |= ZEND_FFI_DCL_DOUBLE;
							break;
						}
					}
				}
			}
			zend_ffi_parser_error(&quot;Unsupported \&quot;mode\&quot; value at line %d&quot;, FFI_G(line));
			// TODO: ???
		case attr_unsupported:
			zend_ffi_parser_error(&quot;Unsupported attribute \&quot;%.*s\&quot; at line %d&quot;, name_len, name, FFI_G(line));
			break;
		default:
			/* ignore */
			break;
	}
}
/* }}} */

void zend_ffi_add_msvc_attribute_value(zend_ffi_dcl *dcl, const char *name, size_t name_len, zend_ffi_val *val) /* {{{ */
{
	if (name_len == sizeof(&quot;align&quot;)-1 &amp;&amp; memcmp(name, &quot;align&quot;, sizeof(&quot;align&quot;)-1) == 0) {
		if ((val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_INT64 || val-&gt;kind == ZEND_FFI_VAL_UINT64)
		 &amp;&amp; val-&gt;i64 &gt; 0 &amp;&amp; val-&gt;i64 &lt;= 0x80000000 &amp;&amp; (val-&gt;i64 &amp; (val-&gt;i64 - 1)) == 0) {
			dcl-&gt;align = val-&gt;i64;
		} else {
			zend_ffi_parser_error(&quot;Incorrect \&quot;alignment\&quot; value at line %d&quot;, FFI_G(line));
		}
	} else {
		/* ignore */
	}
}
/* }}} */

static zend_result zend_ffi_nested_type(zend_ffi_type *type, zend_ffi_type *nested_type) /* {{{ */
{
	nested_type = ZEND_FFI_TYPE(nested_type);
	switch (nested_type-&gt;kind) {
		case ZEND_FFI_TYPE_POINTER:
			/* &quot;char&quot; is used as a terminator of nested declaration */
			if (nested_type-&gt;pointer.type == &amp;zend_ffi_type_char) {
				nested_type-&gt;pointer.type = type;
				return zend_ffi_validate_vla(ZEND_FFI_TYPE(type));
			} else {
				return zend_ffi_nested_type(type, nested_type-&gt;pointer.type);
			}
			break;
		case ZEND_FFI_TYPE_ARRAY:
			/* &quot;char&quot; is used as a terminator of nested declaration */
			if (nested_type-&gt;array.type == &amp;zend_ffi_type_char) {
				nested_type-&gt;array.type = type;
				if (zend_ffi_validate_array_element_type(ZEND_FFI_TYPE(type)) == FAILURE) {
					return FAILURE;
				}
			} else {
				if (zend_ffi_nested_type(type, nested_type-&gt;array.type) != SUCCESS) {
					return FAILURE;
				}
			}
			nested_type-&gt;size = nested_type-&gt;array.length * ZEND_FFI_TYPE(nested_type-&gt;array.type)-&gt;size;
			nested_type-&gt;align = ZEND_FFI_TYPE(nested_type-&gt;array.type)-&gt;align;
			return SUCCESS;
			break;
		case ZEND_FFI_TYPE_FUNC:
			/* &quot;char&quot; is used as a terminator of nested declaration */
			if (nested_type-&gt;func.ret_type == &amp;zend_ffi_type_char) {
				nested_type-&gt;func.ret_type = type;
				return zend_ffi_validate_func_ret_type(ZEND_FFI_TYPE(type));
			} else {
				return zend_ffi_nested_type(type, nested_type-&gt;func.ret_type);
			}
			break;
		default:
			ZEND_UNREACHABLE();
	}
}
/* }}} */

void zend_ffi_nested_declaration(zend_ffi_dcl *dcl, zend_ffi_dcl *nested_dcl) /* {{{ */
{
	/* &quot;char&quot; is used as a terminator of nested declaration */
	zend_ffi_finalize_type(dcl);
	if (!nested_dcl-&gt;type || nested_dcl-&gt;type == &amp;zend_ffi_type_char) {
		nested_dcl-&gt;type = dcl-&gt;type;
	} else {
		if (zend_ffi_nested_type(dcl-&gt;type, nested_dcl-&gt;type) == FAILURE) {
			zend_ffi_cleanup_dcl(nested_dcl);
			LONGJMP(FFI_G(bailout), FAILURE);
		}
	}
	dcl-&gt;type = nested_dcl-&gt;type;
}
/* }}} */

void zend_ffi_align_as_type(zend_ffi_dcl *dcl, zend_ffi_dcl *align_dcl) /* {{{ */
{
	zend_ffi_finalize_type(align_dcl);
	dcl-&gt;align = MAX(align_dcl-&gt;align, ZEND_FFI_TYPE(align_dcl-&gt;type)-&gt;align);
}
/* }}} */

void zend_ffi_align_as_val(zend_ffi_dcl *dcl, zend_ffi_val *align_val) /* {{{ */
{
	switch (align_val-&gt;kind) {
		case ZEND_FFI_VAL_INT32:
		case ZEND_FFI_VAL_UINT32:
			dcl-&gt;align = zend_ffi_type_uint32.align;
			break;
		case ZEND_FFI_VAL_INT64:
		case ZEND_FFI_VAL_UINT64:
			dcl-&gt;align = zend_ffi_type_uint64.align;
			break;
		case ZEND_FFI_VAL_FLOAT:
			dcl-&gt;align = zend_ffi_type_float.align;
			break;
		case ZEND_FFI_VAL_DOUBLE:
			dcl-&gt;align = zend_ffi_type_double.align;
			break;
#ifdef HAVE_LONG_DOUBLE
		case ZEND_FFI_VAL_LONG_DOUBLE:
			dcl-&gt;align = zend_ffi_type_long_double.align;
			break;
#endif
		case ZEND_FFI_VAL_CHAR:
		case ZEND_FFI_VAL_STRING:
			dcl-&gt;align = zend_ffi_type_char.align;
			break;
		default:
			break;
	}
}
/* }}} */

#define zend_ffi_expr_bool(val) do { \
	if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) { \
		val-&gt;kind = ZEND_FFI_VAL_INT32; \
		val-&gt;i64 = !!val-&gt;u64; \
	} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) { \
		val-&gt;kind = ZEND_FFI_VAL_INT32; \
		val-&gt;i64 = !!val-&gt;i64; \
	} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
		val-&gt;kind = ZEND_FFI_VAL_INT32; \
		val-&gt;i64 = !!val-&gt;d; \
	} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) { \
		val-&gt;kind = ZEND_FFI_VAL_INT32; \
		val-&gt;i64 = !!val-&gt;ch; \
	} else { \
		val-&gt;kind = ZEND_FFI_VAL_ERROR; \
	} \
} while (0)

#define zend_ffi_expr_math(val, op2, OP) do { \
	if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32 || op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;kind = MAX(val-&gt;kind, op2-&gt;kind); \
			val-&gt;u64 = val-&gt;u64 OP op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32) { \
			val-&gt;u64 = val-&gt;u64 OP op2-&gt;i64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;u64 = val-&gt;u64 OP op2-&gt;i64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_FLOAT || op2-&gt;kind == ZEND_FFI_VAL_DOUBLE || op2-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
			val-&gt;kind = op2-&gt;kind; \
			val-&gt;d = (zend_ffi_double)val-&gt;u64 OP op2-&gt;d; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_CHAR) { \
			val-&gt;u64 = val-&gt;u64 OP op2-&gt;ch; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32) { \
			val-&gt;i64 = val-&gt;i64 OP op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;i64 = val-&gt;i64 OP op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32 || op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;kind = MAX(val-&gt;kind, op2-&gt;kind); \
			val-&gt;i64 = val-&gt;i64 OP op2-&gt;i64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_FLOAT || op2-&gt;kind == ZEND_FFI_VAL_DOUBLE || op2-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
			val-&gt;kind = op2-&gt;kind; \
			val-&gt;d = (zend_ffi_double)val-&gt;i64 OP op2-&gt;d; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_CHAR) { \
			val-&gt;i64 = val-&gt;i64 OP op2-&gt;ch; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32 || op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;d = val-&gt;d OP (zend_ffi_double)op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32 ||op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;d = val-&gt;d OP (zend_ffi_double)op2-&gt;i64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_FLOAT || op2-&gt;kind == ZEND_FFI_VAL_DOUBLE || op2-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
			val-&gt;kind = MAX(val-&gt;kind, op2-&gt;kind); \
			val-&gt;d = val-&gt;d OP op2-&gt;d; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_CHAR) { \
			val-&gt;d = val-&gt;d OP (zend_ffi_double)op2-&gt;ch; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32 || op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;kind = op2-&gt;kind; \
			val-&gt;u64 = val-&gt;ch OP op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32 || op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;kind = ZEND_FFI_VAL_INT64; \
			val-&gt;i64 = val-&gt;ch OP op2-&gt;i64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_FLOAT || op2-&gt;kind == ZEND_FFI_VAL_DOUBLE || op2-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
			val-&gt;kind = op2-&gt;kind; \
			val-&gt;d = (zend_ffi_double)val-&gt;ch OP op2-&gt;d; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_CHAR) { \
			val-&gt;ch = val-&gt;ch OP op2-&gt;ch; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else { \
		val-&gt;kind = ZEND_FFI_VAL_ERROR; \
	} \
} while (0)

#define zend_ffi_expr_int_math(val, op2, OP) do { \
	if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32 || op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;kind = MAX(val-&gt;kind, op2-&gt;kind); \
			val-&gt;u64 = val-&gt;u64 OP op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32) { \
			val-&gt;u64 = val-&gt;u64 OP op2-&gt;i64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;u64 = val-&gt;u64 OP op2-&gt;i64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_FLOAT || op2-&gt;kind == ZEND_FFI_VAL_DOUBLE || op2-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
			val-&gt;u64 = val-&gt;u64 OP (uint64_t)op2-&gt;d; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_CHAR) { \
			val-&gt;u64 = val-&gt;u64 OP op2-&gt;ch; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32) { \
			val-&gt;i64 = val-&gt;i64 OP op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;i64 = val-&gt;i64 OP op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32 || op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;kind = MAX(val-&gt;kind, op2-&gt;kind); \
			val-&gt;i64 = val-&gt;i64 OP op2-&gt;i64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_FLOAT || op2-&gt;kind == ZEND_FFI_VAL_DOUBLE || op2-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
			val-&gt;u64 = val-&gt;u64 OP (int64_t)op2-&gt;d; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_CHAR) { \
			val-&gt;i64 = val-&gt;i64 OP op2-&gt;ch; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32 || op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;kind = op2-&gt;kind; \
			val-&gt;u64 = (uint64_t)val-&gt;d OP op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32 || op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;kind = op2-&gt;kind; \
			val-&gt;i64 = (int64_t)val-&gt;d OP op2-&gt;i64; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32 || op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;kind = op2-&gt;kind; \
			val-&gt;u64 = (uint64_t)val-&gt;ch OP op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32 || op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;kind = op2-&gt;kind; \
			val-&gt;i64 = (int64_t)val-&gt;ch OP op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_CHAR) { \
			val-&gt;ch = val-&gt;ch OP op2-&gt;ch; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else { \
		val-&gt;kind = ZEND_FFI_VAL_ERROR; \
	} \
} while (0)

#define zend_ffi_expr_cmp(val, op2, OP) do { \
	if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32 || op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;u64 OP op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32 || op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;u64 OP op2-&gt;u64; /*signed/unsigned */ \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_FLOAT || op2-&gt;kind == ZEND_FFI_VAL_DOUBLE || op2-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = (zend_ffi_double)val-&gt;u64 OP op2-&gt;d; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_CHAR) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;u64 OP op2-&gt;d; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32 || op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;i64 OP op2-&gt;i64; /* signed/unsigned */ \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32 || op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;i64 OP op2-&gt;i64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_FLOAT || op2-&gt;kind == ZEND_FFI_VAL_DOUBLE || op2-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = (zend_ffi_double)val-&gt;i64 OP op2-&gt;d; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_CHAR) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;i64 OP op2-&gt;ch; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32 || op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;d OP (zend_ffi_double)op2-&gt;u64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32 ||op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;d OP (zend_ffi_double)op2-&gt;i64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_FLOAT || op2-&gt;kind == ZEND_FFI_VAL_DOUBLE || op2-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;d OP op2-&gt;d; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_CHAR) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;d OP (zend_ffi_double)op2-&gt;ch; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) { \
		if (op2-&gt;kind == ZEND_FFI_VAL_UINT32 || op2-&gt;kind == ZEND_FFI_VAL_UINT64) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;ch OP op2-&gt;i64; /* signed/unsigned */ \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_INT32 || op2-&gt;kind == ZEND_FFI_VAL_INT64) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;ch OP op2-&gt;i64; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_FLOAT || op2-&gt;kind == ZEND_FFI_VAL_DOUBLE || op2-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = (zend_ffi_double)val-&gt;ch OP op2-&gt;d; \
		} else if (op2-&gt;kind == ZEND_FFI_VAL_CHAR) { \
			val-&gt;kind = ZEND_FFI_VAL_INT32; \
			val-&gt;i64 = val-&gt;ch OP op2-&gt;ch; \
		} else { \
			val-&gt;kind = ZEND_FFI_VAL_ERROR; \
		} \
	} else { \
		val-&gt;kind = ZEND_FFI_VAL_ERROR; \
	} \
} while (0)

void zend_ffi_expr_conditional(zend_ffi_val *val, zend_ffi_val *op2, zend_ffi_val *op3) /* {{{ */
{
	zend_ffi_expr_bool(val);
	if (val-&gt;kind == ZEND_FFI_VAL_INT32) {
		if (val-&gt;i64) {
			*val = *op2;
		} else {
			*val = *op3;
		}
	}
}
/* }}} */

void zend_ffi_expr_bool_or(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_bool(val);
	zend_ffi_expr_bool(op2);
	if (val-&gt;kind == ZEND_FFI_VAL_INT32 &amp;&amp; op2-&gt;kind == ZEND_FFI_VAL_INT32) {
		val-&gt;i64 = val-&gt;i64 || op2-&gt;i64;
	} else {
		val-&gt;kind = ZEND_FFI_VAL_ERROR;
	}
}
/* }}} */

void zend_ffi_expr_bool_and(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_bool(val);
	zend_ffi_expr_bool(op2);
	if (val-&gt;kind == ZEND_FFI_VAL_INT32 &amp;&amp; op2-&gt;kind == ZEND_FFI_VAL_INT32) {
		val-&gt;i64 = val-&gt;i64 &amp;&amp; op2-&gt;i64;
	} else {
		val-&gt;kind = ZEND_FFI_VAL_ERROR;
	}
}
/* }}} */

void zend_ffi_expr_bw_or(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_int_math(val, op2, |);
}
/* }}} */

void zend_ffi_expr_bw_xor(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_int_math(val, op2, ^);
}
/* }}} */

void zend_ffi_expr_bw_and(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_int_math(val, op2, &amp;);
}
/* }}} */

void zend_ffi_expr_is_equal(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_cmp(val, op2, ==);
}
/* }}} */

void zend_ffi_expr_is_not_equal(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_cmp(val, op2, !=);
}
/* }}} */

void zend_ffi_expr_is_less(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_cmp(val, op2, &lt;);
}
/* }}} */

void zend_ffi_expr_is_greater(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_cmp(val, op2, &gt;);
}
/* }}} */

void zend_ffi_expr_is_less_or_equal(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_cmp(val, op2, &lt;=);
}
/* }}} */

void zend_ffi_expr_is_greater_or_equal(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_cmp(val, op2, &gt;=);
}
/* }}} */

void zend_ffi_expr_shift_left(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_int_math(val, op2, &lt;&lt;);
}
/* }}} */

void zend_ffi_expr_shift_right(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_int_math(val, op2, &gt;&gt;);
}
/* }}} */

void zend_ffi_expr_add(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_math(val, op2, +);
}
/* }}} */

void zend_ffi_expr_sub(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_math(val, op2, -);
}
/* }}} */

void zend_ffi_expr_mul(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_math(val, op2, *);
}
/* }}} */

void zend_ffi_expr_div(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_math(val, op2, /);
}
/* }}} */

void zend_ffi_expr_mod(zend_ffi_val *val, zend_ffi_val *op2) /* {{{ */
{
	zend_ffi_expr_int_math(val, op2, %); // ???
}
/* }}} */

void zend_ffi_expr_cast(zend_ffi_val *val, zend_ffi_dcl *dcl) /* {{{ */
{
	zend_ffi_finalize_type(dcl);
	switch (ZEND_FFI_TYPE(dcl-&gt;type)-&gt;kind) {
		case ZEND_FFI_TYPE_FLOAT:
			if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) {
				val-&gt;kind = ZEND_FFI_VAL_FLOAT;
				val-&gt;d = val-&gt;u64;
			} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
				val-&gt;kind = ZEND_FFI_VAL_FLOAT;
				val-&gt;d = val-&gt;i64;
			} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
				val-&gt;kind = ZEND_FFI_VAL_FLOAT;
			} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
				val-&gt;kind = ZEND_FFI_VAL_FLOAT;
				val-&gt;d = val-&gt;ch;
			} else {
				val-&gt;kind = ZEND_FFI_VAL_ERROR;
			}
			break;
		case ZEND_FFI_TYPE_DOUBLE:
			if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) {
				val-&gt;kind = ZEND_FFI_VAL_DOUBLE;
				val-&gt;d = val-&gt;u64;
			} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
				val-&gt;kind = ZEND_FFI_VAL_DOUBLE;
				val-&gt;d = val-&gt;i64;
			} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
				val-&gt;kind = ZEND_FFI_VAL_DOUBLE;
			} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
				val-&gt;kind = ZEND_FFI_VAL_DOUBLE;
				val-&gt;d = val-&gt;ch;
			} else {
				val-&gt;kind = ZEND_FFI_VAL_ERROR;
			}
			break;
#ifdef HAVE_LONG_DOUBLE
		case ZEND_FFI_TYPE_LONGDOUBLE:
			if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) {
				val-&gt;kind = ZEND_FFI_VAL_LONG_DOUBLE;
				val-&gt;d = val-&gt;u64;
			} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
				val-&gt;kind = ZEND_FFI_VAL_LONG_DOUBLE;
				val-&gt;d = val-&gt;i64;
			} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
				val-&gt;kind = ZEND_FFI_VAL_LONG_DOUBLE;
			} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
				val-&gt;kind = ZEND_FFI_VAL_LONG_DOUBLE;
				val-&gt;d = val-&gt;ch;
			} else {
				val-&gt;kind = ZEND_FFI_VAL_ERROR;
			}
			break;
#endif
		case ZEND_FFI_TYPE_UINT8:
		case ZEND_FFI_TYPE_UINT16:
		case ZEND_FFI_TYPE_UINT32:
		case ZEND_FFI_TYPE_BOOL:
			if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64 || val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
				val-&gt;kind = ZEND_FFI_VAL_UINT32;
			} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
				val-&gt;kind = ZEND_FFI_VAL_UINT32;
				val-&gt;u64 = val-&gt;d;
			} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
				val-&gt;kind = ZEND_FFI_VAL_UINT32;
				val-&gt;u64 = val-&gt;ch;
			} else {
				val-&gt;kind = ZEND_FFI_VAL_ERROR;
			}
			break;
		case ZEND_FFI_TYPE_SINT8:
		case ZEND_FFI_TYPE_SINT16:
		case ZEND_FFI_TYPE_SINT32:
			if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64 || val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
				val-&gt;kind = ZEND_FFI_VAL_INT32;
			} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
				val-&gt;kind = ZEND_FFI_VAL_INT32;
				val-&gt;i64 = val-&gt;d;
			} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
				val-&gt;kind = ZEND_FFI_VAL_INT32;
				val-&gt;i64 = val-&gt;ch;
			} else {
				val-&gt;kind = ZEND_FFI_VAL_ERROR;
			}
			break;
		case ZEND_FFI_TYPE_UINT64:
			if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64 || val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
				val-&gt;kind = ZEND_FFI_VAL_UINT64;
			} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
				val-&gt;kind = ZEND_FFI_VAL_UINT64;
				val-&gt;u64 = val-&gt;d;
			} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
				val-&gt;kind = ZEND_FFI_VAL_UINT64;
				val-&gt;u64 = val-&gt;ch;
			} else {
				val-&gt;kind = ZEND_FFI_VAL_ERROR;
			}
			break;
		case ZEND_FFI_TYPE_SINT64:
			if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) {
				val-&gt;kind = ZEND_FFI_VAL_CHAR;
				val-&gt;ch = val-&gt;u64;
			} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
				val-&gt;kind = ZEND_FFI_VAL_CHAR;
				val-&gt;ch = val-&gt;i64;
			} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
				val-&gt;kind = ZEND_FFI_VAL_CHAR;
				val-&gt;ch = val-&gt;d;
			} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
			} else {
				val-&gt;kind = ZEND_FFI_VAL_ERROR;
			}
			break;
		case ZEND_FFI_TYPE_CHAR:
			if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64 || val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
				val-&gt;kind = ZEND_FFI_VAL_UINT32;
			} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
				val-&gt;kind = ZEND_FFI_VAL_UINT32;
				val-&gt;u64 = val-&gt;d;
			} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
				val-&gt;kind = ZEND_FFI_VAL_UINT32;
				val-&gt;u64 = val-&gt;ch;
			} else {
				val-&gt;kind = ZEND_FFI_VAL_ERROR;
			}
			break;
		default:
			val-&gt;kind = ZEND_FFI_VAL_ERROR;
			break;
	}
	zend_ffi_type_dtor(dcl-&gt;type);
}
/* }}} */

void zend_ffi_expr_plus(zend_ffi_val *val) /* {{{ */
{
	if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) {
	} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
	} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
	} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
	} else {
		val-&gt;kind = ZEND_FFI_VAL_ERROR;
	}
}
/* }}} */

void zend_ffi_expr_neg(zend_ffi_val *val) /* {{{ */
{
	if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) {
		val-&gt;u64 = -val-&gt;u64;
	} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
		val-&gt;i64 = -val-&gt;i64;
	} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT || val-&gt;kind == ZEND_FFI_VAL_DOUBLE || val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
		val-&gt;d = -val-&gt;d;
	} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
		val-&gt;ch = -val-&gt;ch;
	} else {
		val-&gt;kind = ZEND_FFI_VAL_ERROR;
	}
}
/* }}} */

void zend_ffi_expr_bw_not(zend_ffi_val *val) /* {{{ */
{
	if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_UINT64) {
		val-&gt;u64 = ~val-&gt;u64;
	} else if (val-&gt;kind == ZEND_FFI_VAL_INT32 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
		val-&gt;i64 = ~val-&gt;i64;
	} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
		val-&gt;ch = ~val-&gt;ch;
	} else {
		val-&gt;kind = ZEND_FFI_VAL_ERROR;
	}
}
/* }}} */

void zend_ffi_expr_bool_not(zend_ffi_val *val) /* {{{ */
{
	zend_ffi_expr_bool(val);
	if (val-&gt;kind == ZEND_FFI_VAL_INT32) {
		val-&gt;i64 = !val-&gt;i64;
	}
}
/* }}} */

void zend_ffi_expr_sizeof_val(zend_ffi_val *val) /* {{{ */
{
	if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_INT32) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = zend_ffi_type_uint32.size;
	} else if (val-&gt;kind == ZEND_FFI_VAL_UINT64 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = zend_ffi_type_uint64.size;
	} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = zend_ffi_type_float.size;
	} else if (val-&gt;kind == ZEND_FFI_VAL_DOUBLE) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = zend_ffi_type_double.size;
	} else if (val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
#ifdef _WIN32
		val-&gt;u64 = zend_ffi_type_double.size;
#else
		val-&gt;u64 = zend_ffi_type_long_double.size;
#endif
	} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = zend_ffi_type_char.size;
	} else if (val-&gt;kind == ZEND_FFI_VAL_STRING) {
		if (memchr(val-&gt;str, &#039;\\&#039;, val-&gt;len)) {
			// TODO: support for escape sequences ???
			val-&gt;kind = ZEND_FFI_VAL_ERROR;
		} else {
			val-&gt;kind = ZEND_FFI_VAL_UINT32;
			val-&gt;u64 = val-&gt;len + 1;
		}
	} else {
		val-&gt;kind = ZEND_FFI_VAL_ERROR;
	}
}
/* }}} */

void zend_ffi_expr_sizeof_type(zend_ffi_val *val, zend_ffi_dcl *dcl) /* {{{ */
{
	zend_ffi_type *type;

	zend_ffi_finalize_type(dcl);
	type = ZEND_FFI_TYPE(dcl-&gt;type);
	val-&gt;kind = (type-&gt;size &gt; 0xffffffff) ? ZEND_FFI_VAL_UINT64 : ZEND_FFI_VAL_UINT32;
	val-&gt;u64 = type-&gt;size;
	zend_ffi_type_dtor(dcl-&gt;type);
}
/* }}} */

void zend_ffi_expr_alignof_val(zend_ffi_val *val) /* {{{ */
{
	if (val-&gt;kind == ZEND_FFI_VAL_UINT32 || val-&gt;kind == ZEND_FFI_VAL_INT32) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = zend_ffi_type_uint32.align;
	} else if (val-&gt;kind == ZEND_FFI_VAL_UINT64 || val-&gt;kind == ZEND_FFI_VAL_INT64) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = zend_ffi_type_uint64.align;
	} else if (val-&gt;kind == ZEND_FFI_VAL_FLOAT) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = zend_ffi_type_float.align;
	} else if (val-&gt;kind == ZEND_FFI_VAL_DOUBLE) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = zend_ffi_type_double.align;
#ifdef HAVE_LONG_DOUBLE
	} else if (val-&gt;kind == ZEND_FFI_VAL_LONG_DOUBLE) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = zend_ffi_type_long_double.align;
#endif
	} else if (val-&gt;kind == ZEND_FFI_VAL_CHAR) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = zend_ffi_type_char.size;
	} else if (val-&gt;kind == ZEND_FFI_VAL_STRING) {
		val-&gt;kind = ZEND_FFI_VAL_UINT32;
		val-&gt;u64 = _Alignof(char*);
	} else {
		val-&gt;kind = ZEND_FFI_VAL_ERROR;
	}
}
/* }}} */

void zend_ffi_expr_alignof_type(zend_ffi_val *val, zend_ffi_dcl *dcl) /* {{{ */
{
	zend_ffi_finalize_type(dcl);
	val-&gt;kind = ZEND_FFI_VAL_UINT32;
	val-&gt;u64 = ZEND_FFI_TYPE(dcl-&gt;type)-&gt;align;
	zend_ffi_type_dtor(dcl-&gt;type);
}
/* }}} */

void zend_ffi_val_number(zend_ffi_val *val, int base, const char *str, size_t str_len) /* {{{ */
{
	int u = 0;
	int l = 0;

	if (str[str_len-1] == &#039;u&#039; || str[str_len-1] == &#039;U&#039;) {
		u = 1;
		if (str[str_len-2] == &#039;l&#039; || str[str_len-2] == &#039;L&#039;) {
			l = 1;
			if (str[str_len-3] == &#039;l&#039; || str[str_len-3] == &#039;L&#039;) {
				l = 2;
			}
		}
	} else if (str[str_len-1] == &#039;l&#039; || str[str_len-1] == &#039;L&#039;) {
		l = 1;
		if (str[str_len-2] == &#039;l&#039; || str[str_len-2] == &#039;L&#039;) {
			l = 2;
			if (str[str_len-3] == &#039;u&#039; || str[str_len-3] == &#039;U&#039;) {
				u = 1;
			}
		} else if (str[str_len-2] == &#039;u&#039; || str[str_len-2] == &#039;U&#039;) {
			u = 1;
		}
	}
	if (u) {
		val-&gt;u64 = strtoull(str, NULL, base);
		if (l == 0) {
			val-&gt;kind = ZEND_FFI_VAL_UINT32;
		} else if (l == 1) {
			val-&gt;kind = (sizeof(long) == 4) ? ZEND_FFI_VAL_UINT32 : ZEND_FFI_VAL_UINT64;
		} else if (l == 2) {
			val-&gt;kind = ZEND_FFI_VAL_UINT64;
		}
	} else {
		val-&gt;i64 = strtoll(str, NULL, base);
		if (l == 0) {
			val-&gt;kind = ZEND_FFI_VAL_INT32;
		} else if (l == 1) {
			val-&gt;kind = (sizeof(long) == 4) ? ZEND_FFI_VAL_INT32 : ZEND_FFI_VAL_INT64;
		} else if (l == 2) {
			val-&gt;kind = ZEND_FFI_VAL_INT64;
		}
	}
}
/* }}} */

void zend_ffi_val_float_number(zend_ffi_val *val, const char *str, size_t str_len) /* {{{ */
{
	val-&gt;d = strtold(str, NULL);
	if (str[str_len-1] == &#039;f&#039; || str[str_len-1] == &#039;F&#039;) {
		val-&gt;kind = ZEND_FFI_VAL_FLOAT;
	} else if (str[str_len-1] == &#039;l&#039; || str[str_len-1] == &#039;L&#039;) {
		val-&gt;kind = ZEND_FFI_VAL_LONG_DOUBLE;
	} else {
		val-&gt;kind = ZEND_FFI_VAL_DOUBLE;
	}
}
/* }}} */

void zend_ffi_val_string(zend_ffi_val *val, const char *str, size_t str_len) /* {{{ */
{
	if (str[0] != &#039;\&quot;&#039;) {
		val-&gt;kind = ZEND_FFI_VAL_ERROR;
	} else {
		val-&gt;kind = ZEND_FFI_VAL_STRING;
		val-&gt;str = str + 1;
		val-&gt;len = str_len - 2;
	}
}
/* }}} */

void zend_ffi_val_character(zend_ffi_val *val, const char *str, size_t str_len) /* {{{ */
{
	int n;

	if (str[0] != &#039;\&#039;&#039;) {
		val-&gt;kind = ZEND_FFI_VAL_ERROR;
	} else {
		val-&gt;kind = ZEND_FFI_VAL_CHAR;
		if (str_len == 3) {
			val-&gt;ch = str[1];
		} else if (str[1] == &#039;\\&#039;) {
			if (str[2] == &#039;a&#039;) {
			} else if (str[2] == &#039;b&#039; &amp;&amp; str_len == 4) {
				val-&gt;ch = &#039;\b&#039;;
			} else if (str[2] == &#039;f&#039; &amp;&amp; str_len == 4) {
				val-&gt;ch = &#039;\f&#039;;
			} else if (str[2] == &#039;n&#039; &amp;&amp; str_len == 4) {
				val-&gt;ch = &#039;\n&#039;;
			} else if (str[2] == &#039;r&#039; &amp;&amp; str_len == 4) {
				val-&gt;ch = &#039;\r&#039;;
			} else if (str[2] == &#039;t&#039; &amp;&amp; str_len == 4) {
				val-&gt;ch = &#039;\t&#039;;
			} else if (str[2] == &#039;v&#039; &amp;&amp; str_len == 4) {
				val-&gt;ch = &#039;\v&#039;;
			} else if (str[2] &gt;= &#039;0&#039; &amp;&amp; str[2] &lt;= &#039;7&#039;) {
				n = str[2] - &#039;0&#039;;
				if (str[3] &gt;= &#039;0&#039; &amp;&amp; str[3] &lt;= &#039;7&#039;) {
					n = n * 8 + (str[3] - &#039;0&#039;);
					if ((str[4] &gt;= &#039;0&#039; &amp;&amp; str[4] &lt;= &#039;7&#039;) &amp;&amp; str_len == 6) {
						n = n * 8 + (str[4] - &#039;0&#039;);
					} else if (str_len != 5) {
						val-&gt;kind = ZEND_FFI_VAL_ERROR;
					}
				} else if (str_len != 4) {
					val-&gt;kind = ZEND_FFI_VAL_ERROR;
				}
				if (n &lt;= 0xff) {
					val-&gt;ch = n;
				} else {
					val-&gt;kind = ZEND_FFI_VAL_ERROR;
				}
			} else if (str[2] == &#039;x&#039;) {
				if (str[3] &gt;= &#039;0&#039; &amp;&amp; str[3] &lt;= &#039;9&#039;) {
					n = str[3] - &#039;0&#039;;
				} else if (str[3] &gt;= &#039;A&#039; &amp;&amp; str[3] &lt;= &#039;F&#039;) {
					n = str[3] - &#039;A&#039;;
				} else if (str[3] &gt;= &#039;a&#039; &amp;&amp; str[3] &lt;= &#039;f&#039;) {
					n = str[3] - &#039;a&#039;;
				} else {
					val-&gt;kind = ZEND_FFI_VAL_ERROR;
					return;
				}
				if ((str[4] &gt;= &#039;0&#039; &amp;&amp; str[4] &lt;= &#039;9&#039;) &amp;&amp; str_len == 6) {
					n = n * 16 + (str[4] - &#039;0&#039;);
				} else if ((str[4] &gt;= &#039;A&#039; &amp;&amp; str[4] &lt;= &#039;F&#039;) &amp;&amp; str_len == 6) {
					n = n * 16 + (str[4] - &#039;A&#039;);
				} else if ((str[4] &gt;= &#039;a&#039; &amp;&amp; str[4] &lt;= &#039;f&#039;) &amp;&amp; str_len == 6) {
					n = n * 16 + (str[4] - &#039;a&#039;);
				} else if (str_len != 5) {
					val-&gt;kind = ZEND_FFI_VAL_ERROR;
					return;
				}
				val-&gt;ch = n;
			} else if (str_len == 4) {
				val-&gt;ch = str[2];
			} else {
				val-&gt;kind = ZEND_FFI_VAL_ERROR;
			}
		} else {
			val-&gt;kind = ZEND_FFI_VAL_ERROR;
		}
	}
}
/* }}} */
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fffi'>🔙 Back</a></p>