Modify Object and Ebox, implement SetVal for EBox<Object>.

Author: jmjoy

phper-alloc/src/lib.rs

@@ -7,12 +7,53 @@ Alloc related items for [phper](https://crates.io/crates/phper).
 [Unlicense](https://github.com/jmjoy/phper/blob/master/LICENSE).
 */
 
+use phper_sys::*;
+use std::{
+    mem::{forget, size_of},
+    ops::{Deref, DerefMut},
+};
+
 /// The Box which use php `emalloc` and `efree` to manage memory.
 ///
-/// TODO now feature `allocator_api` is still unstable, using global allocator instead.
-pub type EBox<T> = Box<T>;
+/// TODO now feature `allocator_api` is still unstable, implement myself.
+pub struct EBox<T> {
+    ptr: *mut T,
+}
 
-/// The Vec which use php `emalloc` and `efree` to manage memory.
-///
-/// TODO now feature `allocator_api` is still unstable, using global allocator instead.
-pub type EVec<T> = Vec<T>;
+impl<T> EBox<T> {
+    pub fn new(x: T) -> Self {
+        unsafe {
+            let ptr: *mut T = _emalloc(size_of::<T>()).cast();
+            ptr.write(x);
+            Self { ptr }
+        }
+    }
+
+    pub fn into_raw(b: EBox<T>) -> *mut T {
+        let ptr = b.ptr;
+        forget(b);
+        ptr
+    }
+}
+
+impl<T> Deref for EBox<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        unsafe { self.ptr.as_ref().unwrap() }
+    }
+}
+
+impl<T> DerefMut for EBox<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe { self.ptr.as_mut().unwrap() }
+    }
+}
+
+impl<T> Drop for EBox<T> {
+    fn drop(&mut self) {
+        unsafe {
+            _efree(self.ptr.cast());
+        }
+    }
+}

phper/src/arrays.rs

@@ -44,7 +44,7 @@ impl Array {
         let key = key.as_ref();
         unsafe {
             let value = zend_hash_str_find(&mut self.inner, key.as_ptr().cast(), key.len());
-            Val::from_mut(value)
+            Val::from_mut_ptr(value)
         }
     }
 

phper/src/classes.rs

@@ -1,17 +1,17 @@
-use std::{
-    mem::zeroed,
-    os::raw::c_int,
-    ptr::null_mut,
-    sync::atomic::{AtomicPtr, Ordering},
-};
-
-use once_cell::sync::OnceCell;
-
 use crate::{
+    arrays::Array,
     functions::{Argument, Callable, FunctionEntity, FunctionEntry, Method},
     sys::*,
+    utils::ensure_end_with_zero,
     values::SetVal,
 };
+use once_cell::sync::OnceCell;
+use std::{
+    mem::zeroed,
+    os::raw::c_int,
+    ptr::{null, null_mut},
+    sync::atomic::{AtomicPtr, Ordering},
+};
 
 pub trait Class: Send + Sync {
     fn methods(&mut self) -> &mut [FunctionEntity];
@@ -82,7 +82,15 @@ pub struct ClassEntry {
 }
 
 impl ClassEntry {
-    pub fn as_mut(&mut self) -> *mut zend_class_entry {
+    pub fn from_ptr<'a>(ptr: *const zend_class_entry) -> &'a Self {
+        unsafe { (ptr as *const Self).as_ref() }.expect("ptr should not be null")
+    }
+
+    pub fn as_ptr(&self) -> *const zend_class_entry {
+        &self.inner
+    }
+
+    pub fn as_mut_ptr(&mut self) -> *mut zend_class_entry {
         &mut self.inner
     }
 }
@@ -185,3 +193,15 @@ pub enum Visibility {
     Protected = ZEND_ACC_PROTECTED,
     Private = ZEND_ACC_PRIVATE,
 }
+
+pub(crate) fn get_global_class_entry_ptr(name: impl AsRef<str>) -> *mut zend_class_entry {
+    let name = name.as_ref();
+    unsafe {
+        zend_hash_str_find_ptr_lc(
+            compiler_globals.class_table,
+            name.as_ptr().cast(),
+            name.len(),
+        )
+        .cast()
+    }
+}

phper/src/errors.rs

@@ -20,6 +20,9 @@ pub enum Error {
     #[error(transparent)]
     TypeError(#[from] TypeError),
 
+    #[error(transparent)]
+    ClassNotFound(#[from] ClassNotFoundError),
+
     #[error(transparent)]
     Other(#[from] anyhow::Error),
 }
@@ -34,7 +37,7 @@ impl Error {
 
 /// PHP type error.
 #[derive(thiserror::Error, Debug)]
-#[error("{message}")]
+#[error("type error: {message}")]
 pub struct TypeError {
     message: String,
 }
@@ -45,6 +48,18 @@ impl TypeError {
     }
 }
 
+#[derive(thiserror::Error, Debug)]
+#[error("class `{class_name}` not found")]
+pub struct ClassNotFoundError {
+    class_name: String,
+}
+
+impl ClassNotFoundError {
+    pub fn new(class_name: String) -> Self {
+        Self { class_name }
+    }
+}
+
 /// PHP Throwable, can cause throwing an exception when setting to [crate::values::Val].
 pub trait Throwable: error::Error {
     fn class_entity(&self) -> *const ClassEntity;

phper/src/functions.rs

@@ -151,7 +151,7 @@ pub(crate) unsafe extern "C" fn invoke(
     return_value: *mut zval,
 ) {
     let execute_data = ExecuteData::from_mut(execute_data);
-    let return_value = Val::from_mut(return_value);
+    let return_value = Val::from_mut_ptr(return_value);
 
     let num_args = execute_data.common_num_args();
     let arg_info = execute_data.common_arg_info();
@@ -178,8 +178,14 @@ pub(crate) unsafe extern "C" fn invoke(
             f.call(&mut arguments, return_value);
         }
         Callable::Method(m, class) => {
-            let mut this = Object::new(execute_data.get_this(), class.load(Ordering::SeqCst));
-            m.call(&mut this, &mut arguments, return_value);
+            let mut this = execute_data.get_this();
+            let this = this.as_mut().expect("this should not be null");
+            assert!(this.is_object());
+            m.call(
+                Object::from_mut_ptr(this.inner.value.obj),
+                &mut arguments,
+                return_value,
+            );
         }
     }
 }

phper/src/objects.rs

@@ -1,16 +1,53 @@
-use crate::{classes::ClassEntry, sys::*, values::Val};
-use std::ptr::null_mut;
+use crate::{
+    classes::{get_global_class_entry_ptr, ClassEntry},
+    sys::*,
+    values::{SetVal, Val},
+    ClassNotFoundError,
+};
+use std::{
+    mem::zeroed,
+    ptr::null_mut,
+    sync::atomic::{AtomicPtr, Ordering},
+};
 
+/// Wrapper of [crate::sys::zend_object].
+#[repr(transparent)]
 pub struct Object {
-    val: *mut Val,
-    class: *mut ClassEntry,
+    inner: zend_object,
 }
 
 impl Object {
-    pub(crate) fn new<'a>(val: *mut Val, class: *mut ClassEntry) -> Object {
-        assert!(!val.is_null());
-        assert!(!class.is_null());
-        Self { val, class }
+    pub fn new(class_name: impl AsRef<str>) -> Result<Self, ClassNotFoundError> {
+        unsafe {
+            let mut object = zeroed::<Object>();
+            let class_name = class_name.as_ref();
+            let ce = get_global_class_entry_ptr(class_name);
+            if ce.is_null() {
+                Err(ClassNotFoundError::new(class_name.to_string()))
+            } else {
+                zend_object_std_init(object.as_mut_ptr(), ce);
+                object.inner.handlers = &std_object_handlers;
+                Ok(object)
+            }
+        }
+    }
+
+    pub fn new_std() -> Self {
+        Self::new("stdClass").expect("stdClass not found")
+    }
+
+    pub unsafe fn from_mut_ptr<'a>(ptr: *mut zend_object) -> &'a mut Object {
+        (ptr as *mut Object)
+            .as_mut()
+            .expect("ptr should not be null")
+    }
+
+    pub fn as_ptr(&self) -> *const zend_object {
+        &self.inner
+    }
+
+    pub fn as_mut_ptr(&mut self) -> *mut zend_object {
+        &mut self.inner
     }
 
     pub fn get_property(&self, name: impl AsRef<str>) -> &mut Val {
@@ -20,8 +57,8 @@ impl Object {
             #[cfg(phper_major_version = "8")]
             {
                 zend_read_property(
-                    self.class as *mut _,
-                    (*self.val).inner.value.obj,
+                    self.inner.ce,
+                    &self.inner as *const _ as *mut _,
                     name.as_ptr().cast(),
                     name.len(),
                     false.into(),
@@ -32,8 +69,8 @@ impl Object {
             #[cfg(phper_major_version = "7")]
             {
                 zend_read_property(
-                    self.class as *mut _,
-                    self.val as *mut _,
+                    self.inner.ce,
+                    &self.inner as *const _ as *mut _,
                     name.as_ptr().cast(),
                     name.len(),
                     false.into(),
@@ -42,6 +79,28 @@ impl Object {
             }
         };
 
-        unsafe { Val::from_mut(prop) }
+        unsafe { Val::from_mut_ptr(prop) }
+    }
+
+    pub fn set_property(&mut self, name: impl AsRef<str>, value: impl SetVal) {
+        let name = name.as_ref();
+        let mut val = Val::new(value);
+        unsafe {
+            zend_update_property(
+                self.inner.ce,
+                &mut self.inner as *mut _,
+                name.as_ptr().cast(),
+                name.len(),
+                val.as_mut_ptr(),
+            )
+        }
+    }
+}
+
+impl Drop for Object {
+    fn drop(&mut self) {
+        unsafe {
+            zend_objects_destroy_object(&mut self.inner);
+        }
     }
 }

phper/src/types.rs

@@ -17,6 +17,7 @@ pub enum Type {
     Array = IS_ARRAY,
     ArrayEx = IS_ARRAY_EX,
     Object = IS_OBJECT,
+    ObjectEx = IS_OBJECT_EX,
     Resource = IS_RESOURCE,
     Reference = IS_REFERENCE,
     ConstantAst = IS_CONSTANT_AST,

phper/src/values.rs

@@ -1,4 +1,5 @@
 use crate::{
+    alloc::EBox,
     arrays::Array,
     errors::Throwable,
     objects::Object,
@@ -82,7 +83,7 @@ impl Val {
         Self { inner }
     }
 
-    pub unsafe fn from_mut<'a>(ptr: *mut zval) -> &'a mut Self {
+    pub unsafe fn from_mut_ptr<'a>(ptr: *mut zval) -> &'a mut Self {
         assert!(!ptr.is_null(), "ptr should not be null");
         &mut *(ptr as *mut Self)
     }
@@ -133,6 +134,10 @@ impl Val {
         self.inner.u1.type_info = t as u32;
     }
 
+    pub fn is_object(&self) -> bool {
+        matches!(self.get_type(), Type::Object | Type::ObjectEx)
+    }
+
     pub fn as_bool(&self) -> crate::Result<bool> {
         match self.get_type() {
             Type::True => Ok(true),
@@ -353,6 +358,16 @@ impl SetVal for Array {
     }
 }
 
+impl SetVal for EBox<Object> {
+    fn set_val(mut self, val: &mut Val) {
+        unsafe {
+            let object = EBox::into_raw(self);
+            val.inner.value.obj = object.cast();
+            val.set_type(Type::ObjectEx);
+        }
+    }
+}
+
 impl<T: SetVal> SetVal for Option<T> {
     fn set_val(self, val: &mut Val) {
         match self {

tests/integration/src/values.rs

@@ -1,5 +1,5 @@
 use indexmap::map::IndexMap;
-use phper::{arrays::Array, modules::Module, values::Val};
+use phper::{alloc::EBox, arrays::Array, modules::Module, objects::Object, values::Val};
 use std::collections::HashMap;
 
 pub fn integrate(module: &mut Module) {
@@ -82,6 +82,11 @@ fn integrate_returns(module: &mut Module) {
         integration_values_return_array,
         vec![],
     );
+    module.add_function(
+        "integration_values_return_object",
+        integration_values_return_object,
+        vec![],
+    );
     module.add_function(
         "integration_values_return_option_i64_some",
         integration_values_return_option_i64_some,
@@ -177,6 +182,12 @@ fn integration_values_return_array(_: &mut [Val]) -> Array {
     arr
 }
 
+fn integration_values_return_object(_: &mut [Val]) -> EBox<Object> {
+    let mut object = EBox::new(Object::new_std());
+    object.set_property("foo", "bar");
+    object
+}
+
 fn integration_values_return_option_i64_some(_: &mut [Val]) -> Option<i64> {
     Some(64)
 }