如何在Rust中将整数转换为C中的char *

Question

I have the following use case. A struct in C looks like this:

typedef struct _zend_internal_arg_info {
    const char *name;
    zend_type type;
    zend_uchar pass_by_reference;
    zend_bool is_variadic;
} zend_internal_arg_info;

Normally the name field contains a function name. But due to internal implementation this field can also carry an integer. On C end there is a macro doing the casting like this:

(const char*)(unsigned long int)(1)

What I want to do is to do the same cast on Rust end. I ended up with the following code:

fn create_null_argument(required_args: u8, return_reference: bool) -> ZendFunctionArgument {
    let required_args_ref = Box::into_raw(Box::new(required_args as i8)) as *const i8;
    ZendFunctionArgument {
        arg: php_bindings::_zend_internal_arg_info {
            name: required_args_ref,
            type_: 0,
            pass_by_reference: if return_reference { 1 } else { 0 },
            is_variadic: 0,
        },
    }
}

This seem to work with the following test:

let arguments_ptr = ZendFunctionArguments::new(5, true).into_raw();
unsafe {
    let arguments: Vec<php_bindings::_zend_internal_arg_info> = Vec::from_raw_parts(arguments_ptr as *mut _, 1, 1);
    let required_args = *arguments[0].name;
    assert_eq!(5, required_args);
}

Unfortunatelly on PHP end (when the code is executed) the value is totally random on every execution. What I want to ask here is whether the way I am casting the i8 is correct comparing to the casting on C end ( (const char*)(unsigned long int)(1) )?

---- EDIT -----

Some more details. Generated PHP binding:

#[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 pass_by_reference: zend_uchar,
    pub is_variadic: zend_bool,
}

Here an unused struct with some description of this twisted logic:

/* the following structure repeats the layout of zend_internal_arg_info,
 * but its fields have different meaning. It's used as the first element of
 * arg_info array to define properties of internal functions.
 * It's also used for the return type.
 */
typedef struct _zend_internal_function_info {
    zend_uintptr_t required_num_args;
    zend_type type;
    zend_bool return_reference;
    zend_bool _is_variadic;
} zend_internal_function_info;

Here is the whole macro beig used mormally in c:

#define ZEND_BEGIN_ARG_INFO_EX(name, _unused, return_reference, required_num_args)  \
    static const zend_internal_arg_info name[] = { \
        { (const char*)(zend_uintptr_t)(required_num_args), 0, return_reference, 0 },

And zend_uintptr_t is:

typedef uintptr_t zend_uintptr_t;

and then:

typedef unsigned long int   uintptr_t;

and the struct:

pub struct ZendFunctionArgument {
    arg: php_bindings::_zend_internal_arg_info,
}

Answer 1

Your code is not converting an integer to a pointer - as Stargateur says in the comments, the correct way to do that is more simply required_args as *const ::std::os::raw::c_char .

Instead, you are allocating required_args on the heap with Box::new , and then taking it out of the hands of the memory manager with into_raw - giving a pointer to the value of required_args , which, until you manually clean it up, will live forever.

This seem to work with the following test

Because you are dereferencing the pointer into the heap by doing *arguments[0].name , and the value at that pointer is indeed 5 .

Unfortunatelly on PHP end (when the code is executed) the value is totally random on every execution.

This is unsurprising. Since the end result of your code is that the value of the field is just some pointer into the heap, it will change every time you run the code.