Rewrite implement SetVal for Array.

Author: jmjoy

examples/hello/src/lib.rs

@@ -51,10 +51,10 @@ pub fn get_module() -> Module {
             let mut arr = Array::new();
 
             let mut hello_enable = Val::new(Module::get_bool_ini("hello.enable"));
-            arr.insert("hello.enable", &mut hello_enable);
+            arr.insert("hello.enable", hello_enable);
 
             let mut hello_description = Val::new(Module::get_str_ini("hello.description"));
-            arr.insert("hello.description", &mut hello_description);
+            arr.insert("hello.description", hello_description);
 
             arr
         },

phper-sys/php_wrapper.c

@@ -80,4 +80,26 @@ void phper_zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval
 
 void phper_array_init(zval *arg) {
     array_init(arg);
-}
+}
+
+void phper_zend_hash_merge_with_key(HashTable *target, HashTable *source) {
+    uint32_t idx;
+    Bucket *p;
+    zval *s;
+
+    for (idx = 0; idx < source->nNumUsed; idx++) {
+        p = source->arData + idx;
+        s = &p->val;
+        if (UNEXPECTED(Z_TYPE_P(s) == IS_INDIRECT)) {
+            s = Z_INDIRECT_P(s);
+        }
+        if (UNEXPECTED(Z_TYPE_P(s) == IS_UNDEF)) {
+            continue;
+        }
+        if (p->key) {
+            zend_hash_str_update(target, ZSTR_VAL(p->key), ZSTR_LEN(p->key), s);
+        } else {
+            zend_hash_index_update(target, p->h, s);
+        }
+    }
+}

phper-sys/php_wrapper.h

@@ -35,6 +35,6 @@ void phper_zend_string_release(zend_string *s);
 void phper_zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval *pData);
 
 void phper_array_init(zval *arg);
-
+void phper_zend_hash_merge_with_key(HashTable *target, HashTable *source);
 
 #endif //PHPER_PHP_WRAPPER_H

phper/src/arrays.rs

@@ -1,5 +1,5 @@
 use crate::{sys::*, values::Val};
-use std::mem::{size_of, zeroed};
+use std::mem::zeroed;
 
 #[repr(transparent)]
 pub struct Array {
@@ -15,6 +15,11 @@ impl Array {
         }
     }
 
+    pub(crate) unsafe fn from_raw<'a>(ptr: *mut zend_array) -> &'a mut Array {
+        let ptr = ptr as *mut Array;
+        ptr.as_mut().expect("ptr shouldn't be null")
+    }
+
     pub fn as_ptr(&self) -> *const zend_array {
         &self.inner
     }
@@ -23,7 +28,7 @@ impl Array {
         &mut self.inner
     }
 
-    pub fn insert(&mut self, key: impl AsRef<str>, value: &mut Val) {
+    pub fn insert(&mut self, key: impl AsRef<str>, mut value: Val) {
         let key = key.as_ref();
         unsafe {
             phper_zend_hash_str_update(

phper/src/classes.rs

@@ -10,7 +10,7 @@ use once_cell::sync::OnceCell;
 use crate::{
     functions::{Argument, Callable, FunctionEntity, FunctionEntry, Method},
     sys::*,
-    values::{SetVal, Val},
+    values::SetVal,
 };
 
 pub trait Class: Send + Sync {

phper/src/functions.rs

@@ -22,7 +22,7 @@ where
     R: SetVal,
 {
     fn call(&self, arguments: &mut [Val], return_value: &mut Val) {
-        let mut r = self(arguments);
+        let r = self(arguments);
         r.set_val(return_value);
     }
 }

phper/src/modules.rs

@@ -7,18 +7,14 @@ use crate::{
     utils::ensure_end_with_zero,
     EXCEPTION_CLASS_NAME,
 };
-use once_cell::sync::Lazy;
 use std::{
     borrow::BorrowMut,
     cell::RefCell,
     collections::HashMap,
     mem::{size_of, zeroed},
     os::raw::{c_int, c_uchar, c_uint, c_ushort},
     ptr::{null, null_mut},
-    sync::{
-        atomic::{AtomicPtr, Ordering},
-        RwLock,
-    },
+    sync::atomic::{AtomicPtr, Ordering},
 };
 
 static GLOBAL_MODULE: AtomicPtr<Module> = AtomicPtr::new(null_mut());

phper/src/types.rs

@@ -1,6 +1,6 @@
 use crate::sys::*;
 use num_traits::cast::FromPrimitive;
-use std::{convert::TryInto, ffi::CStr, os::raw::c_int};
+use std::{ffi::CStr, os::raw::c_int};
 
 #[derive(FromPrimitive, PartialEq)]
 #[repr(u32)]
@@ -13,7 +13,9 @@ pub enum Type {
     Long = IS_LONG,
     Double = IS_DOUBLE,
     String = IS_STRING,
+    StringEx = IS_STRING_EX,
     Array = IS_ARRAY,
+    ArrayEx = IS_ARRAY_EX,
     Object = IS_OBJECT,
     Resource = IS_RESOURCE,
     Reference = IS_REFERENCE,

phper/src/values.rs

@@ -1,17 +1,14 @@
 use crate::{
     arrays::Array,
     errors::Throwable,
+    objects::Object,
     sys::*,
     types::{get_type_by_const, Type},
     utils::ensure_end_with_zero,
     TypeError,
 };
 use std::{
-    mem::zeroed,
-    os::raw::{c_char, c_int},
-    slice::from_raw_parts,
-    str,
-    str::Utf8Error,
+    mem::zeroed, os::raw::c_char, slice::from_raw_parts, str, str::Utf8Error,
     sync::atomic::Ordering,
 };
 
@@ -118,24 +115,21 @@ impl Val {
         &mut self.inner
     }
 
-    pub fn set(&mut self, mut v: impl SetVal) {
+    pub fn set(&mut self, v: impl SetVal) {
         v.set_val(self);
     }
 
-    #[inline]
     fn get_type(&self) -> Type {
         let t = unsafe { self.inner.u1.type_info };
         t.into()
     }
 
     fn get_type_name(&self) -> crate::Result<String> {
-        get_type_by_const(unsafe { self.get_type() as u32 })
+        get_type_by_const(self.get_type() as u32)
     }
 
     fn set_type(&mut self, t: Type) {
-        unsafe {
-            self.inner.u1.type_info = t as u32;
-        }
+        self.inner.u1.type_info = t as u32;
     }
 
     pub fn as_bool(&self) -> crate::Result<bool> {
@@ -167,15 +161,14 @@ impl Val {
     }
 
     pub fn as_string(&self) -> crate::Result<String> {
-        if self.get_type() == Type::String {
-            unsafe {
+        match self.get_type() {
+            Type::String | Type::StringEx => unsafe {
                 let s = self.inner.value.str;
                 let buf = from_raw_parts(&(*s).val as *const c_char as *const u8, (*s).len);
                 let string = str::from_utf8(buf)?.to_string();
                 Ok(string)
-            }
-        } else {
-            Err(self.must_be_type_error("string").into())
+            },
+            _ => Err(self.must_be_type_error("string").into()),
         }
     }
 
@@ -189,7 +182,29 @@ impl Val {
         }
     }
 
-    pub fn as_array(&self) {}
+    pub fn as_array(&self) -> crate::Result<&Array> {
+        match self.get_type() {
+            Type::Array | Type::ArrayEx => unsafe {
+                let ptr = self.inner.value.arr;
+                Ok(Array::from_raw(ptr))
+            },
+            _ => Err(self.must_be_type_error("array").into()),
+        }
+    }
+
+    pub fn as_mut_array(&mut self) -> crate::Result<&mut Array> {
+        match self.get_type() {
+            Type::Array | Type::ArrayEx => unsafe {
+                let ptr = self.inner.value.arr;
+                Ok(Array::from_raw(ptr))
+            },
+            _ => Err(self.must_be_type_error("array").into()),
+        }
+    }
+
+    pub fn as_object(&self) -> crate::Result<Object> {
+        todo!()
+    }
 
     fn must_be_type_error(&self, expect_type: &str) -> crate::Error {
         match self.get_type_name() {
@@ -200,6 +215,16 @@ impl Val {
             Err(e) => e.into(),
         }
     }
+
+    fn deep_copy(&self, other: &mut Val) -> crate::Result<()> {
+        match self.get_type() {
+            Type::Null => SetVal::set_val((), other),
+            Type::Long => SetVal::set_val(self.as_i64()?, other),
+            Type::String | Type::StringEx => SetVal::set_val(self.as_string()?, other),
+            _ => unreachable!(),
+        }
+        Ok(())
+    }
 }
 
 pub trait SetVal {
@@ -267,18 +292,18 @@ impl SetVal for String {
 impl SetVal for Array {
     fn set_val(mut self, val: &mut Val) {
         unsafe {
-            let mut new_val = Val::empty();
-            phper_zval_arr(new_val.as_mut_ptr(), self.as_mut_ptr());
-            phper_zval_zval(
-                val.as_mut_ptr(),
-                new_val.as_mut_ptr(),
-                true.into(),
-                false.into(),
-            );
+            phper_array_init(val.as_mut_ptr());
+            phper_zend_hash_merge_with_key((*val.as_mut_ptr()).value.arr, self.as_mut_ptr());
         }
     }
 }
 
+extern "C" fn array_copy_ctor(zv: *mut zval) {
+    let val = unsafe { Val::from_mut(zv) };
+    let other = unsafe { Val::from_mut(zv) };
+    val.deep_copy(other).expect("deep copy failed");
+}
+
 impl<T: SetVal> SetVal for Option<T> {
     fn set_val(self, val: &mut Val) {
         match self {

tests/integration/src/values.rs

@@ -1,4 +1,4 @@
-use phper::{modules::Module, values::Val};
+use phper::{arrays::Array, modules::Module, values::Val};
 
 pub fn integrate(module: &mut Module) {
     integrate_returns(module);
@@ -10,24 +10,90 @@ fn integrate_returns(module: &mut Module) {
         integration_values_return_null,
         vec![],
     );
+    module.add_function(
+        "integration_values_return_true",
+        integration_values_return_true,
+        vec![],
+    );
+    module.add_function(
+        "integration_values_return_false",
+        integration_values_return_false,
+        vec![],
+    );
     module.add_function(
         "integration_values_return_i32",
         integration_values_return_i32,
         vec![],
     );
+    module.add_function(
+        "integration_values_return_u32",
+        integration_values_return_u32,
+        vec![],
+    );
     module.add_function(
         "integration_values_return_i64",
         integration_values_return_i64,
         vec![],
     );
+    module.add_function(
+        "integration_values_return_f64",
+        integration_values_return_f64,
+        vec![],
+    );
+    module.add_function(
+        "integration_values_return_str",
+        integration_values_return_str,
+        vec![],
+    );
+    module.add_function(
+        "integration_values_return_string",
+        integration_values_return_string,
+        vec![],
+    );
+    module.add_function(
+        "integration_values_return_array",
+        integration_values_return_array,
+        vec![],
+    );
 }
 
 fn integration_values_return_null(_: &mut [Val]) {}
 
+fn integration_values_return_true(_: &mut [Val]) -> bool {
+    true
+}
+
+fn integration_values_return_false(_: &mut [Val]) -> bool {
+    false
+}
+
 fn integration_values_return_i32(_: &mut [Val]) -> i32 {
     32
 }
 
+fn integration_values_return_u32(_: &mut [Val]) -> u32 {
+    32
+}
+
 fn integration_values_return_i64(_: &mut [Val]) -> i64 {
     64
 }
+
+fn integration_values_return_f64(_: &mut [Val]) -> f64 {
+    64.0
+}
+
+fn integration_values_return_str(_: &mut [Val]) -> &'static str {
+    "foo"
+}
+
+fn integration_values_return_string(_: &mut [Val]) -> String {
+    "foo".to_string()
+}
+
+fn integration_values_return_array(_: &mut [Val]) -> Array {
+    let mut arr = Array::new();
+    arr.insert("a", Val::new(1));
+    arr.insert("b", Val::new("foo"));
+    arr
+}