Add function and method call, and struct support for macro Throwable.

Author: jmjoy

phper-macros/src/derives.rs

@@ -127,10 +127,14 @@ fn parse_throwable_input(
             })
             .into())
         }
-        Data::Struct(_) => Err(syn::Error::new_spanned(
-            &input,
-            "struct auto derive Throwable is not supported",
-        )),
+        Data::Struct(_) => Ok((quote! {
+            impl #crate_ident::errors::Throwable for #input_ident {
+                fn class_entry(&self) -> &#crate_ident::classes::StatelessClassEntry {
+                    ClassEntry::from_globals(#exception).unwrap()
+                }
+            }
+        })
+        .into()),
         Data::Union(_) => Err(syn::Error::new_spanned(
             &input,
             "union auto derive Throwable is not supported",

phper-macros/src/lib.rs

@@ -90,7 +90,7 @@ pub fn php_get_module(attr: TokenStream, input: TokenStream) -> TokenStream {
 /// }
 /// ```
 ///
-/// TODO Support struct, attbiute `throwable` with `code` and `message`.
+/// TODO Support attribute `throwable` with `code` and `message`, integration tests.
 #[proc_macro_derive(Throwable, attributes(throwable, throwable_crate))]
 pub fn derive_throwable(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);

phper-sys/php_wrapper.c

@@ -147,3 +147,8 @@ void *phper_zend_object_alloc(size_t obj_size, zend_class_entry *ce) {
 zend_object* (**phper_get_create_object(zend_class_entry *ce))(zend_class_entry *class_type) {
     return &ce->create_object;
 }
+
+bool phper_call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[]) {
+    function_table = function_table;
+    return call_user_function(function_table, object, function_name, retval_ptr, param_count, params) == SUCCESS;
+}

phper-sys/php_wrapper.h

@@ -1,6 +1,7 @@
 #ifndef PHPER_PHP_WRAPPER_H
 #define PHPER_PHP_WRAPPER_H
 
+#include <stdbool.h>
 #include <php.h>
 #include <php_ini.h>
 #include <ext/standard/info.h>
@@ -50,4 +51,6 @@ void *phper_zend_object_alloc(size_t obj_size, zend_class_entry *ce);
 
 zend_object* (**phper_get_create_object(zend_class_entry *ce))(zend_class_entry *class_type);
 
+bool phper_call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[]);
+
 #endif //PHPER_PHP_WRAPPER_H

phper/src/classes.rs

@@ -5,6 +5,7 @@ use crate::{
     errors::{ClassNotFoundError, StateTypeError},
     functions::{Argument, Function, FunctionEntity, FunctionEntry, Method},
     objects::{ExtendObject, Object},
+    strings::ZendString,
     sys::*,
     types::Scalar,
     values::{SetVal, Val},
@@ -233,6 +234,10 @@ impl<T: 'static> ClassEntry<T> {
             EBox::from_raw(object.cast())
         }
     }
+
+    pub fn get_name(&self) -> &ZendString {
+        ZendString::from_ptr(self.inner.name)
+    }
 }
 
 fn find_global_class_entry_ptr(name: impl AsRef<str>) -> *mut zend_class_entry {

phper/src/errors.rs

@@ -6,6 +6,7 @@ use crate::{
     Error::Other,
 };
 use anyhow::anyhow;
+use derive_more::Constructor;
 use std::{convert::Infallible, error, ffi::FromBytesWithNulError, io, str::Utf8Error};
 
 /// PHP Throwable, can cause throwing an exception when setting to [crate::values::Val].
@@ -64,6 +65,14 @@ pub enum Error {
     #[error(transparent)]
     #[throwable(transparent)]
     StateType(#[from] StateTypeError),
+
+    #[error(transparent)]
+    #[throwable(transparent)]
+    CallFunction(#[from] CallFunctionError),
+
+    #[error(transparent)]
+    #[throwable(transparent)]
+    CallMethod(#[from] CallMethodError),
 }
 
 impl Error {
@@ -74,73 +83,39 @@ impl Error {
     }
 }
 
-#[derive(thiserror::Error, Debug)]
+#[derive(Debug, thiserror::Error, crate::Throwable, Constructor)]
 #[error("type error: {message}")]
+#[throwable(class = "TypeError")]
+#[throwable_crate]
 pub struct TypeError {
     message: String,
 }
 
-impl TypeError {
-    pub fn new(message: String) -> Self {
-        Self { message }
-    }
-}
-
-impl Throwable for TypeError {
-    fn class_entry(&self) -> &ClassEntry<()> {
-        ClassEntry::from_globals("TypeError").unwrap()
-    }
-}
-
-#[derive(thiserror::Error, Debug)]
+#[derive(Debug, thiserror::Error, crate::Throwable, Constructor)]
 #[error("Class '{class_name}' not found")]
+#[throwable(class = "Error")]
+#[throwable_crate]
 pub struct ClassNotFoundError {
     class_name: String,
 }
 
-impl ClassNotFoundError {
-    pub fn new(class_name: String) -> Self {
-        Self { class_name }
-    }
-}
-
-impl Throwable for ClassNotFoundError {
-    fn class_entry(&self) -> &StatelessClassEntry {
-        ClassEntry::from_globals("Error").unwrap()
-    }
-}
-
-#[derive(thiserror::Error, Debug)]
+#[derive(Debug, thiserror::Error, crate::Throwable)]
 #[error(
     "Actual State type in generic type parameter isn't the state type registered in the class, \
 please confirm the real state type, or use StatelessClassEntry"
 )]
+#[throwable(class = "Error")]
+#[throwable_crate]
 pub struct StateTypeError;
 
-impl Throwable for StateTypeError {
-    fn class_entry(&self) -> &StatelessClassEntry {
-        ClassEntry::from_globals("Error").unwrap()
-    }
-}
-
-#[derive(thiserror::Error, Debug)]
+#[derive(thiserror::Error, Debug, Constructor)]
 #[error("{function_name}(): expects at least {expect_count} parameter(s), {given_count} given")]
 pub struct ArgumentCountError {
     function_name: String,
     expect_count: usize,
     given_count: usize,
 }
 
-impl ArgumentCountError {
-    pub fn new(function_name: String, expect_count: usize, given_count: usize) -> Self {
-        Self {
-            function_name,
-            expect_count,
-            given_count,
-        }
-    }
-}
-
 impl Throwable for ArgumentCountError {
     fn class_entry(&self) -> &StatelessClassEntry {
         let class_name = if PHP_VERSION_ID >= 70100 {
@@ -151,3 +126,20 @@ impl Throwable for ArgumentCountError {
         ClassEntry::from_globals(class_name).unwrap()
     }
 }
+
+#[derive(Debug, thiserror::Error, crate::Throwable, Constructor)]
+#[error("Invalid call to {fn_name}")]
+#[throwable(class = "BadFunctionCallException")]
+#[throwable_crate]
+pub struct CallFunctionError {
+    fn_name: String,
+}
+
+#[derive(Debug, thiserror::Error, crate::Throwable, Constructor)]
+#[error("Invalid call to {class_name}::{method_name}")]
+#[throwable(class = "BadMethodCallException")]
+#[throwable_crate]
+pub struct CallMethodError {
+    class_name: String,
+    method_name: String,
+}

phper/src/functions.rs

@@ -1,19 +1,21 @@
 //! 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,
+    errors::{ArgumentCountError, CallFunctionError},
     objects::Object,
     strings::ZendString,
     sys::*,
     utils::ensure_end_with_zero,
     values::{ExecuteData, SetVal, Val},
 };
-use std::{marker::PhantomData, str::Utf8Error};
+use std::{marker::PhantomData, ptr::null_mut, str::Utf8Error};
 
 pub(crate) trait Callable {
     fn call(&self, execute_data: &mut ExecuteData, arguments: &mut [Val], return_value: &mut Val);
@@ -284,7 +286,6 @@ pub(crate) const fn create_zend_arg_info(
 ) -> zend_internal_arg_info {
     #[cfg(phper_php_version = "8.0")]
     {
-        use std::ptr::null_mut;
         zend_internal_arg_info {
             name,
             type_: zend_type {
@@ -321,3 +322,22 @@ pub(crate) const fn create_zend_arg_info(
         }
     }
 }
+
+pub fn call(fn_name: &str, arguments: &[Val]) -> Result<EBox<Val>, CallFunctionError> {
+    let mut func = Val::new(fn_name);
+    let mut ret = EBox::new(Val::null());
+    unsafe {
+        if phper_call_user_function(
+            compiler_globals.function_table,
+            null_mut(),
+            func.as_mut_ptr(),
+            ret.as_mut_ptr(),
+            arguments.len() as u32,
+            arguments.as_ptr() as *const Val as *mut Val as *mut zval,
+        ) {
+            Ok(ret)
+        } else {
+            Err(CallFunctionError::new(fn_name.to_owned()))
+        }
+    }
+}

phper/src/objects.rs

@@ -3,6 +3,7 @@
 use crate::{
     alloc::{EAllocatable, EBox},
     classes::ClassEntry,
+    errors::CallMethodError,
     sys::*,
     values::Val,
 };
@@ -140,6 +141,30 @@ impl<T: 'static> Object<T> {
     pub fn get_class(&self) -> &ClassEntry<T> {
         ClassEntry::from_ptr(self.inner.ce)
     }
+
+    pub fn call(&self, method_name: &str, arguments: &[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 _);
+
+            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,
+            ) {
+                Ok(ret)
+            } else {
+                let class_name = self.get_class().get_name().to_string()?;
+                Err(CallMethodError::new(class_name, method_name.to_owned()).into())
+            }
+        }
+    }
 }
 
 impl Object<()> {

phper/src/values.rs

@@ -224,6 +224,7 @@ impl Val {
     }
 
     unsafe fn drop_value(&mut self) {
+        // TODO Use zval_dtor.
         let t = self.get_type();
         if t.is_string() {
             ZendString::free(self.inner.value.str as *mut ZendString);

tests/integration/src/functions.rs

@@ -0,0 +1,16 @@
+use phper::{arrays::Array, functions::call, modules::Module, values::Val};
+
+pub fn integrate(module: &mut Module) {
+    module.add_function(
+        "integrate_functions_call",
+        |_: &mut [Val]| -> phper::Result<()> {
+            let mut arr = Array::new();
+            arr.insert("a", Val::new(1));
+            arr.insert("b", Val::new(2));
+            let ret = call("json_encode", &[Val::new(arr)])?;
+            assert_eq!(ret.as_string()?, r#"{"a":1,"b":2}"#);
+            Ok(())
+        },
+        vec![],
+    );
+}