Add references support, and rename ZendFunction. (#91)

Author: jmjoy

phper-sys/php_wrapper.c

@@ -308,12 +308,12 @@ zend_array *phper_z_arr_p(const zval *zv) {
     return Z_ARR_P(zv);
 }
 
-zend_long phper_z_lval_p(const zval *zv) {
-    return Z_LVAL_P(zv);
+zend_long *phper_z_lval_p(zval *zv) {
+    return &(Z_LVAL_P(zv));
 }
 
-double phper_z_dval_p(const zval *zv) {
-    return Z_DVAL_P(zv);
+double *phper_z_dval_p(zval *zv) {
+    return &(Z_DVAL_P(zv));
 }
 
 zend_string *phper_z_str_p(const zval *zv) {
@@ -324,6 +324,10 @@ zend_resource *phper_z_res_p(const zval *zv) {
     return Z_RES_P(zv);
 }
 
+zend_reference *phper_z_ref_p(const zval *zv) {
+    return Z_REF_P(zv);
+}
+
 zend_string *phper_zend_string_copy(zend_string *s) {
     return zend_string_copy(s);
 }
@@ -411,3 +415,21 @@ void phper_zend_hash_foreach_key_val(zend_array *array,
     }
     ZEND_HASH_FOREACH_END();
 }
+
+zend_internal_arg_info
+phper_zend_begin_arg_info_ex(bool return_reference,
+                             uintptr_t required_num_args) {
+#define static
+#define const
+    ZEND_BEGIN_ARG_INFO_EX(info, 0, return_reference, required_num_args)
+    ZEND_END_ARG_INFO()
+    return info[0];
+#undef static
+#undef const
+}
+
+zend_internal_arg_info phper_zend_arg_info(bool pass_by_ref, const char *name) {
+    zend_internal_arg_info info[] = {ZEND_ARG_INFO(pass_by_ref, )};
+    info[0].name = name;
+    return info[0];
+}

phper/src/functions.rs

@@ -28,7 +28,6 @@ use std::{
     ffi::{CStr, CString},
     marker::PhantomData,
     mem::{size_of, transmute, zeroed},
-    os::raw::c_char,
     ptr::null_mut,
     rc::Rc,
 };
@@ -137,15 +136,12 @@ impl FunctionEntry {
         let mut infos = Vec::new();
 
         let require_arg_count = arguments.iter().filter(|arg| arg.required).count();
-        infos.push(create_zend_arg_info(
-            require_arg_count as *const c_char,
-            false,
-        ));
+        infos.push(phper_zend_begin_arg_info_ex(false, require_arg_count));
 
         for arg in arguments {
-            infos.push(create_zend_arg_info(
-                arg.name.as_ptr().cast(),
+            infos.push(phper_zend_arg_info(
                 arg.pass_by_ref,
+                arg.name.as_ptr().cast(),
             ));
         }
 
@@ -287,12 +283,12 @@ impl Argument {
 }
 
 #[repr(transparent)]
-pub struct ZendFunction {
+pub struct ZendFunc {
     inner: zend_function,
 }
 
-impl ZendFunction {
-    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_function) -> &'a mut ZendFunction {
+impl ZendFunc {
+    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_function) -> &'a mut ZendFunc {
         let ptr = ptr as *mut Self;
         ptr.as_mut().expect("ptr shouldn't be null")
     }
@@ -446,55 +442,6 @@ unsafe extern "C" fn invoke(execute_data: *mut zend_execute_data, return_value:
     handler.call(execute_data, transmute(arguments), return_value);
 }
 
-pub(crate) const fn create_zend_arg_info(
-    name: *const c_char, _pass_by_ref: bool,
-) -> zend_internal_arg_info {
-    #[cfg(phper_major_version = "8")]
-    {
-        zend_internal_arg_info {
-            name,
-            type_: zend_type {
-                ptr: null_mut(),
-                type_mask: 0,
-            },
-            default_value: null_mut(),
-        }
-    }
-
-    #[cfg(all(
-        phper_major_version = "7",
-        any(
-            phper_minor_version = "4",
-            phper_minor_version = "3",
-            phper_minor_version = "2",
-        )
-    ))]
-    {
-        #[allow(clippy::unnecessary_cast)]
-        zend_internal_arg_info {
-            name,
-            type_: 0 as crate::sys::zend_type,
-            pass_by_reference: _pass_by_ref as zend_uchar,
-            is_variadic: 0,
-        }
-    }
-
-    #[cfg(all(
-        phper_major_version = "7",
-        any(phper_minor_version = "1", phper_minor_version = "0")
-    ))]
-    {
-        zend_internal_arg_info {
-            name,
-            class_name: std::ptr::null(),
-            type_hint: 0,
-            allow_null: 0,
-            pass_by_reference: _pass_by_ref as zend_uchar,
-            is_variadic: 0,
-        }
-    }
-}
-
 /// Call user function by name.
 ///
 /// # Examples

phper/src/lib.rs

@@ -23,6 +23,7 @@ pub mod ini;
 pub mod modules;
 pub mod objects;
 pub mod output;
+pub mod references;
 pub mod resources;
 pub mod strings;
 pub mod types;

phper/src/objects.rs

@@ -13,7 +13,7 @@
 use crate::{
     alloc::EBox,
     classes::ClassEntry,
-    functions::{call_internal, ZendFunction},
+    functions::{call_internal, ZendFunc},
     sys::*,
     values::ZVal,
 };
@@ -231,7 +231,7 @@ impl ZObj {
                     if f.is_null() {
                         Ok(false)
                     } else {
-                        let zend_fn = ZendFunction::from_mut_ptr(f);
+                        let zend_fn = ZendFunc::from_mut_ptr(f);
                         zend_fn.call(Some(self), arguments)?;
                         Ok(true)
                     }

phper/src/references.rs

@@ -0,0 +1,68 @@
+// Copyright (c) 2022 PHPER Framework Team
+// PHPER is licensed under Mulan PSL v2.
+// You can use this software according to the terms and conditions of the Mulan
+// PSL v2. You may obtain a copy of Mulan PSL v2 at:
+//          http://license.coscl.org.cn/MulanPSL2
+// THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY
+// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+// See the Mulan PSL v2 for more details.
+
+//! Apis relate to [crate::sys::zend_resource].
+
+use crate::{sys::*, values::ZVal};
+
+/// Wrapper of [crate::sys::zend_resource].
+#[repr(transparent)]
+pub struct ZRef {
+    inner: zend_reference,
+}
+
+impl ZRef {
+    /// # Safety
+    ///
+    /// Create from raw pointer.
+    pub unsafe fn from_ptr<'a>(ptr: *const zend_reference) -> &'a Self {
+        (ptr as *const Self)
+            .as_ref()
+            .expect("ptr should not be null")
+    }
+
+    /// # Safety
+    ///
+    /// Create from raw pointer.
+    pub unsafe fn try_from_ptr<'a>(ptr: *const zend_reference) -> Option<&'a Self> {
+        (ptr as *const Self).as_ref()
+    }
+
+    /// # Safety
+    ///
+    /// Create from raw pointer.
+    pub unsafe fn from_mut_ptr<'a>(ptr: *mut zend_reference) -> &'a mut Self {
+        (ptr as *mut Self).as_mut().expect("ptr should not be null")
+    }
+
+    /// # Safety
+    ///
+    /// Create from raw pointer.
+    pub unsafe fn try_from_mut_ptr<'a>(ptr: *mut zend_reference) -> Option<&'a mut Self> {
+        (ptr as *mut Self).as_mut()
+    }
+
+    pub const fn as_ptr(&self) -> *const zend_reference {
+        &self.inner
+    }
+
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut zend_reference {
+        &mut self.inner
+    }
+
+    pub fn val(&self) -> &ZVal {
+        unsafe { ZVal::from_ptr(&self.inner.val) }
+    }
+
+    pub fn val_mut(&mut self) -> &mut ZVal {
+        unsafe { ZVal::from_mut_ptr(&mut self.inner.val) }
+    }
+}