Refactoring

Author: danog

allowed_bindings.rs

@@ -54,6 +54,8 @@ bind! {
     zend_array_destroy,
     zend_array_dup,
     zend_call_known_function,
+    zend_fetch_function_str,
+    zend_hash_str_find_ptr_lc,
     zend_ce_argument_count_error,
     zend_ce_arithmetic_error,
     zend_ce_compile_error,

crates/macros/src/method.rs

@@ -194,28 +194,22 @@ pub fn parser(
                 #hack_tokens
                 let future = async move #stmts;
 
-                let future = GLOBAL_CONNECTION.with_borrow_mut(move |c| {
+                let future = ::ext_php_rs::zend::EVENTLOOP.with_borrow_mut(move |c| {
                     let c = c.as_mut().unwrap();
-                    let f = ::ext_php_rs::get_current_suspension!();
-                    let idx = c.fibers.len() as u64;
-                    let mut callable = Zval::new();
-                    callable.set_array(vec![f, "resume".into_zval(false).unwrap()]).unwrap();
-                    c.fibers.insert_at_index(idx, callable).unwrap();
+                    let idx = c.prepare_resume();
 
                     let sender = c.sender.clone();
                     let mut notifier = c.notify_sender.try_clone().unwrap();
 
-                    ::ext_php_rs::zend::RUNTIME.spawn(async move {
+                    let res = ::ext_php_rs::zend::RUNTIME.spawn(async move {
                         let res = future.await;
                         sender.send(idx).unwrap();
-                        notifier.write_all(&[0]).unwrap();
+                        ::std::io::Write::write_all(&mut notifier, &[0]).unwrap();
                         res
                     })
                 });
 
-                let mut callable = Zval::new();
-                callable.set_array(vec![::ext_php_rs::get_current_suspension!(), "suspend".into_zval(false).unwrap()]).unwrap();
-                call_user_func!(callable).unwrap();
+                ::ext_php_rs::zend::EVENTLOOP.suspend();
 
                 return ::ext_php_rs::zend::RUNTIME
                     .block_on(future).unwrap();

docsrs_bindings.rs

@@ -1,6 +1,6 @@
 /* automatically generated by rust-bindgen 0.65.1 */
 
-pub const ZEND_DEBUG: u32 = 1;
+pub const ZEND_DEBUG: u32 = 0;
 pub const _ZEND_TYPE_NAME_BIT: u32 = 16777216;
 pub const _ZEND_TYPE_NULLABLE_BIT: u32 = 2;
 pub const HT_MIN_SIZE: u32 = 8;
@@ -87,6 +87,11 @@ pub const CONST_CS: u32 = 0;
 pub const CONST_PERSISTENT: u32 = 1;
 pub const CONST_NO_FILE_CACHE: u32 = 2;
 pub const CONST_DEPRECATED: u32 = 4;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __sigset_t {
+    pub __val: [::std::os::raw::c_ulong; 16usize],
+}
 pub type zend_long = i64;
 pub type zend_ulong = u64;
 pub type zend_uchar = ::std::os::raw::c_uchar;
@@ -285,22 +290,10 @@ pub struct _zend_ast_ref {
     pub gc: zend_refcounted_h,
 }
 extern "C" {
-    pub fn _emalloc(
-        size: usize,
-        __zend_filename: *const ::std::os::raw::c_char,
-        __zend_lineno: u32,
-        __zend_orig_filename: *const ::std::os::raw::c_char,
-        __zend_orig_lineno: u32,
-    ) -> *mut ::std::os::raw::c_void;
+    pub fn _emalloc(size: usize) -> *mut ::std::os::raw::c_void;
 }
 extern "C" {
-    pub fn _efree(
-        ptr: *mut ::std::os::raw::c_void,
-        __zend_filename: *const ::std::os::raw::c_char,
-        __zend_lineno: u32,
-        __zend_orig_filename: *const ::std::os::raw::c_char,
-        __zend_orig_lineno: u32,
-    );
+    pub fn _efree(ptr: *mut ::std::os::raw::c_void);
 }
 extern "C" {
     pub fn __zend_malloc(len: usize) -> *mut ::std::os::raw::c_void;
@@ -387,6 +380,13 @@ extern "C" {
 extern "C" {
     pub fn zend_array_destroy(ht: *mut HashTable);
 }
+extern "C" {
+    pub fn zend_hash_str_find_ptr_lc(
+        ht: *const HashTable,
+        str_: *const ::std::os::raw::c_char,
+        len: usize,
+    ) -> *mut ::std::os::raw::c_void;
+}
 extern "C" {
     pub fn gc_possible_root(ref_: *mut zend_refcounted);
 }
@@ -1027,7 +1027,15 @@ pub struct _zend_execute_data {
     pub run_time_cache: *mut *mut ::std::os::raw::c_void,
     pub extra_named_params: *mut zend_array,
 }
-pub type sigjmp_buf = [::std::os::raw::c_int; 49usize];
+pub type __jmp_buf = [::std::os::raw::c_long; 8usize];
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __jmp_buf_tag {
+    pub __jmpbuf: __jmp_buf,
+    pub __mask_was_saved: ::std::os::raw::c_int,
+    pub __saved_mask: __sigset_t,
+}
+pub type jmp_buf = [__jmp_buf_tag; 1usize];
 pub type zend_executor_globals = _zend_executor_globals;
 extern "C" {
     pub static mut executor_globals: zend_executor_globals;
@@ -1094,7 +1102,7 @@ pub struct _zend_executor_globals {
     pub symtable_cache_ptr: *mut *mut zend_array,
     pub symbol_table: zend_array,
     pub included_files: HashTable,
-    pub bailout: *mut sigjmp_buf,
+    pub bailout: *mut jmp_buf,
     pub error_reporting: ::std::os::raw::c_int,
     pub exit_status: ::std::os::raw::c_int,
     pub function_table: *mut HashTable,
@@ -1237,6 +1245,12 @@ pub struct _zend_vm_stack {
     pub end: *mut zval,
     pub prev: zend_vm_stack,
 }
+extern "C" {
+    pub fn zend_fetch_function_str(
+        name: *const ::std::os::raw::c_char,
+        len: usize,
+    ) -> *mut zend_function;
+}
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct _zend_function_entry {

src/builders/module.rs

@@ -1,8 +1,8 @@
 use crate::{
     error::Result,
     ffi::{ext_php_rs_php_build_id, ZEND_MODULE_API_NO},
-    zend::{FunctionEntry, ModuleEntry},
-    PHP_DEBUG, PHP_ZTS,
+    zend::{FunctionEntry, ModuleEntry, request_shutdown, request_startup},
+    PHP_DEBUG, PHP_ZTS, types::ZendClassObject,
 };
 
 use std::{ffi::CString, mem, ptr};
@@ -64,8 +64,8 @@ impl ModuleBuilder {
                 functions: ptr::null(),
                 module_startup_func: None,
                 module_shutdown_func: None,
-                request_startup_func: None,
-                request_shutdown_func: None,
+                request_startup_func: Some(request_startup),
+                request_shutdown_func: Some(request_shutdown),
                 info_func: None,
                 version: ptr::null(),
                 globals_size: 0,

src/error.rs

@@ -52,6 +52,8 @@ pub enum Error {
     InvalidUtf8,
     /// Could not call the given function.
     Callable,
+    /// An object was expected.
+    Object,
     /// An invalid exception type was thrown.
     InvalidException(ClassFlags),
     /// Converting integer arguments resulted in an overflow.
@@ -84,6 +86,7 @@ impl Display for Error {
             ),
             Error::InvalidUtf8 => write!(f, "Invalid Utf8 byte sequence."),
             Error::Callable => write!(f, "Could not call given function."),
+            Error::Object => write!(f, "An object was expected."),
             Error::InvalidException(flags) => {
                 write!(f, "Invalid exception type was thrown: {flags:?}")
             }

src/lib.rs

@@ -5,6 +5,7 @@
 #![allow(non_snake_case)]
 #![cfg_attr(docs, feature(doc_cfg))]
 #![cfg_attr(windows, feature(abi_vectorcall))]
+#![feature(thread_local, local_key_cell_methods)]
 
 pub mod alloc;
 pub mod args;
@@ -35,6 +36,7 @@ pub mod zend;
 /// A module typically glob-imported containing the typically required macros
 /// and imports.
 pub mod prelude {
+    use crate::boxed::ZBox;
     pub use crate::builders::ModuleBuilder;
     #[cfg(any(docs, feature = "closure"))]
     #[cfg_attr(docs, doc(cfg(feature = "closure")))]

src/macros.rs

@@ -72,31 +72,6 @@ macro_rules! call_user_func {
     };
 }
 
-#[macro_export]
-macro_rules! call_static_method {
-    ($clazz: expr, $fn: expr) => {{
-        let mut callable = ext_php_rs::types::Zval::new();
-        callable
-            .set_array(vec![$clazz, $fn])
-            .unwrap();
-        call_user_func!(callable)
-    }};
-
-    ($clazz: expr, $fn: expr, $($param: expr),*) => {{
-        let mut callable = ext_php_rs::types::Zval::new();
-        callable
-            .set_array(vec![$clazz, $fn])
-            .unwrap();
-        call_user_func!(callable, $(&$param),*)
-    }};
-}
-
-#[macro_export]
-macro_rules! get_current_suspension {
-    () => { ext_php_rs::call_static_method!("\\Revolt\\EventLoop", "getSuspension").unwrap() }
-}
-
-
 /// Parses a given list of arguments using the [`ArgParser`] class.
 ///
 /// # Examples

src/types/array.rs

@@ -187,6 +187,33 @@ impl ZendHashTable {
         unsafe { zend_hash_str_find(self, str.as_ptr(), key.len() as _).as_ref() }
     }
 
+    /// Attempts to retrieve a value from the hash table with a string key.
+    ///
+    /// # Parameters
+    ///
+    /// * `key` - The key to search for in the hash table.
+    ///
+    /// # Returns
+    ///
+    /// * `Some(&Zval)` - A reference to the zval at the position in the hash
+    ///   table.
+    /// * `None` - No value at the given position was found.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use ext_php_rs::types::ZendHashTable;
+    ///
+    /// let mut ht = ZendHashTable::new();
+    ///
+    /// ht.insert("test", "hello world");
+    /// assert_eq!(ht.get("test").and_then(|zv| zv.str()), Some("hello world"));
+    /// ```
+    pub fn get_mut(&self, key: &'_ str) -> Option<&mut Zval> {
+        let str = CString::new(key).ok()?;
+        unsafe { zend_hash_str_find(self, str.as_ptr(), key.len() as _).as_mut() }
+    }
+
     /// Attempts to retrieve a value from the hash table with an index.
     ///
     /// # Parameters
@@ -213,6 +240,32 @@ impl ZendHashTable {
         unsafe { zend_hash_index_find(self, key).as_ref() }
     }
 
+    /// Attempts to retrieve a value from the hash table with an index.
+    ///
+    /// # Parameters
+    ///
+    /// * `key` - The key to search for in the hash table.
+    ///
+    /// # Returns
+    ///
+    /// * `Some(&Zval)` - A reference to the zval at the position in the hash
+    ///   table.
+    /// * `None` - No value at the given position was found.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use ext_php_rs::types::ZendHashTable;
+    ///
+    /// let mut ht = ZendHashTable::new();
+    ///
+    /// ht.push(100);
+    /// assert_eq!(ht.get_index(0).and_then(|zv| zv.long()), Some(100));
+    /// ```
+    pub fn get_index_mut(&self, key: u64) -> Option<&mut Zval> {
+        unsafe { zend_hash_index_find(self, key).as_mut() }
+    }
+
     /// Attempts to remove a value from the hash table with a string key.
     ///
     /// # Parameters

src/zend/borrow_unchecked.rs

@@ -0,0 +1,52 @@
+use crate::binary_slice::{BinarySlice, PackSlice};
+
+#[inline(always)]
+pub unsafe fn borrow_unchecked<
+    'original,
+    'unbounded,
+    Ref: BorrowUnchecked<'original, 'unbounded>,
+>(
+    reference: Ref,
+) -> Ref::Unbounded {
+    unsafe { BorrowUnchecked::borrow_unchecked(reference) }
+}
+
+#[doc(hidden)]
+pub unsafe trait BorrowUnchecked<'original, 'unbounded> {
+    type Unbounded;
+
+    unsafe fn borrow_unchecked(self) -> Self::Unbounded;
+}
+
+unsafe impl<'original, 'unbounded, T: 'unbounded> BorrowUnchecked<'original, 'unbounded>
+    for &'original T
+{
+    type Unbounded = &'unbounded T;
+
+    #[inline(always)]
+    unsafe fn borrow_unchecked(self) -> Self::Unbounded {
+        unsafe { ::core::mem::transmute(self) }
+    }
+}
+
+unsafe impl<'original, 'unbounded, T: 'unbounded> BorrowUnchecked<'original, 'unbounded>
+    for &'original mut T
+{
+    type Unbounded = &'unbounded mut T;
+
+    #[inline(always)]
+    unsafe fn borrow_unchecked(self) -> Self::Unbounded {
+        unsafe { ::core::mem::transmute(self) }
+    }
+}
+
+unsafe impl<'original, 'unbounded, T: 'unbounded + PackSlice> BorrowUnchecked<'original, 'unbounded>
+    for BinarySlice<'original, T>
+{
+    type Unbounded = BinarySlice<'unbounded, T>;
+
+    #[inline(always)]
+    unsafe fn borrow_unchecked(self) -> Self::Unbounded {
+        unsafe { ::core::mem::transmute(self) }
+    }
+}