Struct ext_php_rs::ffi::zend_type

source ·

#[repr(C)]pub struct zend_type {
    pub ptr: *mut c_void,
    pub type_mask: u32,
}

Fields§

§ptr: *mut c_void§type_mask: u32

Implementations§

source §

impl zend_type

source

pub fn empty(pass_by_ref: bool, is_variadic: bool) -> Self

Builds an empty Zend type container.

Parameters

pass_by_ref - Whether the value should be passed by reference.
is_variadic - Whether this type represents a variadic argument.

Examples found in repository ?

src/builders/function.rs (line 146)

    pub fn build(mut self) -> Result<FunctionEntry> {
        let mut args = Vec::with_capacity(self.args.len() + 1);

        // argument header, retval etc
        args.push(ArgInfo {
            name: self.n_req.unwrap_or(self.args.len()) as *const _,
            type_: match self.retval {
                Some(retval) => {
                    ZendType::empty_from_type(retval, self.ret_as_ref, false, self.ret_as_null)
                        .ok_or(Error::InvalidCString)?
                }
                None => ZendType::empty(false, false),
            },
            default_value: ptr::null(),
        });

        // arguments
        args.extend(
            self.args
                .iter()
                .map(|arg| arg.as_arg_info())
                .collect::<Result<Vec<_>>>()?,
        );

        self.function.fname = CString::new(self.name)?.into_raw();
        self.function.num_args = (args.len() - 1) as u32;
        self.function.arg_info = Box::into_raw(args.into_boxed_slice()) as *const ArgInfo;

        Ok(self.function)
    }

source

pub fn empty_from_type(
 type_: DataType,
 pass_by_ref: bool,
 is_variadic: bool,
 allow_null: bool
) -> Option<Self>

Attempts to create a zend type for a given datatype. Returns an option containing the type.

Returns None if the data type was a class object where the class name could not be converted into a C string (i.e. contained NUL-bytes).

Parameters

type_ - Data type to create zend type for.
pass_by_ref - Whether the type should be passed by reference.
is_variadic - Whether the type is for a variadic argument.
allow_null - Whether the type should allow null to be passed in place.

Examples found in repository ?

src/args.rs (lines 134-139)

    pub(crate) fn as_arg_info(&self) -> Result<ArgInfo> {
        Ok(ArgInfo {
            name: CString::new(self.name.as_str())?.into_raw(),
            type_: ZendType::empty_from_type(
                self._type,
                self.as_ref,
                self.variadic,
                self.allow_null,
            )
            .ok_or(Error::InvalidCString)?,
            default_value: match &self.default_value {
                Some(val) => CString::new(val.as_str())?.into_raw(),
                None => ptr::null(),
            },
        })
    }

More examples

Hide additional examples

src/builders/function.rs (line 143)

    pub fn build(mut self) -> Result<FunctionEntry> {
        let mut args = Vec::with_capacity(self.args.len() + 1);

        // argument header, retval etc
        args.push(ArgInfo {
            name: self.n_req.unwrap_or(self.args.len()) as *const _,
            type_: match self.retval {
                Some(retval) => {
                    ZendType::empty_from_type(retval, self.ret_as_ref, false, self.ret_as_null)
                        .ok_or(Error::InvalidCString)?
                }
                None => ZendType::empty(false, false),
            },
            default_value: ptr::null(),
        });

        // arguments
        args.extend(
            self.args
                .iter()
                .map(|arg| arg.as_arg_info())
                .collect::<Result<Vec<_>>>()?,
        );

        self.function.fname = CString::new(self.name)?.into_raw();
        self.function.num_args = (args.len() - 1) as u32;
        self.function.arg_info = Box::into_raw(args.into_boxed_slice()) as *const ArgInfo;

        Ok(self.function)
    }