Modify some values apis.

Author: jmjoy

examples/hello/src/lib.rs

@@ -1,12 +1,13 @@
 use phper::{
+    alloc::EBox,
     arrays::Array,
     classes::StdClass,
     functions::Argument,
     ini::Policy,
     modules::{Module, ModuleArgs},
     objects::Object,
     php_get_module,
-    values::{SetVal, Val},
+    values::Val,
 };
 
 fn module_init(_args: ModuleArgs) -> bool {
@@ -56,7 +57,7 @@ pub fn get_module() -> Module {
             let mut hello_description = Val::new(Module::get_str_ini("hello.description"));
             arr.insert("hello.description", hello_description);
 
-            arr
+            EBox::new(arr)
         },
         vec![],
     );

examples/http-client/src/lib.rs

@@ -11,7 +11,7 @@ pub fn get_module() -> Module {
         env!("CARGO_PKG_AUTHORS"),
     );
 
-    let client = HttpClient::new();
+    // let client = HttpClient::new();
     let client_class = StdClass::new();
     module.add_class("HttpClient", client_class);
 

examples/log/tests/integration.rs

@@ -1,5 +1,5 @@
 use phper_test::test_php_scripts_with_condition;
-use std::{env, path::Path, process::Output, str};
+use std::{env, path::Path, str};
 
 #[test]
 fn test_php() {

phper-alloc/src/lib.rs

@@ -29,6 +29,10 @@ impl<T> EBox<T> {
         }
     }
 
+    pub unsafe fn from_raw(raw: *mut T) -> Self {
+        Self { ptr: raw }
+    }
+
     pub fn into_raw(b: EBox<T>) -> *mut T {
         let ptr = b.ptr;
         forget(b);

phper/src/arrays.rs

@@ -10,12 +10,12 @@ impl Array {
     pub fn new() -> Self {
         unsafe {
             let mut array = zeroed::<Array>();
-            _zend_hash_init(&mut array.inner, 0, None, true.into());
+            _zend_hash_init(array.as_mut_ptr(), 0, None, false.into());
             array
         }
     }
 
-    pub(crate) unsafe fn from_raw<'a>(ptr: *mut zend_array) -> &'a mut Array {
+    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_array) -> &'a mut Array {
         let ptr = ptr as *mut Array;
         ptr.as_mut().expect("ptr shouldn't be null")
     }

phper/src/classes.rs

@@ -1,15 +1,14 @@
 use crate::{
-    arrays::Array,
     functions::{Argument, Callable, FunctionEntity, FunctionEntry, Method},
     sys::*,
-    utils::ensure_end_with_zero,
-    values::SetVal,
+    values::{SetVal, Val},
 };
 use once_cell::sync::OnceCell;
 use std::{
     mem::zeroed,
     os::raw::c_int,
-    ptr::{null, null_mut},
+    ptr::null_mut,
+    rc::Rc,
     sync::atomic::{AtomicPtr, Ordering},
 };
 
@@ -175,13 +174,15 @@ impl ClassEntity {
 pub struct PropertyEntity {
     name: String,
     value: Box<dyn SetVal + Send + Sync>,
+    _x: Val,
 }
 
 impl PropertyEntity {
     pub fn new(name: impl ToString, value: impl SetVal + Send + Sync + 'static) -> Self {
         Self {
             name: name.to_string(),
             value: Box::new(value),
+            _x: Val::null(),
         }
     }
 }

phper/src/functions.rs

@@ -1,8 +1,4 @@
-use std::{
-    mem::zeroed,
-    os::raw::c_char,
-    sync::atomic::{AtomicPtr, Ordering},
-};
+use std::{mem::zeroed, os::raw::c_char, sync::atomic::AtomicPtr};
 
 use crate::{
     classes::ClassEntry,
@@ -37,7 +33,7 @@ where
     R: SetVal,
 {
     fn call(&self, this: &mut Object, arguments: &mut [Val], return_value: &mut Val) {
-        let mut r = self(this, arguments);
+        let r = self(this, arguments);
         r.set_val(return_value);
     }
 }
@@ -177,10 +173,10 @@ pub(crate) unsafe extern "C" fn invoke(
         Callable::Function(f) => {
             f.call(&mut arguments, return_value);
         }
-        Callable::Method(m, class) => {
-            let mut this = execute_data.get_this();
+        Callable::Method(m, _class) => {
+            let this = execute_data.get_this();
             let this = this.as_mut().expect("this should not be null");
-            assert!(this.is_object());
+            assert!(this.get_type().is_object());
             m.call(
                 Object::from_mut_ptr(this.inner.value.obj),
                 &mut arguments,

phper/src/objects.rs

@@ -1,14 +1,10 @@
 use crate::{
-    classes::{get_global_class_entry_ptr, ClassEntry},
+    classes::get_global_class_entry_ptr,
     sys::*,
     values::{SetVal, Val},
     ClassNotFoundError,
 };
-use std::{
-    mem::zeroed,
-    ptr::null_mut,
-    sync::atomic::{AtomicPtr, Ordering},
-};
+use std::{mem::zeroed, ptr::null_mut};
 
 /// Wrapper of [crate::sys::zend_object].
 #[repr(transparent)]

phper/src/strings.rs

@@ -1,6 +1,22 @@
 use crate::sys::*;
 
+/// Wrapper of [crate::sys::zend_string].
 #[repr(transparent)]
 pub struct ZendString {
     inner: zend_string,
 }
+
+impl ZendString {
+    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_array) -> &'a mut Self {
+        let ptr = ptr as *mut Self;
+        ptr.as_mut().expect("ptr shouldn't be null")
+    }
+
+    pub fn as_ptr(&self) -> *const zend_string {
+        &self.inner
+    }
+
+    pub fn as_mut_ptr(&mut self) -> *mut zend_string {
+        &mut self.inner
+    }
+}

phper/src/types.rs

@@ -2,7 +2,7 @@ use crate::sys::*;
 use num_traits::cast::FromPrimitive;
 use std::{ffi::CStr, os::raw::c_int};
 
-#[derive(FromPrimitive, PartialEq)]
+#[derive(FromPrimitive, PartialEq, Clone, Copy)]
 #[repr(u32)]
 #[non_exhaustive]
 pub enum Type {
@@ -24,6 +24,53 @@ pub enum Type {
     IsCallable = IS_CALLABLE,
 }
 
+impl Type {
+    #[inline]
+    pub fn is_null(self) -> bool {
+        self == Type::Null
+    }
+
+    #[inline]
+    pub fn is_bool(self) -> bool {
+        matches!(self, Type::True | Type::False)
+    }
+
+    #[inline]
+    pub fn is_true(self) -> bool {
+        self == Type::True
+    }
+
+    #[inline]
+    pub fn is_false(self) -> bool {
+        self == Type::False
+    }
+
+    #[inline]
+    pub fn is_long(self) -> bool {
+        self == Type::Long
+    }
+
+    #[inline]
+    pub fn is_double(self) -> bool {
+        self == Type::Double
+    }
+
+    #[inline]
+    pub fn is_string(self) -> bool {
+        matches!(self, Type::String | Type::StringEx)
+    }
+
+    #[inline]
+    pub fn is_array(self) -> bool {
+        matches!(self, Type::Array | Type::ArrayEx)
+    }
+
+    #[inline]
+    pub fn is_object(self) -> bool {
+        matches!(self, Type::Object | Type::ObjectEx)
+    }
+}
+
 impl From<u32> for Type {
     fn from(n: u32) -> Self {
         match FromPrimitive::from_u32(n) {