Chanage trait SetVal api.

jmjoy · jmjoy · commit 460574941ece · 2021-04-24T15:16:15.000+08:00
diff --git a/examples/hello/src/lib.rs b/examples/hello/src/lib.rs
@@ -75,7 +75,7 @@ pub fn get_module(module: &mut Module) {
         "setFoo",
         |this: &mut Object, arguments: &mut [Val]| {
             let prop = this.get_property("foo");
-            prop.set(&arguments[0]);
+            prop.set(&mut arguments[0]);
         },
         vec![Argument::by_val("foo")],
     );
diff --git a/phper/src/arrays.rs b/phper/src/arrays.rs
@@ -1,67 +1,59 @@
 use crate::{sys::*, values::Val};
-use std::{
-    mem::zeroed,
-    ops::{Deref, DerefMut},
-};
+use std::mem::size_of;
 
 pub struct Array {
-    inner: Box<zend_array>,
+    inner: *mut zend_array,
+    leak: bool,
 }
 
 impl Array {
     pub fn new() -> Self {
-        let mut inner = Box::new(unsafe { zeroed::<zend_array>() });
         unsafe {
-            _zend_hash_init(&mut *inner, 0, None, true.into());
+            let inner = _emalloc(size_of::<zend_array>()).cast();
+            _zend_hash_init(inner, 0, None, true.into());
+            Self { inner, leak: false }
         }
-        Self { inner }
     }
 
     pub fn as_ptr(&self) -> *const zend_array {
-        self.inner.deref()
+        self.inner
+    }
+
+    pub fn as_mut_ptr(&mut self) -> *mut zend_array {
+        self.inner
     }
 
     pub fn insert(&mut self, key: impl AsRef<str>, value: &mut Val) {
         let key = key.as_ref();
         unsafe {
-            phper_zend_hash_str_update(
-                self.inner.deref_mut(),
-                key.as_ptr().cast(),
-                key.len(),
-                value.as_mut(),
-            );
+            phper_zend_hash_str_update(self.inner, key.as_ptr().cast(), key.len(), value.as_mut());
         }
     }
 
     pub fn get(&mut self, key: impl AsRef<str>) -> &mut Val {
         let key = key.as_ref();
         unsafe {
-            let value = zend_hash_str_find(&mut *self.inner, key.as_ptr().cast(), key.len());
+            let value = zend_hash_str_find(self.inner, key.as_ptr().cast(), key.len());
             Val::from_mut(value)
         }
     }
 
     pub fn len(&mut self) -> usize {
-        unsafe { zend_array_count(&mut *self.inner) as usize }
-    }
-}
-
-impl AsRef<zend_array> for Array {
-    fn as_ref(&self) -> &zend_array {
-        self.inner.deref()
+        unsafe { zend_array_count(self.inner) as usize }
     }
-}
 
-impl AsMut<zend_array> for Array {
-    fn as_mut(&mut self) -> &mut zend_array {
-        self.inner.deref_mut()
+    pub(crate) fn leak(&mut self) -> &mut bool {
+        &mut self.leak
     }
 }
 
 impl Drop for Array {
     fn drop(&mut self) {
         unsafe {
-            zend_hash_graceful_destroy(&mut *self.inner);
+            if !self.leak {
+                zend_hash_destroy(self.inner);
+                _efree(self.inner.cast());
+            }
         }
     }
 }
diff --git a/phper/src/classes.rs b/phper/src/classes.rs
@@ -137,7 +137,7 @@ impl ClassEntity {
         let properties = self.class.properties();
         for property in properties {
             let mut val = Val::null();
-            val.set(&property.value);
+            val.set(&mut property.value);
             zend_declare_property(
                 self.entry.load(Ordering::SeqCst).cast(),
                 property.name.as_ptr().cast(),
diff --git a/phper/src/functions.rs b/phper/src/functions.rs
@@ -22,7 +22,7 @@ where
     R: SetVal,
 {
     fn call(&self, arguments: &mut [Val], return_value: &mut Val) {
-        let r = self(arguments);
+        let mut r = self(arguments);
         r.set_val(return_value);
     }
 }
@@ -37,7 +37,7 @@ where
     R: SetVal,
 {
     fn call(&self, this: &mut Object, arguments: &mut [Val], return_value: &mut Val) {
-        let r = self(this, arguments);
+        let mut r = self(this, arguments);
         r.set_val(return_value);
     }
 }
diff --git a/phper/src/values.rs b/phper/src/values.rs
@@ -84,7 +84,7 @@ impl Val {
 
     pub fn null() -> Self {
         let mut val = Self::empty();
-        val.set(&());
+        val.set(());
         val
     }
 
@@ -94,7 +94,7 @@ impl Val {
         val
     }
 
-    pub fn from_val(other: &Val) -> Self {
+    pub fn from_val(other: &mut Val) -> Self {
         let mut val = Self::empty();
         val.set(other);
         val
@@ -104,7 +104,7 @@ impl Val {
         &mut self.inner
     }
 
-    pub fn set(&mut self, v: impl SetVal) {
+    pub fn set(&mut self, mut v: impl SetVal) {
         v.set_val(self);
     }
 
@@ -127,39 +127,39 @@ impl Val {
 }
 
 pub trait SetVal {
-    fn set_val(&self, val: &mut Val);
+    fn set_val(&mut self, val: &mut Val);
 }
 
 impl SetVal for () {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         unsafe {
             *val.type_info() = IS_NULL;
         }
     }
 }
 
 impl SetVal for bool {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         unsafe {
             *val.type_info() = if *self { IS_TRUE } else { IS_FALSE };
         }
     }
 }
 
 impl SetVal for i32 {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         (*self as i64).set_val(val)
     }
 }
 
 impl SetVal for u32 {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         (*self as i64).set_val(val)
     }
 }
 
 impl SetVal for i64 {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         unsafe {
             (*val.as_mut()).value.lval = *self;
             (*val.as_mut()).u1.type_info = IS_LONG;
@@ -168,7 +168,7 @@ impl SetVal for i64 {
 }
 
 impl SetVal for f64 {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         unsafe {
             (*val.as_mut()).value.dval = *self;
             (*val.as_mut()).u1.type_info = IS_DOUBLE;
@@ -177,32 +177,34 @@ impl SetVal for f64 {
 }
 
 impl SetVal for str {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         unsafe {
             phper_zval_stringl(val.as_mut(), self.as_ptr().cast(), self.len());
         }
     }
 }
 
 impl SetVal for String {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         unsafe {
             phper_zval_stringl(val.as_mut(), self.as_ptr().cast(), self.len());
         }
     }
 }
 
 impl SetVal for Array {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         unsafe {
-            phper_array_init(val.as_mut());
-            zend_hash_copy((*val.as_mut()).value.arr, self.as_ptr() as *mut _, None);
+            let mut new_val = zeroed::<zval>();
+            phper_zval_arr(&mut new_val, self.as_mut_ptr());
+            *self.leak() = true;
+            phper_zval_zval(val.as_mut(), &mut new_val, true.into(), false.into());
         }
     }
 }
 
 impl<T: SetVal> SetVal for Option<T> {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         match self {
             Some(t) => t.set_val(val),
             None => ().set_val(val),
@@ -211,7 +213,7 @@ impl<T: SetVal> SetVal for Option<T> {
 }
 
 impl<T: SetVal, E: Throwable> SetVal for Result<T, E> {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         match self {
             Ok(t) => t.set_val(val),
             Err(e) => unsafe {
@@ -232,27 +234,21 @@ impl<T: SetVal, E: Throwable> SetVal for Result<T, E> {
 }
 
 impl SetVal for Val {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         unsafe {
-            phper_zval_copy_value(val.as_mut(), &self.inner as *const _ as *mut _);
+            phper_zval_copy_value(val.as_mut(), &mut self.inner);
         }
     }
 }
 
 impl<T: SetVal + ?Sized> SetVal for Box<T> {
-    fn set_val(&self, val: &mut Val) {
-        T::set_val(&self, val)
-    }
-}
-
-impl<T: SetVal + ?Sized> SetVal for &T {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         T::set_val(self, val)
     }
 }
 
 impl<T: SetVal + ?Sized> SetVal for &mut T {
-    fn set_val(&self, val: &mut Val) {
+    fn set_val(&mut self, val: &mut Val) {
         T::set_val(self, val)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ where`
`22`	`22`	`R: SetVal,`
`23`	`23`	`{`
`24`	`24`	`fn call(&self, arguments: &mut [Val], return_value: &mut Val) {`
`25`		`- let r = self(arguments);`
	`25`	`+ let mut r = self(arguments);`
`26`	`26`	`r.set_val(return_value);`
`27`	`27`	`}`
`28`	`28`	`}`
`@@ -37,7 +37,7 @@ where`
`37`	`37`	`R: SetVal,`
`38`	`38`	`{`
`39`	`39`	`fn call(&self, this: &mut Object, arguments: &mut [Val], return_value: &mut Val) {`
`40`		`- let r = self(this, arguments);`
	`40`	`+ let mut r = self(this, arguments);`
`41`	`41`	`r.set_val(return_value);`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ impl Val {`
`84`	`84`
`85`	`85`	`pub fn null() -> Self {`
`86`	`86`	`let mut val = Self::empty();`
`87`		`- val.set(&());`
	`87`	`+ val.set(());`
`88`	`88`	`val`
`89`	`89`	`}`
`90`	`90`
`@@ -94,7 +94,7 @@ impl Val {`
`94`	`94`	`val`
`95`	`95`	`}`
`96`	`96`
`97`		`- pub fn from_val(other: &Val) -> Self {`
	`97`	`+ pub fn from_val(other: &mut Val) -> Self {`
`98`	`98`	`let mut val = Self::empty();`
`99`	`99`	`val.set(other);`
`100`	`100`	`val`
`@@ -104,7 +104,7 @@ impl Val {`
`104`	`104`	`&mut self.inner`
`105`	`105`	`}`
`106`	`106`
`107`		`- pub fn set(&mut self, v: impl SetVal) {`
	`107`	`+ pub fn set(&mut self, mut v: impl SetVal) {`
`108`	`108`	`v.set_val(self);`
`109`	`109`	`}`
`110`	`110`
`@@ -127,39 +127,39 @@ impl Val {`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`pub trait SetVal {`
`130`		`- fn set_val(&self, val: &mut Val);`
	`130`	`+ fn set_val(&mut self, val: &mut Val);`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`impl SetVal for () {`
`134`		`- fn set_val(&self, val: &mut Val) {`
	`134`	`+ fn set_val(&mut self, val: &mut Val) {`
`135`	`135`	`unsafe {`
`136`	`136`	`*val.type_info() = IS_NULL;`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`impl SetVal for bool {`
`142`		`- fn set_val(&self, val: &mut Val) {`
	`142`	`+ fn set_val(&mut self, val: &mut Val) {`
`143`	`143`	`unsafe {`
`144`	`144`	`val.type_info() = if self { IS_TRUE } else { IS_FALSE };`
`145`	`145`	`}`
`146`	`146`	`}`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`impl SetVal for i32 {`
`150`		`- fn set_val(&self, val: &mut Val) {`
	`150`	`+ fn set_val(&mut self, val: &mut Val) {`
`151`	`151`	`(*self as i64).set_val(val)`
`152`	`152`	`}`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`impl SetVal for u32 {`
`156`		`- fn set_val(&self, val: &mut Val) {`
	`156`	`+ fn set_val(&mut self, val: &mut Val) {`
`157`	`157`	`(*self as i64).set_val(val)`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`	`161`	`impl SetVal for i64 {`
`162`		`- fn set_val(&self, val: &mut Val) {`
	`162`	`+ fn set_val(&mut self, val: &mut Val) {`
`163`	`163`	`unsafe {`
`164`	`164`	`(val.as_mut()).value.lval = self;`
`165`	`165`	`(*val.as_mut()).u1.type_info = IS_LONG;`
`@@ -168,7 +168,7 @@ impl SetVal for i64 {`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`impl SetVal for f64 {`
`171`		`- fn set_val(&self, val: &mut Val) {`
	`171`	`+ fn set_val(&mut self, val: &mut Val) {`
`172`	`172`	`unsafe {`
`173`	`173`	`(val.as_mut()).value.dval = self;`
`174`	`174`	`(*val.as_mut()).u1.type_info = IS_DOUBLE;`
`@@ -177,32 +177,34 @@ impl SetVal for f64 {`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`impl SetVal for str {`
`180`		`- fn set_val(&self, val: &mut Val) {`
	`180`	`+ fn set_val(&mut self, val: &mut Val) {`
`181`	`181`	`unsafe {`
`182`	`182`	`phper_zval_stringl(val.as_mut(), self.as_ptr().cast(), self.len());`
`183`	`183`	`}`
`184`	`184`	`}`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`impl SetVal for String {`
`188`		`- fn set_val(&self, val: &mut Val) {`
	`188`	`+ fn set_val(&mut self, val: &mut Val) {`
`189`	`189`	`unsafe {`
`190`	`190`	`phper_zval_stringl(val.as_mut(), self.as_ptr().cast(), self.len());`
`191`	`191`	`}`
`192`	`192`	`}`
`193`	`193`	`}`
`194`	`194`
`195`	`195`	`impl SetVal for Array {`
`196`		`- fn set_val(&self, val: &mut Val) {`
	`196`	`+ fn set_val(&mut self, val: &mut Val) {`
`197`	`197`	`unsafe {`
`198`		`- phper_array_init(val.as_mut());`
`199`		`- zend_hash_copy((val.as_mut()).value.arr, self.as_ptr() as mut _, None);`
	`198`	`+ let mut new_val = zeroed::<zval>();`
	`199`	`+ phper_zval_arr(&mut new_val, self.as_mut_ptr());`
	`200`	`+ *self.leak() = true;`
	`201`	`+ phper_zval_zval(val.as_mut(), &mut new_val, true.into(), false.into());`
`200`	`202`	`}`
`201`	`203`	`}`
`202`	`204`	`}`
`203`	`205`
`204`	`206`	`impl<T: SetVal> SetVal for Option<T> {`
`205`		`- fn set_val(&self, val: &mut Val) {`
	`207`	`+ fn set_val(&mut self, val: &mut Val) {`
`206`	`208`	`match self {`
`207`	`209`	`Some(t) => t.set_val(val),`
`208`	`210`	`None => ().set_val(val),`
`@@ -211,7 +213,7 @@ impl<T: SetVal> SetVal for Option<T> {`
`211`	`213`	`}`
`212`	`214`
`213`	`215`	`impl<T: SetVal, E: Throwable> SetVal for Result<T, E> {`
`214`		`- fn set_val(&self, val: &mut Val) {`
	`216`	`+ fn set_val(&mut self, val: &mut Val) {`
`215`	`217`	`match self {`
`216`	`218`	`Ok(t) => t.set_val(val),`
`217`	`219`	`Err(e) => unsafe {`
`@@ -232,27 +234,21 @@ impl<T: SetVal, E: Throwable> SetVal for Result<T, E> {`
`232`	`234`	`}`
`233`	`235`
`234`	`236`	`impl SetVal for Val {`
`235`		`- fn set_val(&self, val: &mut Val) {`
	`237`	`+ fn set_val(&mut self, val: &mut Val) {`
`236`	`238`	`unsafe {`
`237`		`- phper_zval_copy_value(val.as_mut(), &self.inner as const _ as mut _);`
	`239`	`+ phper_zval_copy_value(val.as_mut(), &mut self.inner);`
`238`	`240`	`}`
`239`	`241`	`}`
`240`	`242`	`}`
`241`	`243`
`242`	`244`	`impl<T: SetVal + ?Sized> SetVal for Box<T> {`
`243`		`- fn set_val(&self, val: &mut Val) {`
`244`		`- T::set_val(&self, val)`
`245`		`- }`
`246`		`-}`
`247`		`-`
`248`		`-impl<T: SetVal + ?Sized> SetVal for &T {`
`249`		`- fn set_val(&self, val: &mut Val) {`
	`245`	`+ fn set_val(&mut self, val: &mut Val) {`
`250`	`246`	`T::set_val(self, val)`
`251`	`247`	`}`
`252`	`248`	`}`
`253`	`249`
`254`	`250`	`impl<T: SetVal + ?Sized> SetVal for &mut T {`
`255`		`- fn set_val(&self, val: &mut Val) {`
	`251`	`+ fn set_val(&mut self, val: &mut Val) {`
`256`	`252`	`T::set_val(self, val)`
`257`	`253`	`}`
`258`	`254`	`}`