ext-php-rs/docsrs_bindings.rs

/* automatically generated by rust-bindgen 0.68.1 */

#[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 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; 2usize]>,
    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) -> u16 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_is_persistent(&mut self, val: u16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn in_free(&self) -> u16 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u16) }
    }
    #[inline]
    pub fn set_in_free(&mut self, val: u16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub fn eof(&self) -> u16 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_eof(&mut self, val: u16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(3usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn __exposed(&self) -> u16 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set___exposed(&mut self, val: u16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(4usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn fclose_stdiocast(&self) -> u16 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u16) }
    }
    #[inline]
    pub fn set_fclose_stdiocast(&mut self, val: u16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(5usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub fn has_buffered_data(&self) -> u16 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_has_buffered_data(&mut self, val: u16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(7usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn fclose_stdiocast_flush_in_progress(&self) -> u16 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u16) }
    }
    #[inline]
    pub fn set_fclose_stdiocast_flush_in_progress(&mut self, val: u16) {
        unsafe {
            let val: u16 = ::std::mem::transmute(val);
            self._bitfield_1.set(8usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        is_persistent: u16,
        in_free: u16,
        eof: u16,
        __exposed: u16,
        fclose_stdiocast: u16,
        has_buffered_data: u16,
        fclose_stdiocast_flush_in_progress: u16,
    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let is_persistent: u16 = unsafe { ::std::mem::transmute(is_persistent) };
            is_persistent as u64
        });
        __bindgen_bitfield_unit.set(1usize, 2u8, {
            let in_free: u16 = unsafe { ::std::mem::transmute(in_free) };
            in_free as u64
        });
        __bindgen_bitfield_unit.set(3usize, 1u8, {
            let eof: u16 = unsafe { ::std::mem::transmute(eof) };
            eof as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let __exposed: u16 = unsafe { ::std::mem::transmute(__exposed) };
            __exposed as u64
        });
        __bindgen_bitfield_unit.set(5usize, 2u8, {
            let fclose_stdiocast: u16 = unsafe { ::std::mem::transmute(fclose_stdiocast) };
            fclose_stdiocast as u64
        });
        __bindgen_bitfield_unit.set(7usize, 1u8, {
            let has_buffered_data: u16 = unsafe { ::std::mem::transmute(has_buffered_data) };
            has_buffered_data as u64
        });
        __bindgen_bitfield_unit.set(8usize, 1u8, {
            let fclose_stdiocast_flush_in_progress: u16 =
                unsafe { ::std::mem::transmute(fclose_stdiocast_flush_in_progress) };
            fclose_stdiocast_flush_in_progress 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,
    );
}
#[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,
        ),
    >,
}
extern "C" {
    pub fn php_request_startup() -> zend_result;
}
extern "C" {
    pub fn php_request_shutdown(dummy: *mut ::std::os::raw::c_void);
}
extern "C" {
    pub fn php_module_startup(
        sf: *mut sapi_module_struct,
        additional_module: *mut zend_module_entry,
    ) -> zend_result;
}
extern "C" {
    pub fn php_module_shutdown();
}
extern "C" {
    pub fn php_execute_script(primary_file: *mut zend_file_handle) -> bool;
}
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;
}