#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage }
}
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val {
*byte |= mask;
} else {
*byte &= !mask;
}
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
}
pub const ZEND_DEBUG: u32 = 1;
pub const _ZEND_TYPE_NAME_BIT: u32 = 16777216;
pub const _ZEND_TYPE_NULLABLE_BIT: u32 = 2;
pub const HT_MIN_SIZE: u32 = 8;
pub const IS_UNDEF: u32 = 0;
pub const IS_NULL: u32 = 1;
pub const IS_FALSE: u32 = 2;
pub const IS_TRUE: u32 = 3;
pub const IS_LONG: u32 = 4;
pub const IS_DOUBLE: u32 = 5;
pub const IS_STRING: u32 = 6;
pub const IS_ARRAY: u32 = 7;
pub const IS_OBJECT: u32 = 8;
pub const IS_RESOURCE: u32 = 9;
pub const IS_REFERENCE: u32 = 10;
pub const IS_CONSTANT_AST: u32 = 11;
pub const IS_CALLABLE: u32 = 12;
pub const IS_ITERABLE: u32 = 13;
pub const IS_VOID: u32 = 14;
pub const IS_MIXED: u32 = 16;
pub const IS_INDIRECT: u32 = 12;
pub const IS_PTR: u32 = 13;
pub const _IS_BOOL: u32 = 18;
pub const Z_TYPE_FLAGS_SHIFT: u32 = 8;
pub const IS_TYPE_REFCOUNTED: u32 = 1;
pub const IS_TYPE_COLLECTABLE: u32 = 2;
pub const IS_INTERNED_STRING_EX: u32 = 6;
pub const IS_STRING_EX: u32 = 262;
pub const IS_ARRAY_EX: u32 = 775;
pub const IS_OBJECT_EX: u32 = 776;
pub const IS_RESOURCE_EX: u32 = 265;
pub const IS_REFERENCE_EX: u32 = 266;
pub const IS_CONSTANT_AST_EX: u32 = 267;
pub const E_ERROR: u32 = 1;
pub const E_WARNING: u32 = 2;
pub const E_PARSE: u32 = 4;
pub const E_NOTICE: u32 = 8;
pub const E_CORE_ERROR: u32 = 16;
pub const E_CORE_WARNING: u32 = 32;
pub const E_COMPILE_ERROR: u32 = 64;
pub const E_COMPILE_WARNING: u32 = 128;
pub const E_USER_ERROR: u32 = 256;
pub const E_USER_WARNING: u32 = 512;
pub const E_USER_NOTICE: u32 = 1024;
pub const E_STRICT: u32 = 2048;
pub const E_RECOVERABLE_ERROR: u32 = 4096;
pub const E_DEPRECATED: u32 = 8192;
pub const E_USER_DEPRECATED: u32 = 16384;
pub const ZEND_PROPERTY_ISSET: u32 = 0;
pub const ZEND_PROPERTY_EXISTS: u32 = 2;
pub const ZEND_ACC_PUBLIC: u32 = 1;
pub const ZEND_ACC_PROTECTED: u32 = 2;
pub const ZEND_ACC_PRIVATE: u32 = 4;
pub const ZEND_ACC_CHANGED: u32 = 8;
pub const ZEND_ACC_STATIC: u32 = 16;
pub const ZEND_ACC_PROMOTED: u32 = 32;
pub const ZEND_ACC_FINAL: u32 = 32;
pub const ZEND_ACC_ABSTRACT: u32 = 64;
pub const ZEND_ACC_IMMUTABLE: u32 = 128;
pub const ZEND_ACC_HAS_TYPE_HINTS: u32 = 256;
pub const ZEND_ACC_TOP_LEVEL: u32 = 512;
pub const ZEND_ACC_PRELOADED: u32 = 1024;
pub const ZEND_ACC_INTERFACE: u32 = 1;
pub const ZEND_ACC_TRAIT: u32 = 2;
pub const ZEND_ACC_ANON_CLASS: u32 = 4;
pub const ZEND_ACC_LINKED: u32 = 8;
pub const ZEND_ACC_IMPLICIT_ABSTRACT_CLASS: u32 = 16;
pub const ZEND_ACC_USE_GUARDS: u32 = 2048;
pub const ZEND_ACC_CONSTANTS_UPDATED: u32 = 4096;
pub const ZEND_ACC_NO_DYNAMIC_PROPERTIES: u32 = 8192;
pub const ZEND_HAS_STATIC_IN_METHODS: u32 = 16384;
pub const ZEND_ACC_RESOLVED_PARENT: u32 = 131072;
pub const ZEND_ACC_RESOLVED_INTERFACES: u32 = 262144;
pub const ZEND_ACC_UNRESOLVED_VARIANCE: u32 = 524288;
pub const ZEND_ACC_NEARLY_LINKED: u32 = 1048576;
pub const ZEND_ACC_NOT_SERIALIZABLE: u32 = 536870912;
pub const ZEND_ACC_DEPRECATED: u32 = 2048;
pub const ZEND_ACC_RETURN_REFERENCE: u32 = 4096;
pub const ZEND_ACC_HAS_RETURN_TYPE: u32 = 8192;
pub const ZEND_ACC_VARIADIC: u32 = 16384;
pub const ZEND_ACC_HAS_FINALLY_BLOCK: u32 = 32768;
pub const ZEND_ACC_EARLY_BINDING: u32 = 65536;
pub const ZEND_ACC_USES_THIS: u32 = 131072;
pub const ZEND_ACC_CALL_VIA_TRAMPOLINE: u32 = 262144;
pub const ZEND_ACC_NEVER_CACHE: u32 = 524288;
pub const ZEND_ACC_TRAIT_CLONE: u32 = 1048576;
pub const ZEND_ACC_CTOR: u32 = 2097152;
pub const ZEND_ACC_CLOSURE: u32 = 4194304;
pub const ZEND_ACC_FAKE_CLOSURE: u32 = 8388608;
pub const ZEND_ACC_GENERATOR: u32 = 16777216;
pub const ZEND_ACC_DONE_PASS_TWO: u32 = 33554432;
pub const ZEND_ACC_HEAP_RT_CACHE: u32 = 67108864;
pub const ZEND_ACC_STRICT_TYPES: u32 = 2147483648;
pub const ZEND_INTERNAL_FUNCTION: u32 = 1;
pub const ZEND_USER_FUNCTION: u32 = 2;
pub const ZEND_EVAL_CODE: u32 = 4;
pub const ZEND_ISEMPTY: u32 = 1;
pub const _ZEND_SEND_MODE_SHIFT: u32 = 25;
pub const _ZEND_IS_VARIADIC_BIT: u32 = 134217728;
pub const ZEND_MODULE_API_NO: u32 = 20230831;
pub const USING_ZTS: u32 = 0;
pub const MAY_BE_BOOL: u32 = 12;
pub const MAY_BE_ANY: u32 = 1022;
pub const TRACK_VARS_POST: u32 = 0;
pub const TRACK_VARS_GET: u32 = 1;
pub const TRACK_VARS_COOKIE: u32 = 2;
pub const TRACK_VARS_SERVER: u32 = 3;
pub const TRACK_VARS_ENV: u32 = 4;
pub const TRACK_VARS_FILES: u32 = 5;
pub const TRACK_VARS_REQUEST: u32 = 6;
pub const PHP_INI_USER: u32 = 1;
pub const PHP_INI_PERDIR: u32 = 2;
pub const PHP_INI_SYSTEM: u32 = 4;
pub const PHP_INI_ALL: u32 = 7;
pub const CONST_CS: u32 = 0;
pub const CONST_PERSISTENT: u32 = 1;
pub const CONST_NO_FILE_CACHE: u32 = 2;
pub const CONST_DEPRECATED: u32 = 4;
pub type __dev_t = ::std::os::raw::c_ulong;
pub type __uid_t = ::std::os::raw::c_uint;
pub type __gid_t = ::std::os::raw::c_uint;
pub type __ino_t = ::std::os::raw::c_ulong;
pub type __mode_t = ::std::os::raw::c_uint;
pub type __nlink_t = ::std::os::raw::c_ulong;
pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __time_t = ::std::os::raw::c_long;
pub type __blksize_t = ::std::os::raw::c_long;
pub type __blkcnt_t = ::std::os::raw::c_long;
pub type __syscall_slong_t = ::std::os::raw::c_long;
pub type gid_t = __gid_t;
pub type uid_t = __uid_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __sigset_t {
pub __val: [::std::os::raw::c_ulong; 16usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timespec {
pub tv_sec: __time_t,
pub tv_nsec: __syscall_slong_t,
}
pub type FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
_unused: [u8; 0],
}
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
pub _flags: ::std::os::raw::c_int,
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
pub _IO_read_end: *mut ::std::os::raw::c_char,
pub _IO_read_base: *mut ::std::os::raw::c_char,
pub _IO_write_base: *mut ::std::os::raw::c_char,
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
pub _IO_write_end: *mut ::std::os::raw::c_char,
pub _IO_buf_base: *mut ::std::os::raw::c_char,
pub _IO_buf_end: *mut ::std::os::raw::c_char,
pub _IO_save_base: *mut ::std::os::raw::c_char,
pub _IO_backup_base: *mut ::std::os::raw::c_char,
pub _IO_save_end: *mut ::std::os::raw::c_char,
pub _markers: *mut _IO_marker,
pub _chain: *mut _IO_FILE,
pub _fileno: ::std::os::raw::c_int,
pub _flags2: ::std::os::raw::c_int,
pub _old_offset: __off_t,
pub _cur_column: ::std::os::raw::c_ushort,
pub _vtable_offset: ::std::os::raw::c_schar,
pub _shortbuf: [::std::os::raw::c_char; 1usize],
pub _lock: *mut _IO_lock_t,
pub _offset: __off64_t,
pub _codecvt: *mut _IO_codecvt,
pub _wide_data: *mut _IO_wide_data,
pub _freeres_list: *mut _IO_FILE,
pub _freeres_buf: *mut ::std::os::raw::c_void,
pub __pad5: usize,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
pub type zend_long = i64;
pub type zend_ulong = u64;
pub type zend_off_t = i64;
pub const ZEND_RESULT_CODE_SUCCESS: ZEND_RESULT_CODE = 0;
pub const ZEND_RESULT_CODE_FAILURE: ZEND_RESULT_CODE = -1;
pub type ZEND_RESULT_CODE = ::std::os::raw::c_int;
pub use self::ZEND_RESULT_CODE as zend_result;
pub type zend_object_handlers = _zend_object_handlers;
pub type zend_class_entry = _zend_class_entry;
pub type zend_function = _zend_function;
pub type zend_execute_data = _zend_execute_data;
pub type zval = _zval_struct;
pub type zend_refcounted = _zend_refcounted;
pub type zend_string = _zend_string;
pub type zend_array = _zend_array;
pub type zend_object = _zend_object;
pub type zend_resource = _zend_resource;
pub type zend_reference = _zend_reference;
pub type zend_ast_ref = _zend_ast_ref;
pub type dtor_func_t = ::std::option::Option<unsafe extern "C" fn(pDest: *mut zval)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zend_type {
pub ptr: *mut ::std::os::raw::c_void,
pub type_mask: u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zend_value {
pub lval: zend_long,
pub dval: f64,
pub counted: *mut zend_refcounted,
pub str_: *mut zend_string,
pub arr: *mut zend_array,
pub obj: *mut zend_object,
pub res: *mut zend_resource,
pub ref_: *mut zend_reference,
pub ast: *mut zend_ast_ref,
pub zv: *mut zval,
pub ptr: *mut ::std::os::raw::c_void,
pub ce: *mut zend_class_entry,
pub func: *mut zend_function,
pub ww: _zend_value__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_value__bindgen_ty_1 {
pub w1: u32,
pub w2: u32,
}
pub type zend_value = _zend_value;
#[repr(C)]
pub struct _zval_struct {
pub value: zend_value,
pub u1: _zval_struct__bindgen_ty_1,
pub u2: _zval_struct__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zval_struct__bindgen_ty_1 {
pub type_info: u32,
pub v: _zval_struct__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _zval_struct__bindgen_ty_1__bindgen_ty_1 {
pub type_: u8,
pub type_flags: u8,
pub u: _zval_struct__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zval_struct__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
pub extra: u16,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zval_struct__bindgen_ty_2 {
pub next: u32,
pub cache_slot: u32,
pub opline_num: u32,
pub lineno: u32,
pub num_args: u32,
pub fe_pos: u32,
pub fe_iter_idx: u32,
pub guard: u32,
pub constant_flags: u32,
pub extra: u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _zend_refcounted_h {
pub refcount: u32,
pub u: _zend_refcounted_h__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zend_refcounted_h__bindgen_ty_1 {
pub type_info: u32,
}
pub type zend_refcounted_h = _zend_refcounted_h;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _zend_refcounted {
pub gc: zend_refcounted_h,
}
#[repr(C)]
pub struct _zend_string {
pub gc: zend_refcounted_h,
pub h: zend_ulong,
pub len: usize,
pub val: [::std::os::raw::c_char; 1usize],
}
#[repr(C)]
pub struct _Bucket {
pub val: zval,
pub h: zend_ulong,
pub key: *mut zend_string,
}
pub type Bucket = _Bucket;
pub type HashTable = _zend_array;
#[repr(C)]
pub struct _zend_array {
pub gc: zend_refcounted_h,
pub u: _zend_array__bindgen_ty_1,
pub nTableMask: u32,
pub __bindgen_anon_1: _zend_array__bindgen_ty_2,
pub nNumUsed: u32,
pub nNumOfElements: u32,
pub nTableSize: u32,
pub nInternalPointer: u32,
pub nNextFreeElement: zend_long,
pub pDestructor: dtor_func_t,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zend_array__bindgen_ty_1 {
pub v: _zend_array__bindgen_ty_1__bindgen_ty_1,
pub flags: u32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_array__bindgen_ty_1__bindgen_ty_1 {
pub flags: u8,
pub _unused: u8,
pub nIteratorsCount: u8,
pub _unused2: u8,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zend_array__bindgen_ty_2 {
pub arHash: *mut u32,
pub arData: *mut Bucket,
pub arPacked: *mut zval,
}
pub type HashPosition = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _HashTableIterator {
pub ht: *mut HashTable,
pub pos: HashPosition,
pub next_copy: u32,
}
pub type HashTableIterator = _HashTableIterator;
#[repr(C)]
pub struct _zend_object {
pub gc: zend_refcounted_h,
pub handle: u32,
pub ce: *mut zend_class_entry,
pub handlers: *const zend_object_handlers,
pub properties: *mut HashTable,
pub properties_table: [zval; 1usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _zend_resource {
pub gc: zend_refcounted_h,
pub handle: zend_long,
pub type_: ::std::os::raw::c_int,
pub ptr: *mut ::std::os::raw::c_void,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union zend_property_info_source_list {
pub ptr: *mut _zend_property_info,
pub list: usize,
}
#[repr(C)]
pub struct _zend_reference {
pub gc: zend_refcounted_h,
pub val: zval,
pub sources: zend_property_info_source_list,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _zend_ast_ref {
pub gc: zend_refcounted_h,
}
extern "C" {
pub fn _emalloc(
size: usize,
__zend_filename: *const ::std::os::raw::c_char,
__zend_lineno: u32,
__zend_orig_filename: *const ::std::os::raw::c_char,
__zend_orig_lineno: u32,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn _efree(
ptr: *mut ::std::os::raw::c_void,
__zend_filename: *const ::std::os::raw::c_char,
__zend_lineno: u32,
__zend_orig_filename: *const ::std::os::raw::c_char,
__zend_orig_lineno: u32,
);
}
extern "C" {
pub fn __zend_malloc(len: usize) -> *mut ::std::os::raw::c_void;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_llist_element {
pub next: *mut _zend_llist_element,
pub prev: *mut _zend_llist_element,
pub data: [::std::os::raw::c_char; 1usize],
}
pub type zend_llist_element = _zend_llist_element;
pub type llist_dtor_func_t =
::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_llist {
pub head: *mut zend_llist_element,
pub tail: *mut zend_llist_element,
pub count: usize,
pub size: usize,
pub dtor: llist_dtor_func_t,
pub persistent: ::std::os::raw::c_uchar,
pub traverse_ptr: *mut zend_llist_element,
}
pub type zend_llist = _zend_llist;
pub type zend_llist_position = *mut zend_llist_element;
extern "C" {
pub fn zend_llist_get_next_ex(
l: *mut zend_llist,
pos: *mut zend_llist_position,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn zend_llist_get_prev_ex(
l: *mut zend_llist,
pos: *mut zend_llist_position,
) -> *mut ::std::os::raw::c_void;
}
pub type zend_string_init_interned_func_t = ::std::option::Option<
unsafe extern "C" fn(
str_: *const ::std::os::raw::c_char,
size: usize,
permanent: bool,
) -> *mut zend_string,
>;
extern "C" {
pub static mut zend_string_init_interned: zend_string_init_interned_func_t;
}
extern "C" {
pub fn zend_hash_clean(ht: *mut HashTable);
}
extern "C" {
pub fn zend_hash_str_update(
ht: *mut HashTable,
key: *const ::std::os::raw::c_char,
len: usize,
pData: *mut zval,
) -> *mut zval;
}
extern "C" {
pub fn zend_hash_index_update(ht: *mut HashTable, h: zend_ulong, pData: *mut zval)
-> *mut zval;
}
extern "C" {
pub fn zend_hash_next_index_insert(ht: *mut HashTable, pData: *mut zval) -> *mut zval;
}
extern "C" {
pub fn zend_hash_str_del(
ht: *mut HashTable,
key: *const ::std::os::raw::c_char,
len: usize,
) -> zend_result;
}
extern "C" {
pub fn zend_hash_index_del(ht: *mut HashTable, h: zend_ulong) -> zend_result;
}
extern "C" {
pub fn zend_hash_str_find(
ht: *const HashTable,
key: *const ::std::os::raw::c_char,
len: usize,
) -> *mut zval;
}
extern "C" {
pub fn zend_hash_index_find(ht: *const HashTable, h: zend_ulong) -> *mut zval;
}
extern "C" {
pub fn zend_hash_move_forward_ex(ht: *mut HashTable, pos: *mut HashPosition) -> zend_result;
}
extern "C" {
pub fn zend_hash_move_backwards_ex(ht: *mut HashTable, pos: *mut HashPosition) -> zend_result;
}
extern "C" {
pub fn zend_hash_get_current_key_zval_ex(
ht: *const HashTable,
key: *mut zval,
pos: *const HashPosition,
);
}
extern "C" {
pub fn zend_hash_get_current_key_type_ex(
ht: *mut HashTable,
pos: *mut HashPosition,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn zend_hash_get_current_data_ex(ht: *mut HashTable, pos: *mut HashPosition) -> *mut zval;
}
extern "C" {
pub fn _zend_new_array(size: u32) -> *mut HashTable;
}
extern "C" {
pub fn zend_array_count(ht: *mut HashTable) -> u32;
}
extern "C" {
pub fn zend_array_dup(source: *mut HashTable) -> *mut HashTable;
}
extern "C" {
pub fn zend_array_destroy(ht: *mut HashTable);
}
extern "C" {
pub fn zend_hash_str_find_ptr_lc(
ht: *const HashTable,
str_: *const ::std::os::raw::c_char,
len: usize,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn gc_possible_root(ref_: *mut zend_refcounted);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zend_get_gc_buffer {
pub cur: *mut zval,
pub end: *mut zval,
pub start: *mut zval,
}
extern "C" {
pub fn zval_ptr_dtor(zval_ptr: *mut zval);
}
pub type zend_object_iterator = _zend_object_iterator;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_object_iterator_funcs {
pub dtor: ::std::option::Option<unsafe extern "C" fn(iter: *mut zend_object_iterator)>,
pub valid: ::std::option::Option<
unsafe extern "C" fn(iter: *mut zend_object_iterator) -> ::std::os::raw::c_int,
>,
pub get_current_data:
::std::option::Option<unsafe extern "C" fn(iter: *mut zend_object_iterator) -> *mut zval>,
pub get_current_key: ::std::option::Option<
unsafe extern "C" fn(iter: *mut zend_object_iterator, key: *mut zval),
>,
pub move_forward: ::std::option::Option<unsafe extern "C" fn(iter: *mut zend_object_iterator)>,
pub rewind: ::std::option::Option<unsafe extern "C" fn(iter: *mut zend_object_iterator)>,
pub invalidate_current:
::std::option::Option<unsafe extern "C" fn(iter: *mut zend_object_iterator)>,
pub get_gc: ::std::option::Option<
unsafe extern "C" fn(
iter: *mut zend_object_iterator,
table: *mut *mut zval,
n: *mut ::std::os::raw::c_int,
) -> *mut HashTable,
>,
}
pub type zend_object_iterator_funcs = _zend_object_iterator_funcs;
#[repr(C)]
pub struct _zend_object_iterator {
pub std: zend_object,
pub data: zval,
pub funcs: *const zend_object_iterator_funcs,
pub index: zend_ulong,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_class_iterator_funcs {
pub zf_new_iterator: *mut zend_function,
pub zf_valid: *mut zend_function,
pub zf_current: *mut zend_function,
pub zf_key: *mut zend_function,
pub zf_next: *mut zend_function,
pub zf_rewind: *mut zend_function,
}
pub type zend_class_iterator_funcs = _zend_class_iterator_funcs;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_class_arrayaccess_funcs {
pub zf_offsetget: *mut zend_function,
pub zf_offsetexists: *mut zend_function,
pub zf_offsetset: *mut zend_function,
pub zf_offsetunset: *mut zend_function,
}
pub type zend_class_arrayaccess_funcs = _zend_class_arrayaccess_funcs;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct stat {
pub st_dev: __dev_t,
pub st_ino: __ino_t,
pub st_nlink: __nlink_t,
pub st_mode: __mode_t,
pub st_uid: __uid_t,
pub st_gid: __gid_t,
pub __pad0: ::std::os::raw::c_int,
pub st_rdev: __dev_t,
pub st_size: __off_t,
pub st_blksize: __blksize_t,
pub st_blocks: __blkcnt_t,
pub st_atim: timespec,
pub st_mtim: timespec,
pub st_ctim: timespec,
pub __glibc_reserved: [__syscall_slong_t; 3usize],
}
pub type zend_stream_fsizer_t =
::std::option::Option<unsafe extern "C" fn(handle: *mut ::std::os::raw::c_void) -> usize>;
pub type zend_stream_reader_t = ::std::option::Option<
unsafe extern "C" fn(
handle: *mut ::std::os::raw::c_void,
buf: *mut ::std::os::raw::c_char,
len: usize,
) -> isize,
>;
pub type zend_stream_closer_t =
::std::option::Option<unsafe extern "C" fn(handle: *mut ::std::os::raw::c_void)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_stream {
pub handle: *mut ::std::os::raw::c_void,
pub isatty: ::std::os::raw::c_int,
pub reader: zend_stream_reader_t,
pub fsizer: zend_stream_fsizer_t,
pub closer: zend_stream_closer_t,
}
pub type zend_stream = _zend_stream;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _zend_file_handle {
pub handle: _zend_file_handle__bindgen_ty_1,
pub filename: *mut zend_string,
pub opened_path: *mut zend_string,
pub type_: u8,
pub primary_script: bool,
pub in_list: bool,
pub buf: *mut ::std::os::raw::c_char,
pub len: usize,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zend_file_handle__bindgen_ty_1 {
pub fp: *mut FILE,
pub stream: zend_stream,
}
pub type zend_file_handle = _zend_file_handle;
extern "C" {
pub fn zend_stream_init_filename(
handle: *mut zend_file_handle,
filename: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn zend_destroy_file_handle(file_handle: *mut zend_file_handle);
}
pub type zend_stat_t = stat;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_serialize_data {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_unserialize_data {
_unused: [u8; 0],
}
pub type zend_serialize_data = _zend_serialize_data;
pub type zend_unserialize_data = _zend_unserialize_data;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_class_name {
pub name: *mut zend_string,
pub lc_name: *mut zend_string,
}
pub type zend_class_name = _zend_class_name;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_trait_method_reference {
pub method_name: *mut zend_string,
pub class_name: *mut zend_string,
}
pub type zend_trait_method_reference = _zend_trait_method_reference;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_trait_precedence {
pub trait_method: zend_trait_method_reference,
pub num_excludes: u32,
pub exclude_class_names: [*mut zend_string; 1usize],
}
pub type zend_trait_precedence = _zend_trait_precedence;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_trait_alias {
pub trait_method: zend_trait_method_reference,
#[doc = " name for method to be added"]
pub alias: *mut zend_string,
#[doc = " modifiers to be set on trait method"]
pub modifiers: u32,
}
pub type zend_trait_alias = _zend_trait_alias;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_class_mutable_data {
pub default_properties_table: *mut zval,
pub constants_table: *mut HashTable,
pub ce_flags: u32,
pub backed_enum_table: *mut HashTable,
}
pub type zend_class_mutable_data = _zend_class_mutable_data;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_class_dependency {
pub name: *mut zend_string,
pub ce: *mut zend_class_entry,
}
pub type zend_class_dependency = _zend_class_dependency;
pub type zend_inheritance_cache_entry = _zend_inheritance_cache_entry;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_error_info {
pub type_: ::std::os::raw::c_int,
pub lineno: u32,
pub filename: *mut zend_string,
pub message: *mut zend_string,
}
pub type zend_error_info = _zend_error_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_inheritance_cache_entry {
pub next: *mut zend_inheritance_cache_entry,
pub ce: *mut zend_class_entry,
pub parent: *mut zend_class_entry,
pub dependencies: *mut zend_class_dependency,
pub dependencies_count: u32,
pub num_warnings: u32,
pub warnings: *mut *mut zend_error_info,
pub traits_and_interfaces: [*mut zend_class_entry; 1usize],
}
#[repr(C)]
pub struct _zend_class_entry {
pub type_: ::std::os::raw::c_char,
pub name: *mut zend_string,
pub __bindgen_anon_1: _zend_class_entry__bindgen_ty_1,
pub refcount: ::std::os::raw::c_int,
pub ce_flags: u32,
pub default_properties_count: ::std::os::raw::c_int,
pub default_static_members_count: ::std::os::raw::c_int,
pub default_properties_table: *mut zval,
pub default_static_members_table: *mut zval,
pub static_members_table__ptr: *mut zval,
pub function_table: HashTable,
pub properties_info: HashTable,
pub constants_table: HashTable,
pub mutable_data__ptr: *mut zend_class_mutable_data,
pub inheritance_cache: *mut zend_inheritance_cache_entry,
pub properties_info_table: *mut *mut _zend_property_info,
pub constructor: *mut zend_function,
pub destructor: *mut zend_function,
pub clone: *mut zend_function,
pub __get: *mut zend_function,
pub __set: *mut zend_function,
pub __unset: *mut zend_function,
pub __isset: *mut zend_function,
pub __call: *mut zend_function,
pub __callstatic: *mut zend_function,
pub __tostring: *mut zend_function,
pub __debugInfo: *mut zend_function,
pub __serialize: *mut zend_function,
pub __unserialize: *mut zend_function,
pub default_object_handlers: *const zend_object_handlers,
pub iterator_funcs_ptr: *mut zend_class_iterator_funcs,
pub arrayaccess_funcs_ptr: *mut zend_class_arrayaccess_funcs,
pub __bindgen_anon_2: _zend_class_entry__bindgen_ty_2,
pub get_iterator: ::std::option::Option<
unsafe extern "C" fn(
ce: *mut zend_class_entry,
object: *mut zval,
by_ref: ::std::os::raw::c_int,
) -> *mut zend_object_iterator,
>,
pub get_static_method: ::std::option::Option<
unsafe extern "C" fn(
ce: *mut zend_class_entry,
method: *mut zend_string,
) -> *mut zend_function,
>,
pub serialize: ::std::option::Option<
unsafe extern "C" fn(
object: *mut zval,
buffer: *mut *mut ::std::os::raw::c_uchar,
buf_len: *mut usize,
data: *mut zend_serialize_data,
) -> ::std::os::raw::c_int,
>,
pub unserialize: ::std::option::Option<
unsafe extern "C" fn(
object: *mut zval,
ce: *mut zend_class_entry,
buf: *const ::std::os::raw::c_uchar,
buf_len: usize,
data: *mut zend_unserialize_data,
) -> ::std::os::raw::c_int,
>,
pub num_interfaces: u32,
pub num_traits: u32,
pub __bindgen_anon_3: _zend_class_entry__bindgen_ty_3,
pub trait_names: *mut zend_class_name,
pub trait_aliases: *mut *mut zend_trait_alias,
pub trait_precedences: *mut *mut zend_trait_precedence,
pub attributes: *mut HashTable,
pub enum_backing_type: u32,
pub backed_enum_table: *mut HashTable,
pub info: _zend_class_entry__bindgen_ty_4,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zend_class_entry__bindgen_ty_1 {
pub parent: *mut zend_class_entry,
pub parent_name: *mut zend_string,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zend_class_entry__bindgen_ty_2 {
pub create_object: ::std::option::Option<
unsafe extern "C" fn(class_type: *mut zend_class_entry) -> *mut zend_object,
>,
pub interface_gets_implemented: ::std::option::Option<
unsafe extern "C" fn(
iface: *mut zend_class_entry,
class_type: *mut zend_class_entry,
) -> ::std::os::raw::c_int,
>,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zend_class_entry__bindgen_ty_3 {
pub interfaces: *mut *mut zend_class_entry,
pub interface_names: *mut zend_class_name,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zend_class_entry__bindgen_ty_4 {
pub user: _zend_class_entry__bindgen_ty_4__bindgen_ty_1,
pub internal: _zend_class_entry__bindgen_ty_4__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_class_entry__bindgen_ty_4__bindgen_ty_1 {
pub filename: *mut zend_string,
pub line_start: u32,
pub line_end: u32,
pub doc_comment: *mut zend_string,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_class_entry__bindgen_ty_4__bindgen_ty_2 {
pub builtin_functions: *const _zend_function_entry,
pub module: *mut _zend_module_entry,
}
extern "C" {
pub fn _zend_bailout(filename: *const ::std::os::raw::c_char, lineno: u32) -> !;
}
extern "C" {
pub static mut zend_interrupt_function:
::std::option::Option<unsafe extern "C" fn(execute_data: *mut zend_execute_data)>;
}
extern "C" {
pub static mut zend_standard_class_def: *mut zend_class_entry;
}
pub const zend_error_handling_t_EH_NORMAL: zend_error_handling_t = 0;
pub const zend_error_handling_t_EH_THROW: zend_error_handling_t = 1;
pub type zend_error_handling_t = ::std::os::raw::c_uint;
pub type zend_object_read_property_t = ::std::option::Option<
unsafe extern "C" fn(
object: *mut zend_object,
member: *mut zend_string,
type_: ::std::os::raw::c_int,
cache_slot: *mut *mut ::std::os::raw::c_void,
rv: *mut zval,
) -> *mut zval,
>;
pub type zend_object_read_dimension_t = ::std::option::Option<
unsafe extern "C" fn(
object: *mut zend_object,
offset: *mut zval,
type_: ::std::os::raw::c_int,
rv: *mut zval,
) -> *mut zval,
>;
pub type zend_object_write_property_t = ::std::option::Option<
unsafe extern "C" fn(
object: *mut zend_object,
member: *mut zend_string,
value: *mut zval,
cache_slot: *mut *mut ::std::os::raw::c_void,
) -> *mut zval,
>;
pub type zend_object_write_dimension_t = ::std::option::Option<
unsafe extern "C" fn(object: *mut zend_object, offset: *mut zval, value: *mut zval),
>;
pub type zend_object_get_property_ptr_ptr_t = ::std::option::Option<
unsafe extern "C" fn(
object: *mut zend_object,
member: *mut zend_string,
type_: ::std::os::raw::c_int,
cache_slot: *mut *mut ::std::os::raw::c_void,
) -> *mut zval,
>;
pub type zend_object_has_property_t = ::std::option::Option<
unsafe extern "C" fn(
object: *mut zend_object,
member: *mut zend_string,
has_set_exists: ::std::os::raw::c_int,
cache_slot: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
pub type zend_object_has_dimension_t = ::std::option::Option<
unsafe extern "C" fn(
object: *mut zend_object,
member: *mut zval,
check_empty: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
pub type zend_object_unset_property_t = ::std::option::Option<
unsafe extern "C" fn(
object: *mut zend_object,
member: *mut zend_string,
cache_slot: *mut *mut ::std::os::raw::c_void,
),
>;
pub type zend_object_unset_dimension_t =
::std::option::Option<unsafe extern "C" fn(object: *mut zend_object, offset: *mut zval)>;
pub type zend_object_get_properties_t =
::std::option::Option<unsafe extern "C" fn(object: *mut zend_object) -> *mut HashTable>;
pub type zend_object_get_debug_info_t = ::std::option::Option<
unsafe extern "C" fn(
object: *mut zend_object,
is_temp: *mut ::std::os::raw::c_int,
) -> *mut HashTable,
>;
pub const _zend_prop_purpose_ZEND_PROP_PURPOSE_DEBUG: _zend_prop_purpose = 0;
pub const _zend_prop_purpose_ZEND_PROP_PURPOSE_ARRAY_CAST: _zend_prop_purpose = 1;
pub const _zend_prop_purpose_ZEND_PROP_PURPOSE_SERIALIZE: _zend_prop_purpose = 2;
pub const _zend_prop_purpose_ZEND_PROP_PURPOSE_VAR_EXPORT: _zend_prop_purpose = 3;
pub const _zend_prop_purpose_ZEND_PROP_PURPOSE_JSON: _zend_prop_purpose = 4;
pub const _zend_prop_purpose__ZEND_PROP_PURPOSE_NON_EXHAUSTIVE_ENUM: _zend_prop_purpose = 5;
pub type _zend_prop_purpose = ::std::os::raw::c_uint;
pub use self::_zend_prop_purpose as zend_prop_purpose;
pub type zend_object_get_properties_for_t = ::std::option::Option<
unsafe extern "C" fn(object: *mut zend_object, purpose: zend_prop_purpose) -> *mut zend_array,
>;
pub type zend_object_get_method_t = ::std::option::Option<
unsafe extern "C" fn(
object: *mut *mut zend_object,
method: *mut zend_string,
key: *const zval,
) -> *mut zend_function,
>;
pub type zend_object_get_constructor_t =
::std::option::Option<unsafe extern "C" fn(object: *mut zend_object) -> *mut zend_function>;
pub type zend_object_free_obj_t =
::std::option::Option<unsafe extern "C" fn(object: *mut zend_object)>;
pub type zend_object_dtor_obj_t =
::std::option::Option<unsafe extern "C" fn(object: *mut zend_object)>;
pub type zend_object_clone_obj_t =
::std::option::Option<unsafe extern "C" fn(object: *mut zend_object) -> *mut zend_object>;
pub type zend_object_get_class_name_t =
::std::option::Option<unsafe extern "C" fn(object: *const zend_object) -> *mut zend_string>;
pub type zend_object_compare_t = ::std::option::Option<
unsafe extern "C" fn(object1: *mut zval, object2: *mut zval) -> ::std::os::raw::c_int,
>;
pub type zend_object_cast_t = ::std::option::Option<
unsafe extern "C" fn(
readobj: *mut zend_object,
retval: *mut zval,
type_: ::std::os::raw::c_int,
) -> zend_result,
>;
pub type zend_object_count_elements_t = ::std::option::Option<
unsafe extern "C" fn(object: *mut zend_object, count: *mut zend_long) -> zend_result,
>;
pub type zend_object_get_closure_t = ::std::option::Option<
unsafe extern "C" fn(
obj: *mut zend_object,
ce_ptr: *mut *mut zend_class_entry,
fptr_ptr: *mut *mut zend_function,
obj_ptr: *mut *mut zend_object,
check_only: bool,
) -> zend_result,
>;
pub type zend_object_get_gc_t = ::std::option::Option<
unsafe extern "C" fn(
object: *mut zend_object,
table: *mut *mut zval,
n: *mut ::std::os::raw::c_int,
) -> *mut HashTable,
>;
pub type zend_object_do_operation_t = ::std::option::Option<
unsafe extern "C" fn(
opcode: u8,
result: *mut zval,
op1: *mut zval,
op2: *mut zval,
) -> zend_result,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_object_handlers {
pub offset: ::std::os::raw::c_int,
pub free_obj: zend_object_free_obj_t,
pub dtor_obj: zend_object_dtor_obj_t,
pub clone_obj: zend_object_clone_obj_t,
pub read_property: zend_object_read_property_t,
pub write_property: zend_object_write_property_t,
pub read_dimension: zend_object_read_dimension_t,
pub write_dimension: zend_object_write_dimension_t,
pub get_property_ptr_ptr: zend_object_get_property_ptr_ptr_t,
pub has_property: zend_object_has_property_t,
pub unset_property: zend_object_unset_property_t,
pub has_dimension: zend_object_has_dimension_t,
pub unset_dimension: zend_object_unset_dimension_t,
pub get_properties: zend_object_get_properties_t,
pub get_method: zend_object_get_method_t,
pub get_constructor: zend_object_get_constructor_t,
pub get_class_name: zend_object_get_class_name_t,
pub cast_object: zend_object_cast_t,
pub count_elements: zend_object_count_elements_t,
pub get_debug_info: zend_object_get_debug_info_t,
pub get_closure: zend_object_get_closure_t,
pub get_gc: zend_object_get_gc_t,
pub do_operation: zend_object_do_operation_t,
pub compare: zend_object_compare_t,
pub get_properties_for: zend_object_get_properties_for_t,
}
extern "C" {
pub static std_object_handlers: zend_object_handlers;
}
extern "C" {
pub fn zend_std_get_properties(object: *mut zend_object) -> *mut HashTable;
}
extern "C" {
pub fn zend_std_read_property(
object: *mut zend_object,
member: *mut zend_string,
type_: ::std::os::raw::c_int,
cache_slot: *mut *mut ::std::os::raw::c_void,
rv: *mut zval,
) -> *mut zval;
}
extern "C" {
pub fn zend_std_write_property(
object: *mut zend_object,
member: *mut zend_string,
value: *mut zval,
cache_slot: *mut *mut ::std::os::raw::c_void,
) -> *mut zval;
}
extern "C" {
pub fn zend_std_has_property(
object: *mut zend_object,
member: *mut zend_string,
has_set_exists: ::std::os::raw::c_int,
cache_slot: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn zend_is_identical(op1: *const zval, op2: *const zval) -> bool;
}
extern "C" {
pub fn instanceof_function_slow(
instance_ce: *const zend_class_entry,
ce: *const zend_class_entry,
) -> bool;
}
extern "C" {
pub fn zend_is_true(op: *const zval) -> ::std::os::raw::c_int;
}
pub type zend_op_array = _zend_op_array;
pub type zend_op = _zend_op;
#[repr(C)]
#[derive(Copy, Clone)]
pub union _znode_op {
pub constant: u32,
pub var: u32,
pub num: u32,
pub opline_num: u32,
pub jmp_offset: u32,
}
pub type znode_op = _znode_op;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _zend_op {
pub handler: *const ::std::os::raw::c_void,
pub op1: znode_op,
pub op2: znode_op,
pub result: znode_op,
pub extended_value: u32,
pub lineno: u32,
pub opcode: u8,
pub op1_type: u8,
pub op2_type: u8,
pub result_type: u8,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_try_catch_element {
pub try_op: u32,
pub catch_op: u32,
pub finally_op: u32,
pub finally_end: u32,
}
pub type zend_try_catch_element = _zend_try_catch_element;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_live_range {
pub var: u32,
pub start: u32,
pub end: u32,
}
pub type zend_live_range = _zend_live_range;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_property_info {
pub offset: u32,
pub flags: u32,
pub name: *mut zend_string,
pub doc_comment: *mut zend_string,
pub attributes: *mut HashTable,
pub ce: *mut zend_class_entry,
pub type_: zend_type,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_internal_arg_info {
pub name: *const ::std::os::raw::c_char,
pub type_: zend_type,
pub default_value: *const ::std::os::raw::c_char,
}
pub type zend_internal_arg_info = _zend_internal_arg_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_arg_info {
pub name: *mut zend_string,
pub type_: zend_type,
pub default_value: *mut zend_string,
}
pub type zend_arg_info = _zend_arg_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_op_array {
pub type_: u8,
pub arg_flags: [u8; 3usize],
pub fn_flags: u32,
pub function_name: *mut zend_string,
pub scope: *mut zend_class_entry,
pub prototype: *mut zend_function,
pub num_args: u32,
pub required_num_args: u32,
pub arg_info: *mut zend_arg_info,
pub attributes: *mut HashTable,
pub run_time_cache__ptr: *mut *mut ::std::os::raw::c_void,
pub T: u32,
pub cache_size: ::std::os::raw::c_int,
pub last_var: ::std::os::raw::c_int,
pub last: u32,
pub opcodes: *mut zend_op,
pub static_variables_ptr__ptr: *mut HashTable,
pub static_variables: *mut HashTable,
pub vars: *mut *mut zend_string,
pub refcount: *mut u32,
pub last_live_range: ::std::os::raw::c_int,
pub last_try_catch: ::std::os::raw::c_int,
pub live_range: *mut zend_live_range,
pub try_catch_array: *mut zend_try_catch_element,
pub filename: *mut zend_string,
pub line_start: u32,
pub line_end: u32,
pub doc_comment: *mut zend_string,
pub last_literal: ::std::os::raw::c_int,
pub num_dynamic_func_defs: u32,
pub literals: *mut zval,
pub dynamic_func_defs: *mut *mut zend_op_array,
pub reserved: [*mut ::std::os::raw::c_void; 6usize],
}
pub type zif_handler = ::std::option::Option<
unsafe extern "C" fn(execute_data: *mut zend_execute_data, return_value: *mut zval),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_internal_function {
pub type_: u8,
pub arg_flags: [u8; 3usize],
pub fn_flags: u32,
pub function_name: *mut zend_string,
pub scope: *mut zend_class_entry,
pub prototype: *mut zend_function,
pub num_args: u32,
pub required_num_args: u32,
pub arg_info: *mut zend_internal_arg_info,
pub attributes: *mut HashTable,
pub run_time_cache__ptr: *mut *mut ::std::os::raw::c_void,
pub T: u32,
pub handler: zif_handler,
pub module: *mut _zend_module_entry,
pub reserved: [*mut ::std::os::raw::c_void; 6usize],
}
pub type zend_internal_function = _zend_internal_function;
#[repr(C)]
#[derive(Copy, Clone)]
pub union _zend_function {
pub type_: u8,
pub quick_arg_flags: u32,
pub common: _zend_function__bindgen_ty_1,
pub op_array: zend_op_array,
pub internal_function: zend_internal_function,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_function__bindgen_ty_1 {
pub type_: u8,
pub arg_flags: [u8; 3usize],
pub fn_flags: u32,
pub function_name: *mut zend_string,
pub scope: *mut zend_class_entry,
pub prototype: *mut zend_function,
pub num_args: u32,
pub required_num_args: u32,
pub arg_info: *mut zend_arg_info,
pub attributes: *mut HashTable,
pub run_time_cache__ptr: *mut *mut ::std::os::raw::c_void,
pub T: u32,
}
#[repr(C)]
pub struct _zend_execute_data {
pub opline: *const zend_op,
pub call: *mut zend_execute_data,
pub return_value: *mut zval,
pub func: *mut zend_function,
pub This: zval,
pub prev_execute_data: *mut zend_execute_data,
pub symbol_table: *mut zend_array,
pub run_time_cache: *mut *mut ::std::os::raw::c_void,
pub extra_named_params: *mut zend_array,
}
pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __jmp_buf_tag {
pub __jmpbuf: __jmp_buf,
pub __mask_was_saved: ::std::os::raw::c_int,
pub __saved_mask: __sigset_t,
}
pub type jmp_buf = [__jmp_buf_tag; 1usize];
pub type zend_executor_globals = _zend_executor_globals;
extern "C" {
pub static mut executor_globals: zend_executor_globals;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct zend_atomic_bool_s {
pub value: u8,
}
pub type zend_atomic_bool = zend_atomic_bool_s;
extern "C" {
pub fn zend_atomic_bool_store(obj: *mut zend_atomic_bool, desired: bool);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_stack {
pub size: ::std::os::raw::c_int,
pub top: ::std::os::raw::c_int,
pub max: ::std::os::raw::c_int,
pub elements: *mut ::std::os::raw::c_void,
}
pub type zend_stack = _zend_stack;
extern "C" {
pub fn zend_object_std_init(object: *mut zend_object, ce: *mut zend_class_entry);
}
extern "C" {
pub fn zend_objects_new(ce: *mut zend_class_entry) -> *mut zend_object;
}
extern "C" {
pub fn zend_objects_clone_members(new_object: *mut zend_object, old_object: *mut zend_object);
}
extern "C" {
pub fn zend_object_std_dtor(object: *mut zend_object);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_objects_store {
pub object_buckets: *mut *mut zend_object,
pub top: u32,
pub size: u32,
pub free_list_head: ::std::os::raw::c_int,
}
pub type zend_objects_store = _zend_objects_store;
extern "C" {
pub fn zend_objects_store_del(object: *mut zend_object);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_call_stack {
pub base: *mut ::std::os::raw::c_void,
pub max_size: usize,
}
pub type zend_call_stack = _zend_call_stack;
pub type zend_vm_stack = *mut _zend_vm_stack;
pub type zend_ini_entry = _zend_ini_entry;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_fiber_context {
_unused: [u8; 0],
}
pub type zend_fiber_context = _zend_fiber_context;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_fiber {
_unused: [u8; 0],
}
pub type zend_fiber = _zend_fiber;
#[repr(C)]
pub struct _zend_executor_globals {
pub uninitialized_zval: zval,
pub error_zval: zval,
pub symtable_cache: [*mut zend_array; 32usize],
pub symtable_cache_limit: *mut *mut zend_array,
pub symtable_cache_ptr: *mut *mut zend_array,
pub symbol_table: zend_array,
pub included_files: HashTable,
pub bailout: *mut jmp_buf,
pub error_reporting: ::std::os::raw::c_int,
pub exit_status: ::std::os::raw::c_int,
pub function_table: *mut HashTable,
pub class_table: *mut HashTable,
pub zend_constants: *mut HashTable,
pub vm_stack_top: *mut zval,
pub vm_stack_end: *mut zval,
pub vm_stack: zend_vm_stack,
pub vm_stack_page_size: usize,
pub current_execute_data: *mut _zend_execute_data,
pub fake_scope: *mut zend_class_entry,
pub jit_trace_num: u32,
pub ticks_count: ::std::os::raw::c_int,
pub precision: zend_long,
pub persistent_constants_count: u32,
pub persistent_functions_count: u32,
pub persistent_classes_count: u32,
pub no_extensions: bool,
pub full_tables_cleanup: bool,
pub vm_interrupt: zend_atomic_bool,
pub timed_out: zend_atomic_bool,
pub in_autoload: *mut HashTable,
pub hard_timeout: zend_long,
pub stack_base: *mut ::std::os::raw::c_void,
pub stack_limit: *mut ::std::os::raw::c_void,
pub regular_list: HashTable,
pub persistent_list: HashTable,
pub user_error_handler_error_reporting: ::std::os::raw::c_int,
pub exception_ignore_args: bool,
pub user_error_handler: zval,
pub user_exception_handler: zval,
pub user_error_handlers_error_reporting: zend_stack,
pub user_error_handlers: zend_stack,
pub user_exception_handlers: zend_stack,
pub exception_class: *mut zend_class_entry,
pub error_handling: zend_error_handling_t,
pub capture_warnings_during_sccp: ::std::os::raw::c_int,
pub timeout_seconds: zend_long,
pub ini_directives: *mut HashTable,
pub modified_ini_directives: *mut HashTable,
pub error_reporting_ini_entry: *mut zend_ini_entry,
pub objects_store: zend_objects_store,
pub exception: *mut zend_object,
pub prev_exception: *mut zend_object,
pub opline_before_exception: *const zend_op,
pub exception_op: [zend_op; 3usize],
pub current_module: *mut _zend_module_entry,
pub active: bool,
pub flags: u8,
pub assertions: zend_long,
pub ht_iterators_count: u32,
pub ht_iterators_used: u32,
pub ht_iterators: *mut HashTableIterator,
pub ht_iterators_slots: [HashTableIterator; 16usize],
pub saved_fpu_cw_ptr: *mut ::std::os::raw::c_void,
pub trampoline: zend_function,
pub call_trampoline_op: zend_op,
pub weakrefs: HashTable,
pub exception_string_param_max_len: zend_long,
pub get_gc_buffer: zend_get_gc_buffer,
pub main_fiber_context: *mut zend_fiber_context,
pub current_fiber_context: *mut zend_fiber_context,
pub active_fiber: *mut zend_fiber,
pub fiber_stack_size: usize,
pub record_errors: bool,
pub num_errors: u32,
pub errors: *mut *mut zend_error_info,
pub filename_override: *mut zend_string,
pub lineno_override: zend_long,
pub call_stack: zend_call_stack,
pub max_allowed_stack_size: zend_long,
pub reserved_stack_size: zend_ulong,
pub reserved: [*mut ::std::os::raw::c_void; 6usize],
}
extern "C" {
pub fn zend_is_auto_global(name: *mut zend_string) -> bool;
}
pub type zend_module_entry = _zend_module_entry;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_module_entry {
pub size: ::std::os::raw::c_ushort,
pub zend_api: ::std::os::raw::c_uint,
pub zend_debug: ::std::os::raw::c_uchar,
pub zts: ::std::os::raw::c_uchar,
pub ini_entry: *const _zend_ini_entry,
pub deps: *const _zend_module_dep,
pub name: *const ::std::os::raw::c_char,
pub functions: *const _zend_function_entry,
pub module_startup_func: ::std::option::Option<
unsafe extern "C" fn(
type_: ::std::os::raw::c_int,
module_number: ::std::os::raw::c_int,
) -> zend_result,
>,
pub module_shutdown_func: ::std::option::Option<
unsafe extern "C" fn(
type_: ::std::os::raw::c_int,
module_number: ::std::os::raw::c_int,
) -> zend_result,
>,
pub request_startup_func: ::std::option::Option<
unsafe extern "C" fn(
type_: ::std::os::raw::c_int,
module_number: ::std::os::raw::c_int,
) -> zend_result,
>,
pub request_shutdown_func: ::std::option::Option<
unsafe extern "C" fn(
type_: ::std::os::raw::c_int,
module_number: ::std::os::raw::c_int,
) -> zend_result,
>,
pub info_func: ::std::option::Option<unsafe extern "C" fn(zend_module: *mut zend_module_entry)>,
pub version: *const ::std::os::raw::c_char,
pub globals_size: usize,
pub globals_ptr: *mut ::std::os::raw::c_void,
pub globals_ctor:
::std::option::Option<unsafe extern "C" fn(global: *mut ::std::os::raw::c_void)>,
pub globals_dtor:
::std::option::Option<unsafe extern "C" fn(global: *mut ::std::os::raw::c_void)>,
pub post_deactivate_func: ::std::option::Option<unsafe extern "C" fn() -> zend_result>,
pub module_started: ::std::os::raw::c_int,
pub type_: ::std::os::raw::c_uchar,
pub handle: *mut ::std::os::raw::c_void,
pub module_number: ::std::os::raw::c_int,
pub build_id: *const ::std::os::raw::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_module_dep {
pub name: *const ::std::os::raw::c_char,
pub rel: *const ::std::os::raw::c_char,
pub version: *const ::std::os::raw::c_char,
pub type_: ::std::os::raw::c_uchar,
}
extern "C" {
pub fn zend_lookup_class_ex(
name: *mut zend_string,
lcname: *mut zend_string,
flags: u32,
) -> *mut zend_class_entry;
}
extern "C" {
pub fn zend_eval_string(
str_: *const ::std::os::raw::c_char,
retval_ptr: *mut zval,
string_name: *const ::std::os::raw::c_char,
) -> zend_result;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_vm_stack {
pub top: *mut zval,
pub end: *mut zval,
pub prev: zend_vm_stack,
}
extern "C" {
pub fn zend_fetch_function_str(
name: *const ::std::os::raw::c_char,
len: usize,
) -> *mut zend_function;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _zend_function_entry {
pub fname: *const ::std::os::raw::c_char,
pub handler: zif_handler,
pub arg_info: *const _zend_internal_arg_info,
pub num_args: u32,
pub flags: u32,
}
pub type zend_function_entry = _zend_function_entry;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_fcall_info_cache {
pub function_handler: *mut zend_function,
pub calling_scope: *mut zend_class_entry,
pub called_scope: *mut zend_class_entry,
pub object: *mut zend_object,
pub closure: *mut zend_object,
}
pub type zend_fcall_info_cache = _zend_fcall_info_cache;
extern "C" {
pub fn zend_register_module_ex(module: *mut zend_module_entry) -> *mut zend_module_entry;
}
extern "C" {
pub fn zend_register_internal_class_ex(
class_entry: *mut zend_class_entry,
parent_ce: *mut zend_class_entry,
) -> *mut zend_class_entry;
}
extern "C" {
pub fn zend_is_callable(
callable: *mut zval,
check_flags: u32,
callable_name: *mut *mut zend_string,
) -> bool;
}
extern "C" {
pub fn zend_declare_property(
ce: *mut zend_class_entry,
name: *const ::std::os::raw::c_char,
name_length: usize,
property: *mut zval,
access_type: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn zend_declare_class_constant(
ce: *mut zend_class_entry,
name: *const ::std::os::raw::c_char,
name_length: usize,
value: *mut zval,
);
}
extern "C" {
pub fn object_properties_init(object: *mut zend_object, class_type: *mut zend_class_entry);
}
extern "C" {
pub fn _call_user_function_impl(
object: *mut zval,
function_name: *mut zval,
retval_ptr: *mut zval,
param_count: u32,
params: *mut zval,
named_params: *mut HashTable,
) -> zend_result;
}
extern "C" {
pub fn zend_call_known_function(
fn_: *mut zend_function,
object: *mut zend_object,
called_scope: *mut zend_class_entry,
retval_ptr: *mut zval,
param_count: u32,
params: *mut zval,
named_params: *mut HashTable,
);
}
extern "C" {
pub fn zend_is_iterable(iterable: *const zval) -> bool;
}
pub const _zend_expected_type_Z_EXPECTED_LONG: _zend_expected_type = 0;
pub const _zend_expected_type_Z_EXPECTED_LONG_OR_NULL: _zend_expected_type = 1;
pub const _zend_expected_type_Z_EXPECTED_BOOL: _zend_expected_type = 2;
pub const _zend_expected_type_Z_EXPECTED_BOOL_OR_NULL: _zend_expected_type = 3;
pub const _zend_expected_type_Z_EXPECTED_STRING: _zend_expected_type = 4;
pub const _zend_expected_type_Z_EXPECTED_STRING_OR_NULL: _zend_expected_type = 5;
pub const _zend_expected_type_Z_EXPECTED_ARRAY: _zend_expected_type = 6;
pub const _zend_expected_type_Z_EXPECTED_ARRAY_OR_NULL: _zend_expected_type = 7;
pub const _zend_expected_type_Z_EXPECTED_ARRAY_OR_LONG: _zend_expected_type = 8;
pub const _zend_expected_type_Z_EXPECTED_ARRAY_OR_LONG_OR_NULL: _zend_expected_type = 9;
pub const _zend_expected_type_Z_EXPECTED_ITERABLE: _zend_expected_type = 10;
pub const _zend_expected_type_Z_EXPECTED_ITERABLE_OR_NULL: _zend_expected_type = 11;
pub const _zend_expected_type_Z_EXPECTED_FUNC: _zend_expected_type = 12;
pub const _zend_expected_type_Z_EXPECTED_FUNC_OR_NULL: _zend_expected_type = 13;
pub const _zend_expected_type_Z_EXPECTED_RESOURCE: _zend_expected_type = 14;
pub const _zend_expected_type_Z_EXPECTED_RESOURCE_OR_NULL: _zend_expected_type = 15;
pub const _zend_expected_type_Z_EXPECTED_PATH: _zend_expected_type = 16;
pub const _zend_expected_type_Z_EXPECTED_PATH_OR_NULL: _zend_expected_type = 17;
pub const _zend_expected_type_Z_EXPECTED_OBJECT: _zend_expected_type = 18;
pub const _zend_expected_type_Z_EXPECTED_OBJECT_OR_NULL: _zend_expected_type = 19;
pub const _zend_expected_type_Z_EXPECTED_DOUBLE: _zend_expected_type = 20;
pub const _zend_expected_type_Z_EXPECTED_DOUBLE_OR_NULL: _zend_expected_type = 21;
pub const _zend_expected_type_Z_EXPECTED_NUMBER: _zend_expected_type = 22;
pub const _zend_expected_type_Z_EXPECTED_NUMBER_OR_NULL: _zend_expected_type = 23;
pub const _zend_expected_type_Z_EXPECTED_NUMBER_OR_STRING: _zend_expected_type = 24;
pub const _zend_expected_type_Z_EXPECTED_NUMBER_OR_STRING_OR_NULL: _zend_expected_type = 25;
pub const _zend_expected_type_Z_EXPECTED_ARRAY_OR_STRING: _zend_expected_type = 26;
pub const _zend_expected_type_Z_EXPECTED_ARRAY_OR_STRING_OR_NULL: _zend_expected_type = 27;
pub const _zend_expected_type_Z_EXPECTED_STRING_OR_LONG: _zend_expected_type = 28;
pub const _zend_expected_type_Z_EXPECTED_STRING_OR_LONG_OR_NULL: _zend_expected_type = 29;
pub const _zend_expected_type_Z_EXPECTED_OBJECT_OR_CLASS_NAME: _zend_expected_type = 30;
pub const _zend_expected_type_Z_EXPECTED_OBJECT_OR_CLASS_NAME_OR_NULL: _zend_expected_type = 31;
pub const _zend_expected_type_Z_EXPECTED_OBJECT_OR_STRING: _zend_expected_type = 32;
pub const _zend_expected_type_Z_EXPECTED_OBJECT_OR_STRING_OR_NULL: _zend_expected_type = 33;
pub const _zend_expected_type_Z_EXPECTED_LAST: _zend_expected_type = 34;
pub type _zend_expected_type = ::std::os::raw::c_uint;
extern "C" {
pub fn zend_wrong_parameters_count_error(min_num_args: u32, max_num_args: u32);
}
extern "C" {
pub fn php_printf(format: *const ::std::os::raw::c_char, ...) -> usize;
}
extern "C" {
pub fn php_error_docref(
docref: *const ::std::os::raw::c_char,
type_: ::std::os::raw::c_int,
format: *const ::std::os::raw::c_char,
...
);
}
pub type php_stream = _php_stream;
pub type php_stream_wrapper = _php_stream_wrapper;
pub type php_stream_context = _php_stream_context;
pub type php_stream_filter = _php_stream_filter;
pub type php_stream_notification_func = ::std::option::Option<
unsafe extern "C" fn(
context: *mut php_stream_context,
notifycode: ::std::os::raw::c_int,
severity: ::std::os::raw::c_int,
xmsg: *mut ::std::os::raw::c_char,
xcode: ::std::os::raw::c_int,
bytes_sofar: usize,
bytes_max: usize,
ptr: *mut ::std::os::raw::c_void,
),
>;
pub type php_stream_notifier = _php_stream_notifier;
#[repr(C)]
pub struct _php_stream_notifier {
pub func: php_stream_notification_func,
pub dtor: ::std::option::Option<unsafe extern "C" fn(notifier: *mut php_stream_notifier)>,
pub ptr: zval,
pub mask: ::std::os::raw::c_int,
pub progress: usize,
pub progress_max: usize,
}
#[repr(C)]
pub struct _php_stream_context {
pub notifier: *mut php_stream_notifier,
pub options: zval,
pub res: *mut zend_resource,
}
pub type php_stream_bucket = _php_stream_bucket;
pub type php_stream_bucket_brigade = _php_stream_bucket_brigade;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _php_stream_bucket {
pub next: *mut php_stream_bucket,
pub prev: *mut php_stream_bucket,
pub brigade: *mut php_stream_bucket_brigade,
pub buf: *mut ::std::os::raw::c_char,
pub buflen: usize,
pub own_buf: u8,
pub is_persistent: u8,
pub refcount: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _php_stream_bucket_brigade {
pub head: *mut php_stream_bucket,
pub tail: *mut php_stream_bucket,
}
pub const php_stream_filter_status_t_PSFS_ERR_FATAL: php_stream_filter_status_t = 0;
pub const php_stream_filter_status_t_PSFS_FEED_ME: php_stream_filter_status_t = 1;
pub const php_stream_filter_status_t_PSFS_PASS_ON: php_stream_filter_status_t = 2;
pub type php_stream_filter_status_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _php_stream_filter_ops {
pub filter: ::std::option::Option<
unsafe extern "C" fn(
stream: *mut php_stream,
thisfilter: *mut php_stream_filter,
buckets_in: *mut php_stream_bucket_brigade,
buckets_out: *mut php_stream_bucket_brigade,
bytes_consumed: *mut usize,
flags: ::std::os::raw::c_int,
) -> php_stream_filter_status_t,
>,
pub dtor: ::std::option::Option<unsafe extern "C" fn(thisfilter: *mut php_stream_filter)>,
pub label: *const ::std::os::raw::c_char,
}
pub type php_stream_filter_ops = _php_stream_filter_ops;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _php_stream_filter_chain {
pub head: *mut php_stream_filter,
pub tail: *mut php_stream_filter,
pub stream: *mut php_stream,
}
pub type php_stream_filter_chain = _php_stream_filter_chain;
#[repr(C)]
pub struct _php_stream_filter {
pub fops: *const php_stream_filter_ops,
pub abstract_: zval,
pub next: *mut php_stream_filter,
pub prev: *mut php_stream_filter,
pub is_persistent: ::std::os::raw::c_int,
pub chain: *mut php_stream_filter_chain,
pub buffer: php_stream_bucket_brigade,
pub res: *mut zend_resource,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _php_stream_statbuf {
pub sb: zend_stat_t,
}
pub type php_stream_statbuf = _php_stream_statbuf;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _php_stream_ops {
pub write: ::std::option::Option<
unsafe extern "C" fn(
stream: *mut php_stream,
buf: *const ::std::os::raw::c_char,
count: usize,
) -> isize,
>,
pub read: ::std::option::Option<
unsafe extern "C" fn(
stream: *mut php_stream,
buf: *mut ::std::os::raw::c_char,
count: usize,
) -> isize,
>,
pub close: ::std::option::Option<
unsafe extern "C" fn(
stream: *mut php_stream,
close_handle: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
pub flush: ::std::option::Option<
unsafe extern "C" fn(stream: *mut php_stream) -> ::std::os::raw::c_int,
>,
pub label: *const ::std::os::raw::c_char,
pub seek: ::std::option::Option<
unsafe extern "C" fn(
stream: *mut php_stream,
offset: zend_off_t,
whence: ::std::os::raw::c_int,
newoffset: *mut zend_off_t,
) -> ::std::os::raw::c_int,
>,
pub cast: ::std::option::Option<
unsafe extern "C" fn(
stream: *mut php_stream,
castas: ::std::os::raw::c_int,
ret: *mut *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
pub stat: ::std::option::Option<
unsafe extern "C" fn(
stream: *mut php_stream,
ssb: *mut php_stream_statbuf,
) -> ::std::os::raw::c_int,
>,
pub set_option: ::std::option::Option<
unsafe extern "C" fn(
stream: *mut php_stream,
option: ::std::os::raw::c_int,
value: ::std::os::raw::c_int,
ptrparam: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
}
pub type php_stream_ops = _php_stream_ops;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _php_stream_wrapper_ops {
pub stream_opener: ::std::option::Option<
unsafe extern "C" fn(
wrapper: *mut php_stream_wrapper,
filename: *const ::std::os::raw::c_char,
mode: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
opened_path: *mut *mut zend_string,
context: *mut php_stream_context,
__php_stream_call_depth: ::std::os::raw::c_int,
__zend_filename: *const ::std::os::raw::c_char,
__zend_lineno: u32,
__zend_orig_filename: *const ::std::os::raw::c_char,
__zend_orig_lineno: u32,
) -> *mut php_stream,
>,
pub stream_closer: ::std::option::Option<
unsafe extern "C" fn(
wrapper: *mut php_stream_wrapper,
stream: *mut php_stream,
) -> ::std::os::raw::c_int,
>,
pub stream_stat: ::std::option::Option<
unsafe extern "C" fn(
wrapper: *mut php_stream_wrapper,
stream: *mut php_stream,
ssb: *mut php_stream_statbuf,
) -> ::std::os::raw::c_int,
>,
pub url_stat: ::std::option::Option<
unsafe extern "C" fn(
wrapper: *mut php_stream_wrapper,
url: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
ssb: *mut php_stream_statbuf,
context: *mut php_stream_context,
) -> ::std::os::raw::c_int,
>,
pub dir_opener: ::std::option::Option<
unsafe extern "C" fn(
wrapper: *mut php_stream_wrapper,
filename: *const ::std::os::raw::c_char,
mode: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
opened_path: *mut *mut zend_string,
context: *mut php_stream_context,
__php_stream_call_depth: ::std::os::raw::c_int,
__zend_filename: *const ::std::os::raw::c_char,
__zend_lineno: u32,
__zend_orig_filename: *const ::std::os::raw::c_char,
__zend_orig_lineno: u32,
) -> *mut php_stream,
>,
pub label: *const ::std::os::raw::c_char,
pub unlink: ::std::option::Option<
unsafe extern "C" fn(
wrapper: *mut php_stream_wrapper,
url: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
context: *mut php_stream_context,
) -> ::std::os::raw::c_int,
>,
pub rename: ::std::option::Option<
unsafe extern "C" fn(
wrapper: *mut php_stream_wrapper,
url_from: *const ::std::os::raw::c_char,
url_to: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
context: *mut php_stream_context,
) -> ::std::os::raw::c_int,
>,
pub stream_mkdir: ::std::option::Option<
unsafe extern "C" fn(
wrapper: *mut php_stream_wrapper,
url: *const ::std::os::raw::c_char,
mode: ::std::os::raw::c_int,
options: ::std::os::raw::c_int,
context: *mut php_stream_context,
) -> ::std::os::raw::c_int,
>,
pub stream_rmdir: ::std::option::Option<
unsafe extern "C" fn(
wrapper: *mut php_stream_wrapper,
url: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
context: *mut php_stream_context,
) -> ::std::os::raw::c_int,
>,
pub stream_metadata: ::std::option::Option<
unsafe extern "C" fn(
wrapper: *mut php_stream_wrapper,
url: *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
value: *mut ::std::os::raw::c_void,
context: *mut php_stream_context,
) -> ::std::os::raw::c_int,
>,
}
pub type php_stream_wrapper_ops = _php_stream_wrapper_ops;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _php_stream_wrapper {
pub wops: *const php_stream_wrapper_ops,
pub abstract_: *mut ::std::os::raw::c_void,
pub is_url: ::std::os::raw::c_int,
}
#[repr(C)]
pub struct _php_stream {
pub ops: *const php_stream_ops,
pub abstract_: *mut ::std::os::raw::c_void,
pub readfilters: php_stream_filter_chain,
pub writefilters: php_stream_filter_chain,
pub wrapper: *mut php_stream_wrapper,
pub wrapperthis: *mut ::std::os::raw::c_void,
pub wrapperdata: zval,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub mode: [::std::os::raw::c_char; 16usize],
pub flags: u32,
pub res: *mut zend_resource,
pub stdiocast: *mut FILE,
pub orig_path: *mut ::std::os::raw::c_char,
pub ctx: *mut zend_resource,
pub position: zend_off_t,
pub readbuf: *mut ::std::os::raw::c_uchar,
pub readbuflen: usize,
pub readpos: zend_off_t,
pub writepos: zend_off_t,
pub chunk_size: usize,
pub open_filename: *const ::std::os::raw::c_char,
pub open_lineno: u32,
pub enclosing_stream: *mut _php_stream,
}
impl _php_stream {
#[inline]
pub fn is_persistent(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_is_persistent(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn in_free(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u8) }
}
#[inline]
pub fn set_in_free(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 2u8, val as u64)
}
}
#[inline]
pub fn eof(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_eof(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn __exposed(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set___exposed(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn fclose_stdiocast(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u8) }
}
#[inline]
pub fn set_fclose_stdiocast(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 2u8, val as u64)
}
}
#[inline]
pub fn has_buffered_data(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
}
#[inline]
pub fn set_has_buffered_data(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
is_persistent: u8,
in_free: u8,
eof: u8,
__exposed: u8,
fclose_stdiocast: u8,
has_buffered_data: u8,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let is_persistent: u8 = unsafe { ::std::mem::transmute(is_persistent) };
is_persistent as u64
});
__bindgen_bitfield_unit.set(1usize, 2u8, {
let in_free: u8 = unsafe { ::std::mem::transmute(in_free) };
in_free as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let eof: u8 = unsafe { ::std::mem::transmute(eof) };
eof as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let __exposed: u8 = unsafe { ::std::mem::transmute(__exposed) };
__exposed as u64
});
__bindgen_bitfield_unit.set(5usize, 2u8, {
let fclose_stdiocast: u8 = unsafe { ::std::mem::transmute(fclose_stdiocast) };
fclose_stdiocast as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let has_buffered_data: u8 = unsafe { ::std::mem::transmute(has_buffered_data) };
has_buffered_data as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
pub static mut php_stream_stdio_ops: php_stream_ops;
}
extern "C" {
pub fn php_register_url_stream_wrapper(
protocol: *const ::std::os::raw::c_char,
wrapper: *const php_stream_wrapper,
) -> zend_result;
}
extern "C" {
pub fn php_unregister_url_stream_wrapper(
protocol: *const ::std::os::raw::c_char,
) -> zend_result;
}
extern "C" {
pub fn php_register_url_stream_wrapper_volatile(
protocol: *mut zend_string,
wrapper: *mut php_stream_wrapper,
) -> zend_result;
}
extern "C" {
pub fn php_unregister_url_stream_wrapper_volatile(protocol: *mut zend_string) -> zend_result;
}
extern "C" {
pub fn php_stream_locate_url_wrapper(
path: *const ::std::os::raw::c_char,
path_for_open: *mut *const ::std::os::raw::c_char,
options: ::std::os::raw::c_int,
) -> *mut php_stream_wrapper;
}
pub type php_core_globals = _php_core_globals;
#[repr(C)]
pub struct _php_core_globals {
pub output_buffering: zend_long,
pub implicit_flush: bool,
pub enable_dl: bool,
pub display_errors: u8,
pub display_startup_errors: bool,
pub log_errors: bool,
pub ignore_repeated_errors: bool,
pub ignore_repeated_source: bool,
pub report_memleaks: bool,
pub output_handler: *mut ::std::os::raw::c_char,
pub unserialize_callback_func: *mut ::std::os::raw::c_char,
pub serialize_precision: zend_long,
pub memory_limit: zend_long,
pub max_input_time: zend_long,
pub error_log: *mut ::std::os::raw::c_char,
pub doc_root: *mut ::std::os::raw::c_char,
pub user_dir: *mut ::std::os::raw::c_char,
pub include_path: *mut ::std::os::raw::c_char,
pub open_basedir: *mut ::std::os::raw::c_char,
pub open_basedir_modified: bool,
pub extension_dir: *mut ::std::os::raw::c_char,
pub php_binary: *mut ::std::os::raw::c_char,
pub sys_temp_dir: *mut ::std::os::raw::c_char,
pub upload_tmp_dir: *mut ::std::os::raw::c_char,
pub upload_max_filesize: zend_long,
pub error_append_string: *mut ::std::os::raw::c_char,
pub error_prepend_string: *mut ::std::os::raw::c_char,
pub auto_prepend_file: *mut ::std::os::raw::c_char,
pub auto_append_file: *mut ::std::os::raw::c_char,
pub input_encoding: *mut ::std::os::raw::c_char,
pub internal_encoding: *mut ::std::os::raw::c_char,
pub output_encoding: *mut ::std::os::raw::c_char,
pub arg_separator: arg_separators,
pub variables_order: *mut ::std::os::raw::c_char,
pub rfc1867_protected_variables: HashTable,
pub connection_status: ::std::os::raw::c_short,
pub ignore_user_abort: bool,
pub header_is_being_sent: ::std::os::raw::c_uchar,
pub tick_functions: zend_llist,
pub http_globals: [zval; 6usize],
pub expose_php: bool,
pub register_argc_argv: bool,
pub auto_globals_jit: bool,
pub html_errors: bool,
pub xmlrpc_errors: bool,
pub docref_root: *mut ::std::os::raw::c_char,
pub docref_ext: *mut ::std::os::raw::c_char,
pub xmlrpc_error_number: zend_long,
pub activated_auto_globals: [bool; 8usize],
pub modules_activated: bool,
pub file_uploads: bool,
pub during_request_startup: bool,
pub allow_url_fopen: bool,
pub enable_post_data_reading: bool,
pub report_zend_debug: bool,
pub last_error_type: ::std::os::raw::c_int,
pub last_error_lineno: ::std::os::raw::c_int,
pub last_error_message: *mut zend_string,
pub last_error_file: *mut zend_string,
pub php_sys_temp_dir: *mut ::std::os::raw::c_char,
pub disable_classes: *mut ::std::os::raw::c_char,
pub max_input_nesting_level: zend_long,
pub max_input_vars: zend_long,
pub user_ini_filename: *mut ::std::os::raw::c_char,
pub user_ini_cache_ttl: zend_long,
pub request_order: *mut ::std::os::raw::c_char,
pub mail_log: *mut ::std::os::raw::c_char,
pub mail_x_header: bool,
pub mail_mixed_lf_and_crlf: bool,
pub in_error_log: bool,
pub allow_url_include: bool,
pub in_user_include: bool,
pub have_called_openlog: bool,
pub syslog_facility: zend_long,
pub syslog_ident: *mut ::std::os::raw::c_char,
pub syslog_filter: zend_long,
pub error_log_mode: zend_long,
}
extern "C" {
pub static mut core_globals: _php_core_globals;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _arg_separators {
pub output: *mut ::std::os::raw::c_char,
pub input: *mut ::std::os::raw::c_char,
}
pub type arg_separators = _arg_separators;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_ini_entry_def {
pub name: *const ::std::os::raw::c_char,
pub on_modify: ::std::option::Option<
unsafe extern "C" fn(
entry: *mut zend_ini_entry,
new_value: *mut zend_string,
mh_arg1: *mut ::std::os::raw::c_void,
mh_arg2: *mut ::std::os::raw::c_void,
mh_arg3: *mut ::std::os::raw::c_void,
stage: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
pub mh_arg1: *mut ::std::os::raw::c_void,
pub mh_arg2: *mut ::std::os::raw::c_void,
pub mh_arg3: *mut ::std::os::raw::c_void,
pub value: *const ::std::os::raw::c_char,
pub displayer: ::std::option::Option<
unsafe extern "C" fn(ini_entry: *mut zend_ini_entry, type_: ::std::os::raw::c_int),
>,
pub value_length: u32,
pub name_length: u16,
pub modifiable: u8,
}
pub type zend_ini_entry_def = _zend_ini_entry_def;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _zend_ini_entry {
pub name: *mut zend_string,
pub on_modify: ::std::option::Option<
unsafe extern "C" fn(
entry: *mut zend_ini_entry,
new_value: *mut zend_string,
mh_arg1: *mut ::std::os::raw::c_void,
mh_arg2: *mut ::std::os::raw::c_void,
mh_arg3: *mut ::std::os::raw::c_void,
stage: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
pub mh_arg1: *mut ::std::os::raw::c_void,
pub mh_arg2: *mut ::std::os::raw::c_void,
pub mh_arg3: *mut ::std::os::raw::c_void,
pub value: *mut zend_string,
pub orig_value: *mut zend_string,
pub displayer: ::std::option::Option<
unsafe extern "C" fn(ini_entry: *mut zend_ini_entry, type_: ::std::os::raw::c_int),
>,
pub module_number: ::std::os::raw::c_int,
pub modifiable: u8,
pub orig_modifiable: u8,
pub modified: u8,
}
extern "C" {
pub fn zend_register_ini_entries(
ini_entry: *const zend_ini_entry_def,
module_number: ::std::os::raw::c_int,
) -> zend_result;
}
extern "C" {
pub fn zend_register_bool_constant(
name: *const ::std::os::raw::c_char,
name_len: usize,
bval: bool,
flags: ::std::os::raw::c_int,
module_number: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn zend_register_long_constant(
name: *const ::std::os::raw::c_char,
name_len: usize,
lval: zend_long,
flags: ::std::os::raw::c_int,
module_number: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn zend_register_double_constant(
name: *const ::std::os::raw::c_char,
name_len: usize,
dval: f64,
flags: ::std::os::raw::c_int,
module_number: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn zend_register_string_constant(
name: *const ::std::os::raw::c_char,
name_len: usize,
strval: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
module_number: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn php_info_print_table_header(num_cols: ::std::os::raw::c_int, ...);
}
extern "C" {
pub fn php_info_print_table_row(num_cols: ::std::os::raw::c_int, ...);
}
extern "C" {
pub fn php_info_print_table_start();
}
extern "C" {
pub fn php_info_print_table_end();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct hostent {
pub h_name: *mut ::std::os::raw::c_char,
pub h_aliases: *mut *mut ::std::os::raw::c_char,
pub h_addrtype: ::std::os::raw::c_int,
pub h_length: ::std::os::raw::c_int,
pub h_addr_list: *mut *mut ::std::os::raw::c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct php_file_globals {
pub pclose_ret: ::std::os::raw::c_int,
pub def_chunk_size: usize,
pub auto_detect_line_endings: bool,
pub default_socket_timeout: zend_long,
pub user_agent: *mut ::std::os::raw::c_char,
pub from_address: *mut ::std::os::raw::c_char,
pub user_stream_current_filename: *const ::std::os::raw::c_char,
pub default_context: *mut php_stream_context,
pub stream_wrappers: *mut HashTable,
pub stream_filters: *mut HashTable,
pub wrapper_errors: *mut HashTable,
pub pclose_wait: ::std::os::raw::c_int,
pub tmp_host_info: hostent,
pub tmp_host_buf: *mut ::std::os::raw::c_char,
pub tmp_host_buf_len: usize,
}
extern "C" {
pub static mut file_globals: php_file_globals;
}
extern "C" {
pub static mut zend_ce_throwable: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_exception: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_error_exception: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_compile_error: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_parse_error: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_type_error: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_argument_count_error: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_value_error: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_arithmetic_error: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_division_by_zero_error: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_unhandled_match_error: *mut zend_class_entry;
}
extern "C" {
pub fn zend_throw_exception_ex(
exception_ce: *mut zend_class_entry,
code: zend_long,
format: *const ::std::os::raw::c_char,
...
) -> *mut zend_object;
}
extern "C" {
pub fn zend_throw_exception_object(exception: *mut zval);
}
extern "C" {
pub fn zend_do_implement_interface(ce: *mut zend_class_entry, iface: *mut zend_class_entry);
}
extern "C" {
pub static mut zend_ce_traversable: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_aggregate: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_iterator: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_arrayaccess: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_serializable: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_countable: *mut zend_class_entry;
}
extern "C" {
pub static mut zend_ce_stringable: *mut zend_class_entry;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sapi_header_struct {
pub header: *mut ::std::os::raw::c_char,
pub header_len: usize,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sapi_headers_struct {
pub headers: zend_llist,
pub http_response_code: ::std::os::raw::c_int,
pub send_default_content_type: ::std::os::raw::c_uchar,
pub mimetype: *mut ::std::os::raw::c_char,
pub http_status_line: *mut ::std::os::raw::c_char,
}
pub type sapi_post_entry = _sapi_post_entry;
pub type sapi_module_struct = _sapi_module_struct;
extern "C" {
pub static mut sapi_module: sapi_module_struct;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sapi_request_info {
pub request_method: *const ::std::os::raw::c_char,
pub query_string: *mut ::std::os::raw::c_char,
pub cookie_data: *mut ::std::os::raw::c_char,
pub content_length: zend_long,
pub path_translated: *mut ::std::os::raw::c_char,
pub request_uri: *mut ::std::os::raw::c_char,
pub request_body: *mut _php_stream,
pub content_type: *const ::std::os::raw::c_char,
pub headers_only: bool,
pub no_headers: bool,
pub headers_read: bool,
pub post_entry: *mut sapi_post_entry,
pub content_type_dup: *mut ::std::os::raw::c_char,
pub auth_user: *mut ::std::os::raw::c_char,
pub auth_password: *mut ::std::os::raw::c_char,
pub auth_digest: *mut ::std::os::raw::c_char,
pub argv0: *mut ::std::os::raw::c_char,
pub current_user: *mut ::std::os::raw::c_char,
pub current_user_length: ::std::os::raw::c_int,
pub argc: ::std::os::raw::c_int,
pub argv: *mut *mut ::std::os::raw::c_char,
pub proto_num: ::std::os::raw::c_int,
}
#[repr(C)]
pub struct _sapi_globals_struct {
pub server_context: *mut ::std::os::raw::c_void,
pub request_info: sapi_request_info,
pub sapi_headers: sapi_headers_struct,
pub read_post_bytes: i64,
pub post_read: ::std::os::raw::c_uchar,
pub headers_sent: ::std::os::raw::c_uchar,
pub global_stat: zend_stat_t,
pub default_mimetype: *mut ::std::os::raw::c_char,
pub default_charset: *mut ::std::os::raw::c_char,
pub rfc1867_uploaded_files: *mut HashTable,
pub post_max_size: zend_long,
pub options: ::std::os::raw::c_int,
pub sapi_started: bool,
pub global_request_time: f64,
pub known_post_content_types: HashTable,
pub callback_func: zval,
pub fci_cache: zend_fcall_info_cache,
}
pub type sapi_globals_struct = _sapi_globals_struct;
extern "C" {
pub static mut sapi_globals: sapi_globals_struct;
}
extern "C" {
pub fn sapi_startup(sf: *mut sapi_module_struct);
}
extern "C" {
pub fn sapi_shutdown();
}
pub const sapi_header_op_enum_SAPI_HEADER_REPLACE: sapi_header_op_enum = 0;
pub const sapi_header_op_enum_SAPI_HEADER_ADD: sapi_header_op_enum = 1;
pub const sapi_header_op_enum_SAPI_HEADER_DELETE: sapi_header_op_enum = 2;
pub const sapi_header_op_enum_SAPI_HEADER_DELETE_ALL: sapi_header_op_enum = 3;
pub const sapi_header_op_enum_SAPI_HEADER_SET_STATUS: sapi_header_op_enum = 4;
pub type sapi_header_op_enum = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _sapi_module_struct {
pub name: *mut ::std::os::raw::c_char,
pub pretty_name: *mut ::std::os::raw::c_char,
pub startup: ::std::option::Option<
unsafe extern "C" fn(sapi_module: *mut _sapi_module_struct) -> ::std::os::raw::c_int,
>,
pub shutdown: ::std::option::Option<
unsafe extern "C" fn(sapi_module: *mut _sapi_module_struct) -> ::std::os::raw::c_int,
>,
pub activate: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
pub deactivate: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
pub ub_write: ::std::option::Option<
unsafe extern "C" fn(str_: *const ::std::os::raw::c_char, str_length: usize) -> usize,
>,
pub flush:
::std::option::Option<unsafe extern "C" fn(server_context: *mut ::std::os::raw::c_void)>,
pub get_stat: ::std::option::Option<unsafe extern "C" fn() -> *mut zend_stat_t>,
pub getenv: ::std::option::Option<
unsafe extern "C" fn(
name: *const ::std::os::raw::c_char,
name_len: usize,
) -> *mut ::std::os::raw::c_char,
>,
pub sapi_error: ::std::option::Option<
unsafe extern "C" fn(
type_: ::std::os::raw::c_int,
error_msg: *const ::std::os::raw::c_char,
...
),
>,
pub header_handler: ::std::option::Option<
unsafe extern "C" fn(
sapi_header: *mut sapi_header_struct,
op: sapi_header_op_enum,
sapi_headers: *mut sapi_headers_struct,
) -> ::std::os::raw::c_int,
>,
pub send_headers: ::std::option::Option<
unsafe extern "C" fn(sapi_headers: *mut sapi_headers_struct) -> ::std::os::raw::c_int,
>,
pub send_header: ::std::option::Option<
unsafe extern "C" fn(
sapi_header: *mut sapi_header_struct,
server_context: *mut ::std::os::raw::c_void,
),
>,
pub read_post: ::std::option::Option<
unsafe extern "C" fn(buffer: *mut ::std::os::raw::c_char, count_bytes: usize) -> usize,
>,
pub read_cookies: ::std::option::Option<unsafe extern "C" fn() -> *mut ::std::os::raw::c_char>,
pub register_server_variables:
::std::option::Option<unsafe extern "C" fn(track_vars_array: *mut zval)>,
pub log_message: ::std::option::Option<
unsafe extern "C" fn(
message: *const ::std::os::raw::c_char,
syslog_type_int: ::std::os::raw::c_int,
),
>,
pub get_request_time:
::std::option::Option<unsafe extern "C" fn(request_time: *mut f64) -> zend_result>,
pub terminate_process: ::std::option::Option<unsafe extern "C" fn()>,
pub php_ini_path_override: *mut ::std::os::raw::c_char,
pub default_post_reader: ::std::option::Option<unsafe extern "C" fn()>,
pub treat_data: ::std::option::Option<
unsafe extern "C" fn(
arg: ::std::os::raw::c_int,
str_: *mut ::std::os::raw::c_char,
destArray: *mut zval,
),
>,
pub executable_location: *mut ::std::os::raw::c_char,
pub php_ini_ignore: ::std::os::raw::c_int,
pub php_ini_ignore_cwd: ::std::os::raw::c_int,
pub get_fd: ::std::option::Option<
unsafe extern "C" fn(fd: *mut ::std::os::raw::c_int) -> ::std::os::raw::c_int,
>,
pub force_http_10: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
pub get_target_uid:
::std::option::Option<unsafe extern "C" fn(arg1: *mut uid_t) -> ::std::os::raw::c_int>,
pub get_target_gid:
::std::option::Option<unsafe extern "C" fn(arg1: *mut gid_t) -> ::std::os::raw::c_int>,
pub input_filter: ::std::option::Option<
unsafe extern "C" fn(
arg: ::std::os::raw::c_int,
var: *const ::std::os::raw::c_char,
val: *mut *mut ::std::os::raw::c_char,
val_len: usize,
new_val_len: *mut usize,
) -> ::std::os::raw::c_uint,
>,
pub ini_defaults:
::std::option::Option<unsafe extern "C" fn(configuration_hash: *mut HashTable)>,
pub phpinfo_as_text: ::std::os::raw::c_int,
pub ini_entries: *const ::std::os::raw::c_char,
pub additional_functions: *const zend_function_entry,
pub input_filter_init: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_uint>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _sapi_post_entry {
pub content_type: *mut ::std::os::raw::c_char,
pub content_type_len: u32,
pub post_reader: ::std::option::Option<unsafe extern "C" fn()>,
pub post_handler: ::std::option::Option<
unsafe extern "C" fn(
content_type_dup: *mut ::std::os::raw::c_char,
arg: *mut ::std::os::raw::c_void,
),
>,
}