mirror of
https://github.com/danog/ext-php-rs.git
synced 2024-11-30 04:39:04 +01:00
2456 lines
82 KiB
Rust
2456 lines
82 KiB
Rust
/* 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_VOID: u32 = 14;
|
|
pub const IS_MIXED: u32 = 16;
|
|
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 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_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,
|
|
);
|
|
}
|
|
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],
|
|
}
|
|
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,
|
|
);
|
|
}
|
|
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
|
|
}
|
|
}
|
|
#[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();
|
|
}
|
|
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_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;
|
|
}
|
|
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,
|
|
),
|
|
>,
|
|
}
|