Hugging Face's logo

Datasets:
meddyrat
/
dis-bench

Modalities:
Tabular
Text
Formats:
parquet
Size:
1K - 10K
Libraries:
Datasets
pandas
Polars
Dataset card Data Studio Files
xet
 Community
1
dis-bench / src /php /php-src /ext /ffi /ffi.c
meddyrat's picture
meddyrat
Replace repository contents with the original corrected artifact
1e94262
Raw History Blame Contribute Delete
242 kB
/*
+----------------------------------------------------------------------+
| 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 <dmitry@zend.com> |
+----------------------------------------------------------------------+
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "php.h"
#include "php_ffi.h"
#include "ext/standard/info.h"
#include "php_scandir.h"
#include "zend_exceptions.h"
#include "zend_closures.h"
#include "zend_weakrefs.h"
#include "main/SAPI.h"
#include "zend_observer.h"
#include <ffi.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#ifdef HAVE_LIBDL
#ifdef PHP_WIN32
#include "win32/param.h"
#include "win32/winutil.h"
#define GET_DL_ERROR() php_win_err()
#else
#include <sys/param.h>
#define GET_DL_ERROR() DL_ERROR()
#endif
#endif
#include "php_glob.h"
#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] = {"enum", "struct", "union"};
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 "ffi_arginfo.h"
typedef enum _zend_ffi_flags {
ZEND_FFI_FLAG_CONST = (1 << 0),
ZEND_FFI_FLAG_OWNED = (1 << 1),
ZEND_FFI_FLAG_PERSISTENT = (1 << 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<<0)
#define ZEND_FFI_TYPE(t) \
((zend_ffi_type*)(((uintptr_t)(t)) & ~ZEND_FFI_TYPE_OWNED))
#define ZEND_FFI_TYPE_IS_OWNED(t) \
(((uintptr_t)(t)) & 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(const zend_ffi_type *type1, const 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(const zval *arg, const zend_ffi_type *type);
static bool zend_ffi_is_compatible_type(const zend_ffi_type *dst_type, const 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 << GC_FLAGS_SHIFT);
object->extra_flags = 0;
object->ce = ce;
object->handlers = ce->default_object_handlers;
object->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(&cdata->std, class_type);
cdata->type = NULL;
cdata->ptr = NULL;
cdata->flags = 0;
return &cdata->std;
}
/* }}} */
static bool zend_ffi_func_ptr_are_compatible(const zend_ffi_type *dst_type, const zend_ffi_type *src_type) /* {{{ */
{
uint32_t dst_argc, src_argc, i;
zend_ffi_type *dst_arg, *src_arg;
ZEND_ASSERT(dst_type->kind == ZEND_FFI_TYPE_FUNC);
ZEND_ASSERT(src_type->kind == ZEND_FFI_TYPE_FUNC);
/* Ensure calling convention matches */
if (dst_type->func.abi != src_type->func.abi) {
return 0;
}
/* Ensure variadic attr matches */
if ((dst_type->attr & ZEND_FFI_ATTR_VARIADIC) != (src_type->attr & ZEND_FFI_ATTR_VARIADIC)) {
return 0;
}
/* Ensure same arg count */
dst_argc = dst_type->func.args ? zend_hash_num_elements(dst_type->func.args) : 0;
src_argc = src_type->func.args ? zend_hash_num_elements(src_type->func.args) : 0;
if (dst_argc != src_argc) {
return 0;
}
/* Ensure compatible ret_type */
if (!zend_ffi_is_compatible_type(dst_type->func.ret_type, src_type->func.ret_type)) {
return 0;
}
/* Ensure compatible args */
for (i = 0; i < dst_argc; i++) {
dst_arg = zend_hash_index_find_ptr(dst_type->func.args, i);
src_arg = zend_hash_index_find_ptr(src_type->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(const zend_ffi_type *dst_type, const zend_ffi_type *src_type) /* {{{ */
{
while (1) {
if (dst_type == src_type) {
return 1;
} else if (dst_type->kind == src_type->kind) {
if (dst_type->kind < ZEND_FFI_TYPE_POINTER) {
return 1;
} else if (dst_type->kind == ZEND_FFI_TYPE_POINTER) {
dst_type = ZEND_FFI_TYPE(dst_type->pointer.type);
src_type = ZEND_FFI_TYPE(src_type->pointer.type);
if (dst_type->kind == ZEND_FFI_TYPE_VOID ||
src_type->kind == ZEND_FFI_TYPE_VOID) {
return 1;
} else if (dst_type->kind == ZEND_FFI_TYPE_FUNC &&
src_type->kind == ZEND_FFI_TYPE_FUNC) {
return zend_ffi_func_ptr_are_compatible(dst_type, src_type);
}
} else if (dst_type->kind == ZEND_FFI_TYPE_ARRAY &&
(dst_type->array.length == src_type->array.length ||
dst_type->array.length == 0)) {
dst_type = ZEND_FFI_TYPE(dst_type->array.type);
src_type = ZEND_FFI_TYPE(src_type->array.type);
} else {
break;
}
} else if (dst_type->kind == ZEND_FFI_TYPE_POINTER &&
src_type->kind == ZEND_FFI_TYPE_ARRAY) {
dst_type = ZEND_FFI_TYPE(dst_type->pointer.type);
src_type = ZEND_FFI_TYPE(src_type->array.type);
if (dst_type->kind == ZEND_FFI_TYPE_VOID) {
return 1;
}
} else {
break;
}
}
return 0;
}
/* }}} */
static ffi_type* zend_ffi_face_struct_add_fields(ffi_type* t, const zend_ffi_type *type, int *i, size_t size)
{
zend_ffi_field *field;
ZEND_HASH_MAP_FOREACH_PTR(&type->record.fields, field) {
switch (ZEND_FFI_TYPE(field->type)->kind) {
case ZEND_FFI_TYPE_FLOAT:
t->elements[(*i)++] = &ffi_type_float;
break;
case ZEND_FFI_TYPE_DOUBLE:
t->elements[(*i)++] = &ffi_type_double;
break;
#ifdef HAVE_LONG_DOUBLE
case ZEND_FFI_TYPE_LONGDOUBLE:
t->elements[(*i)++] = &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->elements[(*i)++] = &ffi_type_uint8;
break;
case ZEND_FFI_TYPE_SINT16:
case ZEND_FFI_TYPE_UINT16:
t->elements[(*i)++] = &ffi_type_uint16;
break;
case ZEND_FFI_TYPE_SINT32:
case ZEND_FFI_TYPE_UINT32:
t->elements[(*i)++] = &ffi_type_uint32;
break;
case ZEND_FFI_TYPE_SINT64:
case ZEND_FFI_TYPE_UINT64:
t->elements[(*i)++] = &ffi_type_uint64;
break;
case ZEND_FFI_TYPE_POINTER:
t->elements[(*i)++] = &ffi_type_pointer;
break;
case ZEND_FFI_TYPE_STRUCT: {
zend_ffi_type *field_type = ZEND_FFI_TYPE(field->type);
/* for unions we use only the first field */
uint32_t num_fields = !(field_type->attr & ZEND_FFI_ATTR_UNION) ?
zend_hash_num_elements(&field_type->record.fields) : 1;
if (num_fields > 1) {
size += sizeof(ffi_type*) * (num_fields - 1);
t = erealloc(t, size);
t->elements = (ffi_type**)(t + 1);
}
t = zend_ffi_face_struct_add_fields(t, field_type, i, size);
break;
}
default:
t->elements[(*i)++] = &ffi_type_void;
break;
}
if (type->attr & 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(const zend_ffi_type *type) /* {{{ */
{
/* for unions we use only the first field */
uint32_t num_fields = !(type->attr & ZEND_FFI_ATTR_UNION) ?
zend_hash_num_elements(&type->record.fields) : 1;
size_t size = sizeof(ffi_type) + sizeof(ffi_type*) * (num_fields + 1);
ffi_type *t = emalloc(size);
int i;
t->size = type->size;
t->alignment = type->align;
t->type = FFI_TYPE_STRUCT;
t->elements = (ffi_type**)(t + 1);
i = 0;
t = zend_ffi_face_struct_add_fields(t, type, &i, size);
t->elements[i] = NULL;
return t;
}
/* }}} */
static ffi_type *zend_ffi_get_type(const zend_ffi_type *type) /* {{{ */
{
zend_ffi_type_kind kind = type->kind;
again:
switch (kind) {
case ZEND_FFI_TYPE_FLOAT:
return &ffi_type_float;
case ZEND_FFI_TYPE_DOUBLE:
return &ffi_type_double;
#ifdef HAVE_LONG_DOUBLE
case ZEND_FFI_TYPE_LONGDOUBLE:
return &ffi_type_longdouble;
#endif
case ZEND_FFI_TYPE_UINT8:
return &ffi_type_uint8;
case ZEND_FFI_TYPE_SINT8:
return &ffi_type_sint8;
case ZEND_FFI_TYPE_UINT16:
return &ffi_type_uint16;
case ZEND_FFI_TYPE_SINT16:
return &ffi_type_sint16;
case ZEND_FFI_TYPE_UINT32:
return &ffi_type_uint32;
case ZEND_FFI_TYPE_SINT32:
return &ffi_type_sint32;
case ZEND_FFI_TYPE_UINT64:
return &ffi_type_uint64;
case ZEND_FFI_TYPE_SINT64:
return &ffi_type_sint64;
case ZEND_FFI_TYPE_POINTER:
return &ffi_type_pointer;
case ZEND_FFI_TYPE_VOID:
return &ffi_type_void;
case ZEND_FFI_TYPE_BOOL:
return &ffi_type_uint8;
case ZEND_FFI_TYPE_CHAR:
return &ffi_type_sint8;
case ZEND_FFI_TYPE_ENUM:
kind = type->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(&cdata->std, zend_ffi_cdata_ce);
cdata->std.handlers =
(type->kind < ZEND_FFI_TYPE_POINTER) ?
&zend_ffi_cdata_value_handlers :
&zend_ffi_cdata_handlers;
cdata->type = type;
cdata->flags = flags;
cdata->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(&cdata->std, zend_ffi_cdata_ce);
cdata->type = type;
cdata->flags = flags;
cdata->ptr = (void*)&cdata->ptr_holder;
*(void**)cdata->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(&cdata->std, zend_ffi_cdata_ce);
cdata->std.handlers =
(type->kind < ZEND_FFI_TYPE_POINTER) ?
&zend_ffi_cdata_value_handlers :
&zend_ffi_cdata_handlers;
cdata->type = type;
cdata->flags = flags;
if (type->kind == ZEND_FFI_TYPE_POINTER) {
cdata->ptr = (void*)&cdata->ptr_holder;
*(void**)cdata->ptr = *(void**)ptr;
} else if (type->kind == ZEND_FFI_TYPE_STRUCT) {
cdata->ptr = emalloc(type->size);
cdata->flags |= ZEND_FFI_FLAG_OWNED;
memcpy(cdata->ptr, ptr, type->size);
} else {
cdata->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->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->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, "%p", *(void**)ptr));
return;
} else if ((type->attr & ZEND_FFI_ATTR_CONST) && ZEND_FFI_TYPE(type->pointer.type)->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(&cdata->std);
}
ZVAL_OBJ(rv, &cdata->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(&cdata->std);
}
ZVAL_OBJ(rv, &cdata->std);
}
/* }}} */
static uint64_t zend_ffi_bit_field_read(void *ptr, const zend_ffi_field *field) /* {{{ */
{
size_t bit = field->first_bit;
size_t last_bit = bit + field->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 << field->bits) - 1U;
return (*p >> pos) & mask;
}
/* Read partial prefix byte */
if (pos != 0) {
size_t num_bits = 8 - pos;
mask = (1U << num_bits) - 1U;
val = (*p++ >> pos) & mask;
insert_pos += num_bits;
}
/* Read full bytes */
while (p < last_p) {
val |= (uint64_t) *p++ << insert_pos;
insert_pos += 8;
}
/* Read partial suffix byte */
if (p == last_p) {
size_t num_bits = last_bit % 8 + 1;
mask = (1U << num_bits) - 1U;
val |= (uint64_t) (*p & mask) << insert_pos;
}
return val;
}
/* }}} */
static void zend_ffi_bit_field_to_zval(void *ptr, const zend_ffi_field *field, zval *rv) /* {{{ */
{
uint64_t val = zend_ffi_bit_field_read(ptr, field);
if (ZEND_FFI_TYPE(field->type)->kind == ZEND_FFI_TYPE_CHAR
|| ZEND_FFI_TYPE(field->type)->kind == ZEND_FFI_TYPE_SINT8
|| ZEND_FFI_TYPE(field->type)->kind == ZEND_FFI_TYPE_SINT16
|| ZEND_FFI_TYPE(field->type)->kind == ZEND_FFI_TYPE_SINT32
|| ZEND_FFI_TYPE(field->type)->kind == ZEND_FFI_TYPE_SINT64) {
/* Sign extend */
uint64_t shift = 64 - (field->bits % 64);
if (shift != 0) {
val = (int64_t)(val << shift) >> shift;
}
}
ZVAL_LONG(rv, val);
}
/* }}} */
static void zend_ffi_zval_to_bit_field(void *ptr, const zend_ffi_field *field, const zval *value) /* {{{ */
{
uint64_t val = zval_get_long(value);
size_t bit = field->first_bit;
size_t last_bit = bit + field->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 << field->bits) - 1U) << pos;
*p = (*p & ~mask) | ((val << pos) & mask);
return;
}
/* Write partial prefix byte */
if (pos != 0) {
size_t num_bits = 8 - pos;
mask = ((1U << num_bits) - 1U) << pos;
*p = (*p & ~mask) | ((val << pos) & mask);
p++;
val >>= num_bits;
}
/* Write full bytes */
while (p < last_p) {
*p++ = val;
val >>= 8;
}
/* Write partial suffix byte */
if (p == last_p) {
size_t num_bits = last_bit % 8 + 1;
mask = (1U << num_bits) - 1U;
*p = (*p & ~mask) | (val & 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->kind;
/* Pointer type has special handling of CData */
if (kind != ZEND_FFI_TYPE_POINTER && Z_TYPE_P(value) == IS_OBJECT && Z_OBJCE_P(value) == zend_ffi_cdata_ce) {
const zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(value);
if (zend_ffi_is_compatible_type(type, ZEND_FFI_TYPE(cdata->type)) &&
type->size == ZEND_FFI_TYPE(cdata->type)->size) {
memcpy(ptr, cdata->ptr, type->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, &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->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 && Z_OBJCE_P(value) == zend_ffi_cdata_ce) {
const zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(value);
if (zend_ffi_is_compatible_type(type, ZEND_FFI_TYPE(cdata->type))) {
if (ZEND_FFI_TYPE(cdata->type)->kind == ZEND_FFI_TYPE_POINTER) {
*(void**)ptr = *(void**)cdata->ptr;
} else {
if (cdata->flags & ZEND_FFI_FLAG_OWNED) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to perform assign of owned C pointer");
return FAILURE;
}
*(void**)ptr = cdata->ptr;
}
return SUCCESS;
/* Allow transparent assignment of not-owned CData to compatible pointers */
} else if (ZEND_FFI_TYPE(cdata->type)->kind != ZEND_FFI_TYPE_POINTER
&& zend_ffi_is_compatible_type(ZEND_FFI_TYPE(type->pointer.type), ZEND_FFI_TYPE(cdata->type))) {
if (cdata->flags & ZEND_FFI_FLAG_OWNED) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to perform assign pointer to owned C data");
return FAILURE;
}
*(void**)ptr = cdata->ptr;
return SUCCESS;
}
#if FFI_CLOSURES
} else if (ZEND_FFI_TYPE(type->pointer.type)->kind == ZEND_FFI_TYPE_FUNC) {
void *callback = zend_ffi_create_callback(ZEND_FFI_TYPE(type->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've succeeded. */
zend_ffi_assign_incompatible(value, type);
return FAILURE;
}
return SUCCESS;
}
/* }}} */
#if defined(ZEND_WIN32) && (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->func.args, arg_type) {
arg_size += MAX(ZEND_FFI_TYPE(arg_type)->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->func.abi) {
# ifdef HAVE_FFI_FASTCALL
case FFI_FASTCALL:
return strpprintf(0, "@%s@%zu", ZSTR_VAL(name), zend_ffi_arg_size(type));
# endif
# ifdef HAVE_FFI_STDCALL
case FFI_STDCALL:
return strpprintf(0, "_%s@%zu", ZSTR_VAL(name), zend_ffi_arg_size(type));
# endif
# ifdef HAVE_FFI_VECTORCALL_PARTIAL
case FFI_VECTORCALL_PARTIAL:
return strpprintf(0, "%s@@%zu", ZSTR_VAL(name), zend_ffi_arg_size(type));
# endif
default:
/* other calling conventions don't apply name mangling */
break;
}
#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->callback);
if (callback_data->fcc.function_handler->common.fn_flags & ZEND_ACC_CLOSURE) {
OBJ_RELEASE(ZEND_CLOSURE_OBJECT(callback_data->fcc.function_handler));
}
for (uint32_t i = 0; i < callback_data->arg_count; ++i) {
if (callback_data->arg_types[i]->type == FFI_TYPE_STRUCT) {
efree(callback_data->arg_types[i]);
}
}
if (callback_data->ret_type->type == FFI_TYPE_STRUCT) {
efree(callback_data->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(&fci.function_name);
fci.retval = &retval;
fci.params = do_alloca(sizeof(zval) *callback_data->arg_count, use_heap);
fci.object = NULL;
fci.param_count = callback_data->arg_count;
fci.named_params = NULL;
if (callback_data->type->func.args) {
int n = 0;
zend_ffi_type *arg_type;
ZEND_HASH_PACKED_FOREACH_PTR(callback_data->type->func.args, arg_type) {
arg_type = ZEND_FFI_TYPE(arg_type);
zend_ffi_cdata_to_zval(NULL, args[n], arg_type, BP_VAR_R, &fci.params[n], (zend_ffi_flags)(arg_type->attr & ZEND_FFI_ATTR_CONST), 0, 0);
n++;
} ZEND_HASH_FOREACH_END();
}
ZVAL_UNDEF(&retval);
if (zend_call_function(&fci, &callback_data->fcc) != SUCCESS) {
zend_throw_error(zend_ffi_exception_ce, "Cannot call callback");
}
if (callback_data->arg_count) {
for (uint32_t n = 0; n < callback_data->arg_count; n++) {
zval_ptr_dtor(&fci.params[n]);
}
}
free_alloca(fci.params, use_heap);
if (EG(exception)) {
zend_error_noreturn(E_ERROR, "Throwing from FFI callbacks is not allowed");
}
ret_type = ZEND_FFI_TYPE(callback_data->type->func.ret_type);
if (ret_type->kind != ZEND_FFI_TYPE_VOID) {
zend_ffi_zval_to_cdata(ret, ret_type, &retval);
#ifdef WORDS_BIGENDIAN
if (ret_type->size < sizeof(ffi_arg)
&& ret_type->kind >= ZEND_FFI_TYPE_UINT8
&& ret_type->kind < ZEND_FFI_TYPE_POINTER) {
/* We need to widen the value (zero extend) */
switch (ret_type->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(&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->attr & ZEND_FFI_ATTR_VARIADIC) {
zend_throw_error(zend_ffi_exception_ce, "Variadic function closures are not supported");
return NULL;
}
if (!zend_is_callable_ex(value, NULL, 0, NULL, &fcc, &error)) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to assign an invalid callback, %s", error);
return NULL;
}
arg_count = type->func.args ? zend_hash_num_elements(type->func.args) : 0;
if (arg_count < fcc.function_handler->common.required_num_args) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to assign an invalid callback, insufficient number of arguments");
return NULL;
}
callback = ffi_closure_alloc(sizeof(ffi_closure), &code);
if (!callback) {
zend_throw_error(zend_ffi_exception_ce, "Cannot allocate callback");
return NULL;
}
callback_data = emalloc(sizeof(zend_ffi_callback_data) + sizeof(ffi_type*) * arg_count);
memcpy(&callback_data->fcc, &fcc, sizeof(zend_fcall_info_cache));
callback_data->type = type;
callback_data->callback = callback;
callback_data->code = code;
callback_data->arg_count = arg_count;
if (type->func.args) {
int n = 0;
zend_ffi_type *arg_type;
ZEND_HASH_PACKED_FOREACH_PTR(type->func.args, arg_type) {
arg_type = ZEND_FFI_TYPE(arg_type);
callback_data->arg_types[n] = zend_ffi_get_type(arg_type);
if (!callback_data->arg_types[n]) {
zend_ffi_pass_unsupported(arg_type);
for (int i = 0; i < n; ++i) {
if (callback_data->arg_types[i]->type == FFI_TYPE_STRUCT) {
efree(callback_data->arg_types[i]);
}
}
efree(callback_data);
ffi_closure_free(callback);
return NULL;
}
n++;
} ZEND_HASH_FOREACH_END();
}
callback_data->ret_type = zend_ffi_get_type(ZEND_FFI_TYPE(type->func.ret_type));
if (!callback_data->ret_type) {
zend_ffi_return_unsupported(type->func.ret_type);
for (int i = 0; i < callback_data->arg_count; ++i) {
if (callback_data->arg_types[i]->type == FFI_TYPE_STRUCT) {
efree(callback_data->arg_types[i]);
}
}
efree(callback_data);
ffi_closure_free(callback);
return NULL;
}
if (ffi_prep_cif(&callback_data->cif, type->func.abi, callback_data->arg_count, callback_data->ret_type, callback_data->arg_types) != FFI_OK) {
zend_throw_error(zend_ffi_exception_ce, "Cannot prepare callback CIF");
goto free_on_failure;
}
if (ffi_prep_closure_loc(callback, &callback_data->cif, zend_ffi_callback_trampoline, callback_data, code) != FFI_OK) {
zend_throw_error(zend_ffi_exception_ce, "Cannot prepare callback");
free_on_failure: ;
for (int i = 0; i < callback_data->arg_count; ++i) {
if (callback_data->arg_types[i]->type == FFI_TYPE_STRUCT) {
efree(callback_data->arg_types[i]);
}
}
if (callback_data->ret_type->type == FFI_TYPE_STRUCT) {
efree(callback_data->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->common.fn_flags & 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->type);
#if 0
if (UNEXPECTED(!cdata->ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return &EG(uninitialized_zval);
}
#endif
if (UNEXPECTED(!zend_string_equals_literal(member, "cdata"))) {
zend_throw_error(zend_ffi_exception_ce, "Only 'cdata' property may be read");
return &EG(uninitialized_zval);
}
zend_ffi_cdata_to_zval(cdata, cdata->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->type);
#if 0
if (UNEXPECTED(!cdata->ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return &EG(uninitialized_zval);
}
#endif
if (UNEXPECTED(!zend_string_equals_literal(member, "cdata"))) {
zend_throw_error(zend_ffi_exception_ce, "Only 'cdata' property may be set");
return &EG(uninitialized_zval);
}
zend_ffi_zval_to_cdata(cdata->ptr, type, value);
return value;
}
/* }}} */
static zend_result zend_ffi_cdata_cast_object(zend_object *readobj, zval *writeobj, int type) /* {{{ */
{
if (type == IS_STRING) {
const zend_ffi_cdata *cdata = (zend_ffi_cdata*)readobj;
const zend_ffi_type *ctype = ZEND_FFI_TYPE(cdata->type);
void *ptr = cdata->ptr;
zend_ffi_type_kind kind = ctype->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->enumeration.kind;
goto again;
case ZEND_FFI_TYPE_POINTER:
if (*(void**)ptr == NULL) {
ZVAL_NULL(writeobj);
break;
} else if ((ctype->attr & ZEND_FFI_ATTR_CONST) && ZEND_FFI_TYPE(ctype->pointer.type)->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->type);
void *ptr = cdata->ptr;
zend_ffi_field *field;
if (cache_slot && *cache_slot == type) {
field = *(cache_slot + 1);
} else {
if (type->kind == ZEND_FFI_TYPE_POINTER) {
type = ZEND_FFI_TYPE(type->pointer.type);
}
if (UNEXPECTED(type->kind != ZEND_FFI_TYPE_STRUCT)) {
if (UNEXPECTED(type->kind != ZEND_FFI_TYPE_STRUCT)) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to read field '%s' of non C struct/union", ZSTR_VAL(field_name));
return &EG(uninitialized_zval);
}
}
field = zend_hash_find_ptr(&type->record.fields, field_name);
if (UNEXPECTED(!field)) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to read undefined field '%s' of C struct/union", ZSTR_VAL(field_name));
return &EG(uninitialized_zval);
}
if (cache_slot) {
*cache_slot = type;
*(cache_slot + 1) = field;
}
}
if (ZEND_FFI_TYPE(cdata->type)->kind == ZEND_FFI_TYPE_POINTER) {
/* transparently dereference the pointer */
if (UNEXPECTED(!ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return &EG(uninitialized_zval);
}
ptr = (void*)(*(char**)ptr);
if (UNEXPECTED(!ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return &EG(uninitialized_zval);
}
type = ZEND_FFI_TYPE(type->pointer.type);
}
#if 0
if (UNEXPECTED(!ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return &EG(uninitialized_zval);
}
#endif
if (EXPECTED(!field->bits)) {
zend_ffi_type *field_type = field->type;
if (ZEND_FFI_TYPE_IS_OWNED(field_type)) {
field_type = ZEND_FFI_TYPE(field_type);
if (!(field_type->attr & ZEND_FFI_ATTR_STORED)
&& field_type->kind == ZEND_FFI_TYPE_POINTER) {
field->type = field_type = zend_ffi_remember_type(field_type);
}
}
ptr = (void*)(((char*)ptr) + field->offset);
zend_ffi_cdata_to_zval(NULL, ptr, field_type, read_type, rv, (cdata->flags & ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)field->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->type);
void *ptr = cdata->ptr;
zend_ffi_field *field;
if (cache_slot && *cache_slot == type) {
field = *(cache_slot + 1);
} else {
if (UNEXPECTED(type == NULL)) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to assign field '%s' to uninitialized FFI\\CData object", ZSTR_VAL(field_name));
return value;
}
if (type->kind == ZEND_FFI_TYPE_POINTER) {
type = ZEND_FFI_TYPE(type->pointer.type);
}
if (UNEXPECTED(type->kind != ZEND_FFI_TYPE_STRUCT)) {
if (UNEXPECTED(type->kind != ZEND_FFI_TYPE_STRUCT)) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to assign field '%s' of non C struct/union", ZSTR_VAL(field_name));
return value;
}
}
field = zend_hash_find_ptr(&type->record.fields, field_name);
if (UNEXPECTED(!field)) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to assign undefined field '%s' of C struct/union", ZSTR_VAL(field_name));
return value;
}
if (cache_slot) {
*cache_slot = type;
*(cache_slot + 1) = field;
}
}
if (ZEND_FFI_TYPE(cdata->type)->kind == ZEND_FFI_TYPE_POINTER) {
/* transparently dereference the pointer */
if (UNEXPECTED(!ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return value;
}
ptr = (void*)(*(char**)ptr);
if (UNEXPECTED(!ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return value;
}
}
#if 0
if (UNEXPECTED(!ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return value;
}
#endif
if (UNEXPECTED(cdata->flags & ZEND_FFI_FLAG_CONST)) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to assign read-only location");
return value;
} else if (UNEXPECTED(field->is_const)) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to assign read-only field '%s'", ZSTR_VAL(field_name));
return value;
}
if (EXPECTED(!field->bits)) {
ptr = (void*)(((char*)ptr) + field->offset);
zend_ffi_zval_to_cdata(ptr, ZEND_FFI_TYPE(field->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->type);
zend_long dim = zval_get_long(offset);
zend_ffi_type *dim_type;
void *ptr;
zend_ffi_flags is_const;
if (EXPECTED(type->kind == ZEND_FFI_TYPE_ARRAY)) {
if (UNEXPECTED((zend_ulong)(dim) >= (zend_ulong)type->array.length)
&& (UNEXPECTED(dim < 0) || UNEXPECTED(type->array.length != 0))) {
zend_throw_error(zend_ffi_exception_ce, "C array index out of bounds");
return &EG(uninitialized_zval);
}
is_const = (cdata->flags & ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)(type->attr & ZEND_FFI_ATTR_CONST);
dim_type = type->array.type;
if (ZEND_FFI_TYPE_IS_OWNED(dim_type)) {
dim_type = ZEND_FFI_TYPE(dim_type);
if (!(dim_type->attr & ZEND_FFI_ATTR_STORED)
&& dim_type->kind == ZEND_FFI_TYPE_POINTER) {
type->array.type = dim_type = zend_ffi_remember_type(dim_type);
}
}
#if 0
if (UNEXPECTED(!cdata->ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return &EG(uninitialized_zval);
}
#endif
ptr = (void*)(((char*)cdata->ptr) + dim_type->size * dim);
} else if (EXPECTED(type->kind == ZEND_FFI_TYPE_POINTER)) {
is_const = (cdata->flags & ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)(type->attr & ZEND_FFI_ATTR_CONST);
dim_type = type->pointer.type;
if (ZEND_FFI_TYPE_IS_OWNED(dim_type)) {
dim_type = ZEND_FFI_TYPE(dim_type);
if (!(dim_type->attr & ZEND_FFI_ATTR_STORED)
&& dim_type->kind == ZEND_FFI_TYPE_POINTER) {
type->pointer.type = dim_type = zend_ffi_remember_type(dim_type);
}
}
if (UNEXPECTED(!cdata->ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return &EG(uninitialized_zval);
}
ptr = (void*)((*(char**)cdata->ptr) + dim_type->size * dim);
} else {
zend_throw_error(zend_ffi_exception_ce, "Attempt to read element of non C array");
return &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->type);
zend_long dim;
void *ptr;
zend_ffi_flags is_const;
if (offset == NULL) {
zend_throw_error(zend_ffi_exception_ce, "Cannot add next element to object of type FFI\\CData");
return;
}
dim = zval_get_long(offset);
if (EXPECTED(type->kind == ZEND_FFI_TYPE_ARRAY)) {
if (UNEXPECTED((zend_ulong)(dim) >= (zend_ulong)type->array.length)
&& (UNEXPECTED(dim < 0) || UNEXPECTED(type->array.length != 0))) {
zend_throw_error(zend_ffi_exception_ce, "C array index out of bounds");
return;
}
is_const = (cdata->flags & ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)(type->attr & ZEND_FFI_ATTR_CONST);
type = ZEND_FFI_TYPE(type->array.type);
#if 0
if (UNEXPECTED(!cdata->ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return;
}
#endif
ptr = (void*)(((char*)cdata->ptr) + type->size * dim);
} else if (EXPECTED(type->kind == ZEND_FFI_TYPE_POINTER)) {
is_const = (cdata->flags & ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)(type->attr & ZEND_FFI_ATTR_CONST);
type = ZEND_FFI_TYPE(type->pointer.type);
if (UNEXPECTED(!cdata->ptr)) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return;
}
ptr = (void*)((*(char**)cdata->ptr) + type->size * dim);
} else {
zend_throw_error(zend_ffi_exception_ce, "Attempt to assign element of non C array");
return;
}
if (UNEXPECTED(is_const)) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to assign read-only location");
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->start -= len;
if (buf->start < buf->buf) {
return 0;
}
memcpy(buf->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->end + len > buf->buf + MAX_TYPE_NAME_LEN) {
return 0;
}
buf->end = zend_mempcpy(buf->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->kind) {
case ZEND_FFI_TYPE_VOID:
name = "void";
break;
case ZEND_FFI_TYPE_FLOAT:
name = "float";
break;
case ZEND_FFI_TYPE_DOUBLE:
name = "double";
break;
#ifdef HAVE_LONG_DOUBLE
case ZEND_FFI_TYPE_LONGDOUBLE:
name = "long double";
break;
#endif
case ZEND_FFI_TYPE_UINT8:
name = "uint8_t";
break;
case ZEND_FFI_TYPE_SINT8:
name = "int8_t";
break;
case ZEND_FFI_TYPE_UINT16:
name = "uint16_t";
break;
case ZEND_FFI_TYPE_SINT16:
name = "int16_t";
break;
case ZEND_FFI_TYPE_UINT32:
name = "uint32_t";
break;
case ZEND_FFI_TYPE_SINT32:
name = "int32_t";
break;
case ZEND_FFI_TYPE_UINT64:
name = "uint64_t";
break;
case ZEND_FFI_TYPE_SINT64:
name = "int64_t";
break;
case ZEND_FFI_TYPE_ENUM:
if (type->enumeration.tag_name) {
zend_ffi_ctype_name_prepend(buf, ZSTR_VAL(type->enumeration.tag_name), ZSTR_LEN(type->enumeration.tag_name));
} else {
zend_ffi_ctype_name_prepend(buf, "<anonymous>", sizeof("<anonymous>")-1);
}
name = "enum ";
break;
case ZEND_FFI_TYPE_BOOL:
name = "bool";
break;
case ZEND_FFI_TYPE_CHAR:
name = "char";
break;
case ZEND_FFI_TYPE_POINTER:
if (!zend_ffi_ctype_name_prepend(buf, "*", 1)) {
return 0;
}
is_ptr = 1;
type = ZEND_FFI_TYPE(type->pointer.type);
break;
case ZEND_FFI_TYPE_FUNC:
if (is_ptr) {
is_ptr = 0;
if (!zend_ffi_ctype_name_prepend(buf, "(", 1)
|| !zend_ffi_ctype_name_append(buf, ")", 1)) {
return 0;
}
}
if (!zend_ffi_ctype_name_append(buf, "(", 1)
|| !zend_ffi_ctype_name_append(buf, ")", 1)) {
return 0;
}
type = ZEND_FFI_TYPE(type->func.ret_type);
break;
case ZEND_FFI_TYPE_ARRAY:
if (is_ptr) {
is_ptr = 0;
if (!zend_ffi_ctype_name_prepend(buf, "(", 1)
|| !zend_ffi_ctype_name_append(buf, ")", 1)) {
return 0;
}
}
if (!zend_ffi_ctype_name_append(buf, "[", 1)) {
return 0;
}
if (type->attr & ZEND_FFI_ATTR_VLA) {
if (!zend_ffi_ctype_name_append(buf, "*", 1)) {
return 0;
}
} else if (!(type->attr & ZEND_FFI_ATTR_INCOMPLETE_ARRAY)) {
char str[MAX_LENGTH_OF_LONG + 1];
char *s = zend_print_long_to_buf(str + sizeof(str) - 1, type->array.length);
if (!zend_ffi_ctype_name_append(buf, s, strlen(s))) {
return 0;
}
}
if (!zend_ffi_ctype_name_append(buf, "]", 1)) {
return 0;
}
type = ZEND_FFI_TYPE(type->array.type);
break;
case ZEND_FFI_TYPE_STRUCT:
if (type->attr & ZEND_FFI_ATTR_UNION) {
if (type->record.tag_name) {
zend_ffi_ctype_name_prepend(buf, ZSTR_VAL(type->record.tag_name), ZSTR_LEN(type->record.tag_name));
} else {
zend_ffi_ctype_name_prepend(buf, "<anonymous>", sizeof("<anonymous>")-1);
}
name = "union ";
} else {
if (type->record.tag_name) {
zend_ffi_ctype_name_prepend(buf, ZSTR_VAL(type->record.tag_name), ZSTR_LEN(type->record.tag_name));
} else {
zend_ffi_ctype_name_prepend(buf, "<anonymous>", sizeof("<anonymous>")-1);
}
name = "struct ";
}
break;
default:
ZEND_UNREACHABLE();
}
if (name) {
break;
}
}
// if (buf->start != buf->end && *buf->start != '[') {
// if (!zend_ffi_ctype_name_prepend(buf, " ", 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->kind == ZEND_FFI_TYPE_STRUCT) {
zend_throw_error(zend_ffi_exception_ce, "FFI return struct/union is not implemented");
} else if (type->kind == ZEND_FFI_TYPE_ARRAY) {
zend_throw_error(zend_ffi_exception_ce, "FFI return array is not implemented");
} else {
zend_throw_error(zend_ffi_exception_ce, "FFI internal error. Unsupported return type");
}
}
/* }}} */
static ZEND_COLD void zend_ffi_pass_unsupported(zend_ffi_type *type) /* {{{ */
{
type = ZEND_FFI_TYPE(type);
if (type->kind == ZEND_FFI_TYPE_STRUCT) {
zend_throw_error(zend_ffi_exception_ce, "FFI passing struct/union is not implemented");
} else if (type->kind == ZEND_FFI_TYPE_ARRAY) {
zend_throw_error(zend_ffi_exception_ce, "FFI passing array is not implemented");
} else {
zend_throw_error(zend_ffi_exception_ce, "FFI internal error. Unsupported parameter type");
}
}
/* }}} */
static ZEND_COLD void zend_ffi_pass_incompatible(const zval *arg, const zend_ffi_type *type, uint32_t n, const 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(&buf1, type)) {
zend_throw_error(zend_ffi_exception_ce, "Passing incompatible argument %d of C function '%s'", n + 1, ZSTR_VAL(EX(func)->internal_function.function_name));
} else {
*buf1.end = 0;
if (Z_TYPE_P(arg) == IS_OBJECT && Z_OBJCE_P(arg) == zend_ffi_cdata_ce) {
const zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(arg);
type = ZEND_FFI_TYPE(cdata->type);
buf2.start = buf2.end = buf2.buf + ((MAX_TYPE_NAME_LEN * 3) / 4);
if (!zend_ffi_ctype_name(&buf2, type)) {
zend_throw_error(zend_ffi_exception_ce, "Passing incompatible argument %d of C function '%s', expecting '%s'", n + 1, ZSTR_VAL(EX(func)->internal_function.function_name), buf1.start);
} else {
*buf2.end = 0;
zend_throw_error(zend_ffi_exception_ce, "Passing incompatible argument %d of C function '%s', expecting '%s', found '%s'", n + 1, ZSTR_VAL(EX(func)->internal_function.function_name), buf1.start, buf2.start);
}
} else {
zend_throw_error(zend_ffi_exception_ce, "Passing incompatible argument %d of C function '%s', expecting '%s', found PHP '%s'", n + 1, ZSTR_VAL(EX(func)->internal_function.function_name), buf1.start, zend_zval_value_name(arg));
}
}
}
/* }}} */
static ZEND_COLD void zend_ffi_assign_incompatible(const zval *arg, const 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(&buf1, type)) {
zend_throw_error(zend_ffi_exception_ce, "Incompatible types when assigning");
} else {
*buf1.end = 0;
if (Z_TYPE_P(arg) == IS_OBJECT && Z_OBJCE_P(arg) == zend_ffi_cdata_ce) {
const zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(arg);
type = ZEND_FFI_TYPE(cdata->type);
buf2.start = buf2.end = buf2.buf + ((MAX_TYPE_NAME_LEN * 3) / 4);
if (!zend_ffi_ctype_name(&buf2, type)) {
zend_throw_error(zend_ffi_exception_ce, "Incompatible types when assigning to type '%s'", buf1.start);
} else {
*buf2.end = 0;
zend_throw_error(zend_ffi_exception_ce, "Incompatible types when assigning to type '%s' from type '%s'", buf1.start, buf2.start);
}
} else {
zend_throw_error(zend_ffi_exception_ce, "Incompatible types when assigning to type '%s' from PHP '%s'", 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(&buf, type)) {
return zend_string_copy(prefix);
} else {
return zend_string_concat3(
ZSTR_VAL(prefix), ZSTR_LEN(prefix), ":", 1, buf.start, buf.end - buf.start);
}
}
/* }}} */
static zend_string *zend_ffi_cdata_get_class_name(const zend_object *zobj) /* {{{ */
{
const zend_ffi_cdata *cdata = (zend_ffi_cdata*)zobj;
return zend_ffi_get_class_name(zobj->ce->name, ZEND_FFI_TYPE(cdata->type));
}
/* }}} */
static int zend_ffi_cdata_compare_objects(zval *o1, zval *o2) /* {{{ */
{
if (Z_TYPE_P(o1) == IS_OBJECT && Z_OBJCE_P(o1) == zend_ffi_cdata_ce &&
Z_TYPE_P(o2) == IS_OBJECT && Z_OBJCE_P(o2) == zend_ffi_cdata_ce) {
const zend_ffi_cdata *cdata1 = (zend_ffi_cdata*)Z_OBJ_P(o1);
const zend_ffi_cdata *cdata2 = (zend_ffi_cdata*)Z_OBJ_P(o2);
const zend_ffi_type *type1 = ZEND_FFI_TYPE(cdata1->type);
const zend_ffi_type *type2 = ZEND_FFI_TYPE(cdata2->type);
if (type1->kind == ZEND_FFI_TYPE_POINTER && type2->kind == ZEND_FFI_TYPE_POINTER) {
void *ptr1 = *(void**)cdata1->ptr;
void *ptr2 = *(void**)cdata2->ptr;
if (!ptr1 || !ptr2) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return 0;
}
return ptr1 == ptr2 ? 0 : (ptr1 < ptr2 ? -1 : 1);
}
}
zend_throw_error(zend_ffi_exception_ce, "Comparison of incompatible C types");
return 0;
}
/* }}} */
static zend_result zend_ffi_cdata_count_elements(zend_object *obj, zend_long *count) /* {{{ */
{
const zend_ffi_cdata *cdata = (zend_ffi_cdata*)obj;
const zend_ffi_type *type = ZEND_FFI_TYPE(cdata->type);
if (type->kind != ZEND_FFI_TYPE_ARRAY) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to count() on non C array");
return FAILURE;
} else {
*count = type->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->kind == ZEND_FFI_TYPE_POINTER) {
if (ZEND_FFI_TYPE_IS_OWNED(base_cdata->type)) {
if (!(base_type->attr & ZEND_FFI_ATTR_STORED)) {
if (GC_REFCOUNT(&base_cdata->std) == 1) {
/* transfer type ownership */
base_cdata->type = base_type;
base_type = ZEND_FFI_TYPE_MAKE_OWNED(base_type);
} else {
base_cdata->type = base_type = zend_ffi_remember_type(base_type);
}
}
}
cdata->type = base_type;
ptr = (char*)(*(void**)base_cdata->ptr);
ptr_type = ZEND_FFI_TYPE(base_type)->pointer.type;
} else {
zend_ffi_type *new_type = emalloc(sizeof(zend_ffi_type));
new_type->kind = ZEND_FFI_TYPE_POINTER;
new_type->attr = 0;
new_type->size = sizeof(void*);
new_type->align = _Alignof(void*);
ptr_type = base_type->array.type;
if (ZEND_FFI_TYPE_IS_OWNED(ptr_type)) {
ptr_type = ZEND_FFI_TYPE(ptr_type);
if (!(ptr_type->attr & ZEND_FFI_ATTR_STORED)) {
if (GC_REFCOUNT(&base_cdata->std) == 1) {
/* transfer type ownership */
base_type->array.type = ptr_type;
ptr_type = ZEND_FFI_TYPE_MAKE_OWNED(ptr_type);
} else {
base_type->array.type = ptr_type = zend_ffi_remember_type(ptr_type);
}
}
}
new_type->pointer.type = ptr_type;
cdata->type = ZEND_FFI_TYPE_MAKE_OWNED(new_type);
ptr = (char*)base_cdata->ptr;
}
cdata->ptr = &cdata->ptr_holder;
cdata->ptr_holder = ptr +
(ptrdiff_t) (offset * ZEND_FFI_TYPE(ptr_type)->size);
cdata->flags = base_cdata->flags & ZEND_FFI_FLAG_CONST;
return &cdata->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 && 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->type);
if (type1->kind == ZEND_FFI_TYPE_POINTER || type1->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(&cdata1->std);
}
return SUCCESS;
} else if (opcode == ZEND_SUB) {
if (Z_TYPE_P(op2) == IS_OBJECT && Z_OBJCE_P(op2) == zend_ffi_cdata_ce) {
const zend_ffi_cdata *cdata2 = (zend_ffi_cdata*)Z_OBJ_P(op2);
const zend_ffi_type *type2 = ZEND_FFI_TYPE(cdata2->type);
if (type2->kind == ZEND_FFI_TYPE_POINTER || type2->kind == ZEND_FFI_TYPE_ARRAY) {
zend_ffi_type *t1, *t2;
char *p1, *p2;
if (type1->kind == ZEND_FFI_TYPE_POINTER) {
t1 = ZEND_FFI_TYPE(type1->pointer.type);
p1 = (char*)(*(void**)cdata1->ptr);
} else {
t1 = ZEND_FFI_TYPE(type1->array.type);
p1 = cdata1->ptr;
}
if (type2->kind == ZEND_FFI_TYPE_POINTER) {
t2 = ZEND_FFI_TYPE(type2->pointer.type);
p2 = (char*)(*(void**)cdata2->ptr);
} else {
t2 = ZEND_FFI_TYPE(type2->array.type);
p2 = cdata2->ptr;
}
if (zend_ffi_is_same_type(t1, t2)) {
ZVAL_LONG(result,
(zend_long)(p1 - p2) / (zend_long)t1->size);
return SUCCESS;
}
}
}
offset = zval_get_long(op2);
ZVAL_OBJ(result, zend_ffi_add(cdata1, type1, -offset));
if (result == op1) {
OBJ_RELEASE(&cdata1->std);
}
return SUCCESS;
}
}
} else if (Z_TYPE_P(op2) == IS_OBJECT && 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->type);
if (type2->kind == ZEND_FFI_TYPE_POINTER || type2->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(&((zend_ffi_cdata_iterator*)iter)->value);
zval_ptr_dtor(&iter->data);
}
/* }}} */
static zend_result zend_ffi_cdata_it_valid(zend_object_iterator *it) /* {{{ */
{
const zend_ffi_cdata_iterator *iter = (zend_ffi_cdata_iterator*)it;
const zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ(iter->it.data);
const zend_ffi_type *type = ZEND_FFI_TYPE(cdata->type);
return (iter->key >= 0 && iter->key < type->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->it.data);
zend_ffi_type *type = ZEND_FFI_TYPE(cdata->type);
zend_ffi_type *dim_type;
void *ptr;
if (!cdata->ptr) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return &EG(uninitialized_zval);
}
dim_type = type->array.type;
if (ZEND_FFI_TYPE_IS_OWNED(dim_type)) {
dim_type = ZEND_FFI_TYPE(dim_type);
if (!(dim_type->attr & ZEND_FFI_ATTR_STORED)
&& dim_type->kind == ZEND_FFI_TYPE_POINTER) {
type->array.type = dim_type = zend_ffi_remember_type(dim_type);
}
}
ptr = (void*)((char*)cdata->ptr + dim_type->size * iter->it.index);
zval_ptr_dtor(&iter->value);
zend_ffi_cdata_to_zval(NULL, ptr, dim_type, iter->by_ref ? BP_VAR_RW : BP_VAR_R, &iter->value, (cdata->flags & ZEND_FFI_FLAG_CONST) | (zend_ffi_flags)(type->attr & ZEND_FFI_ATTR_CONST), 0, 0);
return &iter->value;
}
/* }}} */
static void zend_ffi_cdata_it_get_current_key(zend_object_iterator *it, zval *key) /* {{{ */
{
const zend_ffi_cdata_iterator *iter = (zend_ffi_cdata_iterator*)it;
ZVAL_LONG(key, iter->key);
}
/* }}} */
static void zend_ffi_cdata_it_move_forward(zend_object_iterator *it) /* {{{ */
{
zend_ffi_cdata_iterator *iter = (zend_ffi_cdata_iterator*)it;
iter->key++;
}
/* }}} */
static void zend_ffi_cdata_it_rewind(zend_object_iterator *it) /* {{{ */
{
zend_ffi_cdata_iterator *iter = (zend_ffi_cdata_iterator*)it;
iter->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->type);
zend_ffi_cdata_iterator *iter;
if (type->kind != ZEND_FFI_TYPE_ARRAY) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to iterate on non C array");
return NULL;
}
iter = emalloc(sizeof(zend_ffi_cdata_iterator));
zend_iterator_init(&iter->it);
Z_ADDREF_P(object);
ZVAL_OBJ(&iter->it.data, Z_OBJ_P(object));
iter->it.funcs = &zend_ffi_cdata_it_funcs;
iter->key = 0;
iter->by_ref = by_ref;
ZVAL_UNDEF(&iter->value);
return &iter->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->type);
void *ptr = cdata->ptr;
HashTable *ht = NULL;
zend_string *key;
zend_ffi_field *f;
zend_long n;
zval tmp;
if (!cdata->ptr) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return NULL;
}
switch (type->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, &tmp, ZEND_FFI_FLAG_CONST, 0, 0);
ht = zend_new_array(1);
zend_hash_str_add(ht, "cdata", sizeof("cdata")-1, &tmp);
*is_temp = 1;
return ht;
break;
case ZEND_FFI_TYPE_POINTER:
if (*(void**)ptr == NULL) {
ZVAL_NULL(&tmp);
ht = zend_new_array(1);
zend_hash_index_add_new(ht, 0, &tmp);
*is_temp = 1;
return ht;
} else if (ZEND_FFI_TYPE(type->pointer.type)->kind == ZEND_FFI_TYPE_VOID) {
ZVAL_LONG(&tmp, (uintptr_t)*(void**)ptr);
ht = zend_new_array(1);
zend_hash_index_add_new(ht, 0, &tmp);
*is_temp = 1;
return ht;
} else {
zend_ffi_cdata_to_zval(NULL, *(void**)ptr, ZEND_FFI_TYPE(type->pointer.type), BP_VAR_R, &tmp, ZEND_FFI_FLAG_CONST, 0, 0);
ht = zend_new_array(1);
zend_hash_index_add_new(ht, 0, &tmp);
*is_temp = 1;
return ht;
}
break;
case ZEND_FFI_TYPE_STRUCT:
ht = zend_new_array(zend_hash_num_elements(&type->record.fields));
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&type->record.fields, key, f) {
if (key) {
if (!f->bits) {
void *f_ptr = (void*)(((char*)ptr) + f->offset);
zend_ffi_cdata_to_zval(NULL, f_ptr, ZEND_FFI_TYPE(f->type), BP_VAR_R, &tmp, ZEND_FFI_FLAG_CONST, 0, type->attr & ZEND_FFI_ATTR_UNION);
zend_hash_add(ht, key, &tmp);
} else {
zend_ffi_bit_field_to_zval(ptr, f, &tmp);
zend_hash_add(ht, key, &tmp);
}
}
} ZEND_HASH_FOREACH_END();
*is_temp = 1;
return ht;
case ZEND_FFI_TYPE_ARRAY:
ht = zend_new_array(type->array.length);
for (n = 0; n < type->array.length; n++) {
zend_ffi_cdata_to_zval(NULL, ptr, ZEND_FFI_TYPE(type->array.type), BP_VAR_R, &tmp, ZEND_FFI_FLAG_CONST, 0, 0);
zend_hash_index_add(ht, n, &tmp);
ptr = (void*)(((char*)ptr) + ZEND_FFI_TYPE(type->array.type)->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->type);
zend_function *func;
if (type->kind != ZEND_FFI_TYPE_POINTER) {
if (!check_only) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to call non C function pointer");
}
return FAILURE;
}
type = ZEND_FFI_TYPE(type->pointer.type);
if (type->kind != ZEND_FFI_TYPE_FUNC) {
if (!check_only) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to call non C function pointer");
}
return FAILURE;
}
if (!cdata->ptr) {
if (!check_only) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
}
return FAILURE;
}
if (EXPECTED(EG(trampoline).common.function_name == NULL)) {
func = &EG(trampoline);
} else {
func = ecalloc(1, sizeof(zend_internal_function));
}
func->type = ZEND_INTERNAL_FUNCTION;
func->common.arg_flags[0] = 0;
func->common.arg_flags[1] = 0;
func->common.arg_flags[2] = 0;
func->common.fn_flags = ZEND_ACC_CALL_VIA_TRAMPOLINE;
func->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->common.num_args = 0;
func->common.required_num_args = type->func.args ? zend_hash_num_elements(type->func.args) : 0;
func->common.scope = NULL;
func->common.prototype = NULL;
func->common.arg_info = NULL;
func->internal_function.handler = ZEND_FN(ffi_trampoline);
func->internal_function.module = NULL;
func->internal_function.doc_comment = NULL;
func->internal_function.reserved[0] = type;
func->internal_function.reserved[1] = *(void**)cdata->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(&ctype->std, class_type);
ctype->type = NULL;
return &ctype->std;
}
/* }}} */
static void zend_ffi_ctype_free_obj(zend_object *object) /* {{{ */
{
zend_ffi_ctype *ctype = (zend_ffi_ctype*)object;
zend_ffi_type_dtor(ctype->type);
if (UNEXPECTED(GC_FLAGS(object) & IS_OBJ_WEAKLY_REFERENCED)) {
zend_weakrefs_notify(object);
}
}
/* }}} */
static bool zend_ffi_is_same_type(const zend_ffi_type *type1, const zend_ffi_type *type2) /* {{{ */
{
while (1) {
if (type1 == type2) {
return 1;
} else if (type1->kind == type2->kind) {
if (type1->kind < ZEND_FFI_TYPE_POINTER) {
return 1;
} else if (type1->kind == ZEND_FFI_TYPE_POINTER) {
type1 = ZEND_FFI_TYPE(type1->pointer.type);
type2 = ZEND_FFI_TYPE(type2->pointer.type);
if (type1->kind == ZEND_FFI_TYPE_VOID ||
type2->kind == ZEND_FFI_TYPE_VOID) {
return 1;
}
} else if (type1->kind == ZEND_FFI_TYPE_ARRAY &&
type1->array.length == type2->array.length) {
type1 = ZEND_FFI_TYPE(type1->array.type);
type2 = ZEND_FFI_TYPE(type2->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->ce->name, ZEND_FFI_TYPE(ctype->type));
}
/* }}} */
static int zend_ffi_ctype_compare_objects(zval *o1, zval *o2) /* {{{ */
{
if (Z_TYPE_P(o1) == IS_OBJECT && Z_OBJCE_P(o1) == zend_ffi_ctype_ce &&
Z_TYPE_P(o2) == IS_OBJECT && Z_OBJCE_P(o2) == zend_ffi_ctype_ce) {
const zend_ffi_ctype *ctype1 = (zend_ffi_ctype*)Z_OBJ_P(o1);
const zend_ffi_ctype *ctype2 = (zend_ffi_ctype*)Z_OBJ_P(o2);
const zend_ffi_type *type1 = ZEND_FFI_TYPE(ctype1->type);
const zend_ffi_type *type2 = ZEND_FFI_TYPE(ctype2->type);
if (zend_ffi_is_same_type(type1, type2)) {
return 0;
} else {
return 1;
}
}
zend_throw_error(zend_ffi_exception_ce, "Comparison of incompatible C types");
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(&ffi->std, class_type);
ffi->lib = NULL;
ffi->symbols = NULL;
ffi->tags = NULL;
ffi->persistent = 0;
return &ffi->std;
}
/* }}} */
static void _zend_ffi_type_dtor(zend_ffi_type *type) /* {{{ */
{
type = ZEND_FFI_TYPE(type);
switch (type->kind) {
case ZEND_FFI_TYPE_ENUM:
if (type->enumeration.tag_name) {
zend_string_release(type->enumeration.tag_name);
}
break;
case ZEND_FFI_TYPE_STRUCT:
if (type->record.tag_name) {
zend_string_release(type->record.tag_name);
}
zend_hash_destroy(&type->record.fields);
break;
case ZEND_FFI_TYPE_POINTER:
zend_ffi_type_dtor(type->pointer.type);
break;
case ZEND_FFI_TYPE_ARRAY:
zend_ffi_type_dtor(type->array.type);
break;
case ZEND_FFI_TYPE_FUNC:
if (type->func.args) {
zend_hash_destroy(type->func.args);
pefree(type->func.args, type->attr & ZEND_FFI_ATTR_PERSISTENT);
}
zend_ffi_type_dtor(type->func.ret_type);
break;
default:
break;
}
pefree(type, type->attr & 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->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->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->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->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->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->type);
free(tag);
}
/* }}} */
static void zend_ffi_cdata_dtor(zend_ffi_cdata *cdata) /* {{{ */
{
zend_ffi_type_dtor(cdata->type);
if (cdata->flags & ZEND_FFI_FLAG_OWNED) {
if (cdata->ptr != (void*)&cdata->ptr_holder) {
pefree(cdata->ptr, cdata->flags & ZEND_FFI_FLAG_PERSISTENT);
} else {
pefree(cdata->ptr_holder, cdata->flags & ZEND_FFI_FLAG_PERSISTENT);
}
}
}
/* }}} */
static void zend_ffi_scope_hash_dtor(zval *zv) /* {{{ */
{
zend_ffi_scope *scope = Z_PTR_P(zv);
if (scope->symbols) {
zend_hash_destroy(scope->symbols);
free(scope->symbols);
}
if (scope->tags) {
zend_hash_destroy(scope->tags);
free(scope->tags);
}
free(scope);
}
/* }}} */
static void zend_ffi_free_obj(zend_object *object) /* {{{ */
{
zend_ffi *ffi = (zend_ffi*)object;
if (ffi->persistent) {
return;
}
if (ffi->lib) {
DL_UNLOAD(ffi->lib);
ffi->lib = NULL;
}
if (ffi->symbols) {
zend_hash_destroy(ffi->symbols);
efree(ffi->symbols);
}
if (ffi->tags) {
zend_hash_destroy(ffi->tags);
efree(ffi->tags);
}
if (UNEXPECTED(GC_FLAGS(object) & 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) & 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->type);
zend_ffi_cdata *new_cdata;
new_cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
if (type->kind < ZEND_FFI_TYPE_POINTER) {
new_cdata->std.handlers = &zend_ffi_cdata_value_handlers;
}
new_cdata->type = type;
new_cdata->ptr = emalloc(type->size);
memcpy(new_cdata->ptr, old_cdata->ptr, type->size);
new_cdata->flags |= ZEND_FFI_FLAG_OWNED;
return &new_cdata->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->symbols) {
sym = zend_hash_find_ptr(ffi->symbols, var_name);
if (sym && sym->kind != ZEND_FFI_SYM_VAR && sym->kind != ZEND_FFI_SYM_CONST && sym->kind != ZEND_FFI_SYM_FUNC) {
sym = NULL;
}
}
if (!sym) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to read undefined C variable '%s'", ZSTR_VAL(var_name));
return &EG(uninitialized_zval);
}
if (sym->kind == ZEND_FFI_SYM_VAR) {
zend_ffi_cdata_to_zval(NULL, sym->addr, ZEND_FFI_TYPE(sym->type), read_type, rv, (zend_ffi_flags)sym->is_const, 0, 0);
} else if (sym->kind == ZEND_FFI_SYM_FUNC) {
zend_ffi_cdata *cdata;
zend_ffi_type *new_type = emalloc(sizeof(zend_ffi_type));
new_type->kind = ZEND_FFI_TYPE_POINTER;
new_type->attr = 0;
new_type->size = sizeof(void*);
new_type->align = _Alignof(void*);
new_type->pointer.type = ZEND_FFI_TYPE(sym->type);
cdata = emalloc(sizeof(zend_ffi_cdata));
zend_ffi_object_init(&cdata->std, zend_ffi_cdata_ce);
cdata->type = ZEND_FFI_TYPE_MAKE_OWNED(new_type);
cdata->flags = ZEND_FFI_FLAG_CONST;
cdata->ptr_holder = sym->addr;
cdata->ptr = &cdata->ptr_holder;
ZVAL_OBJ(rv, &cdata->std);
} else {
ZVAL_LONG(rv, sym->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->symbols) {
sym = zend_hash_find_ptr(ffi->symbols, var_name);
if (sym && sym->kind != ZEND_FFI_SYM_VAR) {
sym = NULL;
}
}
if (!sym) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to assign undefined C variable '%s'", ZSTR_VAL(var_name));
return value;
}
if (sym->is_const) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to assign read-only C variable '%s'", ZSTR_VAL(var_name));
return value;
}
zend_ffi_zval_to_cdata(sym->addr, ZEND_FFI_TYPE(sym->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, const zend_execute_data *execute_data) /* {{{ */
{
zend_long lval;
double dval;
zend_string *str, *tmp_str;
zend_ffi_type_kind kind = type->kind;
ZVAL_DEREF(arg);
again:
switch (kind) {
case ZEND_FFI_TYPE_FLOAT:
dval = zval_get_double(arg);
*pass_type = &ffi_type_float;
*(float*)arg_values[n] = (float)dval;
break;
case ZEND_FFI_TYPE_DOUBLE:
dval = zval_get_double(arg);
*pass_type = &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 = &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 = &ffi_type_uint8;
*(uint8_t*)arg_values[n] = (uint8_t)lval;
break;
case ZEND_FFI_TYPE_SINT8:
lval = zval_get_long(arg);
*pass_type = &ffi_type_sint8;
*(int8_t*)arg_values[n] = (int8_t)lval;
break;
case ZEND_FFI_TYPE_UINT16:
lval = zval_get_long(arg);
*pass_type = &ffi_type_uint16;
*(uint16_t*)arg_values[n] = (uint16_t)lval;
break;
case ZEND_FFI_TYPE_SINT16:
lval = zval_get_long(arg);
*pass_type = &ffi_type_sint16;
*(int16_t*)arg_values[n] = (int16_t)lval;
break;
case ZEND_FFI_TYPE_UINT32:
lval = zval_get_long(arg);
*pass_type = &ffi_type_uint32;
*(uint32_t*)arg_values[n] = (uint32_t)lval;
break;
case ZEND_FFI_TYPE_SINT32:
lval = zval_get_long(arg);
*pass_type = &ffi_type_sint32;
*(int32_t*)arg_values[n] = (int32_t)lval;
break;
case ZEND_FFI_TYPE_UINT64:
lval = zval_get_long(arg);
*pass_type = &ffi_type_uint64;
*(uint64_t*)arg_values[n] = (uint64_t)lval;
break;
case ZEND_FFI_TYPE_SINT64:
lval = zval_get_long(arg);
*pass_type = &ffi_type_sint64;
*(int64_t*)arg_values[n] = (int64_t)lval;
break;
case ZEND_FFI_TYPE_POINTER:
*pass_type = &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
&& ((ZEND_FFI_TYPE(type->pointer.type)->kind == ZEND_FFI_TYPE_CHAR)
|| (ZEND_FFI_TYPE(type->pointer.type)->kind == ZEND_FFI_TYPE_VOID))) {
*(void**)arg_values[n] = Z_STRVAL_P(arg);
return SUCCESS;
} else if (Z_TYPE_P(arg) == IS_OBJECT && 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->type))) {
if (ZEND_FFI_TYPE(cdata->type)->kind == ZEND_FFI_TYPE_POINTER) {
if (!cdata->ptr) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
return FAILURE;
}
*(void**)arg_values[n] = *(void**)cdata->ptr;
} else {
*(void**)arg_values[n] = cdata->ptr;
}
return SUCCESS;
}
#if FFI_CLOSURES
} else if (ZEND_FFI_TYPE(type->pointer.type)->kind == ZEND_FFI_TYPE_FUNC) {
void *callback = zend_ffi_create_callback(ZEND_FFI_TYPE(type->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 = &ffi_type_uint8;
*(uint8_t*)arg_values[n] = zend_is_true(arg);
break;
case ZEND_FFI_TYPE_CHAR:
str = zval_get_tmp_string(arg, &tmp_str);
*pass_type = &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->enumeration.kind;
goto again;
case ZEND_FFI_TYPE_STRUCT:
if (Z_TYPE_P(arg) == IS_OBJECT && 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->type))) {
*pass_type = zend_ffi_make_fake_struct_type(type);
arg_values[n] = cdata->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, const zend_execute_data *execute_data) /* {{{ */
{
ZVAL_DEREF(arg);
switch (Z_TYPE_P(arg)) {
case IS_NULL:
*pass_type = &ffi_type_pointer;
*(void**)arg_values[n] = NULL;
break;
case IS_FALSE:
*pass_type = &ffi_type_uint8;
*(uint8_t*)arg_values[n] = 0;
break;
case IS_TRUE:
*pass_type = &ffi_type_uint8;
*(uint8_t*)arg_values[n] = 1;
break;
case IS_LONG:
if (sizeof(zend_long) == 4) {
*pass_type = &ffi_type_sint32;
*(int32_t*)arg_values[n] = Z_LVAL_P(arg);
} else {
*pass_type = &ffi_type_sint64;
*(int64_t*)arg_values[n] = Z_LVAL_P(arg);
}
break;
case IS_DOUBLE:
*pass_type = &ffi_type_double;
*(double*)arg_values[n] = Z_DVAL_P(arg);
break;
case IS_STRING:
*pass_type = &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->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, "Unsupported argument type");
return FAILURE;
}
return SUCCESS;
}
/* }}} */
static ZEND_FUNCTION(ffi_trampoline) /* {{{ */
{
zend_ffi_type *type = EX(func)->internal_function.reserved[0];
void *addr = EX(func)->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->kind == ZEND_FFI_TYPE_FUNC);
arg_count = type->func.args ? zend_hash_num_elements(type->func.args) : 0;
if (type->attr & ZEND_FFI_ATTR_VARIADIC) {
if (arg_count > EX_NUM_ARGS()) {
zend_throw_error(zend_ffi_exception_ce, "Incorrect number of arguments for C function '%s', expecting at least %d parameter%s", ZSTR_VAL(EX(func)->internal_function.function_name), arg_count, (arg_count != 1) ? "s" : "");
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->func.args) {
ZEND_HASH_PACKED_FOREACH_PTR(type->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, &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 < 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), &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->func.ret_type));
if (!ret_type) {
zend_ffi_return_unsupported(type->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(&cif, type->func.abi, arg_count, EX_NUM_ARGS(), ret_type, arg_types) != FFI_OK) {
zend_throw_error(zend_ffi_exception_ce, "Cannot prepare callback CIF");
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, "Incorrect number of arguments for C function '%s', expecting exactly %d parameter%s", ZSTR_VAL(EX(func)->internal_function.function_name), arg_count, (arg_count != 1) ? "s" : "");
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->func.args) {
ZEND_HASH_PACKED_FOREACH_PTR(type->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, &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->func.ret_type));
if (!ret_type) {
zend_ffi_return_unsupported(type->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(&cif, type->func.abi, arg_count, ret_type, arg_types) != FFI_OK) {
zend_throw_error(zend_ffi_exception_ce, "Cannot prepare callback CIF");
free_alloca(arg_types, arg_types_use_heap);
free_alloca(arg_values, arg_values_use_heap);
goto exit;
}
}
ret = do_alloca(MAX(ret_type->size, sizeof(ffi_arg)), ret_use_heap);
ffi_call(&cif, addr, ret, arg_values);
for (n = 0; n < arg_count; n++) {
if (arg_types[n]->type == FFI_TYPE_STRUCT) {
efree(arg_types[n]);
}
}
if (ret_type->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->func.ret_type)->kind != ZEND_FFI_TYPE_VOID) {
zend_ffi_type *func_ret_type = ZEND_FFI_TYPE(type->func.ret_type);
#ifdef WORDS_BIGENDIAN
if (func_ret_type->size < sizeof(ffi_arg)
&& func_ret_type->kind >= ZEND_FFI_TYPE_UINT8
&& func_ret_type->kind < ZEND_FFI_TYPE_POINTER) {
/* We need to narrow the value (truncate) */
switch (func_ret_type->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)->common.function_name);
if (EX(func)->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
zend_free_trampoline(EX(func));
EX(func) = NULL;
}
}
/* }}} */
/* This function was manually optimized to reduce the overhead of calling native functions */
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("new") -1
&& (ZSTR_VAL(name)[0] == 'n' || ZSTR_VAL(name)[0] == 'N')
&& (ZSTR_VAL(name)[1] == 'e' || ZSTR_VAL(name)[1] == 'E')
&& (ZSTR_VAL(name)[2] == 'w' || ZSTR_VAL(name)[2] == 'W')) {
return (zend_function*)&zend_ffi_new_fn;
} else if (ZSTR_LEN(name) == sizeof("cast") -1
&& (ZSTR_VAL(name)[0] == 'c' || ZSTR_VAL(name)[0] == 'C')
&& (ZSTR_VAL(name)[1] == 'a' || ZSTR_VAL(name)[1] == 'A')
&& (ZSTR_VAL(name)[2] == 's' || ZSTR_VAL(name)[2] == 'S')
&& (ZSTR_VAL(name)[3] == 't' || ZSTR_VAL(name)[3] == 'T')) {
return (zend_function*)&zend_ffi_cast_fn;
} else if (ZSTR_LEN(name) == sizeof("type") -1
&& (ZSTR_VAL(name)[0] == 't' || ZSTR_VAL(name)[0] == 'T')
&& (ZSTR_VAL(name)[1] == 'y' || ZSTR_VAL(name)[1] == 'Y')
&& (ZSTR_VAL(name)[2] == 'p' || ZSTR_VAL(name)[2] == 'P')
&& (ZSTR_VAL(name)[3] == 'e' || ZSTR_VAL(name)[3] == 'E')) {
return (zend_function*)&zend_ffi_type_fn;
}
if (ffi->symbols) {
sym = zend_hash_find_ptr(ffi->symbols, name);
if (sym && sym->kind != ZEND_FFI_SYM_FUNC) {
sym = NULL;
}
}
if (!sym) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to call undefined C function '%s'", ZSTR_VAL(name));
return NULL;
}
type = ZEND_FFI_TYPE(sym->type);
ZEND_ASSERT(type->kind == ZEND_FFI_TYPE_FUNC);
if (EXPECTED(EG(trampoline).common.function_name == NULL)) {
func = &EG(trampoline);
} else {
func = ecalloc(1, sizeof(zend_internal_function));
}
func->common.type = ZEND_INTERNAL_FUNCTION;
func->common.arg_flags[0] = 0;
func->common.arg_flags[1] = 0;
func->common.arg_flags[2] = 0;
func->common.fn_flags = ZEND_ACC_CALL_VIA_TRAMPOLINE;
func->common.function_name = zend_string_copy(name);
/* set to 0 to avoid arg_info[] allocation, because all values are passed by value anyway */
func->common.num_args = 0;
func->common.required_num_args = type->func.args ? zend_hash_num_elements(type->func.args) : 0;
func->common.scope = NULL;
func->common.prototype = NULL;
func->common.arg_info = NULL;
func->internal_function.handler = ZEND_FN(ffi_trampoline);
func->internal_function.module = NULL;
func->internal_function.doc_comment = NULL;
func->internal_function.reserved[0] = type;
func->internal_function.reserved[1] = sym->addr;
return func;
}
/* }}} */
static int zend_fake_compare_objects(zval *o1, zval *o2)
{
zend_throw_error(zend_ffi_exception_ce, "Cannot compare FFI objects");
return ZEND_UNCOMPARABLE;
}
static zend_never_inline int zend_ffi_disabled(void) /* {{{ */
{
zend_throw_error(zend_ffi_exception_ce, "FFI API is restricted by \"ffi.enable\" configuration directive");
return 0;
}
/* }}} */
static zend_always_inline bool zend_ffi_validate_api_restriction(const zend_execute_data *execute_data) /* {{{ */
{
if (EXPECTED(FFI_G(restriction) > ZEND_FFI_ENABLED)) {
ZEND_ASSERT(FFI_G(restriction) == ZEND_FFI_PRELOAD);
if (FFI_G(is_cli)
|| (execute_data->prev_execute_data
&& (execute_data->prev_execute_data->func->common.fn_flags & ZEND_ACC_PRELOADED))
|| (CG(compiler_options) & 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)
#ifdef PHP_WIN32
# include <Psapi.h>
# ifndef DWORD_MAX
# define DWORD_MAX ULONG_MAX
# endif
# define NUM_MODULES 1024
/* A rough approximation of dlysm(RTLD_DEFAULT) */
static void *dlsym_loaded(char *symbol)
{
HMODULE modules_static[NUM_MODULES], *modules = modules_static;
DWORD num = NUM_MODULES, i;
void * addr;
if (!EnumProcessModules(GetCurrentProcess(), modules, num * sizeof(HMODULE), &num)) {
return NULL;
}
if (num >= NUM_MODULES && num <= DWORD_MAX / sizeof(HMODULE)) {
modules = emalloc(num *sizeof(HMODULE));
if (!EnumProcessModules(GetCurrentProcess(), modules, num * sizeof(HMODULE), &num)) {
efree(modules);
return NULL;
}
}
for (i = 0; i < num; i++) {
addr = GetProcAddress(modules[i], symbol);
if (addr != NULL) break;
}
if (modules != modules_static) {
efree(modules);
}
return addr;
}
# undef DL_FETCH_SYMBOL
# define DL_FETCH_SYMBOL(h, s) (h == NULL ? dlsym_loaded(s) : (void*) GetProcAddress(h, s))
#endif
ZEND_METHOD(FFI, cdef) /* {{{ */
{
zend_string *code = NULL;
zend_string *lib = NULL;
zend_ffi *ffi = NULL;
DL_HANDLE handle = NULL;
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) {
char *err = GET_DL_ERROR();
#ifdef PHP_WIN32
if (err && err[0]) {
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s' (%s)", ZSTR_VAL(lib), err);
php_win32_error_msg_free(err);
} else {
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s' (Unknown reason)", ZSTR_VAL(lib));
}
#else
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s' (%s)", 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 && 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) {
void *addr;
if (sym->kind == ZEND_FFI_SYM_VAR) {
addr = DL_FETCH_SYMBOL(handle, ZSTR_VAL(name));
if (!addr) {
zend_throw_error(zend_ffi_exception_ce, "Failed resolving C variable '%s'", ZSTR_VAL(name));
RETURN_THROWS();
}
sym->addr = addr;
} else if (sym->kind == ZEND_FFI_SYM_FUNC) {
zend_string *mangled_name = zend_ffi_mangled_func_name(name, ZEND_FFI_TYPE(sym->type));
addr = DL_FETCH_SYMBOL(handle, ZSTR_VAL(mangled_name));
zend_string_release(mangled_name);
if (!addr) {
zend_throw_error(zend_ffi_exception_ce, "Failed resolving C function '%s'", ZSTR_VAL(name));
RETURN_THROWS();
}
sym->addr = addr;
}
} ZEND_HASH_FOREACH_END();
}
}
ffi = (zend_ffi*)zend_ffi_new(zend_ffi_ce);
ffi->lib = handle;
ffi->symbols = FFI_G(symbols);
ffi->tags = FFI_G(tags);
FFI_G(symbols) = NULL;
FFI_G(tags) = NULL;
RETURN_OBJ(&ffi->std);
}
/* }}} */
static bool zend_ffi_same_types(const zend_ffi_type *old, const zend_ffi_type *type) /* {{{ */
{
if (old == type) {
return 1;
}
if (old->kind != type->kind
|| old->size != type->size
|| old->align != type->align
|| old->attr != type->attr) {
return 0;
}
switch (old->kind) {
case ZEND_FFI_TYPE_ENUM:
return old->enumeration.kind == type->enumeration.kind;
case ZEND_FFI_TYPE_ARRAY:
return old->array.length == type->array.length
&& zend_ffi_same_types(ZEND_FFI_TYPE(old->array.type), ZEND_FFI_TYPE(type->array.type));
case ZEND_FFI_TYPE_POINTER:
return zend_ffi_same_types(ZEND_FFI_TYPE(old->pointer.type), ZEND_FFI_TYPE(type->pointer.type));
case ZEND_FFI_TYPE_STRUCT:
if (zend_hash_num_elements(&old->record.fields) != zend_hash_num_elements(&type->record.fields)) {
return 0;
} else {
zend_ffi_field *old_field, *field;
zend_string *key;
const Bucket *b = type->record.fields.arData;
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&old->record.fields, key, old_field) {
while (Z_TYPE(b->val) == IS_UNDEF) {
b++;
}
if (key) {
if (!b->key
|| !zend_string_equals(key, b->key)) {
return 0;
}
} else if (b->key) {
return 0;
}
field = Z_PTR(b->val);
if (old_field->offset != field->offset
|| old_field->is_const != field->is_const
|| old_field->is_nested != field->is_nested
|| old_field->first_bit != field->first_bit
|| old_field->bits != field->bits
|| !zend_ffi_same_types(ZEND_FFI_TYPE(old_field->type), ZEND_FFI_TYPE(field->type))) {
return 0;
}
b++;
} ZEND_HASH_FOREACH_END();
}
break;
case ZEND_FFI_TYPE_FUNC:
if (old->func.abi != type->func.abi
|| ((old->func.args ? zend_hash_num_elements(old->func.args) : 0) != (type->func.args ? zend_hash_num_elements(type->func.args) : 0))
|| !zend_ffi_same_types(ZEND_FFI_TYPE(old->func.ret_type), ZEND_FFI_TYPE(type->func.ret_type))) {
return 0;
} else if (old->func.args) {
zend_ffi_type *arg_type;
const zval *zv = type->func.args->arPacked;
ZEND_HASH_PACKED_FOREACH_PTR(old->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(const zend_ffi_symbol *old, const zend_ffi_symbol *sym) /* {{{ */
{
if (old->kind != sym->kind || old->is_const != sym->is_const) {
return 0;
}
if (old->kind == ZEND_FFI_SYM_CONST) {
if (old->value != sym->value) {
return 0;
}
}
return zend_ffi_same_types(ZEND_FFI_TYPE(old->type), ZEND_FFI_TYPE(sym->type));
}
/* }}} */
static bool zend_ffi_same_tags(const zend_ffi_tag *old, const zend_ffi_tag *tag) /* {{{ */
{
if (old->kind != tag->kind) {
return 0;
}
return zend_ffi_same_types(ZEND_FFI_TYPE(old->type), ZEND_FFI_TYPE(tag->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->kind) {
case ZEND_FFI_TYPE_POINTER:
return zend_ffi_subst_old_type(&dcl_type->pointer.type, old, type);
case ZEND_FFI_TYPE_ARRAY:
return zend_ffi_subst_old_type(&dcl_type->array.type, old, type);
case ZEND_FFI_TYPE_FUNC:
if (zend_ffi_subst_old_type(&dcl_type->func.ret_type, old, type)) {
return 1;
}
if (dcl_type->func.args) {
zval *zv;
ZEND_HASH_PACKED_FOREACH_VAL(dcl_type->func.args, zv) {
if (zend_ffi_subst_old_type((zend_ffi_type**)&Z_PTR_P(zv), old, type)) {
return 1;
}
} ZEND_HASH_FOREACH_END();
}
break;
case ZEND_FFI_TYPE_STRUCT:
ZEND_HASH_MAP_FOREACH_PTR(&dcl_type->record.fields, field) {
if (zend_ffi_subst_old_type(&field->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(&sym->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(&tag->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->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;
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;
if (stat(filename, &buf) != 0) {
if (preload) {
zend_error(E_WARNING, "FFI: failed pre-loading '%s', file doesn't exist", filename);
} else {
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s', file doesn't exist", filename);
}
return NULL;
}
if ((buf.st_mode & S_IFMT) != S_IFREG) {
if (preload) {
zend_error(E_WARNING, "FFI: failed pre-loading '%s', not a regular file", filename);
} else {
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s', not a regular file", 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 < 0 || read(fd, code, code_size) != code_size) {
if (preload) {
zend_error(E_WARNING, "FFI: Failed pre-loading '%s', cannot read_file", filename);
} else {
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s', cannot read_file", 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, &scope_name, &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, "FFI: failed pre-loading '%s'", filename);
} else {
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s'", filename);
}
goto cleanup;
}
if (lib) {
handle = DL_LOAD(lib);
if (!handle) {
if (preload) {
zend_error(E_WARNING, "FFI: Failed pre-loading '%s'", lib);
} else {
char *err = GET_DL_ERROR();
#ifdef PHP_WIN32
if (err && err[0]) {
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s' (%s)", lib, err);
php_win32_error_msg_free(err);
} else {
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s' (Unknown reason)", lib);
}
#else
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s' (%s)", 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 = "C";
}
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) {
void *addr;
if (sym->kind == ZEND_FFI_SYM_VAR) {
addr = DL_FETCH_SYMBOL(handle, ZSTR_VAL(name));
if (!addr) {
if (preload) {
zend_error(E_WARNING, "FFI: failed pre-loading '%s', cannot resolve C variable '%s'", filename, ZSTR_VAL(name));
} else {
zend_throw_error(zend_ffi_exception_ce, "Failed resolving C variable '%s'", ZSTR_VAL(name));
}
if (lib) {
DL_UNLOAD(handle);
}
goto cleanup;
}
sym->addr = addr;
} else if (sym->kind == ZEND_FFI_SYM_FUNC) {
zend_string *mangled_name = zend_ffi_mangled_func_name(name, ZEND_FFI_TYPE(sym->type));
addr = DL_FETCH_SYMBOL(handle, ZSTR_VAL(mangled_name));
zend_string_release(mangled_name);
if (!addr) {
if (preload) {
zend_error(E_WARNING, "failed pre-loading '%s', cannot resolve C function '%s'", filename, ZSTR_VAL(name));
} else {
zend_throw_error(zend_ffi_exception_ce, "Failed resolving C function '%s'", ZSTR_VAL(name));
}
if (lib) {
DL_UNLOAD(handle);
}
goto cleanup;
}
sym->addr = addr;
}
if (scope && scope->symbols) {
zend_ffi_symbol *old_sym = zend_hash_find_ptr(scope->symbols, name);
if (old_sym) {
if (zend_ffi_same_symbols(old_sym, sym)) {
if (ZEND_FFI_TYPE_IS_OWNED(sym->type)
&& ZEND_FFI_TYPE(old_sym->type) != ZEND_FFI_TYPE(sym->type)) {
zend_ffi_type *type = ZEND_FFI_TYPE(sym->type);
zend_ffi_cleanup_type(ZEND_FFI_TYPE(old_sym->type), ZEND_FFI_TYPE(type));
zend_ffi_type_dtor(type);
}
} else {
zend_error(E_WARNING, "FFI: failed pre-loading '%s', redefinition of '%s'", filename, ZSTR_VAL(name));
if (lib) {
DL_UNLOAD(handle);
}
goto cleanup;
}
}
}
} ZEND_HASH_FOREACH_END();
}
if (preload) {
if (scope && scope->tags && 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->tags, name);
if (old_tag) {
if (zend_ffi_same_tags(old_tag, tag)) {
if (ZEND_FFI_TYPE_IS_OWNED(tag->type)
&& ZEND_FFI_TYPE(old_tag->type) != ZEND_FFI_TYPE(tag->type)) {
zend_ffi_type *type = ZEND_FFI_TYPE(tag->type);
zend_ffi_cleanup_type(ZEND_FFI_TYPE(old_tag->type), ZEND_FFI_TYPE(type));
zend_ffi_type_dtor(type);
}
} else {
zend_error(E_WARNING, "FFI: failed pre-loading '%s', redefinition of '%s %s'", filename, zend_ffi_tag_kind_name[tag->kind], ZSTR_VAL(name));
if (lib) {
DL_UNLOAD(handle);
}
goto cleanup;
}
}
} ZEND_HASH_FOREACH_END();
}
if (!scope) {
scope = malloc(sizeof(zend_ffi_scope));
scope->symbols = FFI_G(symbols);
scope->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->symbols) {
scope->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->symbols, name, sym)) {
zend_ffi_type_dtor(sym->type);
free(sym);
}
} ZEND_HASH_FOREACH_END();
FFI_G(symbols)->pDestructor = NULL;
zend_hash_destroy(FFI_G(symbols));
}
}
if (FFI_G(tags)) {
if (!scope->tags) {
scope->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->tags, name, tag)) {
zend_ffi_type_dtor(tag->type);
free(tag);
}
} ZEND_HASH_FOREACH_END();
FFI_G(tags)->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->symbols = scope->symbols;
ffi->tags = scope->tags;
ffi->persistent = 1;
} else {
ffi = (zend_ffi*)zend_ffi_new(zend_ffi_ce);
ffi->lib = handle;
ffi->symbols = FFI_G(symbols);
ffi->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) & ZEND_COMPILE_PRELOAD_IN_CHILD) {
zend_throw_error(zend_ffi_exception_ce, "FFI::load() doesn't work in conjunction with \"opcache.preload_user\". Use \"ffi.preload\" instead.");
RETURN_THROWS();
}
ffi = zend_ffi_load(ZSTR_VAL(fn), (CG(compiler_options) & ZEND_COMPILE_PRELOAD) != 0);
if (ffi) {
RETURN_OBJ(&ffi->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, "Failed loading scope '%s'", ZSTR_VAL(scope_name));
RETURN_THROWS();
}
ffi = (zend_ffi*)zend_ffi_new(zend_ffi_ce);
ffi->symbols = scope->symbols;
ffi->tags = scope->tags;
ffi->persistent = 1;
RETURN_OBJ(&ffi->std);
}
/* }}} */
void zend_ffi_cleanup_dcl(zend_ffi_dcl *dcl) /* {{{ */
{
if (dcl) {
zend_ffi_type_dtor(dcl->type);
dcl->type = NULL;
}
}
/* }}} */
static void zend_ffi_throw_parser_error(const char *format, ...) /* {{{ */
{
va_list va;
char *message = NULL;
va_start(va, format);
zend_vspprintf(&message, 0, format, va);
if (EG(current_execute_data)) {
zend_throw_exception(zend_ffi_parser_exception_ce, message, 0);
} else {
zend_error(E_WARNING, "FFI Parser: %s", message);
}
efree(message);
va_end(va);
}
/* }}} */
static zend_result zend_ffi_validate_vla(const zend_ffi_type *type) /* {{{ */
{
if (!FFI_G(allow_vla) && (type->attr & ZEND_FFI_ATTR_VLA)) {
zend_ffi_throw_parser_error("\"[*]\" is not allowed in other than function prototype scope at line %d", FFI_G(line));
return FAILURE;
}
return SUCCESS;
}
/* }}} */
static zend_result zend_ffi_validate_incomplete_type(const zend_ffi_type *type, bool allow_incomplete_tag, bool allow_incomplete_array) /* {{{ */
{
if (!allow_incomplete_tag && (type->attr & 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->type) == type) {
if (type->kind == ZEND_FFI_TYPE_ENUM) {
zend_ffi_throw_parser_error("Incomplete enum \"%s\" at line %d", ZSTR_VAL(key), FFI_G(line));
} else if (type->attr & ZEND_FFI_ATTR_UNION) {
zend_ffi_throw_parser_error("Incomplete union \"%s\" at line %d", ZSTR_VAL(key), FFI_G(line));
} else {
zend_ffi_throw_parser_error("Incomplete struct \"%s\" at line %d", 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->type)) {
zend_ffi_throw_parser_error("Incomplete C type %s at line %d", ZSTR_VAL(key), FFI_G(line));
return FAILURE;
}
} ZEND_HASH_FOREACH_END();
}
zend_ffi_throw_parser_error("Incomplete type at line %d", FFI_G(line));
return FAILURE;
} else if (!allow_incomplete_array && (type->attr & ZEND_FFI_ATTR_INCOMPLETE_ARRAY)) {
zend_ffi_throw_parser_error("\"[]\" is not allowed at line %d", FFI_G(line));
return FAILURE;
} else if (!FFI_G(allow_vla) && (type->attr & ZEND_FFI_ATTR_VLA)) {
zend_ffi_throw_parser_error("\"[*]\" is not allowed in other than function prototype scope at line %d", FFI_G(line));
return FAILURE;
}
return SUCCESS;
}
/* }}} */
static zend_result zend_ffi_validate_type(const zend_ffi_type *type, bool allow_incomplete_tag, bool allow_incomplete_array) /* {{{ */
{
if (type->kind == ZEND_FFI_TYPE_VOID) {
zend_ffi_throw_parser_error("void type is not allowed at line %d", 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(const zend_ffi_type *type, bool allow_incomplete_array) /* {{{ */
{
if (type->kind == ZEND_FFI_TYPE_FUNC) {
zend_ffi_throw_parser_error("function type is not allowed at line %d", 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->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->kind) {
case ZEND_FFI_TYPE_POINTER:
return zend_ffi_subst_type(&dcl_type->pointer.type, type);
case ZEND_FFI_TYPE_ARRAY:
return zend_ffi_subst_type(&dcl_type->array.type, type);
case ZEND_FFI_TYPE_FUNC:
if (zend_ffi_subst_type(&dcl_type->func.ret_type, type)) {
return 1;
}
if (dcl_type->func.args) {
zval *zv;
ZEND_HASH_PACKED_FOREACH_VAL(dcl_type->func.args, zv) {
if (zend_ffi_subst_type((zend_ffi_type**)&Z_PTR_P(zv), type)) {
return 1;
}
} ZEND_HASH_FOREACH_END();
}
break;
case ZEND_FFI_TYPE_STRUCT:
ZEND_HASH_MAP_FOREACH_PTR(&dcl_type->record.fields, field) {
if (zend_ffi_subst_type(&field->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->type)) {
zend_ffi_type *type = ZEND_FFI_TYPE(tag->type);
zend_ffi_subst_type(&dcl->type, type);
tag->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, "Calling FFI::new() statically is deprecated");
if (EG(exception)) {
RETURN_THROWS();
}
}
if (!owned) {
flags &= ~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->symbols;
FFI_G(tags) = ffi->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), &dcl) == FAILURE) {
zend_ffi_type_dtor(dcl.type);
if (clean_tags && FFI_G(tags)) {
zend_hash_destroy(FFI_G(tags));
efree(FFI_G(tags));
FFI_G(tags) = NULL;
}
if (clean_symbols && 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 & ZEND_FFI_ATTR_CONST) {
is_const = 1;
}
if (clean_tags && FFI_G(tags)) {
zend_ffi_tags_cleanup(&dcl);
}
if (clean_symbols && 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->type;
if (ZEND_FFI_TYPE_IS_OWNED(type)) {
type = ZEND_FFI_TYPE(type);
if (!(type->attr & ZEND_FFI_ATTR_STORED)) {
if (GC_REFCOUNT(&ctype->std) == 1) {
/* transfer type ownership */
ctype->type = type;
} else {
ctype->type = type_ptr = type = zend_ffi_remember_type(type);
}
}
}
}
if (type->size == 0) {
zend_throw_error(zend_ffi_exception_ce, "Cannot instantiate FFI\\CData of zero size");
zend_ffi_type_dtor(type_ptr);
return;
}
ptr = pemalloc(type->size, flags & ZEND_FFI_FLAG_PERSISTENT);
memset(ptr, 0, type->size);
cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
if (type->kind < ZEND_FFI_TYPE_POINTER) {
cdata->std.handlers = &zend_ffi_cdata_value_handlers;
}
cdata->type = type_ptr;
cdata->ptr = ptr;
cdata->flags = flags;
if (is_const) {
cdata->flags |= ZEND_FFI_FLAG_CONST;
}
RETURN_OBJ(&cdata->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->type)->kind == ZEND_FFI_TYPE_POINTER) {
if (!cdata->ptr) {
zend_throw_error(zend_ffi_exception_ce, "NULL pointer dereference");
RETURN_THROWS();
}
if (cdata->ptr != (void*)&cdata->ptr_holder) {
pefree(*(void**)cdata->ptr, cdata->flags & ZEND_FFI_FLAG_PERSISTENT);
} else {
pefree(cdata->ptr_holder, (cdata->flags & ZEND_FFI_FLAG_PERSISTENT) || !is_zend_ptr(cdata->ptr_holder));
}
*(void**)cdata->ptr = NULL;
} else if (!(cdata->flags & ZEND_FFI_FLAG_OWNED)) {
pefree(cdata->ptr, cdata->flags & ZEND_FFI_FLAG_PERSISTENT);
cdata->ptr = NULL;
cdata->flags &= ~(ZEND_FFI_FLAG_OWNED|ZEND_FFI_FLAG_PERSISTENT);
cdata->std.handlers = &zend_ffi_cdata_free_handlers;
} else {
zend_throw_error(zend_ffi_exception_ce, "free() non a C pointer");
}
}
/* }}} */
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, "Calling FFI::cast() statically is deprecated");
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->symbols;
FFI_G(tags) = ffi->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), &dcl) == FAILURE) {
zend_ffi_type_dtor(dcl.type);
if (clean_tags && FFI_G(tags)) {
zend_hash_destroy(FFI_G(tags));
efree(FFI_G(tags));
FFI_G(tags) = NULL;
}
if (clean_symbols && 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 & ZEND_FFI_ATTR_CONST) {
is_const = 1;
}
if (clean_tags && FFI_G(tags)) {
zend_ffi_tags_cleanup(&dcl);
}
if (clean_symbols && 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->type;
if (ZEND_FFI_TYPE_IS_OWNED(type)) {
type = ZEND_FFI_TYPE(type);
if (!(type->attr & ZEND_FFI_ATTR_STORED)) {
if (GC_REFCOUNT(&ctype->std) == 1) {
/* transfer type ownership */
ctype->type = type;
} else {
ctype->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->kind < ZEND_FFI_TYPE_POINTER && Z_TYPE_P(zv) < IS_STRING) {
/* numeric conversion */
cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
cdata->std.handlers = &zend_ffi_cdata_value_handlers;
cdata->type = type_ptr;
cdata->ptr = emalloc(type->size);
zend_ffi_zval_to_cdata(cdata->ptr, type, zv);
cdata->flags = ZEND_FFI_FLAG_OWNED;
if (is_const) {
cdata->flags |= ZEND_FFI_FLAG_CONST;
}
RETURN_OBJ(&cdata->std);
} else if (type->kind == ZEND_FFI_TYPE_POINTER && Z_TYPE_P(zv) == IS_LONG) {
/* number to pointer conversion */
cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
cdata->type = type_ptr;
cdata->ptr = &cdata->ptr_holder;
cdata->ptr_holder = (void*)(intptr_t)Z_LVAL_P(zv);
if (is_const) {
cdata->flags |= ZEND_FFI_FLAG_CONST;
}
RETURN_OBJ(&cdata->std);
} else if (type->kind == ZEND_FFI_TYPE_POINTER && Z_TYPE_P(zv) == IS_NULL) {
/* null -> pointer */
cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
cdata->type = type_ptr;
cdata->ptr = &cdata->ptr_holder;
cdata->ptr_holder = NULL;
if (is_const) {
cdata->flags |= ZEND_FFI_FLAG_CONST;
}
RETURN_OBJ(&cdata->std);
} else {
zend_wrong_parameter_class_error(2, "FFI\\CData", zv);
RETURN_THROWS();
}
}
old_cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
old_type = ZEND_FFI_TYPE(old_cdata->type);
ptr = old_cdata->ptr;
cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
if (type->kind < ZEND_FFI_TYPE_POINTER) {
cdata->std.handlers = &zend_ffi_cdata_value_handlers;
}
cdata->type = type_ptr;
if (old_type->kind == ZEND_FFI_TYPE_POINTER
&& type->kind != ZEND_FFI_TYPE_POINTER
&& ZEND_FFI_TYPE(old_type->pointer.type)->kind == ZEND_FFI_TYPE_VOID) {
/* automatically dereference void* pointers ??? */
cdata->ptr = *(void**)ptr;
} else if (old_type->kind == ZEND_FFI_TYPE_ARRAY
&& type->kind == ZEND_FFI_TYPE_POINTER
&& zend_ffi_is_compatible_type(ZEND_FFI_TYPE(old_type->array.type), ZEND_FFI_TYPE(type->pointer.type))) {
cdata->ptr = &cdata->ptr_holder;
cdata->ptr_holder = old_cdata->ptr;
} else if (old_type->kind == ZEND_FFI_TYPE_POINTER
&& type->kind == ZEND_FFI_TYPE_ARRAY
&& zend_ffi_is_compatible_type(ZEND_FFI_TYPE(old_type->pointer.type), ZEND_FFI_TYPE(type->array.type))) {
cdata->ptr = old_cdata->ptr_holder;
} else if (type->size > old_type->size) {
zend_object_release(&cdata->std);
zend_throw_error(zend_ffi_exception_ce, "attempt to cast to larger type");
RETURN_THROWS();
} else if (ptr != &old_cdata->ptr_holder) {
cdata->ptr = ptr;
} else {
cdata->ptr = &cdata->ptr_holder;
cdata->ptr_holder = old_cdata->ptr_holder;
}
if (is_const) {
cdata->flags |= ZEND_FFI_FLAG_CONST;
}
if (old_cdata->flags & ZEND_FFI_FLAG_OWNED) {
if (GC_REFCOUNT(&old_cdata->std) == 1 && Z_REFCOUNT_P(arg) == 1) {
/* transfer ownership */
old_cdata->flags &= ~ZEND_FFI_FLAG_OWNED;
cdata->flags |= ZEND_FFI_FLAG_OWNED;
} else {
//???zend_throw_error(zend_ffi_exception_ce, "Attempt to cast owned C pointer");
}
}
RETURN_OBJ(&cdata->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, "Calling FFI::type() statically is deprecated");
if (EG(exception)) {
RETURN_THROWS();
}
}
if (!is_static_call) {
zend_ffi *ffi = (zend_ffi*)Z_OBJ(EX(This));
FFI_G(symbols) = ffi->symbols;
FFI_G(tags) = ffi->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), &dcl) == FAILURE) {
zend_ffi_type_dtor(dcl.type);
if (clean_tags && FFI_G(tags)) {
zend_hash_destroy(FFI_G(tags));
efree(FFI_G(tags));
FFI_G(tags) = NULL;
}
if (clean_symbols && FFI_G(symbols)) {
zend_hash_destroy(FFI_G(symbols));
efree(FFI_G(symbols));
FFI_G(symbols) = NULL;
}
return;
}
if (clean_tags && FFI_G(tags)) {
zend_ffi_tags_cleanup(&dcl);
}
if (clean_symbols && 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->type = dcl.type;
RETURN_OBJ(&ctype->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 && Z_OBJCE_P(zv) == zend_ffi_cdata_ce) {
zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
type = cdata->type;
if (ZEND_FFI_TYPE_IS_OWNED(type)) {
type = ZEND_FFI_TYPE(type);
if (!(type->attr & ZEND_FFI_ATTR_STORED)) {
if (GC_REFCOUNT(&cdata->std) == 1 && Z_REFCOUNT_P(arg) == 1) {
/* transfer type ownership */
cdata->type = type;
type = ZEND_FFI_TYPE_MAKE_OWNED(type);
} else {
cdata->type = type = zend_ffi_remember_type(type);
}
}
}
} else {
zend_wrong_parameter_class_error(1, "FFI\\CData", zv);
RETURN_THROWS();
}
ctype = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
ctype->type = type;
RETURN_OBJ(&ctype->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->type);
if (type->kind == ZEND_FFI_TYPE_FUNC) {
zend_throw_error(zend_ffi_exception_ce, "Array of functions is not allowed");
RETURN_THROWS();
} else if (type->kind == ZEND_FFI_TYPE_ARRAY && (type->attr & ZEND_FFI_ATTR_INCOMPLETE_ARRAY)) {
zend_throw_error(zend_ffi_exception_ce, "Only the leftmost array can be undimensioned");
RETURN_THROWS();
} else if (type->kind == ZEND_FFI_TYPE_VOID) {
zend_throw_error(zend_ffi_exception_ce, "Array of void type is not allowed");
RETURN_THROWS();
} else if (type->attr & ZEND_FFI_ATTR_INCOMPLETE_TAG) {
zend_throw_error(zend_ffi_exception_ce, "Array of incomplete type is not allowed");
RETURN_THROWS();
}
if (ZEND_FFI_TYPE_IS_OWNED(ctype->type)) {
if (!(type->attr & ZEND_FFI_ATTR_STORED)) {
if (GC_REFCOUNT(&ctype->std) == 1) {
/* transfer type ownership */
ctype->type = type;
type = ZEND_FFI_TYPE_MAKE_OWNED(type);
} else {
ctype->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 < 0) {
zend_throw_error(zend_ffi_exception_ce, "negative array index");
zend_ffi_type_dtor(type);
RETURN_THROWS();
} else if (ZEND_FFI_TYPE(type)->kind == ZEND_FFI_TYPE_ARRAY && (ZEND_FFI_TYPE(type)->attr & ZEND_FFI_ATTR_INCOMPLETE_ARRAY)) {
zend_throw_error(zend_ffi_exception_ce, "only the leftmost array can be undimensioned");
zend_ffi_type_dtor(type);
RETURN_THROWS();
}
new_type = emalloc(sizeof(zend_ffi_type));
new_type->kind = ZEND_FFI_TYPE_ARRAY;
new_type->attr = 0;
new_type->size = n * ZEND_FFI_TYPE(type)->size;
new_type->align = ZEND_FFI_TYPE(type)->align;
new_type->array.type = type;
new_type->array.length = n;
if (n == 0) {
new_type->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->type = type;
RETURN_OBJ(&ctype->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, "FFI\\CData", zv);
RETURN_THROWS();
}
cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
type = ZEND_FFI_TYPE(cdata->type);
if (GC_REFCOUNT(&cdata->std) == 1 && Z_REFCOUNT_P(arg) == 1 && type->kind == ZEND_FFI_TYPE_POINTER
&& cdata->ptr == &cdata->ptr_holder) {
zend_throw_error(zend_ffi_exception_ce, "FFI::addr() cannot create a reference to a temporary pointer");
RETURN_THROWS();
}
new_type = emalloc(sizeof(zend_ffi_type));
new_type->kind = ZEND_FFI_TYPE_POINTER;
new_type->attr = 0;
new_type->size = sizeof(void*);
new_type->align = _Alignof(void*);
/* life-time (source must relive the resulting pointer) ??? */
new_type->pointer.type = type;
new_cdata = (zend_ffi_cdata*)zend_ffi_cdata_new(zend_ffi_cdata_ce);
new_cdata->type = ZEND_FFI_TYPE_MAKE_OWNED(new_type);
new_cdata->ptr_holder = cdata->ptr;
new_cdata->ptr = &new_cdata->ptr_holder;
if (GC_REFCOUNT(&cdata->std) == 1 && Z_REFCOUNT_P(arg) == 1) {
if (ZEND_FFI_TYPE_IS_OWNED(cdata->type)) {
/* transfer type ownership */
cdata->type = type;
new_type->pointer.type = ZEND_FFI_TYPE_MAKE_OWNED(type);
}
if (cdata->flags & ZEND_FFI_FLAG_OWNED) {
/* transfer ownership */
cdata->flags &= ~ZEND_FFI_FLAG_OWNED;
new_cdata->flags |= ZEND_FFI_FLAG_OWNED;
}
}
RETURN_OBJ(&new_cdata->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 && Z_OBJCE_P(zv) == zend_ffi_cdata_ce) {
zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
type = ZEND_FFI_TYPE(cdata->type);
} else if (Z_TYPE_P(zv) == IS_OBJECT && Z_OBJCE_P(zv) == zend_ffi_ctype_ce) {
zend_ffi_ctype *ctype = (zend_ffi_ctype*)Z_OBJ_P(zv);
type = ZEND_FFI_TYPE(ctype->type);
} else {
zend_wrong_parameter_class_error(1, "FFI\\CData or FFI\\CType", zv);
RETURN_THROWS();
}
RETURN_LONG(type->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 && Z_OBJCE_P(zv) == zend_ffi_cdata_ce) {
zend_ffi_cdata *cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
type = ZEND_FFI_TYPE(cdata->type);
} else if (Z_TYPE_P(zv) == IS_OBJECT && Z_OBJCE_P(zv) == zend_ffi_ctype_ce) {
zend_ffi_ctype *ctype = (zend_ffi_ctype*)Z_OBJ_P(zv);
type = ZEND_FFI_TYPE(ctype->type);
} else {
zend_wrong_parameter_class_error(1, "FFI\\CData or FFI\\CType", zv);
RETURN_THROWS();
}
RETURN_LONG(type->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->type);
if (type1->kind == ZEND_FFI_TYPE_POINTER) {
ptr1 = *(void**)cdata1->ptr;
} else {
ptr1 = cdata1->ptr;
if (type1->kind != ZEND_FFI_TYPE_POINTER && size > type1->size) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to write over data boundary");
RETURN_THROWS();
}
}
ZVAL_DEREF(zv2);
if (Z_TYPE_P(zv2) == IS_STRING) {
ptr2 = Z_STRVAL_P(zv2);
if (size > Z_STRLEN_P(zv2)) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to read over string boundary");
RETURN_THROWS();
}
} else if (Z_TYPE_P(zv2) == IS_OBJECT && Z_OBJCE_P(zv2) == zend_ffi_cdata_ce) {
cdata2 = (zend_ffi_cdata*)Z_OBJ_P(zv2);
type2 = ZEND_FFI_TYPE(cdata2->type);
if (type2->kind == ZEND_FFI_TYPE_POINTER) {
ptr2 = *(void**)cdata2->ptr;
} else {
ptr2 = cdata2->ptr;
if (type2->kind != ZEND_FFI_TYPE_POINTER && size > type2->size) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to read over data boundary");
RETURN_THROWS();
}
}
} else {
zend_wrong_parameter_class_error(2, "FFI\\CData or string", 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 > Z_STRLEN_P(zv1)) {
zend_throw_error(zend_ffi_exception_ce, "attempt to read over string boundary");
RETURN_THROWS();
}
} else if (Z_TYPE_P(zv1) == IS_OBJECT && Z_OBJCE_P(zv1) == zend_ffi_cdata_ce) {
cdata1 = (zend_ffi_cdata*)Z_OBJ_P(zv1);
type1 = ZEND_FFI_TYPE(cdata1->type);
if (type1->kind == ZEND_FFI_TYPE_POINTER) {
ptr1 = *(void**)cdata1->ptr;
} else {
ptr1 = cdata1->ptr;
if (type1->kind != ZEND_FFI_TYPE_POINTER && size > type1->size) {
zend_throw_error(zend_ffi_exception_ce, "attempt to read over data boundary");
RETURN_THROWS();
}
}
} else {
zend_wrong_parameter_class_error(1, "FFI\\CData or string", zv1);
RETURN_THROWS();
}
ZVAL_DEREF(zv2);
if (Z_TYPE_P(zv2) == IS_STRING) {
ptr2 = Z_STRVAL_P(zv2);
if (size > Z_STRLEN_P(zv2)) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to read over string boundary");
RETURN_THROWS();
}
} else if (Z_TYPE_P(zv2) == IS_OBJECT && Z_OBJCE_P(zv2) == zend_ffi_cdata_ce) {
cdata2 = (zend_ffi_cdata*)Z_OBJ_P(zv2);
type2 = ZEND_FFI_TYPE(cdata2->type);
if (type2->kind == ZEND_FFI_TYPE_POINTER) {
ptr2 = *(void**)cdata2->ptr;
} else {
ptr2 = cdata2->ptr;
if (type2->kind != ZEND_FFI_TYPE_POINTER && size > type2->size) {
zend_throw_error(zend_ffi_exception_ce, "Attempt to read over data boundary");
RETURN_THROWS();
}
}
} else {
zend_wrong_parameter_class_error(2, "FFI\\CData or string", zv2);
RETURN_THROWS();
}
ret = memcmp(ptr1, ptr2, size);
if (ret == 0) {
RETVAL_LONG(0);
} else if (ret < 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->type);
if (type->kind == ZEND_FFI_TYPE_POINTER) {
ptr = *(void**)cdata->ptr;
} else {
ptr = cdata->ptr;
if (type->kind != ZEND_FFI_TYPE_POINTER && size > type->size) {
zend_throw_error(zend_ffi_exception_ce, "attempt to write over data boundary");
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->type);
if (!size_is_null) {
if (type->kind == ZEND_FFI_TYPE_POINTER) {
ptr = *(void**)cdata->ptr;
} else {
ptr = cdata->ptr;
if (type->kind != ZEND_FFI_TYPE_POINTER && size > type->size) {
zend_throw_error(zend_ffi_exception_ce, "attempt to read over data boundary");
RETURN_THROWS();
}
}
RETURN_STRINGL((char*)ptr, size);
} else {
if (type->kind == ZEND_FFI_TYPE_POINTER && ZEND_FFI_TYPE(type->pointer.type)->kind == ZEND_FFI_TYPE_CHAR) {
ptr = *(void**)cdata->ptr;
} else if (type->kind == ZEND_FFI_TYPE_ARRAY && ZEND_FFI_TYPE(type->array.type)->kind == ZEND_FFI_TYPE_CHAR) {
ptr = cdata->ptr;
} else {
zend_throw_error(zend_ffi_exception_ce, "FFI\\Cdata is not a C string");
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, "FFI\\CData", zv);
RETURN_THROWS();
}
cdata = (zend_ffi_cdata*)Z_OBJ_P(zv);
type = ZEND_FFI_TYPE(cdata->type);
if (type->kind != ZEND_FFI_TYPE_POINTER){
zend_throw_error(zend_ffi_exception_ce, "FFI\\Cdata is not a pointer");
RETURN_THROWS();
}
RETURN_BOOL(*(void**)cdata->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(&buf, ZEND_FFI_TYPE(ctype->type))) {
RETURN_STR_COPY(Z_OBJ_P(ZEND_THIS)->ce->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) /* {{{ */
{
const zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
const zend_ffi_type *type;
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
}
type = ZEND_FFI_TYPE(ctype->type);
RETURN_LONG(type->kind);
}
/* }}} */
ZEND_METHOD(FFI_CType, getSize) /* {{{ */
{
const zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
const zend_ffi_type *type;
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
}
type = ZEND_FFI_TYPE(ctype->type);
RETURN_LONG(type->size);
}
/* }}} */
ZEND_METHOD(FFI_CType, getAlignment) /* {{{ */
{
const zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
const zend_ffi_type *type;
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
}
type = ZEND_FFI_TYPE(ctype->type);
RETURN_LONG(type->align);
}
/* }}} */
ZEND_METHOD(FFI_CType, getAttributes) /* {{{ */
{
const zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
const zend_ffi_type *type;
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
}
type = ZEND_FFI_TYPE(ctype->type);
RETURN_LONG(type->attr);
}
/* }}} */
ZEND_METHOD(FFI_CType, getEnumKind) /* {{{ */
{
const zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
const zend_ffi_type *type;
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
}
type = ZEND_FFI_TYPE(ctype->type);
if (type->kind != ZEND_FFI_TYPE_ENUM) {
zend_throw_error(zend_ffi_exception_ce, "FFI\\CType is not an enumeration");
RETURN_THROWS();
}
RETURN_LONG(type->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->type);
if (type->kind != ZEND_FFI_TYPE_ARRAY) {
zend_throw_error(zend_ffi_exception_ce, "FFI\\CType is not an array");
RETURN_THROWS();
}
ret = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
ret->type = ZEND_FFI_TYPE(type->array.type);
RETURN_OBJ(&ret->std);
}
/* }}} */
ZEND_METHOD(FFI_CType, getArrayLength) /* {{{ */
{
const zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
const zend_ffi_type *type;
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
}
type = ZEND_FFI_TYPE(ctype->type);
if (type->kind != ZEND_FFI_TYPE_ARRAY) {
zend_throw_error(zend_ffi_exception_ce, "FFI\\CType is not an array");
RETURN_THROWS();
}
RETURN_LONG(type->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->type);
if (type->kind != ZEND_FFI_TYPE_POINTER) {
zend_throw_error(zend_ffi_exception_ce, "FFI\\CType is not a pointer");
RETURN_THROWS();
}
ret = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
ret->type = ZEND_FFI_TYPE(type->pointer.type);
RETURN_OBJ(&ret->std);
}
/* }}} */
ZEND_METHOD(FFI_CType, getStructFieldNames) /* {{{ */
{
const zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
const zend_ffi_type *type;
HashTable *ht;
zend_string* name;
zval zv;
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
}
type = ZEND_FFI_TYPE(ctype->type);
if (type->kind != ZEND_FFI_TYPE_STRUCT) {
zend_throw_error(zend_ffi_exception_ce, "FFI\\CType is not a structure");
RETURN_THROWS();
}
ht = zend_new_array(zend_hash_num_elements(&type->record.fields));
RETVAL_ARR(ht);
ZEND_HASH_MAP_FOREACH_STR_KEY(&type->record.fields, name) {
ZVAL_STR_COPY(&zv, name);
zend_hash_next_index_insert_new(ht, &zv);
} ZEND_HASH_FOREACH_END();
}
/* }}} */
ZEND_METHOD(FFI_CType, getStructFieldOffset) /* {{{ */
{
const zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
const zend_ffi_type *type;
zend_string *name;
const zend_ffi_field *ptr;
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_STR(name)
ZEND_PARSE_PARAMETERS_END();
type = ZEND_FFI_TYPE(ctype->type);
if (type->kind != ZEND_FFI_TYPE_STRUCT) {
zend_throw_error(zend_ffi_exception_ce, "FFI\\CType is not a structure");
RETURN_THROWS();
}
ptr = zend_hash_find_ptr(&type->record.fields, name);
if (!ptr) {
zend_throw_error(zend_ffi_exception_ce, "Wrong field name");
RETURN_THROWS();
}
RETURN_LONG(ptr->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->type);
if (type->kind != ZEND_FFI_TYPE_STRUCT) {
zend_throw_error(zend_ffi_exception_ce, "FFI\\CType is not a structure");
RETURN_THROWS();
}
ptr = zend_hash_find_ptr(&type->record.fields, name);
if (!ptr) {
zend_throw_error(zend_ffi_exception_ce, "Wrong field name");
RETURN_THROWS();
}
ret = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
ret->type = ZEND_FFI_TYPE(ptr->type);
RETURN_OBJ(&ret->std);
}
/* }}} */
ZEND_METHOD(FFI_CType, getFuncABI) /* {{{ */
{
const zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
const zend_ffi_type *type;
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
}
type = ZEND_FFI_TYPE(ctype->type);
if (type->kind != ZEND_FFI_TYPE_FUNC) {
zend_throw_error(zend_ffi_exception_ce, "FFI\\CType is not a function");
RETURN_THROWS();
}
RETURN_LONG(type->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->type);
if (type->kind != ZEND_FFI_TYPE_FUNC) {
zend_throw_error(zend_ffi_exception_ce, "FFI\\CType is not a function");
RETURN_THROWS();
}
ret = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
ret->type = ZEND_FFI_TYPE(type->func.ret_type);
RETURN_OBJ(&ret->std);
}
/* }}} */
ZEND_METHOD(FFI_CType, getFuncParameterCount) /* {{{ */
{
const zend_ffi_ctype *ctype = (zend_ffi_ctype*)(Z_OBJ_P(ZEND_THIS));
const zend_ffi_type *type;
if (zend_parse_parameters_none() == FAILURE) {
RETURN_THROWS();
}
type = ZEND_FFI_TYPE(ctype->type);
if (type->kind != ZEND_FFI_TYPE_FUNC) {
zend_throw_error(zend_ffi_exception_ce, "FFI\\CType is not a function");
RETURN_THROWS();
}
RETURN_LONG(type->func.args ? zend_hash_num_elements(type->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->type);
if (type->kind != ZEND_FFI_TYPE_FUNC) {
zend_throw_error(zend_ffi_exception_ce, "FFI\\CType is not a function");
RETURN_THROWS();
}
if (!type->func.args) {
zend_throw_error(zend_ffi_exception_ce, "Wrong argument number");
RETURN_THROWS();
}
ptr = zend_hash_index_find_ptr(type->func.args, n);
if (!ptr) {
zend_throw_error(zend_ffi_exception_ce, "Wrong argument number");
RETURN_THROWS();
}
ret = (zend_ffi_ctype*)zend_ffi_ctype_new(zend_ffi_ctype_ce);
ret->type = ZEND_FFI_TYPE(ptr);
RETURN_OBJ(&ret->std);
}
/* }}} */
static char *zend_ffi_skip_ws_and_comments(char *p, bool allow_standalone_newline)
{
while (true) {
if (*p == ' ' || *p == '\t') {
p++;
} else if (allow_standalone_newline && (*p == '\r' || *p == '\n' || *p == '\f' || *p == '\v')) {
p++;
} else if (allow_standalone_newline && *p == '/' && p[1] == '/') {
p += 2;
while (*p && *p != '\r' && *p != '\n') {
p++;
}
} else if (*p == '/' && p[1] == '*') {
p += 2;
while (*p && (*p != '*' || p[1] != '/')) {
p++;
}
if (*p == '*') {
p++;
if (*p == '/') {
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 == '#') {
if (strncmp(code_pos, ZEND_STRL("#define")) == 0) {
p = zend_ffi_skip_ws_and_comments(code_pos + sizeof("#define") - 1, false);
char **target = NULL;
const char *target_name = NULL;
if (strncmp(p, ZEND_STRL("FFI_SCOPE")) == 0) {
p = zend_ffi_skip_ws_and_comments(p + sizeof("FFI_SCOPE") - 1, false);
target = scope_name;
target_name = "FFI_SCOPE";
} else if (strncmp(p, ZEND_STRL("FFI_LIB")) == 0) {
p = zend_ffi_skip_ws_and_comments(p + sizeof("FFI_LIB") - 1, false);
target = lib;
target_name = "FFI_LIB";
} else {
while (*p && *p != '\n' && *p != '\r') {
p++;
}
code_pos = zend_ffi_skip_ws_and_comments(p, true);
continue;
}
if (*p != '"') {
if (preload) {
zend_error(E_WARNING, "FFI: failed pre-loading '%s', bad %s define", filename, target_name);
} else {
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s', bad %s define", filename, target_name);
}
return NULL;
}
p++;
if (*target) {
if (preload) {
zend_error(E_WARNING, "FFI: failed pre-loading '%s', %s defined twice", filename, target_name);
} else {
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s', %s defined twice", filename, target_name);
}
return NULL;
}
*target = p;
while (1) {
if (*p == '\"') {
*p = 0;
p++;
break;
} else if (*p <= ' ') {
if (preload) {
zend_error(E_WARNING, "FFI: failed pre-loading '%s', bad %s define", filename, target_name);
} else {
zend_throw_error(zend_ffi_exception_ce, "Failed loading '%s', bad %s define", 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, "Instantiation of %s is not allowed", ZSTR_VAL(object->ce->name));
return NULL;
}
/* }}} */
static ZEND_COLD zend_never_inline void zend_bad_array_access(zend_class_entry *ce) /* {{{ */
{
zend_throw_error(NULL, "Cannot use object of type %s as array", ZSTR_VAL(ce->name));
}
/* }}} */
static ZEND_COLD zval *zend_fake_read_dimension(zend_object *obj, zval *offset, int type, zval *rv) /* {{{ */
{
zend_bad_array_access(obj->ce);
return NULL;
}
/* }}} */
static ZEND_COLD void zend_fake_write_dimension(zend_object *obj, zval *offset, zval *value) /* {{{ */
{
zend_bad_array_access(obj->ce);
}
/* }}} */
static ZEND_COLD int zend_fake_has_dimension(zend_object *obj, zval *offset, int check_empty) /* {{{ */
{
zend_bad_array_access(obj->ce);
return 0;
}
/* }}} */
static ZEND_COLD void zend_fake_unset_dimension(zend_object *obj, zval *offset) /* {{{ */
{
zend_bad_array_access(obj->ce);
}
/* }}} */
static ZEND_COLD zend_never_inline void zend_bad_property_access(zend_class_entry *ce) /* {{{ */
{
zend_throw_error(NULL, "Cannot access property of object of type %s", ZSTR_VAL(ce->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->ce);
return &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->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->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->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)->ce;
zend_throw_error(NULL, "Object of type %s does not support method calls", ZSTR_VAL(ce->name));
return NULL;
}
/* }}} */
static HashTable *zend_fake_get_properties(zend_object *obj) /* {{{ */
{
return (HashTable*)&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, "Use after free()");
}
/* }}} */
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 &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, "preload")) {
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("preload");
} else if (FFI_G(restriction) == ZEND_FFI_ENABLED) {
ZEND_PUTS("On");
} else {
ZEND_PUTS("Off");
}
}
/* }}} */
ZEND_INI_BEGIN()
ZEND_INI_ENTRY_EX("ffi.enable", "preload", ZEND_INI_SYSTEM, OnUpdateFFIEnable, zend_ffi_enable_displayer_cb)
STD_ZEND_INI_ENTRY("ffi.preload", NULL, ZEND_INI_SYSTEM, OnUpdateString, preload, zend_ffi_globals, ffi_globals)
ZEND_INI_END()
static zend_result zend_ffi_preload_glob(const char *filename) /* {{{ */
{
php_glob_t globbuf;
int ret;
unsigned int i;
memset(&globbuf, 0, sizeof(globbuf));
ret = php_glob(filename, 0, NULL, &globbuf);
#ifdef PHP_GLOB_NOMATCH
if (ret == PHP_GLOB_NOMATCH || !globbuf.gl_pathc) {
#else
if (!globbuf.gl_pathc) {
#endif
/* pass */
} else {
for(i=0 ; i<globbuf.gl_pathc; i++) {
zend_ffi *ffi = zend_ffi_load(globbuf.gl_pathv[i], 1);
if (!ffi) {
php_globfree(&globbuf);
return FAILURE;
}
efree(ffi);
}
php_globfree(&globbuf);
}
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 '*':
case '?':
case '[':
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 "new", "cast", and "type" 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(&zend_ffi_ce->function_table, "new", sizeof("new")-1))->run_time_cache);
ZEND_MAP_PTR(zend_ffi_cast_fn.run_time_cache) = ZEND_MAP_PTR(((zend_internal_function *)zend_hash_str_find_ptr(&zend_ffi_ce->function_table, "cast", sizeof("cast")-1))->run_time_cache);
ZEND_MAP_PTR(zend_ffi_type_fn.run_time_cache) = ZEND_MAP_PTR(((zend_internal_function *)zend_hash_str_find_ptr(&zend_ffi_ce->function_table, "type", sizeof("type")-1))->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, "cli") == 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->create_object = zend_ffi_new;
zend_ffi_ce->default_object_handlers = &zend_ffi_handlers;
memcpy(&zend_ffi_new_fn, zend_hash_str_find_ptr(&zend_ffi_ce->function_table, "new", sizeof("new")-1), sizeof(zend_internal_function));
zend_ffi_new_fn.fn_flags &= ~ZEND_ACC_STATIC;
memcpy(&zend_ffi_cast_fn, zend_hash_str_find_ptr(&zend_ffi_ce->function_table, "cast", sizeof("cast")-1), sizeof(zend_internal_function));
zend_ffi_cast_fn.fn_flags &= ~ZEND_ACC_STATIC;
memcpy(&zend_ffi_type_fn, zend_hash_str_find_ptr(&zend_ffi_ce->function_table, "type", sizeof("type")-1), sizeof(zend_internal_function));
zend_ffi_type_fn.fn_flags &= ~ZEND_ACC_STATIC;
prev_zend_post_startup_cb = zend_post_startup_cb;
zend_post_startup_cb = ffi_fixup_temporaries;
memcpy(&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->create_object = zend_ffi_cdata_new;
zend_ffi_cdata_ce->default_object_handlers = &zend_ffi_cdata_handlers;
zend_ffi_cdata_ce->get_iterator = zend_ffi_cdata_get_iterator;
memcpy(&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(&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(&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->create_object = zend_ffi_ctype_new;
zend_ffi_ctype_ce->default_object_handlers = &zend_ffi_ctype_handlers;
memcpy(&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, "WeakTypes: %d\n", 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, "FFI support", "enabled");
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*)&zend_ffi_type_void};
static const struct {
const char *name;
const zend_ffi_type *type;
} zend_ffi_types[] = {
{"void", &zend_ffi_type_void},
{"char", &zend_ffi_type_char},
{"bool", &zend_ffi_type_bool},
{"int8_t", &zend_ffi_type_sint8},
{"uint8_t", &zend_ffi_type_uint8},
{"int16_t", &zend_ffi_type_sint16},
{"uint16_t", &zend_ffi_type_uint16},
{"int32_t", &zend_ffi_type_sint32},
{"uint32_t", &zend_ffi_type_uint32},
{"int64_t", &zend_ffi_type_sint64},
{"uint64_t", &zend_ffi_type_uint64},
{"float", &zend_ffi_type_float},
{"double", &zend_ffi_type_double},
#ifdef HAVE_LONG_DOUBLE
{"long double", &zend_ffi_type_long_double},
#endif
#if SIZEOF_SIZE_T == 4
{"uintptr_t", &zend_ffi_type_uint32},
{"intptr_t", &zend_ffi_type_sint32},
{"size_t", &zend_ffi_type_uint32},
{"ssize_t", &zend_ffi_type_sint32},
{"ptrdiff_t", &zend_ffi_type_sint32},
#else
{"uintptr_t", &zend_ffi_type_uint64},
{"intptr_t", &zend_ffi_type_sint64},
{"size_t", &zend_ffi_type_uint64},
{"ssize_t", &zend_ffi_type_sint64},
{"ptrdiff_t", &zend_ffi_type_sint64},
#endif
#if SIZEOF_OFF_T == 4
{"off_t", &zend_ffi_type_sint32},
#else
{"off_t", &zend_ffi_type_sint64},
#endif
{"va_list", &zend_ffi_type_ptr},
{"__builtin_va_list", &zend_ffi_type_ptr},
{"__gnuc_va_list", &zend_ffi_type_ptr},
};
/* {{{ ZEND_GINIT_FUNCTION */
static ZEND_GINIT_FUNCTION(ffi)
{
size_t i;
#if defined(COMPILE_DL_FFI) && defined(ZTS)
ZEND_TSRMLS_CACHE_UPDATE();
#endif
memset(ffi_globals, 0, sizeof(*ffi_globals));
zend_hash_init(&ffi_globals->types, 0, NULL, NULL, 1);
for (i = 0; i < sizeof(zend_ffi_types)/sizeof(zend_ffi_types[0]); i++) {
zend_hash_str_add_new_ptr(&ffi_globals->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->scopes) {
zend_hash_destroy(ffi_globals->scopes);
free(ffi_globals->scopes);
}
zend_hash_destroy(&ffi_globals->types);
}
/* }}} */
/* {{{ ffi_module_entry */
zend_module_entry ffi_module_entry = {
STANDARD_MODULE_HEADER,
"FFI", /* 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(&message, 0, format, va);
if (EG(current_execute_data)) {
zend_throw_exception(zend_ffi_parser_exception_ce, message, 0);
} else {
zend_error(E_WARNING, "FFI Parser: %s", message);
}
efree(message);
va_end(va);
LONGJMP(FFI_G(bailout), FAILURE);
}
/* }}} */
static void zend_ffi_finalize_type(zend_ffi_dcl *dcl) /* {{{ */
{
if (!dcl->type) {
switch (dcl->flags & ZEND_FFI_DCL_TYPE_SPECIFIERS) {
case ZEND_FFI_DCL_VOID:
dcl->type = (zend_ffi_type*)&zend_ffi_type_void;
break;
case ZEND_FFI_DCL_CHAR:
dcl->type = (zend_ffi_type*)&zend_ffi_type_char;
break;
case ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_SIGNED:
dcl->type = (zend_ffi_type*)&zend_ffi_type_sint8;
break;
case ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_UNSIGNED:
case ZEND_FFI_DCL_BOOL:
dcl->type = (zend_ffi_type*)&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->type = (zend_ffi_type*)&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->type = (zend_ffi_type*)&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->type = (zend_ffi_type*)&zend_ffi_type_sint32;
break;
case ZEND_FFI_DCL_UNSIGNED:
case ZEND_FFI_DCL_UNSIGNED|ZEND_FFI_DCL_INT:
dcl->type = (zend_ffi_type*)&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->type = (zend_ffi_type*)&zend_ffi_type_sint32;
} else {
dcl->type = (zend_ffi_type*)&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->type = (zend_ffi_type*)&zend_ffi_type_uint32;
} else {
dcl->type = (zend_ffi_type*)&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->type = (zend_ffi_type*)&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->type = (zend_ffi_type*)&zend_ffi_type_uint64;
break;
case ZEND_FFI_DCL_FLOAT:
dcl->type = (zend_ffi_type*)&zend_ffi_type_float;
break;
case ZEND_FFI_DCL_DOUBLE:
dcl->type = (zend_ffi_type*)&zend_ffi_type_double;
break;
case ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_DOUBLE:
#ifdef _WIN32
dcl->type = (zend_ffi_type*)&zend_ffi_type_double;
#else
dcl->type = (zend_ffi_type*)&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("Unsupported type _Complex at line %d", FFI_G(line));
break;
default:
zend_ffi_parser_error("Unsupported type specifier combination at line %d", FFI_G(line));
break;
}
dcl->flags &= ~ZEND_FFI_DCL_TYPE_SPECIFIERS;
dcl->flags |= ZEND_FFI_DCL_TYPEDEF_NAME;
}
}
/* }}} */
bool zend_ffi_is_typedef_name(const char *name, size_t name_len) /* {{{ */
{
const zend_ffi_symbol *sym;
const zend_ffi_type *type;
if (FFI_G(symbols)) {
sym = zend_hash_str_find_ptr(FFI_G(symbols), name, name_len);
if (sym) {
return (sym->kind == ZEND_FFI_SYM_TYPE);
}
}
type = zend_hash_str_find_ptr(&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 && sym->kind == ZEND_FFI_SYM_TYPE) {
dcl->type = ZEND_FFI_TYPE(sym->type);
if (sym->is_const) {
dcl->attr |= ZEND_FFI_ATTR_CONST;
}
return;
}
}
type = zend_hash_str_find_ptr(&FFI_G(types), name, name_len);
if (type) {
dcl->type = type;
return;
}
zend_ffi_parser_error("Undefined C type \"%.*s\" at line %d", name_len, name, FFI_G(line));
}
/* }}} */
void zend_ffi_resolve_const(const char *name, size_t name_len, zend_ffi_val *val) /* {{{ */
{
if (UNEXPECTED(FFI_G(attribute_parsing))) {
val->kind = ZEND_FFI_VAL_NAME;
val->str = name;
val->len = name_len;
return;
} else if (FFI_G(symbols)) {
const zend_ffi_symbol *sym = zend_hash_str_find_ptr(FFI_G(symbols), name, name_len);
if (sym && sym->kind == ZEND_FFI_SYM_CONST) {
val->i64 = sym->value;
switch (sym->type->kind) {
case ZEND_FFI_TYPE_SINT8:
case ZEND_FFI_TYPE_SINT16:
case ZEND_FFI_TYPE_SINT32:
val->kind = ZEND_FFI_VAL_INT32;
break;
case ZEND_FFI_TYPE_SINT64:
val->kind = ZEND_FFI_VAL_INT64;
break;
case ZEND_FFI_TYPE_UINT8:
case ZEND_FFI_TYPE_UINT16:
case ZEND_FFI_TYPE_UINT32:
val->kind = ZEND_FFI_VAL_UINT32;
break;
case ZEND_FFI_TYPE_UINT64:
val->kind = ZEND_FFI_VAL_UINT64;
break;
default:
ZEND_UNREACHABLE();
}
return;
}
}
val->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->kind = ZEND_FFI_TYPE_ENUM;
type->attr = FFI_G(default_type_attr) | (dcl->attr & ZEND_FFI_ENUM_ATTRS);
type->enumeration.tag_name = NULL;
if (type->attr & ZEND_FFI_ATTR_PACKED) {
type->size = zend_ffi_type_uint8.size;
type->align = zend_ffi_type_uint8.align;
type->enumeration.kind = ZEND_FFI_TYPE_UINT8;
} else {
type->size = zend_ffi_type_uint32.size;
type->align = zend_ffi_type_uint32.align;
type->enumeration.kind = ZEND_FFI_TYPE_UINT32;
}
dcl->type = ZEND_FFI_TYPE_MAKE_OWNED(type);
dcl->attr &= ~ZEND_FFI_ENUM_ATTRS;
}
/* }}} */
void zend_ffi_add_enum_val(zend_ffi_dcl *enum_dcl, const char *name, size_t name_len, const 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->type);
bool overflow = 0;
bool is_signed =
(enum_type->enumeration.kind == ZEND_FFI_TYPE_SINT8 ||
enum_type->enumeration.kind == ZEND_FFI_TYPE_SINT16 ||
enum_type->enumeration.kind == ZEND_FFI_TYPE_SINT32 ||
enum_type->enumeration.kind == ZEND_FFI_TYPE_SINT64);
ZEND_ASSERT(enum_type && enum_type->kind == ZEND_FFI_TYPE_ENUM);
if (val->kind == ZEND_FFI_VAL_EMPTY) {
if (is_signed) {
if (*last == 0x7FFFFFFFFFFFFFFFLL) {
overflow = 1;
}
} else {
if ((*min != 0 || *max != 0)
&& (uint64_t)*last == 0xFFFFFFFFFFFFFFFFULL) {
overflow = 1;
}
}
value = *last + 1;
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
if (!is_signed && val->ch < 0) {
if ((uint64_t)*max > 0x7FFFFFFFFFFFFFFFULL) {
overflow = 1;
} else {
is_signed = 1;
}
}
value = val->ch;
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
if (!is_signed && val->i64 < 0) {
if ((uint64_t)*max > 0x7FFFFFFFFFFFFFFFULL) {
overflow = 1;
} else {
is_signed = 1;
}
}
value = val->i64;
} else if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) {
if (is_signed && val->u64 > 0x7FFFFFFFFFFFFFFFULL) {
overflow = 1;
}
value = val->u64;
} else {
zend_ffi_parser_error("Enumerator value \"%.*s\" must be an integer at line %d", name_len, name, FFI_G(line));
return;
}
if (overflow) {
zend_ffi_parser_error("Overflow in enumeration values \"%.*s\" at line %d", name_len, name, FFI_G(line));
return;
}
if (is_signed) {
*min = MIN(*min, value);
*max = MAX(*max, value);
if ((enum_type->attr & ZEND_FFI_ATTR_PACKED)
&& *min >= -0x7FLL-1 && *max <= 0x7FLL) {
sym_type = &zend_ffi_type_sint8;
} else if ((enum_type->attr & ZEND_FFI_ATTR_PACKED)
&& *min >= -0x7FFFLL-1 && *max <= 0x7FFFLL) {
sym_type = &zend_ffi_type_sint16;
} else if (*min >= -0x7FFFFFFFLL-1 && *max <= 0x7FFFFFFFLL) {
sym_type = &zend_ffi_type_sint32;
} else {
sym_type = &zend_ffi_type_sint64;
}
} else {
*min = MIN((uint64_t)*min, (uint64_t)value);
*max = MAX((uint64_t)*max, (uint64_t)value);
if ((enum_type->attr & ZEND_FFI_ATTR_PACKED)
&& (uint64_t)*max <= 0xFFULL) {
sym_type = &zend_ffi_type_uint8;
} else if ((enum_type->attr & ZEND_FFI_ATTR_PACKED)
&& (uint64_t)*max <= 0xFFFFULL) {
sym_type = &zend_ffi_type_uint16;
} else if ((uint64_t)*max <= 0xFFFFFFFFULL) {
sym_type = &zend_ffi_type_uint32;
} else {
sym_type = &zend_ffi_type_uint64;
}
}
enum_type->enumeration.kind = sym_type->kind;
enum_type->size = sym_type->size;
enum_type->align = sym_type->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("Redeclaration of \"%.*s\" at line %d", name_len, name, FFI_G(line));
} else {
sym = pemalloc(sizeof(zend_ffi_symbol), FFI_G(persistent));
sym->kind = ZEND_FFI_SYM_CONST;
sym->type = (zend_ffi_type*)sym_type;
sym->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->kind = ZEND_FFI_TYPE_STRUCT;
type->attr = FFI_G(default_type_attr) | (dcl->attr & ZEND_FFI_STRUCT_ATTRS);
type->size = 0;
type->align = dcl->align > 1 ? dcl->align : 1;
if (dcl->flags & ZEND_FFI_DCL_UNION) {
type->attr |= ZEND_FFI_ATTR_UNION;
}
dcl->type = ZEND_FFI_TYPE_MAKE_OWNED(type);
type->record.tag_name = NULL;
zend_hash_init(&type->record.fields, 0, NULL, FFI_G(persistent) ? zend_ffi_field_hash_persistent_dtor :zend_ffi_field_hash_dtor, FFI_G(persistent));
dcl->attr &= ~ZEND_FFI_STRUCT_ATTRS;
dcl->align = 0;
}
/* }}} */
static zend_result zend_ffi_validate_prev_field_type(zend_ffi_type *struct_type) /* {{{ */
{
if (zend_hash_num_elements(&struct_type->record.fields) > 0) {
const zend_ffi_field *field = NULL;
ZEND_HASH_MAP_REVERSE_FOREACH_PTR(&struct_type->record.fields, field) {
break;
} ZEND_HASH_FOREACH_END();
if (ZEND_FFI_TYPE(field->type)->attr & ZEND_FFI_ATTR_INCOMPLETE_ARRAY) {
zend_ffi_throw_parser_error("Flexible array member not at end of struct at line %d", FFI_G(line));
return FAILURE;
}
}
return SUCCESS;
}
/* }}} */
static zend_result zend_ffi_validate_field_type(const zend_ffi_type *type, zend_ffi_type *struct_type) /* {{{ */
{
if (type == struct_type) {
zend_ffi_throw_parser_error("Struct/union can't contain an instance of itself at line %d", FFI_G(line));
return FAILURE;
} else if (zend_ffi_validate_var_type(type, 1) == FAILURE) {
return FAILURE;
} else if (struct_type->attr & ZEND_FFI_ATTR_UNION) {
if (type->attr & ZEND_FFI_ATTR_INCOMPLETE_ARRAY) {
zend_ffi_throw_parser_error("Flexible array member in union at line %d", 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->type);
zend_ffi_type *field_type;
ZEND_ASSERT(struct_type && struct_type->kind == ZEND_FFI_TYPE_STRUCT);
zend_ffi_finalize_type(field_dcl);
field_type = ZEND_FFI_TYPE(field_dcl->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->attr & ZEND_FFI_ATTR_PACKED) && !(field_dcl->attr & ZEND_FFI_ATTR_PACKED)) {
struct_type->align = MAX(struct_type->align, MAX(field_type->align, field_dcl->align));
}
if (struct_type->attr & ZEND_FFI_ATTR_UNION) {
field->offset = 0;
struct_type->size = MAX(struct_type->size, field_type->size);
} else {
if (!(struct_type->attr & ZEND_FFI_ATTR_PACKED) && !(field_dcl->attr & ZEND_FFI_ATTR_PACKED)) {
uint32_t field_align = MAX(field_type->align, field_dcl->align);
struct_type->size = ((struct_type->size + (field_align - 1)) / field_align) * field_align;
}
field->offset = struct_type->size;
struct_type->size += field_type->size;
}
field->type = field_dcl->type;
field->is_const = (bool)(field_dcl->attr & ZEND_FFI_ATTR_CONST);
field->is_nested = 0;
field->first_bit = 0;
field->bits = 0;
field_dcl->type = field_type; /* reset "owned" flag */
if (!zend_hash_str_add_ptr(&struct_type->record.fields, name, name_len, field)) {
zend_ffi_type_dtor(field->type);
pefree(field, FFI_G(persistent));
zend_ffi_parser_error("Duplicate field name \"%.*s\" at line %d", 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->type);
zend_ffi_type *field_type;
zend_ffi_field *field;
zend_string *key;
ZEND_ASSERT(struct_type && struct_type->kind == ZEND_FFI_TYPE_STRUCT);
zend_ffi_finalize_type(field_dcl);
field_type = ZEND_FFI_TYPE(field_dcl->type);
if (field_type->kind != ZEND_FFI_TYPE_STRUCT) {
zend_ffi_cleanup_dcl(field_dcl);
zend_ffi_parser_error("Declaration does not declare anything at line %d", FFI_G(line));
return;
}
if (!(struct_type->attr & ZEND_FFI_ATTR_PACKED) && !(field_dcl->attr & ZEND_FFI_ATTR_PACKED)) {
struct_type->align = MAX(struct_type->align, MAX(field_type->align, field_dcl->align));
}
if (!(struct_type->attr & 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->attr & ZEND_FFI_ATTR_PACKED) && !(field_dcl->attr & ZEND_FFI_ATTR_PACKED)) {
uint32_t field_align = MAX(field_type->align, field_dcl->align);
struct_type->size = ((struct_type->size + (field_align - 1)) / field_align) * field_align;
}
}
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&field_type->record.fields, key, field) {
zend_ffi_field *new_field = pemalloc(sizeof(zend_ffi_field), FFI_G(persistent));
if (struct_type->attr & ZEND_FFI_ATTR_UNION) {
new_field->offset = field->offset;
} else {
new_field->offset = struct_type->size + field->offset;
}
new_field->type = field->type;
new_field->is_const = field->is_const;
new_field->is_nested = 1;
new_field->first_bit = field->first_bit;
new_field->bits = field->bits;
field->type = ZEND_FFI_TYPE(field->type); /* reset "owned" flag */
if (key) {
if (!zend_hash_add_ptr(&struct_type->record.fields, key, new_field)) {
zend_ffi_type_dtor(new_field->type);
pefree(new_field, FFI_G(persistent));
zend_ffi_parser_error("Duplicate field name \"%s\" at line %d", ZSTR_VAL(key), FFI_G(line));
return;
}
} else {
zend_hash_next_index_insert_ptr(&struct_type->record.fields, field);
}
} ZEND_HASH_FOREACH_END();
if (struct_type->attr & ZEND_FFI_ATTR_UNION) {
struct_type->size = MAX(struct_type->size, field_type->size);
} else {
struct_type->size += field_type->size;
}
zend_ffi_type_dtor(field_dcl->type);
field_dcl->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, const zend_ffi_val *bits) /* {{{ */
{
zend_ffi_type *struct_type = ZEND_FFI_TYPE(struct_dcl->type);
zend_ffi_type *field_type;
zend_ffi_field *field;
ZEND_ASSERT(struct_type && struct_type->kind == ZEND_FFI_TYPE_STRUCT);
zend_ffi_finalize_type(field_dcl);
field_type = ZEND_FFI_TYPE(field_dcl->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->kind < ZEND_FFI_TYPE_UINT8 || field_type->kind > ZEND_FFI_TYPE_BOOL) {
zend_ffi_cleanup_dcl(field_dcl);
zend_ffi_parser_error("Wrong type of bit field \"%.*s\" at line %d", name ? name_len : sizeof("<anonymous>")-1, name ? name : "<anonymous>", FFI_G(line));
}
if (bits->kind == ZEND_FFI_VAL_INT32 || bits->kind == ZEND_FFI_VAL_INT64) {
if (bits->i64 < 0) {
zend_ffi_cleanup_dcl(field_dcl);
zend_ffi_parser_error("Negative width in bit-field \"%.*s\" at line %d", name ? name_len : sizeof("<anonymous>")-1, name ? name : "<anonymous>", FFI_G(line));
} else if (bits->i64 == 0) {
zend_ffi_cleanup_dcl(field_dcl);
if (name) {
zend_ffi_parser_error("Zero width in bit-field \"%.*s\" at line %d", name ? name_len : sizeof("<anonymous>")-1, name ? name : "<anonymous>", FFI_G(line));
}
return;
} else if (bits->i64 > field_type->size * 8) {
zend_ffi_cleanup_dcl(field_dcl);
zend_ffi_parser_error("Width of \"%.*s\" exceeds its type at line %d", name ? name_len : sizeof("<anonymous>")-1, name ? name : "<anonymous>", FFI_G(line));
}
} else if (bits->kind == ZEND_FFI_VAL_UINT32 || bits->kind == ZEND_FFI_VAL_UINT64) {
if (bits->u64 == 0) {
zend_ffi_cleanup_dcl(field_dcl);
if (name) {
zend_ffi_parser_error("Zero width in bit-field \"%.*s\" at line %d", name ? name_len : sizeof("<anonymous>")-1, name ? name : "<anonymous>", FFI_G(line));
}
return;
} else if (bits->u64 > field_type->size * 8) {
zend_ffi_cleanup_dcl(field_dcl);
zend_ffi_parser_error("Width of \"%.*s\" exceeds its type at line %d", name ? name_len : sizeof("<anonymous>")-1, name ? name : "<anonymous>", FFI_G(line));
}
} else {
zend_ffi_cleanup_dcl(field_dcl);
zend_ffi_parser_error("Bit field \"%.*s\" width not an integer constant at line %d", name ? name_len : sizeof("<anonymous>")-1, name ? name : "<anonymous>", FFI_G(line));
}
field = pemalloc(sizeof(zend_ffi_field), FFI_G(persistent));
if (!(struct_type->attr & ZEND_FFI_ATTR_PACKED)) {
struct_type->align = MAX(struct_type->align, sizeof(uint32_t));
}
if (struct_type->attr & ZEND_FFI_ATTR_UNION) {
field->offset = 0;
field->first_bit = 0;
field->bits = bits->u64;
if (struct_type->attr & ZEND_FFI_ATTR_PACKED) {
struct_type->size = MAX(struct_type->size, (bits->u64 + 7) / 8);
} else {
struct_type->size = MAX(struct_type->size, ((bits->u64 + 31) / 32) * 4);
}
} else {
const zend_ffi_field *prev_field = NULL;
if (zend_hash_num_elements(&struct_type->record.fields) > 0) {
ZEND_HASH_MAP_REVERSE_FOREACH_PTR(&struct_type->record.fields, prev_field) {
break;
} ZEND_HASH_FOREACH_END();
}
if (prev_field && prev_field->bits) {
field->offset = prev_field->offset;
field->first_bit = prev_field->first_bit + prev_field->bits;
field->bits = bits->u64;
} else {
field->offset = struct_type->size;
field->first_bit = 0;
field->bits = bits->u64;
}
if (struct_type->attr & ZEND_FFI_ATTR_PACKED) {
struct_type->size = field->offset + ((field->first_bit + field->bits) + 7) / 8;
} else {
struct_type->size = field->offset + (((field->first_bit + field->bits) + 31) / 32) * 4;
}
}
field->type = field_dcl->type;
field->is_const = (bool)(field_dcl->attr & ZEND_FFI_ATTR_CONST);
field->is_nested = 0;
field_dcl->type = field_type; /* reset "owned" flag */
if (name) {
if (!zend_hash_str_add_ptr(&struct_type->record.fields, name, name_len, field)) {
zend_ffi_type_dtor(field->type);
pefree(field, FFI_G(persistent));
zend_ffi_parser_error("Duplicate field name \"%.*s\" at line %d", name_len, name, FFI_G(line));
}
} else {
zend_hash_next_index_insert_ptr(&struct_type->record.fields, field);
}
}
/* }}} */
void zend_ffi_adjust_struct_size(zend_ffi_dcl *dcl) /* {{{ */
{
zend_ffi_type *struct_type = ZEND_FFI_TYPE(dcl->type);
ZEND_ASSERT(struct_type->kind == ZEND_FFI_TYPE_STRUCT);
if (dcl->align > struct_type->align) {
struct_type->align = dcl->align;
}
if (!(struct_type->attr & ZEND_FFI_ATTR_PACKED)) {
struct_type->size = ((struct_type->size + (struct_type->align - 1)) / struct_type->align) * struct_type->align;
}
dcl->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->kind = ZEND_FFI_TYPE_POINTER;
type->attr = FFI_G(default_type_attr) | (dcl->attr & ZEND_FFI_POINTER_ATTRS);
type->size = sizeof(void*);
type->align = _Alignof(void*);
zend_ffi_finalize_type(dcl);
if (zend_ffi_validate_vla(ZEND_FFI_TYPE(dcl->type)) == FAILURE) {
zend_ffi_cleanup_dcl(dcl);
LONGJMP(FFI_G(bailout), FAILURE);
}
type->pointer.type = dcl->type;
dcl->type = ZEND_FFI_TYPE_MAKE_OWNED(type);
dcl->flags &= ~ZEND_FFI_DCL_TYPE_QUALIFIERS;
dcl->attr &= ~ZEND_FFI_POINTER_ATTRS;
dcl->align = 0;
}
/* }}} */
static zend_result zend_ffi_validate_array_element_type(const zend_ffi_type *type) /* {{{ */
{
if (type->kind == ZEND_FFI_TYPE_FUNC) {
zend_ffi_throw_parser_error("Array of functions is not allowed at line %d", FFI_G(line));
return FAILURE;
} else if (type->kind == ZEND_FFI_TYPE_ARRAY && (type->attr & ZEND_FFI_ATTR_INCOMPLETE_ARRAY)) {
zend_ffi_throw_parser_error("Only the leftmost array can be undimensioned at line %d", FFI_G(line));
return FAILURE;
}
return zend_ffi_validate_type(type, 0, 1);
}
/* }}} */
void zend_ffi_make_array_type(zend_ffi_dcl *dcl, const zend_ffi_val *len) /* {{{ */
{
int64_t length = 0;
const zend_ffi_type *element_type;
zend_ffi_type *type;
zend_ffi_finalize_type(dcl);
element_type = ZEND_FFI_TYPE(dcl->type);
if (len->kind == ZEND_FFI_VAL_EMPTY) {
length = 0;
} else if (len->kind == ZEND_FFI_VAL_UINT32 || len->kind == ZEND_FFI_VAL_UINT64) {
length = len->u64;
} else if (len->kind == ZEND_FFI_VAL_INT32 || len->kind == ZEND_FFI_VAL_INT64) {
length = len->i64;
} else if (len->kind == ZEND_FFI_VAL_CHAR) {
length = len->ch;
} else {
zend_ffi_cleanup_dcl(dcl);
zend_ffi_parser_error("Unsupported array index type at line %d", FFI_G(line));
return;
}
if (length < 0) {
zend_ffi_cleanup_dcl(dcl);
zend_ffi_parser_error("Negative array index at line %d", 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->kind = ZEND_FFI_TYPE_ARRAY;
type->attr = FFI_G(default_type_attr) | (dcl->attr & ZEND_FFI_ARRAY_ATTRS);
type->size = length * element_type->size;
type->align = element_type->align;
type->array.type = dcl->type;
type->array.length = length;
dcl->type = ZEND_FFI_TYPE_MAKE_OWNED(type);
dcl->flags &= ~ZEND_FFI_DCL_TYPE_QUALIFIERS;
dcl->attr &= ~ZEND_FFI_ARRAY_ATTRS;
dcl->align = 0;
}
/* }}} */
static zend_result zend_ffi_validate_func_ret_type(const zend_ffi_type *type) /* {{{ */
{
if (type->kind == ZEND_FFI_TYPE_FUNC) {
zend_ffi_throw_parser_error("Function returning function is not allowed at line %d", FFI_G(line));
return FAILURE;
} else if (type->kind == ZEND_FFI_TYPE_ARRAY) {
zend_ffi_throw_parser_error("Function returning array is not allowed at line %d", 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->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->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("void type is not allowed at line %d", 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->abi == ZEND_FFI_ABI_VECTORCALL && 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 >= 4 && i <= 5 && (arg_type->kind == ZEND_FFI_TYPE_FLOAT || arg_type->kind == ZEND_FFI_TYPE_DOUBLE)) {
# else
if (i < 6 && (arg_type->kind == ZEND_FFI_TYPE_FLOAT || arg_type->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("Type float/double is not allowed at position " ZEND_ULONG_FMT " with __vectorcall at line %d", 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->kind = ZEND_FFI_TYPE_FUNC;
type->attr = FFI_G(default_type_attr) | (dcl->attr & ZEND_FFI_FUNC_ATTRS);
type->size = sizeof(void*);
type->align = 1;
type->func.ret_type = dcl->type;
switch (dcl->abi) {
case ZEND_FFI_ABI_DEFAULT:
case ZEND_FFI_ABI_CDECL:
type->func.abi = FFI_DEFAULT_ABI;
break;
#ifdef HAVE_FFI_FASTCALL
case ZEND_FFI_ABI_FASTCALL:
type->func.abi = FFI_FASTCALL;
break;
#endif
#ifdef HAVE_FFI_THISCALL
case ZEND_FFI_ABI_THISCALL:
type->func.abi = FFI_THISCALL;
break;
#endif
#ifdef HAVE_FFI_STDCALL
case ZEND_FFI_ABI_STDCALL:
type->func.abi = FFI_STDCALL;
break;
#endif
#ifdef HAVE_FFI_PASCAL
case ZEND_FFI_ABI_PASCAL:
type->func.abi = FFI_PASCAL;
break;
#endif
#ifdef HAVE_FFI_REGISTER
case ZEND_FFI_ABI_REGISTER:
type->func.abi = FFI_REGISTER;
break;
#endif
#ifdef HAVE_FFI_MS_CDECL
case ZEND_FFI_ABI_MS:
type->func.abi = FFI_MS_CDECL;
break;
#endif
#ifdef HAVE_FFI_SYSV
case ZEND_FFI_ABI_SYSV:
type->func.abi = FFI_SYSV;
break;
#endif
#ifdef HAVE_FFI_VECTORCALL_PARTIAL
case ZEND_FFI_ABI_VECTORCALL:
type->func.abi = FFI_VECTORCALL_PARTIAL;
break;
#endif
default:
type->func.abi = FFI_DEFAULT_ABI;
zend_ffi_cleanup_dcl(nested_dcl);
if (args) {
zend_hash_destroy(args);
pefree(args, FFI_G(persistent));
}
type->func.args = NULL;
_zend_ffi_type_dtor(type);
zend_ffi_parser_error("Unsupported calling convention line %d", FFI_G(line));
break;
}
type->func.args = args;
dcl->type = ZEND_FFI_TYPE_MAKE_OWNED(type);
dcl->attr &= ~ZEND_FFI_FUNC_ATTRS;
dcl->align = 0;
dcl->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->type);
if (type->kind == ZEND_FFI_TYPE_ARRAY) {
if (ZEND_FFI_TYPE_IS_OWNED(arg_dcl->type)) {
type->kind = ZEND_FFI_TYPE_POINTER;
type->size = sizeof(void*);
} else {
zend_ffi_type *new_type = pemalloc(sizeof(zend_ffi_type), FFI_G(persistent));
new_type->kind = ZEND_FFI_TYPE_POINTER;
new_type->attr = FFI_G(default_type_attr) | (type->attr & ZEND_FFI_POINTER_ATTRS);
new_type->size = sizeof(void*);
new_type->align = _Alignof(void*);
new_type->pointer.type = ZEND_FFI_TYPE(type->array.type);
arg_dcl->type = ZEND_FFI_TYPE_MAKE_OWNED(new_type);
}
} else if (type->kind == ZEND_FFI_TYPE_FUNC) {
zend_ffi_type *new_type = pemalloc(sizeof(zend_ffi_type), FFI_G(persistent));
new_type->kind = ZEND_FFI_TYPE_POINTER;
new_type->attr = FFI_G(default_type_attr);
new_type->size = sizeof(void*);
new_type->align = _Alignof(void*);
new_type->pointer.type = arg_dcl->type;
arg_dcl->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->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->flags & ZEND_FFI_DCL_STORAGE_CLASS) == ZEND_FFI_DCL_TYPEDEF
&& sym->kind == ZEND_FFI_SYM_TYPE
&& zend_ffi_is_same_type(ZEND_FFI_TYPE(sym->type), ZEND_FFI_TYPE(dcl->type))
&& sym->is_const == (bool)(dcl->attr & ZEND_FFI_ATTR_CONST)) {
/* allowed redeclaration */
zend_ffi_type_dtor(dcl->type);
return;
} else if ((dcl->flags & ZEND_FFI_DCL_STORAGE_CLASS) == 0
|| (dcl->flags & ZEND_FFI_DCL_STORAGE_CLASS) == ZEND_FFI_DCL_EXTERN) {
const zend_ffi_type *type = ZEND_FFI_TYPE(dcl->type);
if (type->kind == ZEND_FFI_TYPE_FUNC) {
if (sym->kind == ZEND_FFI_SYM_FUNC
&& zend_ffi_same_types(ZEND_FFI_TYPE(sym->type), type)) {
/* allowed redeclaration */
zend_ffi_type_dtor(dcl->type);
return;
}
} else {
if (sym->kind == ZEND_FFI_SYM_VAR
&& zend_ffi_is_same_type(ZEND_FFI_TYPE(sym->type), type)
&& sym->is_const == (bool)(dcl->attr & ZEND_FFI_ATTR_CONST)) {
/* allowed redeclaration */
zend_ffi_type_dtor(dcl->type);
return;
}
}
}
zend_ffi_parser_error("Redeclaration of \"%.*s\" at line %d", name_len, name, FFI_G(line));
} else {
if ((dcl->flags & ZEND_FFI_DCL_STORAGE_CLASS) == ZEND_FFI_DCL_TYPEDEF) {
if (zend_ffi_validate_vla(ZEND_FFI_TYPE(dcl->type)) == FAILURE) {
zend_ffi_cleanup_dcl(dcl);
LONGJMP(FFI_G(bailout), FAILURE);
}
if (dcl->align && dcl->align > ZEND_FFI_TYPE(dcl->type)->align) {
if (ZEND_FFI_TYPE_IS_OWNED(dcl->type)) {
ZEND_FFI_TYPE(dcl->type)->align = dcl->align;
} else {
zend_ffi_type *type = pemalloc(sizeof(zend_ffi_type), FFI_G(persistent));
memcpy(type, ZEND_FFI_TYPE(dcl->type), sizeof(zend_ffi_type));
type->attr |= FFI_G(default_type_attr);
type->align = dcl->align;
dcl->type = ZEND_FFI_TYPE_MAKE_OWNED(type);
}
}
sym = pemalloc(sizeof(zend_ffi_symbol), FFI_G(persistent));
sym->kind = ZEND_FFI_SYM_TYPE;
sym->type = dcl->type;
sym->is_const = (bool)(dcl->attr & ZEND_FFI_ATTR_CONST);
dcl->type = ZEND_FFI_TYPE(dcl->type); /* reset "owned" flag */
zend_hash_str_add_new_ptr(FFI_G(symbols), name, name_len, sym);
} else {
zend_ffi_type *type;
type = ZEND_FFI_TYPE(dcl->type);
if (zend_ffi_validate_type(type, (dcl->flags & ZEND_FFI_DCL_STORAGE_CLASS) == ZEND_FFI_DCL_EXTERN, 1) == FAILURE) {
zend_ffi_cleanup_dcl(dcl);
LONGJMP(FFI_G(bailout), FAILURE);
}
if ((dcl->flags & ZEND_FFI_DCL_STORAGE_CLASS) == 0 ||
(dcl->flags & ZEND_FFI_DCL_STORAGE_CLASS) == ZEND_FFI_DCL_EXTERN) {
sym = pemalloc(sizeof(zend_ffi_symbol), FFI_G(persistent));
sym->kind = (type->kind == ZEND_FFI_TYPE_FUNC) ? ZEND_FFI_SYM_FUNC : ZEND_FFI_SYM_VAR;
sym->type = dcl->type;
sym->is_const = (bool)(dcl->attr & ZEND_FFI_ATTR_CONST);
dcl->type = type; /* reset "owned" flag */
zend_hash_str_add_new_ptr(FFI_G(symbols), name, name_len, sym);
} else {
/* useless declaration */
zend_ffi_type_dtor(dcl->type);
}
}
}
}
/* }}} */
void zend_ffi_declare_tag(const char *name, size_t name_len, zend_ffi_dcl *dcl, bool incomplete) /* {{{ */
{
zend_ffi_tag *tag;
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->type);
if (dcl->flags & ZEND_FFI_DCL_STRUCT) {
if (tag->kind != ZEND_FFI_TAG_STRUCT) {
zend_ffi_parser_error("\"%.*s\" defined as wrong kind of tag at line %d", name_len, name, FFI_G(line));
return;
} else if (!incomplete && !(type->attr & ZEND_FFI_ATTR_INCOMPLETE_TAG)) {
zend_ffi_parser_error("Redefinition of \"struct %.*s\" at line %d", name_len, name, FFI_G(line));
return;
}
} else if (dcl->flags & ZEND_FFI_DCL_UNION) {
if (tag->kind != ZEND_FFI_TAG_UNION) {
zend_ffi_parser_error("\"%.*s\" defined as wrong kind of tag at line %d", name_len, name, FFI_G(line));
return;
} else if (!incomplete && !(type->attr & ZEND_FFI_ATTR_INCOMPLETE_TAG)) {
zend_ffi_parser_error("Redefinition of \"union %.*s\" at line %d", name_len, name, FFI_G(line));
return;
}
} else if (dcl->flags & ZEND_FFI_DCL_ENUM) {
if (tag->kind != ZEND_FFI_TAG_ENUM) {
zend_ffi_parser_error("\"%.*s\" defined as wrong kind of tag at line %d", name_len, name, FFI_G(line));
return;
} else if (!incomplete && !(type->attr & ZEND_FFI_ATTR_INCOMPLETE_TAG)) {
zend_ffi_parser_error("Redefinition of \"enum %.*s\" at line %d", name_len, name, FFI_G(line));
return;
}
} else {
ZEND_UNREACHABLE();
return;
}
dcl->type = type;
if (!incomplete) {
type->attr &= ~ZEND_FFI_ATTR_INCOMPLETE_TAG;
}
} else {
zend_string *tag_name = zend_string_init(name, name_len, FFI_G(persistent));
zend_ffi_type *type;
tag = pemalloc(sizeof(zend_ffi_tag), FFI_G(persistent));
if (dcl->flags & ZEND_FFI_DCL_STRUCT) {
tag->kind = ZEND_FFI_TAG_STRUCT;
zend_ffi_make_struct_type(dcl);
type = ZEND_FFI_TYPE(dcl->type);
type->record.tag_name = zend_string_copy(tag_name);
} else if (dcl->flags & ZEND_FFI_DCL_UNION) {
tag->kind = ZEND_FFI_TAG_UNION;
zend_ffi_make_struct_type(dcl);
type = ZEND_FFI_TYPE(dcl->type);
type->record.tag_name = zend_string_copy(tag_name);
} else if (dcl->flags & ZEND_FFI_DCL_ENUM) {
tag->kind = ZEND_FFI_TAG_ENUM;
zend_ffi_make_enum_type(dcl);
type = ZEND_FFI_TYPE(dcl->type);
type->enumeration.tag_name = zend_string_copy(tag_name);
} else {
ZEND_UNREACHABLE();
}
tag->type = ZEND_FFI_TYPE_MAKE_OWNED(dcl->type);
dcl->type = ZEND_FFI_TYPE(dcl->type);
if (incomplete) {
dcl->type->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->abi != ZEND_FFI_ABI_DEFAULT) {
zend_ffi_parser_error("Multiple calling convention specifiers at line %d", FFI_G(line));
} else {
dcl->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 > 4
&& name[0] == '_'
&& name[1] == '_'
&& name[name_len-2] == '_'
&& name[name_len-1] == '_') {
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->align = __BIGGEST_ALIGNMENT__;
break;
case attr_packed:
dcl->attr |= ZEND_FFI_ATTR_PACKED;
break;
case attr_ms_struct:
dcl->attr |= ZEND_FFI_ATTR_MS_STRUCT;
break;
case attr_gcc_struct:
dcl->attr |= ZEND_FFI_ATTR_GCC_STRUCT;
break;
case attr_unsupported:
zend_ffi_parser_error("Unsupported attribute \"%.*s\" at line %d", 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, const 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 > 4
&& name[0] == '_'
&& name[1] == '_'
&& name[name_len-2] == '_'
&& name[name_len-1] == '_') {
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
&& (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_INT64 || val->kind == ZEND_FFI_VAL_UINT64)
&& val->i64 == 3) {
zend_ffi_set_abi(dcl, ZEND_FFI_ABI_REGISTER);
} else {
zend_ffi_parser_error("Incorrect \"regparam\" value at line %d", FFI_G(line));
}
break;
case attr_aligned:
if (n == 0
&& (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_INT64 || val->kind == ZEND_FFI_VAL_UINT64)
&& val->i64 > 0 && val->i64 <= 0x80000000 && (val->i64 & (val->i64 - 1)) == 0) {
dcl->align = val->i64;
} else {
zend_ffi_parser_error("Incorrect \"alignment\" value at line %d", FFI_G(line));
}
break;
case attr_mode:
if (n == 0
&& (val->kind == ZEND_FFI_VAL_NAME)) {
const char *str = val->str;
size_t len = val->len;
if (len > 4
&& str[0] == '_'
&& str[1] == '_'
&& str[len-2] == '_'
&& str[len-1] == '_') {
str += 2;
len -= 4;
}
// TODO: Add support for vector type 'VnXX' ???
if (len == 2) {
if (str[1] == 'I') {
if (dcl->flags & (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] == 'Q') {
dcl->flags &= ~(ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_INT|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_LONG_LONG);
dcl->flags |= ZEND_FFI_DCL_CHAR;
break;
} else if (str[0] == 'H') {
dcl->flags &= ~(ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_INT|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_LONG_LONG);
dcl->flags |= ZEND_FFI_DCL_SHORT;
break;
} else if (str[0] == 'S') {
dcl->flags &= ~(ZEND_FFI_DCL_CHAR|ZEND_FFI_DCL_SHORT|ZEND_FFI_DCL_INT|ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_LONG_LONG);
dcl->flags |= ZEND_FFI_DCL_INT;
break;
} else if (str[0] == 'D') {
dcl->flags &= ~(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->flags |= ZEND_FFI_DCL_LONG;
} else {
dcl->flags |= ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_LONG_LONG;
}
break;
}
} else if (str[1] == 'F') {
if (dcl->flags & (ZEND_FFI_DCL_TYPE_SPECIFIERS-(ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_FLOAT|ZEND_FFI_DCL_DOUBLE))) {
/* inappropriate type */
} else if (str[0] == 'S') {
dcl->flags &= ~(ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_FLOAT|ZEND_FFI_DCL_DOUBLE);
dcl->flags |= ZEND_FFI_DCL_FLOAT;
break;
} else if (str[0] == 'D') {
dcl->flags &= ~(ZEND_FFI_DCL_LONG|ZEND_FFI_DCL_FLOAT|ZEND_FFI_DCL_DOUBLE);
dcl->flags |= ZEND_FFI_DCL_DOUBLE;
break;
}
}
}
}
zend_ffi_parser_error("Unsupported \"mode\" value at line %d", FFI_G(line));
// TODO: ???
case attr_unsupported:
zend_ffi_parser_error("Unsupported attribute \"%.*s\" at line %d", 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, const zend_ffi_val *val) /* {{{ */
{
if (name_len == sizeof("align")-1 && memcmp(name, "align", sizeof("align")-1) == 0) {
if ((val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_INT64 || val->kind == ZEND_FFI_VAL_UINT64)
&& val->i64 > 0 && val->i64 <= 0x80000000 && (val->i64 & (val->i64 - 1)) == 0) {
dcl->align = val->i64;
} else {
zend_ffi_parser_error("Incorrect \"alignment\" value at line %d", 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->kind) {
case ZEND_FFI_TYPE_POINTER:
/* "char" is used as a terminator of nested declaration */
if (nested_type->pointer.type == &zend_ffi_type_char) {
nested_type->pointer.type = type;
return zend_ffi_validate_vla(ZEND_FFI_TYPE(type));
} else {
return zend_ffi_nested_type(type, nested_type->pointer.type);
}
break;
case ZEND_FFI_TYPE_ARRAY:
/* "char" is used as a terminator of nested declaration */
if (nested_type->array.type == &zend_ffi_type_char) {
nested_type->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->array.type) != SUCCESS) {
return FAILURE;
}
}
nested_type->size = nested_type->array.length * ZEND_FFI_TYPE(nested_type->array.type)->size;
nested_type->align = ZEND_FFI_TYPE(nested_type->array.type)->align;
return SUCCESS;
break;
case ZEND_FFI_TYPE_FUNC:
/* "char" is used as a terminator of nested declaration */
if (nested_type->func.ret_type == &zend_ffi_type_char) {
nested_type->func.ret_type = type;
return zend_ffi_validate_func_ret_type(ZEND_FFI_TYPE(type));
} else {
return zend_ffi_nested_type(type, nested_type->func.ret_type);
}
break;
default:
ZEND_UNREACHABLE();
}
}
/* }}} */
void zend_ffi_nested_declaration(zend_ffi_dcl *dcl, zend_ffi_dcl *nested_dcl) /* {{{ */
{
/* "char" is used as a terminator of nested declaration */
zend_ffi_finalize_type(dcl);
if (!nested_dcl->type || nested_dcl->type == &zend_ffi_type_char) {
nested_dcl->type = dcl->type;
} else {
if (zend_ffi_nested_type(dcl->type, nested_dcl->type) == FAILURE) {
zend_ffi_cleanup_dcl(nested_dcl);
LONGJMP(FFI_G(bailout), FAILURE);
}
}
dcl->type = nested_dcl->type;
}
/* }}} */
void zend_ffi_align_as_type(zend_ffi_dcl *dcl, zend_ffi_dcl *align_dcl) /* {{{ */
{
zend_ffi_finalize_type(align_dcl);
dcl->align = MAX(align_dcl->align, ZEND_FFI_TYPE(align_dcl->type)->align);
}
/* }}} */
void zend_ffi_align_as_val(zend_ffi_dcl *dcl, const zend_ffi_val *align_val) /* {{{ */
{
switch (align_val->kind) {
case ZEND_FFI_VAL_INT32:
case ZEND_FFI_VAL_UINT32:
dcl->align = zend_ffi_type_uint32.align;
break;
case ZEND_FFI_VAL_INT64:
case ZEND_FFI_VAL_UINT64:
dcl->align = zend_ffi_type_uint64.align;
break;
case ZEND_FFI_VAL_FLOAT:
dcl->align = zend_ffi_type_float.align;
break;
case ZEND_FFI_VAL_DOUBLE:
dcl->align = zend_ffi_type_double.align;
break;
#ifdef HAVE_LONG_DOUBLE
case ZEND_FFI_VAL_LONG_DOUBLE:
dcl->align = zend_ffi_type_long_double.align;
break;
#endif
case ZEND_FFI_VAL_CHAR:
case ZEND_FFI_VAL_STRING:
dcl->align = zend_ffi_type_char.align;
break;
default:
break;
}
}
/* }}} */
#define zend_ffi_expr_bool(val) do { \
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = !!val->u64; \
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = !!val->i64; \
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = !!val->d; \
} else if (val->kind == ZEND_FFI_VAL_CHAR) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = !!val->ch; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} while (0)
#define zend_ffi_expr_math(val, op2, OP) do { \
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) { \
if (op2->kind == ZEND_FFI_VAL_UINT32 || op2->kind == ZEND_FFI_VAL_UINT64) { \
val->kind = MAX(val->kind, op2->kind); \
val->u64 = val->u64 OP op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_INT32) { \
val->u64 = val->u64 OP op2->i64; \
} else if (op2->kind == ZEND_FFI_VAL_INT64) { \
val->u64 = val->u64 OP op2->i64; \
} else if (op2->kind == ZEND_FFI_VAL_FLOAT || op2->kind == ZEND_FFI_VAL_DOUBLE || op2->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
val->kind = op2->kind; \
val->d = (zend_ffi_double)val->u64 OP op2->d; \
} else if (op2->kind == ZEND_FFI_VAL_CHAR) { \
val->u64 = val->u64 OP op2->ch; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) { \
if (op2->kind == ZEND_FFI_VAL_UINT32) { \
val->i64 = val->i64 OP op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_UINT64) { \
val->i64 = val->i64 OP op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_INT32 || op2->kind == ZEND_FFI_VAL_INT64) { \
val->kind = MAX(val->kind, op2->kind); \
val->i64 = val->i64 OP op2->i64; \
} else if (op2->kind == ZEND_FFI_VAL_FLOAT || op2->kind == ZEND_FFI_VAL_DOUBLE || op2->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
val->kind = op2->kind; \
val->d = (zend_ffi_double)val->i64 OP op2->d; \
} else if (op2->kind == ZEND_FFI_VAL_CHAR) { \
val->i64 = val->i64 OP op2->ch; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
if (op2->kind == ZEND_FFI_VAL_UINT32 || op2->kind == ZEND_FFI_VAL_UINT64) { \
val->d = val->d OP (zend_ffi_double)op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_INT32 ||op2->kind == ZEND_FFI_VAL_INT64) { \
val->d = val->d OP (zend_ffi_double)op2->i64; \
} else if (op2->kind == ZEND_FFI_VAL_FLOAT || op2->kind == ZEND_FFI_VAL_DOUBLE || op2->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
val->kind = MAX(val->kind, op2->kind); \
val->d = val->d OP op2->d; \
} else if (op2->kind == ZEND_FFI_VAL_CHAR) { \
val->d = val->d OP (zend_ffi_double)op2->ch; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else if (val->kind == ZEND_FFI_VAL_CHAR) { \
if (op2->kind == ZEND_FFI_VAL_UINT32 || op2->kind == ZEND_FFI_VAL_UINT64) { \
val->kind = op2->kind; \
val->u64 = val->ch OP op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_INT32 || op2->kind == ZEND_FFI_VAL_INT64) { \
val->kind = ZEND_FFI_VAL_INT64; \
val->i64 = val->ch OP op2->i64; \
} else if (op2->kind == ZEND_FFI_VAL_FLOAT || op2->kind == ZEND_FFI_VAL_DOUBLE || op2->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
val->kind = op2->kind; \
val->d = (zend_ffi_double)val->ch OP op2->d; \
} else if (op2->kind == ZEND_FFI_VAL_CHAR) { \
val->ch = val->ch OP op2->ch; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} while (0)
#define zend_ffi_expr_int_math(val, op2, OP) do { \
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) { \
if (op2->kind == ZEND_FFI_VAL_UINT32 || op2->kind == ZEND_FFI_VAL_UINT64) { \
val->kind = MAX(val->kind, op2->kind); \
val->u64 = val->u64 OP op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_INT32) { \
val->u64 = val->u64 OP op2->i64; \
} else if (op2->kind == ZEND_FFI_VAL_INT64) { \
val->u64 = val->u64 OP op2->i64; \
} else if (op2->kind == ZEND_FFI_VAL_FLOAT || op2->kind == ZEND_FFI_VAL_DOUBLE || op2->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
val->u64 = val->u64 OP (uint64_t)op2->d; \
} else if (op2->kind == ZEND_FFI_VAL_CHAR) { \
val->u64 = val->u64 OP op2->ch; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) { \
if (op2->kind == ZEND_FFI_VAL_UINT32) { \
val->i64 = val->i64 OP op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_UINT64) { \
val->i64 = val->i64 OP op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_INT32 || op2->kind == ZEND_FFI_VAL_INT64) { \
val->kind = MAX(val->kind, op2->kind); \
val->i64 = val->i64 OP op2->i64; \
} else if (op2->kind == ZEND_FFI_VAL_FLOAT || op2->kind == ZEND_FFI_VAL_DOUBLE || op2->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
val->u64 = val->u64 OP (int64_t)op2->d; \
} else if (op2->kind == ZEND_FFI_VAL_CHAR) { \
val->i64 = val->i64 OP op2->ch; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
if (op2->kind == ZEND_FFI_VAL_UINT32 || op2->kind == ZEND_FFI_VAL_UINT64) { \
val->kind = op2->kind; \
val->u64 = (uint64_t)val->d OP op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_INT32 || op2->kind == ZEND_FFI_VAL_INT64) { \
val->kind = op2->kind; \
val->i64 = (int64_t)val->d OP op2->i64; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else if (val->kind == ZEND_FFI_VAL_CHAR) { \
if (op2->kind == ZEND_FFI_VAL_UINT32 || op2->kind == ZEND_FFI_VAL_UINT64) { \
val->kind = op2->kind; \
val->u64 = (uint64_t)val->ch OP op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_INT32 || op2->kind == ZEND_FFI_VAL_INT64) { \
val->kind = op2->kind; \
val->i64 = (int64_t)val->ch OP op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_CHAR) { \
val->ch = val->ch OP op2->ch; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} while (0)
#define zend_ffi_expr_cmp(val, op2, OP) do { \
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) { \
if (op2->kind == ZEND_FFI_VAL_UINT32 || op2->kind == ZEND_FFI_VAL_UINT64) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->u64 OP op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_INT32 || op2->kind == ZEND_FFI_VAL_INT64) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->u64 OP op2->u64; /*signed/unsigned */ \
} else if (op2->kind == ZEND_FFI_VAL_FLOAT || op2->kind == ZEND_FFI_VAL_DOUBLE || op2->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = (zend_ffi_double)val->u64 OP op2->d; \
} else if (op2->kind == ZEND_FFI_VAL_CHAR) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->u64 OP op2->d; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) { \
if (op2->kind == ZEND_FFI_VAL_UINT32 || op2->kind == ZEND_FFI_VAL_UINT64) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->i64 OP op2->i64; /* signed/unsigned */ \
} else if (op2->kind == ZEND_FFI_VAL_INT32 || op2->kind == ZEND_FFI_VAL_INT64) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->i64 OP op2->i64; \
} else if (op2->kind == ZEND_FFI_VAL_FLOAT || op2->kind == ZEND_FFI_VAL_DOUBLE || op2->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = (zend_ffi_double)val->i64 OP op2->d; \
} else if (op2->kind == ZEND_FFI_VAL_CHAR) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->i64 OP op2->ch; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
if (op2->kind == ZEND_FFI_VAL_UINT32 || op2->kind == ZEND_FFI_VAL_UINT64) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->d OP (zend_ffi_double)op2->u64; \
} else if (op2->kind == ZEND_FFI_VAL_INT32 ||op2->kind == ZEND_FFI_VAL_INT64) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->d OP (zend_ffi_double)op2->i64; \
} else if (op2->kind == ZEND_FFI_VAL_FLOAT || op2->kind == ZEND_FFI_VAL_DOUBLE || op2->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->d OP op2->d; \
} else if (op2->kind == ZEND_FFI_VAL_CHAR) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->d OP (zend_ffi_double)op2->ch; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else if (val->kind == ZEND_FFI_VAL_CHAR) { \
if (op2->kind == ZEND_FFI_VAL_UINT32 || op2->kind == ZEND_FFI_VAL_UINT64) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->ch OP op2->i64; /* signed/unsigned */ \
} else if (op2->kind == ZEND_FFI_VAL_INT32 || op2->kind == ZEND_FFI_VAL_INT64) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->ch OP op2->i64; \
} else if (op2->kind == ZEND_FFI_VAL_FLOAT || op2->kind == ZEND_FFI_VAL_DOUBLE || op2->kind == ZEND_FFI_VAL_LONG_DOUBLE) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = (zend_ffi_double)val->ch OP op2->d; \
} else if (op2->kind == ZEND_FFI_VAL_CHAR) { \
val->kind = ZEND_FFI_VAL_INT32; \
val->i64 = val->ch OP op2->ch; \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} else { \
val->kind = ZEND_FFI_VAL_ERROR; \
} \
} while (0)
void zend_ffi_expr_conditional(zend_ffi_val *val, const zend_ffi_val *op2, const zend_ffi_val *op3) /* {{{ */
{
zend_ffi_expr_bool(val);
if (val->kind == ZEND_FFI_VAL_INT32) {
if (val->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->kind == ZEND_FFI_VAL_INT32 && op2->kind == ZEND_FFI_VAL_INT32) {
val->i64 = val->i64 || op2->i64;
} else {
val->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->kind == ZEND_FFI_VAL_INT32 && op2->kind == ZEND_FFI_VAL_INT32) {
val->i64 = val->i64 && op2->i64;
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
}
/* }}} */
void zend_ffi_expr_bw_or(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_int_math(val, op2, |);
}
/* }}} */
void zend_ffi_expr_bw_xor(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_int_math(val, op2, ^);
}
/* }}} */
void zend_ffi_expr_bw_and(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_int_math(val, op2, &);
}
/* }}} */
void zend_ffi_expr_is_equal(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_cmp(val, op2, ==);
}
/* }}} */
void zend_ffi_expr_is_not_equal(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_cmp(val, op2, !=);
}
/* }}} */
void zend_ffi_expr_is_less(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_cmp(val, op2, <);
}
/* }}} */
void zend_ffi_expr_is_greater(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_cmp(val, op2, >);
}
/* }}} */
void zend_ffi_expr_is_less_or_equal(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_cmp(val, op2, <=);
}
/* }}} */
void zend_ffi_expr_is_greater_or_equal(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_cmp(val, op2, >=);
}
/* }}} */
void zend_ffi_expr_shift_left(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_int_math(val, op2, <<);
}
/* }}} */
void zend_ffi_expr_shift_right(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_int_math(val, op2, >>);
}
/* }}} */
void zend_ffi_expr_add(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_math(val, op2, +);
}
/* }}} */
void zend_ffi_expr_sub(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_math(val, op2, -);
}
/* }}} */
void zend_ffi_expr_mul(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_math(val, op2, *);
}
/* }}} */
void zend_ffi_expr_div(zend_ffi_val *val, const zend_ffi_val *op2) /* {{{ */
{
zend_ffi_expr_math(val, op2, /);
}
/* }}} */
void zend_ffi_expr_mod(zend_ffi_val *val, const 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->type)->kind) {
case ZEND_FFI_TYPE_FLOAT:
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) {
val->kind = ZEND_FFI_VAL_FLOAT;
val->d = (zend_ffi_double) val->u64;
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
val->kind = ZEND_FFI_VAL_FLOAT;
val->d = (zend_ffi_double) val->i64;
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
val->kind = ZEND_FFI_VAL_FLOAT;
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
val->kind = ZEND_FFI_VAL_FLOAT;
val->d = val->ch;
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
break;
case ZEND_FFI_TYPE_DOUBLE:
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) {
val->kind = ZEND_FFI_VAL_DOUBLE;
val->d = (zend_ffi_double) val->u64;
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
val->kind = ZEND_FFI_VAL_DOUBLE;
val->d = (zend_ffi_double) val->i64;
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
val->kind = ZEND_FFI_VAL_DOUBLE;
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
val->kind = ZEND_FFI_VAL_DOUBLE;
val->d = val->ch;
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
break;
#ifdef HAVE_LONG_DOUBLE
case ZEND_FFI_TYPE_LONGDOUBLE:
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) {
val->kind = ZEND_FFI_VAL_LONG_DOUBLE;
val->d = val->u64;
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
val->kind = ZEND_FFI_VAL_LONG_DOUBLE;
val->d = val->i64;
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
val->kind = ZEND_FFI_VAL_LONG_DOUBLE;
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
val->kind = ZEND_FFI_VAL_LONG_DOUBLE;
val->d = val->ch;
} else {
val->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->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64 || val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
val->kind = ZEND_FFI_VAL_UINT32;
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = (uint64_t) val->d;
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = val->ch;
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
break;
case ZEND_FFI_TYPE_SINT8:
case ZEND_FFI_TYPE_SINT16:
case ZEND_FFI_TYPE_SINT32:
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64 || val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
val->kind = ZEND_FFI_VAL_INT32;
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
val->kind = ZEND_FFI_VAL_INT32;
val->i64 = (uint64_t) val->d;
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
val->kind = ZEND_FFI_VAL_INT32;
val->i64 = val->ch;
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
break;
case ZEND_FFI_TYPE_UINT64:
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64 || val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
val->kind = ZEND_FFI_VAL_UINT64;
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
val->kind = ZEND_FFI_VAL_UINT64;
val->u64 = (uint64_t) val->d;
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
val->kind = ZEND_FFI_VAL_UINT64;
val->u64 = val->ch;
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
break;
case ZEND_FFI_TYPE_SINT64:
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) {
val->kind = ZEND_FFI_VAL_CHAR;
val->ch = val->u64;
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
val->kind = ZEND_FFI_VAL_CHAR;
val->ch = val->i64;
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
val->kind = ZEND_FFI_VAL_CHAR;
val->ch = (char) val->d;
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
break;
case ZEND_FFI_TYPE_CHAR:
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64 || val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
val->kind = ZEND_FFI_VAL_UINT32;
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = (uint64_t) val->d;
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = val->ch;
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
break;
default:
val->kind = ZEND_FFI_VAL_ERROR;
break;
}
zend_ffi_type_dtor(dcl->type);
}
/* }}} */
void zend_ffi_expr_plus(zend_ffi_val *val) /* {{{ */
{
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) {
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
}
/* }}} */
void zend_ffi_expr_neg(zend_ffi_val *val) /* {{{ */
{
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) {
val->u64 = -val->u64;
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
val->i64 = -val->i64;
} else if (val->kind == ZEND_FFI_VAL_FLOAT || val->kind == ZEND_FFI_VAL_DOUBLE || val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
val->d = -val->d;
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
val->ch = -val->ch;
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
}
/* }}} */
void zend_ffi_expr_bw_not(zend_ffi_val *val) /* {{{ */
{
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_UINT64) {
val->u64 = ~val->u64;
} else if (val->kind == ZEND_FFI_VAL_INT32 || val->kind == ZEND_FFI_VAL_INT64) {
val->i64 = ~val->i64;
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
val->ch = ~val->ch;
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
}
/* }}} */
void zend_ffi_expr_bool_not(zend_ffi_val *val) /* {{{ */
{
zend_ffi_expr_bool(val);
if (val->kind == ZEND_FFI_VAL_INT32) {
val->i64 = !val->i64;
}
}
/* }}} */
void zend_ffi_expr_sizeof_val(zend_ffi_val *val) /* {{{ */
{
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_INT32) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = zend_ffi_type_uint32.size;
} else if (val->kind == ZEND_FFI_VAL_UINT64 || val->kind == ZEND_FFI_VAL_INT64) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = zend_ffi_type_uint64.size;
} else if (val->kind == ZEND_FFI_VAL_FLOAT) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = zend_ffi_type_float.size;
} else if (val->kind == ZEND_FFI_VAL_DOUBLE) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = zend_ffi_type_double.size;
} else if (val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
val->kind = ZEND_FFI_VAL_UINT32;
#ifdef _WIN32
val->u64 = zend_ffi_type_double.size;
#else
val->u64 = zend_ffi_type_long_double.size;
#endif
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = zend_ffi_type_char.size;
} else if (val->kind == ZEND_FFI_VAL_STRING) {
if (memchr(val->str, '\\', val->len)) {
// TODO: support for escape sequences ???
val->kind = ZEND_FFI_VAL_ERROR;
} else {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = val->len + 1;
}
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
}
/* }}} */
void zend_ffi_expr_sizeof_type(zend_ffi_val *val, zend_ffi_dcl *dcl) /* {{{ */
{
const zend_ffi_type *type;
zend_ffi_finalize_type(dcl);
type = ZEND_FFI_TYPE(dcl->type);
val->kind = (type->size > 0xffffffff) ? ZEND_FFI_VAL_UINT64 : ZEND_FFI_VAL_UINT32;
val->u64 = type->size;
zend_ffi_type_dtor(dcl->type);
}
/* }}} */
void zend_ffi_expr_alignof_val(zend_ffi_val *val) /* {{{ */
{
if (val->kind == ZEND_FFI_VAL_UINT32 || val->kind == ZEND_FFI_VAL_INT32) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = zend_ffi_type_uint32.align;
} else if (val->kind == ZEND_FFI_VAL_UINT64 || val->kind == ZEND_FFI_VAL_INT64) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = zend_ffi_type_uint64.align;
} else if (val->kind == ZEND_FFI_VAL_FLOAT) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = zend_ffi_type_float.align;
} else if (val->kind == ZEND_FFI_VAL_DOUBLE) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = zend_ffi_type_double.align;
#ifdef HAVE_LONG_DOUBLE
} else if (val->kind == ZEND_FFI_VAL_LONG_DOUBLE) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = zend_ffi_type_long_double.align;
#endif
} else if (val->kind == ZEND_FFI_VAL_CHAR) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = zend_ffi_type_char.size;
} else if (val->kind == ZEND_FFI_VAL_STRING) {
val->kind = ZEND_FFI_VAL_UINT32;
val->u64 = _Alignof(char*);
} else {
val->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->kind = ZEND_FFI_VAL_UINT32;
val->u64 = ZEND_FFI_TYPE(dcl->type)->align;
zend_ffi_type_dtor(dcl->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] == 'u' || str[str_len-1] == 'U') {
u = 1;
if (str[str_len-2] == 'l' || str[str_len-2] == 'L') {
l = 1;
if (str[str_len-3] == 'l' || str[str_len-3] == 'L') {
l = 2;
}
}
} else if (str[str_len-1] == 'l' || str[str_len-1] == 'L') {
l = 1;
if (str[str_len-2] == 'l' || str[str_len-2] == 'L') {
l = 2;
if (str[str_len-3] == 'u' || str[str_len-3] == 'U') {
u = 1;
}
} else if (str[str_len-2] == 'u' || str[str_len-2] == 'U') {
u = 1;
}
}
if (u) {
val->u64 = strtoull(str, NULL, base);
if (l == 0) {
val->kind = ZEND_FFI_VAL_UINT32;
} else if (l == 1) {
val->kind = (sizeof(long) == 4) ? ZEND_FFI_VAL_UINT32 : ZEND_FFI_VAL_UINT64;
} else if (l == 2) {
val->kind = ZEND_FFI_VAL_UINT64;
}
} else {
val->i64 = strtoll(str, NULL, base);
if (l == 0) {
val->kind = ZEND_FFI_VAL_INT32;
} else if (l == 1) {
val->kind = (sizeof(long) == 4) ? ZEND_FFI_VAL_INT32 : ZEND_FFI_VAL_INT64;
} else if (l == 2) {
val->kind = ZEND_FFI_VAL_INT64;
}
}
}
/* }}} */
void zend_ffi_val_float_number(zend_ffi_val *val, const char *str, size_t str_len) /* {{{ */
{
val->d = strtold(str, NULL);
if (str[str_len-1] == 'f' || str[str_len-1] == 'F') {
val->kind = ZEND_FFI_VAL_FLOAT;
} else if (str[str_len-1] == 'l' || str[str_len-1] == 'L') {
val->kind = ZEND_FFI_VAL_LONG_DOUBLE;
} else {
val->kind = ZEND_FFI_VAL_DOUBLE;
}
}
/* }}} */
void zend_ffi_val_string(zend_ffi_val *val, const char *str, size_t str_len) /* {{{ */
{
if (str[0] != '\"') {
val->kind = ZEND_FFI_VAL_ERROR;
} else {
val->kind = ZEND_FFI_VAL_STRING;
val->str = str + 1;
val->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] != '\'') {
val->kind = ZEND_FFI_VAL_ERROR;
} else {
val->kind = ZEND_FFI_VAL_CHAR;
if (str_len == 3) {
val->ch = str[1];
} else if (str[1] == '\\') {
if (str[2] == 'a') {
} else if (str[2] == 'b' && str_len == 4) {
val->ch = '\b';
} else if (str[2] == 'f' && str_len == 4) {
val->ch = '\f';
} else if (str[2] == 'n' && str_len == 4) {
val->ch = '\n';
} else if (str[2] == 'r' && str_len == 4) {
val->ch = '\r';
} else if (str[2] == 't' && str_len == 4) {
val->ch = '\t';
} else if (str[2] == 'v' && str_len == 4) {
val->ch = '\v';
} else if (str[2] >= '0' && str[2] <= '7') {
n = str[2] - '0';
if (str[3] >= '0' && str[3] <= '7') {
n = n * 8 + (str[3] - '0');
if ((str[4] >= '0' && str[4] <= '7') && str_len == 6) {
n = n * 8 + (str[4] - '0');
} else if (str_len != 5) {
val->kind = ZEND_FFI_VAL_ERROR;
}
} else if (str_len != 4) {
val->kind = ZEND_FFI_VAL_ERROR;
}
if (n <= 0xff) {
val->ch = n;
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
} else if (str[2] == 'x') {
if (str[3] >= '0' && str[3] <= '9') {
n = str[3] - '0';
} else if (str[3] >= 'A' && str[3] <= 'F') {
n = str[3] - 'A';
} else if (str[3] >= 'a' && str[3] <= 'f') {
n = str[3] - 'a';
} else {
val->kind = ZEND_FFI_VAL_ERROR;
return;
}
if ((str[4] >= '0' && str[4] <= '9') && str_len == 6) {
n = n * 16 + (str[4] - '0');
} else if ((str[4] >= 'A' && str[4] <= 'F') && str_len == 6) {
n = n * 16 + (str[4] - 'A');
} else if ((str[4] >= 'a' && str[4] <= 'f') && str_len == 6) {
n = n * 16 + (str[4] - 'a');
} else if (str_len != 5) {
val->kind = ZEND_FFI_VAL_ERROR;
return;
}
val->ch = n;
} else if (str_len == 4) {
val->ch = str[2];
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
} else {
val->kind = ZEND_FFI_VAL_ERROR;
}
}
}
/* }}} */