Modify ZVal as_* methods.

Author: jmjoy

phper-sys/php_wrapper.c

@@ -265,3 +265,27 @@ void phper_zval_str(zval *zv, zend_string *s) {
 zend_array *phper_zend_new_array(uint32_t nSize) {
     return zend_new_array(nSize);
 }
+
+zend_array *phper_zend_array_dup(zend_array *source) {
+    return zend_array_dup(source);
+}
+
+zend_array *phper_z_arr_p(const zval *zv) {
+    return Z_ARR_P(zv);
+}
+
+zend_long phper_z_lval_p(const zval *zv) {
+    return Z_LVAL_P(zv);
+}
+
+double phper_z_dval_p(const zval *zv) {
+    return Z_DVAL_P(zv);
+}
+
+zend_string *phper_z_str_p(const zval *zv) {
+    return Z_STR_P(zv);
+}
+
+zend_resource *phper_z_res_p(const zval *zv) {
+    return Z_RES_P(zv);
+}

phper/src/arrays.rs

@@ -18,6 +18,7 @@ use crate::{
 };
 use derive_more::From;
 use std::{
+    borrow::Borrow,
     convert::TryInto,
     marker::PhantomData,
     mem::{forget, zeroed},
@@ -163,14 +164,6 @@ impl ZArr {
         }
     }
 
-    pub fn clone_arr(&self) -> EBox<Self> {
-        let mut other = Self::new();
-        unsafe {
-            zend_hash_copy(other.as_mut_ptr(), self.as_ptr() as *mut _, None);
-        }
-        other
-    }
-
     pub fn iter(&self) -> Iter<'_> {
         Iter {
             index: 0,
@@ -179,19 +172,29 @@ impl ZArr {
     }
 }
 
+impl ToOwned for ZArr {
+    type Owned = ZArray;
+
+    fn to_owned(&self) -> Self::Owned {
+        unsafe {
+            // TODO The source really immutable?
+            let dest = phper_zend_array_dup(self.as_ptr() as *mut _);
+            ZArray::from_raw(dest)
+        }
+    }
+}
+
 /// Wrapper of [crate::sys::zend_array].
 #[repr(transparent)]
 pub struct ZArray {
-    inner: *mut zend_array,
+    inner: *mut ZArr,
 }
 
 impl ZArray {
     pub fn new() -> Self {
         unsafe {
             let ptr = phper_zend_new_array(0);
-            Self {
-                inner: ZArr::from_mut_ptr(ptr),
-            }
+            Self::from_raw(ptr)
         }
     }
 
@@ -224,6 +227,18 @@ impl DerefMut for ZArray {
     }
 }
 
+impl Borrow<ZArr> for ZArray {
+    fn borrow(&self) -> &ZArr {
+        self.deref()
+    }
+}
+
+impl Clone for ZArray {
+    fn clone(&self) -> Self {
+        self.deref().to_owned()
+    }
+}
+
 impl Drop for ZArray {
     fn drop(&mut self) {
         unsafe {
@@ -235,7 +250,7 @@ impl Drop for ZArray {
 /// Iter created by [Array::iter].
 pub struct Iter<'a> {
     index: isize,
-    array: &'a ZArray,
+    array: &'a ZArr,
 }
 
 impl<'a> Iterator for Iter<'a> {

phper/src/classes.rs

@@ -12,7 +12,7 @@
 
 use crate::{
     alloc::EBox,
-    arrays::ZArray,
+    arrays::{ZArr, ZArray},
     errors::{ClassNotFoundError, InitializeObjectError, StateTypeError},
     functions::{Argument, Function, FunctionEntity, FunctionEntry, Method},
     objects::{ExtendObject, Object},
@@ -89,7 +89,7 @@ impl<T: Send + 'static> DynamicClass<T> {
         &mut self, name: impl ToString, vis: Visibility, handler: F, arguments: Vec<Argument>,
     ) where
         F: Fn(&mut Object<T>, &mut [ZVal]) -> R + Send + Sync + 'static,
-        R: SetVal + 'static,
+        R: Into<ZVal> + 'static,
     {
         self.method_entities.push(FunctionEntity::new(
             name,
@@ -104,7 +104,7 @@ impl<T: Send + 'static> DynamicClass<T> {
         &mut self, name: impl ToString, vis: Visibility, handler: F, arguments: Vec<Argument>,
     ) where
         F: Fn(&mut [ZVal]) -> R + Send + Sync + 'static,
-        R: SetVal + 'static,
+        R: Into<ZVal> + 'static,
     {
         self.method_entities.push(FunctionEntity::new(
             name,
@@ -233,7 +233,7 @@ impl<T: 'static> ClassEntry<T> {
     pub fn init_object(&self) -> crate::Result<EBox<Object<T>>> {
         unsafe {
             let ptr = self.as_ptr() as *mut _;
-            let mut val = ZVal::undef();
+            let mut val = ZVal::from(());
             if !phper_object_init_ex(val.as_mut_ptr(), ptr) {
                 Err(InitializeObjectError::new(self.get_name().to_str()?.to_owned()).into())
             } else {
@@ -251,7 +251,7 @@ impl<T: 'static> ClassEntry<T> {
 
     pub fn has_method(&self, method_name: &str) -> bool {
         unsafe {
-            let function_table = ZArray::from_ptr(&self.inner.function_table).unwrap();
+            let function_table = ZArr::from_ptr(&self.inner.function_table);
             function_table.exists(method_name)
         }
     }

phper/src/functions.rs

@@ -22,7 +22,7 @@ use crate::{
     strings::{ZStr, ZString},
     sys::*,
     utils::ensure_end_with_zero,
-    values::{ExecuteData, SetVal, ZVal},
+    values::{ExecuteData, ZVal},
 };
 use std::{
     convert::TryInto,
@@ -39,12 +39,12 @@ pub(crate) trait Callable {
 pub(crate) struct Function<F, R>(F)
 where
     F: Fn(&mut [ZVal]) -> R + Send + Sync,
-    R: SetVal;
+    R: Into<ZVal>;
 
 impl<F, R> Function<F, R>
 where
     F: Fn(&mut [ZVal]) -> R + Send + Sync,
-    R: SetVal,
+    R: Into<ZVal>,
 {
     pub fn new(f: F) -> Self {
         Self(f)
@@ -54,20 +54,18 @@ where
 impl<F, R> Callable for Function<F, R>
 where
     F: Fn(&mut [ZVal]) -> R + Send + Sync,
-    R: SetVal,
+    R: Into<ZVal>,
 {
     fn call(&self, _: &mut ExecuteData, arguments: &mut [ZVal], return_value: &mut ZVal) {
         let r = (self.0)(arguments);
-        unsafe {
-            r.set_val(return_value);
-        }
+        *return_value = r.into();
     }
 }
 
 pub(crate) struct Method<F, R, T>
 where
     F: Fn(&mut Object<T>, &mut [ZVal]) -> R + Send + Sync,
-    R: SetVal,
+    R: Into<ZVal>,
 {
     f: F,
     _p0: PhantomData<R>,
@@ -77,7 +75,7 @@ where
 impl<F, R, T> Method<F, R, T>
 where
     F: Fn(&mut Object<T>, &mut [ZVal]) -> R + Send + Sync,
-    R: SetVal,
+    R: Into<ZVal>,
 {
     pub(crate) fn new(f: F) -> Self {
         Self {
@@ -91,15 +89,15 @@ where
 impl<F, R, T: 'static> Callable for Method<F, R, T>
 where
     F: Fn(&mut Object<T>, &mut [ZVal]) -> R + Send + Sync,
-    R: SetVal,
+    R: Into<ZVal>,
 {
     fn call(
         &self, execute_data: &mut ExecuteData, arguments: &mut [ZVal], return_value: &mut ZVal,
     ) {
         unsafe {
             let this = execute_data.get_this::<T>().unwrap();
             let r = (self.f)(this, arguments);
-            r.set_val(return_value);
+            *return_value = r.into();
         }
     }
 }
@@ -272,7 +270,7 @@ impl ZendFunction {
             |ret| unsafe {
                 let mut fci = zend_fcall_info {
                     size: size_of::<zend_fcall_info>().try_into().unwrap(),
-                    function_name: ZVal::undef().into_inner(),
+                    function_name: ZVal::from(()).into_inner(),
                     retval: ret.as_mut_ptr(),
                     params: arguments.as_mut_ptr().cast(),
                     object: object_ptr,
@@ -349,7 +347,7 @@ unsafe extern "C" fn invoke(execute_data: *mut zend_execute_data, return_value:
                 ))
             })
             .map_err(crate::Error::Utf8);
-        SetVal::set_val(result, return_value);
+        *return_value = ZVal::from(result);
         return;
     }
 
@@ -426,7 +424,7 @@ pub(crate) const fn create_zend_arg_info(
 /// }
 /// ```
 pub fn call(fn_name: &str, arguments: impl AsMut<[ZVal]>) -> crate::Result<EBox<ZVal>> {
-    let mut func = ZVal::new(fn_name);
+    let mut func = fn_name.into();
     let none: Option<&mut StatelessObject> = None;
     call_internal(&mut func, none, arguments)
 }
@@ -437,7 +435,7 @@ pub(crate) fn call_internal<T: 'static>(
     let func_ptr = func.as_mut_ptr();
     let arguments = arguments.as_mut();
 
-    let mut object_val = ZVal::undef();
+    let mut object_val = ZVal::from(());
     let mut object_val = object.as_mut().map(|o| unsafe {
         phper_zval_obj(object_val.as_mut_ptr(), o.as_mut_ptr());
         &mut object_val
@@ -474,7 +472,7 @@ pub(crate) fn call_raw_common<T: 'static>(
     call_fn: impl FnOnce(&mut ZVal) -> bool, name_fn: impl FnOnce() -> crate::Result<String>,
     object: Option<&mut Object<T>>,
 ) -> crate::Result<EBox<ZVal>> {
-    let mut ret = EBox::new(ZVal::undef());
+    let mut ret = EBox::new(ZVal::from(()));
 
     if call_fn(&mut ret) && !ret.get_type_info().is_undef() {
         return Ok(ret);

phper/src/modules.rs

@@ -17,7 +17,7 @@ use crate::{
     ini::Ini,
     sys::*,
     utils::ensure_end_with_zero,
-    values::{SetVal, ZVal},
+    values::ZVal,
 };
 use std::{
     mem::{replace, size_of, zeroed},
@@ -148,7 +148,7 @@ impl Module {
     pub fn add_function<F, R>(&mut self, name: impl ToString, handler: F, arguments: Vec<Argument>)
     where
         F: Fn(&mut [ZVal]) -> R + Send + Sync + 'static,
-        R: SetVal + 'static,
+        R: Into<ZVal> + 'static,
     {
         self.function_entities.push(FunctionEntity::new(
             name,

phper/src/objects.rs

@@ -196,10 +196,10 @@ impl<T: 'static> Object<T> {
     pub fn call(
         &mut self, method_name: &str, arguments: impl AsMut<[ZVal]>,
     ) -> crate::Result<EBox<ZVal>> {
-        let mut method = ZVal::new(method_name);
+        let mut method = method_name.into();
 
         unsafe {
-            let mut val = ZVal::undef();
+            let mut val = ZVal::from(());
             phper_zval_obj(val.as_mut_ptr(), self.as_mut_ptr());
             call_internal(&mut method, Some(self), arguments)
         }

phper/src/resources.rs

@@ -14,12 +14,17 @@ use crate::sys::*;
 
 /// Wrapper of [crate::sys::zend_resource].
 #[repr(transparent)]
-pub struct Resource {
+pub struct ZRes {
     inner: zend_resource,
 }
 
-impl Resource {
-    /// # Safety
+impl ZRes {
+    pub unsafe fn from_ptr<'a>(ptr: *const zend_resource) -> &'a Self {
+        (ptr as *const Self)
+            .as_ref()
+            .expect("ptr should not be null")
+    }
+
     pub unsafe fn from_mut_ptr<'a>(ptr: *mut zend_resource) -> &'a mut Self {
         (ptr as *mut Self).as_mut().expect("ptr should not be null")
     }

phper/src/strings.rs

@@ -98,9 +98,7 @@ impl ZString {
                 s.len().try_into().unwrap(),
                 false.into(),
             );
-            Self {
-                inner: ZStr::from_mut_ptr(ptr.cast()),
-            }
+            Self::from_raw(ptr)
         }
     }