Add arguments for new object, some call functions.

Author: jmjoy

examples/http-client/src/client.rs

@@ -49,8 +49,8 @@ pub fn make_client_builder_class() -> DynamicClass<ClientBuilder> {
         |this, _arguments| {
             let state = this.as_mut_state();
             let client = replace_and_get(state, ClientBuilder::new(), ClientBuilder::build)?;
-            let mut object =
-                ClassEntry::<Option<Client>>::from_globals(HTTP_CLIENT_CLASS_NAME)?.new_object();
+            let mut object = ClassEntry::<Option<Client>>::from_globals(HTTP_CLIENT_CLASS_NAME)?
+                .new_object_without_construct();
             *object.as_mut_state() = Some(client);
             Ok::<_, HttpClientError>(object)
         },
@@ -79,7 +79,7 @@ pub fn make_client_class() -> DynamicClass<Option<Client>> {
             let request_builder = client.get(url);
             let mut object =
                 ClassEntry::<Option<RequestBuilder>>::from_globals(REQUEST_BUILDER_CLASS_NAME)?
-                    .new_object();
+                    .new_object_without_construct();
             *object.as_mut_state() = Some(request_builder);
             Ok::<_, HttpClientError>(object)
         },
@@ -95,7 +95,7 @@ pub fn make_client_class() -> DynamicClass<Option<Client>> {
             let request_builder = client.post(url);
             let mut object =
                 ClassEntry::<Option<RequestBuilder>>::from_globals(REQUEST_BUILDER_CLASS_NAME)?
-                    .new_object();
+                    .new_object_without_construct();
             *object.as_mut_state() = Some(request_builder);
             Ok::<_, HttpClientError>(object)
         },

examples/http-client/src/request.rs

@@ -23,8 +23,8 @@ pub fn make_request_builder_class() -> DynamicClass<Option<RequestBuilder>> {
         |this, _arguments| {
             let state = this.as_mut_state();
             let response = replace_and_get(state, None, |builder| builder.unwrap().send())?;
-            let mut object =
-                ClassEntry::<Option<Response>>::from_globals(RESPONSE_CLASS_NAME)?.new_object();
+            let mut object = ClassEntry::<Option<Response>>::from_globals(RESPONSE_CLASS_NAME)?
+                .new_object_without_construct();
             *object.as_mut_state() = Some(response);
             Ok::<_, HttpClientError>(object)
         },

phper-sys/php_wrapper.c

@@ -152,3 +152,11 @@ bool phper_call_user_function(HashTable *function_table, zval *object, zval *fun
     function_table = function_table;
     return call_user_function(function_table, object, function_name, retval_ptr, param_count, params) == SUCCESS;
 }
+
+bool phper_zend_hash_str_exists(const HashTable *ht, const char *str, size_t len) {
+    return zend_hash_str_exists(ht, str, len) != 0;
+}
+
+bool phper_zend_hash_index_exists(const HashTable *ht, zend_ulong h) {
+    return zend_hash_index_exists(ht, h) != 0;
+}

phper-sys/php_wrapper.h

@@ -53,4 +53,7 @@ zend_object* (**phper_get_create_object(zend_class_entry *ce))(zend_class_entry
 
 bool phper_call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[]);
 
+bool phper_zend_hash_str_exists(const HashTable *ht, const char *str, size_t len);
+bool phper_zend_hash_index_exists(const HashTable *ht, zend_ulong h);
+
 #endif //PHPER_PHP_WRAPPER_H

phper/src/arrays.rs

@@ -53,7 +53,12 @@ impl Array {
         }
     }
 
-    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_array) -> &'a mut Array {
+    pub unsafe fn from_ptr<'a>(ptr: *const zend_array) -> &'a Array {
+        let ptr = ptr as *const Array;
+        ptr.as_ref().expect("ptr shouldn't be null")
+    }
+
+    pub 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")
     }
@@ -108,6 +113,20 @@ impl Array {
         unsafe { zend_array_count(&mut self.inner) as usize }
     }
 
+    pub fn exists<'a>(&self, key: impl Into<Key<'a>>) -> bool {
+        let key = key.into();
+        unsafe {
+            match key {
+                Key::Index(i) => phper_zend_hash_index_exists(&self.inner, i),
+                Key::Str(s) => phper_zend_hash_str_exists(
+                    &self.inner,
+                    s.as_ref().as_ptr().cast(),
+                    s.as_ref().len(),
+                ),
+            }
+        }
+    }
+
     pub fn clone(&self) -> EBox<Self> {
         let mut other = Self::new();
         unsafe {

phper/src/classes.rs

@@ -2,6 +2,7 @@
 
 use crate::{
     alloc::EBox,
+    arrays::Array,
     errors::{ClassNotFoundError, StateTypeError},
     functions::{Argument, Function, FunctionEntity, FunctionEntry, Method},
     objects::{ExtendObject, Object},
@@ -226,18 +227,40 @@ impl<T: 'static> ClassEntry<T> {
         &mut self.inner
     }
 
-    pub fn new_object(&self) -> EBox<Object<T>> {
+    /// Create the object from class and call `__construct` with arguments.
+    pub fn new_object(&self, arguments: &mut [Val]) -> crate::Result<EBox<Object<T>>> {
         unsafe {
             let ptr = self.as_ptr() as *mut _;
             let f = (*phper_get_create_object(ptr)).unwrap_or(zend_objects_new);
             let object = f(ptr);
-            EBox::from_raw(object.cast())
+            let mut object: EBox<Object<T>> = EBox::from_raw(object.cast());
+            let _ = object.call_construct(arguments)?;
+            Ok(object)
+        }
+    }
+
+    /// Create the object from class, without calling `__construct`, be careful when `__construct`
+    /// is necessary.
+    pub fn new_object_without_construct(&self) -> EBox<Object<T>> {
+        unsafe {
+            let ptr = self.as_ptr() as *mut _;
+            let f = (*phper_get_create_object(ptr)).unwrap_or(zend_objects_new);
+            let object = f(ptr);
+            let object: EBox<Object<T>> = EBox::from_raw(object.cast());
+            object
         }
     }
 
     pub fn get_name(&self) -> &ZendString {
         ZendString::from_ptr(self.inner.name)
     }
+
+    pub fn has_method(&self, method_name: &str) -> bool {
+        unsafe {
+            let function_table = Array::from_ptr(&self.inner.function_table);
+            function_table.exists(method_name)
+        }
+    }
 }
 
 fn find_global_class_entry_ptr(name: impl AsRef<str>) -> *mut zend_class_entry {

phper/src/functions.rs

@@ -1,21 +1,20 @@
 //! Apis relate to [crate::sys::zend_function_entry].
 //!
-//! TODO Add php function call.
 //! TODO Add lambda.
 
 use std::{mem::zeroed, os::raw::c_char};
 
 use crate::{
     alloc::EBox,
     classes::Visibility,
-    errors::{ArgumentCountError, CallFunctionError},
+    errors::{ArgumentCountError, CallFunctionError, CallMethodError},
     objects::Object,
     strings::ZendString,
     sys::*,
     utils::ensure_end_with_zero,
     values::{ExecuteData, SetVal, Val},
 };
-use std::{marker::PhantomData, ptr::null_mut, str::Utf8Error};
+use std::{marker::PhantomData, mem::size_of, ptr::null_mut};
 
 pub(crate) trait Callable {
     fn call(&self, execute_data: &mut ExecuteData, arguments: &mut [Val], return_value: &mut Val);
@@ -225,10 +224,73 @@ impl ZendFunction {
         &mut self.inner
     }
 
-    pub fn get_name(&self) -> Result<String, Utf8Error> {
+    pub fn get_name(&self) -> EBox<ZendString> {
         unsafe {
             let s = phper_get_function_or_method_name(self.as_ptr());
-            ZendString::from_raw(s).to_string()
+            ZendString::from_raw(s)
+        }
+    }
+
+    pub(crate) fn call_method<T: 'static>(
+        &mut self,
+        object: &mut Object<T>,
+        arguments: &mut [Val],
+    ) -> crate::Result<EBox<Val>> {
+        let mut ret_val = EBox::new(Val::undef());
+
+        let mut fci = zend_fcall_info {
+            size: size_of::<zend_fcall_info>(),
+            function_name: Val::undef().into_inner(),
+            retval: ret_val.as_mut_ptr(),
+            params: arguments.as_mut_ptr().cast(),
+            object: object.as_mut_ptr(),
+            param_count: arguments.len() as u32,
+            #[cfg(phper_major_version = "8")]
+            named_params: null_mut(),
+            #[cfg(phper_major_version = "7")]
+            no_separation: 1,
+            #[cfg(all(phper_major_version = "7", phper_minor_version = "0"))]
+            function_table: null_mut(),
+            #[cfg(all(phper_major_version = "7", phper_minor_version = "0"))]
+            symbol_table: null_mut(),
+        };
+
+        let called_scope = unsafe {
+            let mut called_scope = object.get_class().as_ptr() as *mut zend_class_entry;
+            if called_scope.is_null() {
+                called_scope = self.inner.common.scope;
+            }
+            called_scope
+        };
+
+        let mut fcc = zend_fcall_info_cache {
+            function_handler: self.as_mut_ptr(),
+            calling_scope: null_mut(),
+            called_scope,
+            object: object.as_mut_ptr(),
+            #[cfg(all(
+                phper_major_version = "7",
+                any(
+                    phper_minor_version = "0",
+                    phper_minor_version = "1",
+                    phper_minor_version = "2",
+                )
+            ))]
+            initialized: 1,
+        };
+
+        unsafe {
+            if zend_call_function(&mut fci, &mut fcc) != ZEND_RESULT_CODE_SUCCESS
+                || ret_val.get_type().is_undef()
+            {
+                Err(CallMethodError::new(
+                    object.get_class().get_name().to_string()?,
+                    self.get_name().to_string()?,
+                )
+                .into())
+            } else {
+                Ok(ret_val)
+            }
         }
     }
 }
@@ -262,6 +324,7 @@ unsafe extern "C" fn invoke(execute_data: *mut zend_execute_data, return_value:
     if num_args < required_num_args {
         let func_name = execute_data.func().get_name();
         let result = func_name
+            .to_string()
             .map(|func_name| {
                 Err::<(), _>(ArgumentCountError::new(
                     func_name,
@@ -323,7 +386,23 @@ pub(crate) const fn create_zend_arg_info(
     }
 }
 
-pub fn call(fn_name: &str, arguments: &[Val]) -> Result<EBox<Val>, CallFunctionError> {
+/// Call user function by name.
+///
+/// # Examples
+///
+/// ```
+/// use phper::{arrays::Array, functions::call, values::Val};
+///
+/// fn example() -> phper::Result<()> {
+///     let mut arr = Array::new();
+///     arr.insert("a", Val::new(1));
+///     arr.insert("b", Val::new(2));
+///     let ret = call("json_encode", &mut [Val::new(arr)])?;
+///     assert_eq!(ret.as_string()?, r#"{"a":1,"b":2}"#);
+///     Ok(())
+/// }
+/// ```
+pub fn call(fn_name: &str, arguments: &mut [Val]) -> Result<EBox<Val>, CallFunctionError> {
     let mut func = Val::new(fn_name);
     let mut ret = EBox::new(Val::null());
     unsafe {
@@ -333,8 +412,9 @@ pub fn call(fn_name: &str, arguments: &[Val]) -> Result<EBox<Val>, CallFunctionE
             func.as_mut_ptr(),
             ret.as_mut_ptr(),
             arguments.len() as u32,
-            arguments.as_ptr() as *const Val as *mut Val as *mut zval,
-        ) {
+            arguments.as_mut_ptr().cast(),
+        ) && !ret.get_type().is_undef()
+        {
             Ok(ret)
         } else {
             Err(CallFunctionError::new(fn_name.to_owned()))

phper/src/objects.rs

@@ -4,6 +4,7 @@ use crate::{
     alloc::{EAllocatable, EBox},
     classes::ClassEntry,
     errors::CallMethodError,
+    functions::ZendFunction,
     sys::*,
     values::Val,
 };
@@ -26,13 +27,17 @@ pub struct Object<T: 'static> {
 }
 
 impl<T: 'static> Object<T> {
-    pub fn new(class_entry: &ClassEntry<T>) -> EBox<Self> {
-        class_entry.new_object()
+    /// Another way to new object like [crate::classes::ClassEntry::new_object].
+    pub fn new(class_entry: &ClassEntry<T>, arguments: &mut [Val]) -> crate::Result<EBox<Self>> {
+        class_entry.new_object(arguments)
     }
 
-    pub fn new_by_class_name(class_name: impl AsRef<str>) -> crate::Result<EBox<Self>> {
+    pub fn new_by_class_name(
+        class_name: impl AsRef<str>,
+        arguments: &mut [Val],
+    ) -> crate::Result<EBox<Self>> {
         let class_entry = ClassEntry::from_globals(class_name)?;
-        Ok(Self::new(class_entry))
+        Self::new(class_entry, arguments)
     }
 
     pub unsafe fn from_mut_ptr<'a>(ptr: *mut zend_object) -> &'a mut Self {
@@ -142,21 +147,34 @@ impl<T: 'static> Object<T> {
         ClassEntry::from_ptr(self.inner.ce)
     }
 
-    pub fn call(&self, method_name: &str, arguments: &[Val]) -> crate::Result<EBox<Val>> {
+    /// Call the object method byn name.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use phper::{alloc::EBox, classes::StatelessClassEntry, values::Val};
+    ///
+    /// fn example() -> phper::Result<EBox<Val>> {
+    ///     let mut memcached = StatelessClassEntry::from_globals("Memcached")?.new_object(&mut [])?;
+    ///     memcached.call("addServer", &mut [Val::new("127.0.0.1"), Val::new(11211)])?;
+    ///     memcached.call("get", &mut [Val::new("hello")])
+    /// }
+    /// ```
+    pub fn call(&mut self, method_name: &str, arguments: &mut [Val]) -> crate::Result<EBox<Val>> {
         let mut method = Val::new(method_name);
         let mut ret = EBox::new(Val::null());
 
         unsafe {
             let mut object = std::mem::zeroed::<zval>();
-            phper_zval_obj(&mut object, self.as_ptr() as *mut _);
+            phper_zval_obj(&mut object, self.as_mut_ptr());
 
             if phper_call_user_function(
                 null_mut(),
                 &mut object,
                 method.as_mut_ptr(),
                 ret.as_mut_ptr(),
                 arguments.len() as u32,
-                arguments.as_ptr() as *const Val as *mut Val as *mut zval,
+                arguments.as_mut_ptr().cast(),
             ) {
                 Ok(ret)
             } else {
@@ -165,11 +183,28 @@ impl<T: 'static> Object<T> {
             }
         }
     }
+
+    pub(crate) fn call_construct(&mut self, arguments: &mut [Val]) -> crate::Result<Option<()>> {
+        unsafe {
+            (*self.inner.handlers)
+                .get_constructor
+                .and_then(|get_constructor| {
+                    let f = get_constructor(self.as_ptr() as *mut _);
+                    if f.is_null() {
+                        None
+                    } else {
+                        let zend_fn = ZendFunction::from_mut_ptr(f);
+                        Some(zend_fn.call_method(self, arguments).map(|_| ()))
+                    }
+                })
+                .transpose()
+        }
+    }
 }
 
 impl Object<()> {
     pub fn new_by_std_class() -> EBox<Self> {
-        Self::new_by_class_name("stdclass").unwrap()
+        Self::new_by_class_name("stdclass", &mut []).unwrap()
     }
 }