feat(iterator): handle exception

Author: joelwurtz

src/types/iterable.rs

@@ -1,6 +1,7 @@
 use super::array::Iter as ZendHashTableIter;
 use super::iterator::Iter as ZendIteratorIter;
 use crate::convert::FromZval;
+use crate::exception::PhpResult;
 use crate::flags::DataType;
 use crate::types::iterator::IterKey;
 use crate::types::{ZendHashTable, ZendIterator, Zval};
@@ -15,10 +16,10 @@ pub enum Iterable<'a> {
 
 impl<'a> Iterable<'a> {
     /// Creates a new rust iterator from a PHP iterable.
-    pub fn iter(&mut self) -> Iter {
+    pub fn iter(&mut self) -> PhpResult<Iter> {
         match self {
-            Iterable::Array(array) => Iter::Array(array.iter()),
-            Iterable::Traversable(traversable) => Iter::Traversable(traversable.iter()),
+            Iterable::Array(array) => Ok(Iter::Array(array.iter())),
+            Iterable::Traversable(traversable) => Ok(Iter::Traversable(traversable.iter()?)),
         }
     }
 }
@@ -46,11 +47,11 @@ pub enum Iter<'a> {
 }
 
 impl<'a> Iterator for Iter<'a> {
-    type Item = (IterKey, &'a Zval);
+    type Item = PhpResult<(IterKey, &'a Zval)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self {
-            Iter::Array(array) => array.next(),
+            Iter::Array(array) => array.next().map(Ok),
             Iter::Traversable(traversable) => traversable.next(),
         }
     }

src/types/iterator.rs

@@ -1,7 +1,9 @@
 use crate::convert::{FromZval, FromZvalMut};
-use crate::ffi::zend_object_iterator;
+use crate::ffi::{zend_object_iterator, ZEND_RESULT_CODE_SUCCESS};
 use crate::flags::DataType;
+use crate::prelude::PhpResult;
 use crate::types::Zval;
+use crate::zend::ExecutorGlobals;
 use std::fmt::{Debug, Display, Formatter};
 
 /// A PHP Iterator.
@@ -16,47 +18,55 @@ impl ZendIterator {
     /// # Returns
     ///
     /// Returns a iterator over the zend_object_iterator.
-    pub fn iter(&mut self) -> Iter {
+    pub fn iter(&mut self) -> PhpResult<Iter> {
         self.index = 0;
-        self.rewind();
+        self.rewind()?;
 
-        Iter { zi: self }
+        Ok(Iter { zi: self })
     }
 
     /// Check if the current position of the iterator is valid.
     ///
     /// As an example this will call the user defined valid method of the ['\Iterator'] interface.
     /// see <https://www.php.net/manual/en/iterator.valid.php>
-    pub fn valid(&mut self) -> bool {
+    pub fn valid(&mut self) -> PhpResult<bool> {
         if let Some(valid) = unsafe { (*self.funcs).valid } {
-            unsafe { valid(&mut *self) != 0 }
+            let valid = unsafe { valid(&mut *self) == ZEND_RESULT_CODE_SUCCESS };
+
+            ExecutorGlobals::throw_if_exception()?;
+
+            Ok(valid)
         } else {
-            true
+            Ok(true)
         }
     }
 
     /// Rewind the iterator to the first element.
     ///
     /// As an example this will call the user defined rewind method of the ['\Iterator'] interface.
     /// see <https://www.php.net/manual/en/iterator.rewind.php>
-    pub fn rewind(&mut self) {
+    pub fn rewind(&mut self) -> PhpResult<()> {
         if let Some(rewind) = unsafe { (*self.funcs).rewind } {
             unsafe {
                 rewind(&mut *self);
             }
         }
+
+        ExecutorGlobals::throw_if_exception()
     }
 
     /// Move the iterator forward to the next element.
     ///
     /// As an example this will call the user defined next method of the ['\Iterator'] interface.
     /// see <https://www.php.net/manual/en/iterator.next.php>
-    pub fn move_forward(&mut self) {
+    pub fn move_forward(&mut self) -> PhpResult<()> {
         if let Some(move_forward) = unsafe { (*self.funcs).move_forward } {
             unsafe {
                 move_forward(&mut *self);
             }
         }
+
+        ExecutorGlobals::throw_if_exception()
     }
 
     /// Get the current data of the iterator.
@@ -65,11 +75,16 @@ impl ZendIterator {
     ///
     /// Returns a reference to the current data of the iterator if available
     /// , ['None'] otherwise.
-    pub fn get_current_data<'a>(&mut self) -> Option<&'a Zval> {
-        let get_current_data = unsafe { (*self.funcs).get_current_data }?;
+    pub fn get_current_data<'a>(&mut self) -> PhpResult<Option<&'a Zval>> {
+        let get_current_data = match unsafe { (*self.funcs).get_current_data } {
+            Some(get_current_data) => get_current_data,
+            None => return Ok(None),
+        };
         let value = unsafe { &*get_current_data(&mut *self) };
 
-        Some(value)
+        ExecutorGlobals::throw_if_exception()?;
+
+        Ok(Some(value))
     }
 
     /// Get the current key of the iterator.
@@ -78,14 +93,21 @@ impl ZendIterator {
     ///
     /// Returns a new ['Zval'] containing the current key of the iterator if available
     /// , ['None'] otherwise.
-    pub fn get_current_key(&mut self) -> Option<Zval> {
-        let get_current_key = unsafe { (*self.funcs).get_current_key }?;
+    pub fn get_current_key(&mut self) -> PhpResult<Option<Zval>> {
+        let get_current_key = match unsafe { (*self.funcs).get_current_key } {
+            Some(get_current_key) => get_current_key,
+            None => return Ok(None),
+        };
+
         let mut key = Zval::new();
+
         unsafe {
             get_current_key(&mut *self, &mut key);
         }
 
-        Some(key)
+        ExecutorGlobals::throw_if_exception()?;
+
+        Ok(Some(key))
     }
 }
 
@@ -142,31 +164,40 @@ pub struct Iter<'a> {
 }
 
 impl<'a> Iterator for Iter<'a> {
-    type Item = (IterKey, &'a Zval);
+    type Item = PhpResult<(IterKey, &'a Zval)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         // Call next when index > 0, so next is really called at the start of each iteration, which allow to work better with generator iterator
         if self.zi.index > 0 {
-            self.zi.move_forward();
-
-            if !self.zi.valid() {
-                return None;
+            if let Err(err) = self.zi.move_forward() {
+                return Some(Err(err));
             }
         }
 
+        match self.zi.valid() {
+            Err(err) => return Some(Err(err)),
+            Ok(false) => return None,
+            Ok(true) => (),
+        }
+
         self.zi.index += 1;
 
-        let key = self.zi.get_current_key();
-        let value = self.zi.get_current_data()?;
         let real_index = self.zi.index - 1;
 
-        Some(match key {
-            Some(key) => match IterKey::from_zval(&key) {
-                Some(key) => (key, value),
-                None => (IterKey::Long(real_index), value),
+        let key = match self.zi.get_current_key() {
+            Err(err) => return Some(Err(err)),
+            Ok(None) => IterKey::Long(real_index),
+            Ok(Some(key)) => match IterKey::from_zval(&key) {
+                Some(key) => key,
+                None => IterKey::Long(real_index),
             },
-            None => (IterKey::Long(real_index), value),
-        })
+        };
+
+        match self.zi.get_current_data() {
+            Err(err) => Some(Err(err)),
+            Ok(None) => None,
+            Ok(Some(value)) => Some(Ok((key, value))),
+        }
     }
 }
 

src/zend/globals.rs

@@ -6,6 +6,7 @@ use std::ops::{Deref, DerefMut};
 use parking_lot::{const_rwlock, RwLock, RwLockReadGuard, RwLockWriteGuard};
 
 use crate::boxed::ZBox;
+use crate::exception::PhpResult;
 #[cfg(php82)]
 use crate::ffi::zend_atomic_bool_store;
 use crate::ffi::{_zend_executor_globals, ext_php_rs_executor_globals, zend_ini_entry};
@@ -87,6 +88,13 @@ impl ExecutorGlobals {
     /// could lead to a deadlock if the globals are already borrowed immutably
     /// or mutably.
     pub fn take_exception() -> Option<ZBox<ZendObject>> {
+        {
+            // This avoid a write lock if there is no exception.
+            if Self::get().exception.is_null() {
+                return None;
+            }
+        }
+
         let mut globals = Self::get_mut();
 
         let mut exception_ptr = std::ptr::null_mut();
@@ -96,6 +104,20 @@ impl ExecutorGlobals {
         Some(unsafe { ZBox::from_raw(exception_ptr.as_mut()?) })
     }
 
+    /// Attempts to extract the last PHP exception captured by the interpreter.
+    /// Returned inside a [`PhpResult`].
+    ///
+    /// This function requires the executor globals to be mutably held, which
+    /// could lead to a deadlock if the globals are already borrowed immutably
+    /// or mutably.
+    pub fn throw_if_exception() -> PhpResult<()> {
+        if let Some(e) = Self::take_exception() {
+            Err(crate::error::Error::Exception(e).into())
+        } else {
+            Ok(())
+        }
+    }
+
     /// Request an interrupt of the PHP VM. This will call the registered
     /// interrupt handler function.
     /// set with [`crate::ffi::zend_interrupt_function`].