15788182852

Committed 20 Jun 2025 09:32PM UTC coverage: 22.034%. Remained the same

Build # 15788182852

Build Type

Pull #460

github

Committed by

web-flow

Commit Message

Merge d4fc01bb5 into 660f308c0

Pull Request Pull Request #460: chore(clippy): flowing lifetimes warning and clippy::mut_from_ref

Run Details

6 of 56 new or added lines in 13 files covered. (10.71%)

3 existing lines in 2 files now uncovered.

871 of 3953 relevant lines covered (22.03%)

2.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

11.63

/src/zend/function.rs

//! Builder for creating functions and methods in PHP.

use std::{fmt::Debug, os::raw::c_char, ptr};

use crate::{
    convert::IntoZvalDyn,
    error::Result,
    ffi::{
        zend_call_known_function, zend_fetch_function_str, zend_function, zend_function_entry,
        zend_hash_str_find_ptr_lc,
    },
    flags::FunctionType,
    types::Zval,
};

use super::ClassEntry;

/// A Zend function entry.
pub type FunctionEntry = zend_function_entry;

impl Debug for FunctionEntry {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("_zend_function_entry")
            .field("fname", &self.fname)
            .field("arg_info", &self.arg_info)
            .field("num_args", &self.num_args)
            .field("flags", &self.flags)
            .finish()
    }
}

impl FunctionEntry {
    /// Returns an empty function entry, signifing the end of a function list.
    #[must_use]
    pub fn end() -> Self {
        Self {
            fname: ptr::null::<c_char>(),
            handler: None,
            arg_info: ptr::null(),
            num_args: 0,
            flags: 0,
            #[cfg(php84)]
            doc_comment: ptr::null(),
            #[cfg(php84)]
            frameless_function_infos: ptr::null(),
        }
    }

    /// Converts the function entry into a raw and pointer, releasing it to the
    /// C world.
    #[must_use]
    pub fn into_raw(self) -> *mut Self {
        Box::into_raw(Box::new(self))
    }
}

/// PHP function.
pub type Function = zend_function;

impl Function {
    /// Returns the function type.
    #[must_use]
    pub fn function_type(&self) -> FunctionType {
        FunctionType::from(unsafe { self.type_ })
    }

    /// Attempts to fetch a [`Function`] from the function name.
    #[must_use]
    pub fn try_from_function(name: &str) -> Option<Self> {
        unsafe {
            let res = zend_fetch_function_str(name.as_ptr().cast::<c_char>(), name.len());
            if res.is_null() {
                return None;
            }
            Some(*res)
        }
    }

    /// Attempts to fetch a [`Function`] from the class and method name.
    #[must_use]
    pub fn try_from_method(class: &str, name: &str) -> Option<Self> {
        match ClassEntry::try_find(class) {
            None => None,
            Some(ce) => unsafe {
                let res = zend_hash_str_find_ptr_lc(
                    &raw const ce.function_table,
                    name.as_ptr().cast::<c_char>(),
                    name.len(),
                )
                .cast::<zend_function>();
                if res.is_null() {
                    return None;
                }
                Some(*res)
            },
        }
    }

    /// Attempts to call the callable with a list of arguments to pass to the
    /// function.
    ///
    /// You should not call this function directly, rather through the
    /// [`call_user_func`] macro.
    ///
    /// # Parameters
    ///
    /// * `params` - A list of parameters to call the function with.
    ///
    /// # Returns
    ///
    /// Returns the result wrapped in [`Ok`] upon success.
    ///
    /// # Errors
    ///
    /// * If the function call fails, an [`Err`] is returned.
    /// * If the number of parameters is not a valid `u32` value.
    ///
    /// # Example
    ///
    /// ```no_run
    /// use ext_php_rs::types::ZendCallable;
    ///
    /// let strpos = ZendCallable::try_from_name("strpos").unwrap();
    /// let result = strpos.try_call(vec![&"hello", &"e"]).unwrap();
    /// assert_eq!(result.long(), Some(1));
    /// ```
    // TODO: Measure this
    #[allow(clippy::inline_always)]
    #[inline(always)]
    pub fn try_call(&self, params: Vec<&dyn IntoZvalDyn>) -> Result<Zval> {
        let mut retval = Zval::new();
        let len = params.len();
        let params = params
            .into_iter()
            .map(|val| val.as_zval(false))
            .collect::<Result<Vec<_>>>()?;
        let packed = params.into_boxed_slice();

        unsafe {
            zend_call_known_function(
                ptr::from_ref(self).cast_mut(),
                ptr::null_mut(),
                ptr::null_mut(),
                &raw mut retval,
                len.try_into()?,
                packed.as_ptr().cast_mut(),
                ptr::null_mut(),
            );
        };

        Ok(retval)
    }
}

1	//! Builder for creating functions and methods in PHP.
2
3	use std::{fmt::Debug, os::raw::c_char, ptr};
4
5	use crate::{
6	convert::IntoZvalDyn,
7	error::Result,
8	ffi::{
9	zend_call_known_function, zend_fetch_function_str, zend_function, zend_function_entry,
10	zend_hash_str_find_ptr_lc,
11	},
12	flags::FunctionType,
13	types::Zval,
14	};
15
16	use super::ClassEntry;
17
18	/// A Zend function entry.
19	pub type FunctionEntry = zend_function_entry;
20
21	impl Debug for FunctionEntry {
22	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	×
23	f.debug_struct("_zend_function_entry")	×
24	.field("fname", &self.fname)	×
25	.field("arg_info", &self.arg_info)	×
26	.field("num_args", &self.num_args)	×
27	.field("flags", &self.flags)	×
28	.finish()
29	}
30	}
31
32	impl FunctionEntry {
33	/// Returns an empty function entry, signifing the end of a function list.
34	#[must_use]
35	pub fn end() -> Self {	3✔
36	Self {
37	fname: ptr::null::<c_char>(),	3✔
38	handler: None,
39	arg_info: ptr::null(),	3✔
40	num_args: 0,
41	flags: 0,
42	#[cfg(php84)]
43	doc_comment: ptr::null(),	3✔
44	#[cfg(php84)]
45	frameless_function_infos: ptr::null(),	3✔
46	}
47	}
48
49	/// Converts the function entry into a raw and pointer, releasing it to the
50	/// C world.
51	#[must_use]
52	pub fn into_raw(self) -> *mut Self {	×
53	Box::into_raw(Box::new(self))	×
54	}
55	}
56
57	/// PHP function.
58	pub type Function = zend_function;
59
60	impl Function {
61	/// Returns the function type.
62	#[must_use]
63	pub fn function_type(&self) -> FunctionType {	×
64	FunctionType::from(unsafe { self.type_ })	×
65	}
66
67	/// Attempts to fetch a [`Function`] from the function name.
68	#[must_use]
69	pub fn try_from_function(name: &str) -> Option<Self> {	×
70	unsafe {
71	let res = zend_fetch_function_str(name.as_ptr().cast::<c_char>(), name.len());	×
72	if res.is_null() {	×
73	return None;	×
74	}
75	Some(*res)	×
76	}
77	}
78
79	/// Attempts to fetch a [`Function`] from the class and method name.
80	#[must_use]
81	pub fn try_from_method(class: &str, name: &str) -> Option<Self> {	×
82	match ClassEntry::try_find(class) {	×
83	None => None,	×
84	Some(ce) => unsafe {
85	let res = zend_hash_str_find_ptr_lc(
NEW 86	&raw const ce.function_table,	×
87	name.as_ptr().cast::<c_char>(),	×
88	name.len(),	×
89	)
90	.cast::<zend_function>();
91	if res.is_null() {	×
92	return None;	×
93	}
94	Some(*res)	×
95	},
96	}
97	}
98
99	/// Attempts to call the callable with a list of arguments to pass to the
100	/// function.
101	///
102	/// You should not call this function directly, rather through the
103	/// [`call_user_func`] macro.
104	///
105	/// # Parameters
106	///
107	/// * `params` - A list of parameters to call the function with.
108	///
109	/// # Returns
110	///
111	/// Returns the result wrapped in [`Ok`] upon success.
112	///
113	/// # Errors
114	///
115	/// * If the function call fails, an [`Err`] is returned.
116	/// * If the number of parameters is not a valid `u32` value.
117	///
118	/// # Example
119	///
120	/// ```no_run
121	/// use ext_php_rs::types::ZendCallable;
122	///
123	/// let strpos = ZendCallable::try_from_name("strpos").unwrap();
124	/// let result = strpos.try_call(vec![&"hello", &"e"]).unwrap();
125	/// assert_eq!(result.long(), Some(1));
126	/// ```
127	// TODO: Measure this
128	#[allow(clippy::inline_always)]
129	#[inline(always)]
130	pub fn try_call(&self, params: Vec<&dyn IntoZvalDyn>) -> Result<Zval> {	×
131	let mut retval = Zval::new();	×
132	let len = params.len();	×
133	let params = params	×
134	.into_iter()
135	.map(\|val\| val.as_zval(false))	×
136	.collect::<Result<Vec<_>>>()?;
137	let packed = params.into_boxed_slice();	×
138
139	unsafe {
140	zend_call_known_function(
141	ptr::from_ref(self).cast_mut(),	×
NEW 142	ptr::null_mut(),	×
NEW 143	ptr::null_mut(),	×
NEW 144	&raw mut retval,	×
145	len.try_into()?,	×
146	packed.as_ptr().cast_mut(),	×
NEW 147	ptr::null_mut(),	×
148	);
149	};
150
151	Ok(retval)	×
152	}
153	}

davidcole1340 / ext-php-rs / 15788182852

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous