Add intergation tests for Array and Object.

Author: jmjoy

examples/hello/src/lib.rs

@@ -76,7 +76,7 @@ pub fn get_module() -> Module {
     foo_class.add_method(
         "setFoo",
         |this: &mut Object, arguments: &mut [Val]| -> phper::Result<()> {
-            this.set_property("foo", arguments[0].as_string_value()?);
+            this.set_property("foo", Val::new(arguments[0].as_string_value()?));
             Ok(())
         },
         vec![Argument::by_val("foo")],

phper-alloc/src/lib.rs

@@ -13,14 +13,22 @@ use std::{
     ops::{Deref, DerefMut},
 };
 
+pub trait EAllocatable {
+    fn free(ptr: *mut Self) {
+        unsafe {
+            _efree(ptr.cast());
+        }
+    }
+}
+
 /// The Box which use php `emalloc` and `efree` to manage memory.
 ///
 /// TODO now feature `allocator_api` is still unstable, implement myself.
-pub struct EBox<T> {
+pub struct EBox<T: EAllocatable> {
     ptr: *mut T,
 }
 
-impl<T> EBox<T> {
+impl<T: EAllocatable> EBox<T> {
     pub fn new(x: T) -> Self {
         unsafe {
             let ptr: *mut T = _emalloc(size_of::<T>()).cast();
@@ -40,24 +48,22 @@ impl<T> EBox<T> {
     }
 }
 
-impl<T> Deref for EBox<T> {
+impl<T: EAllocatable> Deref for EBox<T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
         unsafe { self.ptr.as_ref().unwrap() }
     }
 }
 
-impl<T> DerefMut for EBox<T> {
+impl<T: EAllocatable> DerefMut for EBox<T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { self.ptr.as_mut().unwrap() }
     }
 }
 
-impl<T> Drop for EBox<T> {
+impl<T: EAllocatable> Drop for EBox<T> {
     fn drop(&mut self) {
-        unsafe {
-            _efree(self.ptr.cast());
-        }
+        <T>::free(self.ptr);
     }
 }

phper/src/arrays.rs

@@ -1,15 +1,38 @@
 //! Apis relate to [crate::sys::zend_array].
 
-use crate::{sys::*, values::Val};
-use phper_alloc::EBox;
+use crate::{
+    alloc::{EAllocatable, EBox},
+    sys::*,
+    values::Val,
+};
 use std::mem::zeroed;
 
+/// Key for [Array].
+pub enum Key<'a> {
+    Index(u64),
+    Str(&'a str),
+}
+
+impl From<u64> for Key<'_> {
+    fn from(i: u64) -> Self {
+        Key::Index(i)
+    }
+}
+
+impl<'a> From<&'a str> for Key<'a> {
+    fn from(s: &'a str) -> Self {
+        Key::Str(s)
+    }
+}
+
+/// Wrapper of [crate::sys::zend_array].
 #[repr(transparent)]
 pub struct Array {
     inner: zend_array,
 }
 
 impl Array {
+    // TODO Change to EBox<Self>.
     pub fn new() -> Self {
         unsafe {
             let mut array = zeroed::<Array>();
@@ -31,25 +54,38 @@ impl Array {
         &mut self.inner
     }
 
-    // TODO key should be int or string.
-    pub fn insert(&mut self, key: impl AsRef<str>, value: Val) {
-        let key = key.as_ref();
+    pub fn insert<'a>(&mut self, key: impl Into<Key<'a>>, value: Val) {
+        let key = key.into();
         let value = EBox::new(value);
         unsafe {
-            phper_zend_hash_str_update(
-                &mut self.inner,
-                key.as_ptr().cast(),
-                key.len(),
-                EBox::into_raw(value).cast(),
-            );
+            match key {
+                Key::Index(i) => {
+                    zend_hash_index_update(&mut self.inner, i, EBox::into_raw(value).cast());
+                }
+                Key::Str(s) => {
+                    phper_zend_hash_str_update(
+                        &mut self.inner,
+                        s.as_ptr().cast(),
+                        s.len(),
+                        EBox::into_raw(value).cast(),
+                    );
+                }
+            }
         }
     }
 
-    pub fn get(&mut self, key: impl AsRef<str>) -> &mut Val {
-        let key = key.as_ref();
+    pub fn get<'a>(&self, key: impl Into<Key<'a>>) -> Option<&Val> {
+        let key = key.into();
         unsafe {
-            let value = zend_hash_str_find(&mut self.inner, key.as_ptr().cast(), key.len());
-            Val::from_mut_ptr(value)
+            let value = match key {
+                Key::Index(i) => zend_hash_index_find(&self.inner, i),
+                Key::Str(s) => zend_hash_str_find(&self.inner, s.as_ptr().cast(), s.len()),
+            };
+            if value.is_null() {
+                None
+            } else {
+                Some(Val::from_mut_ptr(value))
+            }
         }
     }
 
@@ -58,6 +94,14 @@ impl Array {
     }
 }
 
+impl EAllocatable for Array {
+    fn free(ptr: *mut Self) {
+        unsafe {
+            zend_hash_destroy(ptr.cast());
+        }
+    }
+}
+
 impl Drop for Array {
     fn drop(&mut self) {
         unsafe {

phper/src/classes.rs

@@ -1,8 +1,10 @@
+//! Apis relate to [crate::sys::zend_class_entry].
+
 use crate::{
+    errors::ClassNotFoundError,
     functions::{Argument, Callable, FunctionEntity, FunctionEntry, Method},
     sys::*,
     utils::ensure_end_with_zero,
-    ClassNotFoundError,
 };
 use once_cell::sync::OnceCell;
 use std::{

phper/src/cmd.rs

@@ -1,3 +1,5 @@
+//! Command tools for build, test and install extension process.
+
 use crate::sys::PHP_EXTENSION_DIR;
 use anyhow::Context;
 use clap::Clap;
@@ -23,6 +25,16 @@ enum SubCommand {
 #[derive(Clap)]
 struct InstallCommand {}
 
+/// Make.
+///
+/// # Examples
+/// ```
+/// use phper::cmd::make;
+///
+/// fn main() {
+///     make();
+/// }
+/// ```
 pub fn make() {
     try_make().expect("make failed");
 }

phper/src/functions.rs

@@ -180,7 +180,7 @@ pub(crate) unsafe extern "C" fn invoke(
     execute_data: *mut zend_execute_data,
     return_value: *mut zval,
 ) {
-    let execute_data = ExecuteData::from_mut(execute_data);
+    let execute_data = ExecuteData::from_mut_ptr(execute_data);
     let return_value = Val::from_mut_ptr(return_value);
 
     let num_args = execute_data.common_num_args();

phper/src/lib.rs

@@ -96,7 +96,7 @@ mod macros;
 pub mod arrays;
 pub mod classes;
 pub mod cmd;
-mod errors;
+pub mod errors;
 pub mod functions;
 pub mod ini;
 pub mod modules;
@@ -107,7 +107,7 @@ pub mod types;
 mod utils;
 pub mod values;
 
-pub use crate::errors::*;
+pub use crate::errors::{Error, Result};
 pub use phper_alloc as alloc;
 pub use phper_macros::*;
 pub use phper_sys as sys;

phper/src/modules.rs

@@ -1,11 +1,11 @@
 use crate::{
     c_str_ptr,
     classes::{Class, ClassEntity, StdClass},
+    errors::EXCEPTION_CLASS_NAME,
     functions::{Argument, Callable, Function, FunctionEntity},
     ini::{IniEntity, IniValue, Policy, StrPtrBox},
     sys::*,
     utils::ensure_end_with_zero,
-    EXCEPTION_CLASS_NAME,
 };
 use std::{
     borrow::BorrowMut,

phper/src/objects.rs

@@ -1,10 +1,10 @@
 use crate::{
+    alloc::{EAllocatable, EBox},
     classes::ClassEntry,
+    errors::ClassNotFoundError,
     sys::*,
     values::{SetVal, Val},
-    ClassNotFoundError,
 };
-use phper_alloc::EBox;
 use std::{
     mem::{forget, zeroed},
     ptr::null_mut,
@@ -17,21 +17,21 @@ pub struct Object {
 }
 
 impl Object {
-    pub fn new(class_entry: &ClassEntry) -> Self {
+    pub fn new(class_entry: &ClassEntry) -> EBox<Self> {
         unsafe {
-            let mut object = zeroed::<Object>();
-            zend_object_std_init(object.as_mut_ptr(), class_entry.as_ptr() as *mut _);
-            object.inner.handlers = &std_object_handlers;
-            object
+            let ptr = zend_objects_new(class_entry.as_ptr() as *mut _);
+            EBox::from_raw(ptr.cast())
         }
     }
 
-    pub fn new_by_class_name(class_name: impl AsRef<str>) -> Result<Self, ClassNotFoundError> {
+    pub fn new_by_class_name(
+        class_name: impl AsRef<str>,
+    ) -> Result<EBox<Self>, ClassNotFoundError> {
         let class_entry = ClassEntry::from_globals(class_name)?;
         Ok(Self::new(class_entry))
     }
 
-    pub fn new_by_std_class() -> Self {
+    pub fn new_by_std_class() -> EBox<Self> {
         Self::new_by_class_name("stdclass").unwrap()
     }
 
@@ -49,7 +49,7 @@ impl Object {
         &mut self.inner
     }
 
-    pub fn get_property(&self, name: impl AsRef<str>) -> &mut Val {
+    pub fn get_property(&self, name: impl AsRef<str>) -> &Val {
         let name = name.as_ref();
 
         let prop = unsafe {
@@ -82,9 +82,9 @@ impl Object {
         unsafe { Val::from_mut_ptr(prop) }
     }
 
-    pub fn set_property(&mut self, name: impl AsRef<str>, value: impl SetVal) {
+    pub fn set_property(&mut self, name: impl AsRef<str>, val: Val) {
         let name = name.as_ref();
-        let mut val = Val::new(value);
+        let val = EBox::new(val);
         unsafe {
             #[cfg(phper_major_version = "8")]
             {
@@ -93,7 +93,7 @@ impl Object {
                     &mut self.inner,
                     name.as_ptr().cast(),
                     name.len(),
-                    val.as_mut_ptr(),
+                    EBox::into_raw(val).cast(),
                 )
             }
             #[cfg(phper_major_version = "7")]
@@ -105,7 +105,7 @@ impl Object {
                     &mut zv,
                     name.as_ptr().cast(),
                     name.len(),
-                    val.as_mut_ptr(),
+                    EBox::into_raw(val).cast(),
                 )
             }
         }
@@ -119,10 +119,16 @@ impl Object {
     }
 }
 
-impl Drop for Object {
-    fn drop(&mut self) {
+impl EAllocatable for Object {
+    fn free(ptr: *mut Self) {
         unsafe {
-            zend_objects_destroy_object(&mut self.inner);
+            zend_objects_destroy_object(ptr.cast());
         }
     }
 }
+
+impl Drop for Object {
+    fn drop(&mut self) {
+        unreachable!("Allocation on the stack is not allowed")
+    }
+}

phper/src/strings.rs

@@ -22,8 +22,4 @@ impl ZendString {
     pub fn as_mut_ptr(&mut self) -> *mut zend_string {
         &mut self.inner
     }
-
-    pub unsafe fn from_raw(s: *mut zend_string) -> EBox<ZendString> {
-        EBox::from_raw(s.cast())
-    }
 }