Refactor Array to Val.

Author: jmjoy

examples/hello/src/lib.rs

@@ -1,9 +1,10 @@
 use phper::{
     arrays::Array,
-    classes::{StdClass, This},
+    classes::StdClass,
     functions::Argument,
     ini::Policy,
     modules::{Module, ModuleArgs},
+    objects::This,
     php_get_module,
     values::{SetVal, Val},
 };

phper-sys/php_wrapper.c

@@ -77,3 +77,7 @@ void phper_zend_string_release(zend_string *s) {
 void phper_zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval *pData) {
     zend_hash_str_update(ht, key, len, pData);
 }
+
+void phper_array_init(zval *arg) {
+    array_init(arg);
+}

phper-sys/php_wrapper.h

@@ -34,6 +34,7 @@ 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);
 
 
 #endif //PHPER_PHP_WRAPPER_H

phper/src/arrays.rs

@@ -12,7 +12,6 @@ impl Array {
     pub fn new() -> Self {
         let mut inner = Box::new(unsafe { zeroed::<zend_array>() });
         unsafe {
-            // TODO should destroy in module shutdown hook.
             _zend_hash_init(&mut *inner, 0, None, true.into());
         }
         Self { inner }
@@ -59,10 +58,10 @@ impl AsMut<zend_array> for Array {
     }
 }
 
-// impl Drop for Array {
-//     fn drop(&mut self) {
-//         unsafe {
-//             zend_hash_graceful_destroy(&mut *self.inner);
-//         }
-//     }
-// }
+impl Drop for Array {
+    fn drop(&mut self) {
+        unsafe {
+            zend_hash_graceful_destroy(&mut *self.inner);
+        }
+    }
+}

phper/src/classes.rs

@@ -1,16 +1,18 @@
-use crate::{
-    functions::{Argument, Callable, FunctionEntity, FunctionEntry, Method},
-    sys::*,
-    values::{SetVal, Val},
-};
-use once_cell::sync::OnceCell;
 use std::{
     mem::zeroed,
     os::raw::c_int,
     ptr::null_mut,
     sync::atomic::{AtomicPtr, Ordering},
 };
 
+use once_cell::sync::OnceCell;
+
+use crate::{
+    functions::{Argument, Callable, FunctionEntity, FunctionEntry, Method},
+    sys::*,
+    values::{SetVal, Val},
+};
+
 pub trait Class: Send + Sync {
     fn methods(&mut self) -> &mut [FunctionEntity];
     fn properties(&mut self) -> &mut [PropertyEntity];
@@ -161,51 +163,6 @@ impl ClassEntity {
     }
 }
 
-pub struct This {
-    val: *mut Val,
-    class: *mut ClassEntry,
-}
-
-impl This {
-    pub(crate) fn new<'a>(val: *mut Val, class: *mut ClassEntry) -> This {
-        assert!(!val.is_null());
-        assert!(!class.is_null());
-        Self { val, class }
-    }
-
-    pub fn get_property(&self, name: impl AsRef<str>) -> &mut Val {
-        let name = name.as_ref();
-
-        let prop = unsafe {
-            #[cfg(phper_major_version = "8")]
-            {
-                zend_read_property(
-                    self.class as *mut _,
-                    (*self.val).inner.value.obj,
-                    name.as_ptr().cast(),
-                    name.len(),
-                    false.into(),
-                    null_mut(),
-                )
-            }
-
-            #[cfg(phper_major_version = "7")]
-            {
-                zend_read_property(
-                    self.class as *mut _,
-                    self.val as *mut _,
-                    name.as_ptr().cast(),
-                    name.len(),
-                    false.into(),
-                    null_mut(),
-                )
-            }
-        };
-
-        unsafe { Val::from_mut(prop) }
-    }
-}
-
 pub struct PropertyEntity {
     name: String,
     value: Box<dyn SetVal + Send + Sync>,

phper/src/functions.rs

@@ -1,15 +1,17 @@
-use crate::{
-    classes::{ClassEntry, This},
-    sys::*,
-    values::{ExecuteData, SetVal, Val},
-};
 use std::{
     mem::zeroed,
     os::raw::c_char,
     ptr::null,
     sync::atomic::{AtomicPtr, Ordering},
 };
 
+use crate::{
+    classes::ClassEntry,
+    objects::This,
+    sys::*,
+    values::{ExecuteData, SetVal, Val},
+};
+
 pub trait Function: Send + Sync {
     fn call(&self, arguments: &mut [Val], return_value: &mut Val);
 }

phper/src/lib.rs

@@ -130,6 +130,7 @@ pub mod functions;
 pub mod ini;
 pub mod logs;
 pub mod modules;
+pub mod objects;
 pub mod strings;
 mod utils;
 pub mod values;

phper/src/modules.rs

@@ -19,11 +19,13 @@ use std::{
 
 static GLOBAL_MODULE: Lazy<RwLock<Module>> = Lazy::new(Default::default);
 
+#[doc(hidden)]
 pub fn read_global_module<R>(f: impl FnOnce(&Module) -> R) -> R {
     let module = (&*GLOBAL_MODULE).read().expect("get write lock failed");
     f(&module)
 }
 
+#[doc(hidden)]
 pub fn write_global_module<R>(f: impl FnOnce(&mut Module) -> R) -> R {
     let mut module = (&*GLOBAL_MODULE).write().expect("get write lock failed");
     f(&mut module)

phper/src/objects.rs

@@ -0,0 +1,47 @@
+use crate::{classes::ClassEntry, sys::*, values::Val};
+use std::ptr::null_mut;
+
+pub struct This {
+    val: *mut Val,
+    class: *mut ClassEntry,
+}
+
+impl This {
+    pub(crate) fn new<'a>(val: *mut Val, class: *mut ClassEntry) -> This {
+        assert!(!val.is_null());
+        assert!(!class.is_null());
+        Self { val, class }
+    }
+
+    pub fn get_property(&self, name: impl AsRef<str>) -> &mut Val {
+        let name = name.as_ref();
+
+        let prop = unsafe {
+            #[cfg(phper_major_version = "8")]
+            {
+                zend_read_property(
+                    self.class as *mut _,
+                    (*self.val).inner.value.obj,
+                    name.as_ptr().cast(),
+                    name.len(),
+                    false.into(),
+                    null_mut(),
+                )
+            }
+
+            #[cfg(phper_major_version = "7")]
+            {
+                zend_read_property(
+                    self.class as *mut _,
+                    self.val as *mut _,
+                    name.as_ptr().cast(),
+                    name.len(),
+                    false.into(),
+                    null_mut(),
+                )
+            }
+        };
+
+        unsafe { Val::from_mut(prop) }
+    }
+}

phper/src/values.rs

@@ -195,7 +195,8 @@ impl SetVal for String {
 impl SetVal for Array {
     fn set_val(&self, val: &mut Val) {
         unsafe {
-            phper_zval_arr(&mut val.inner, self.as_ptr() as *mut _);
+            phper_array_init(val.as_mut());
+            zend_hash_copy((*val.as_mut()).value.arr, self.as_ptr() as *mut _, None);
         }
     }
 }