Add Display impl for ZendObject (#74)

* Add support to capture execptions from PHP

* Add extract function to Zval

* Add FromZendObject trait for casting objects to other types

Author: vodik

build.rs

@@ -176,6 +176,7 @@ const ALLOWED_BINDINGS: &[&str] = &[
     "std_object_handlers",
     "zend_array_destroy",
     "zend_array_dup",
+    "zend_call_known_function",
     "zend_ce_argument_count_error",
     "zend_ce_arithmetic_error",
     "zend_ce_compile_error",

src/php/globals.rs

@@ -2,7 +2,7 @@
 
 use crate::bindings::{_zend_executor_globals, ext_php_rs_executor_globals};
 
-use super::types::array::HashTable;
+use super::types::{array::HashTable, object::ZendObject};
 
 /// Stores global variables used in the PHP executor.
 pub type ExecutorGlobals = _zend_executor_globals;
@@ -16,8 +16,32 @@ impl ExecutorGlobals {
             .expect("Static executor globals were invalid")
     }
 
+    fn get_mut() -> &'static mut Self {
+        // SAFETY: PHP executor globals are statically declared therefore should never
+        // return an invalid pointer.
+        // TODO: Should this be syncronized?
+        unsafe { ext_php_rs_executor_globals().as_mut() }
+            .expect("Static executor globals were invalid")
+    }
+
     /// Attempts to retrieve the global class hash table.
     pub fn class_table(&self) -> Option<&HashTable> {
         unsafe { self.class_table.as_ref() }
     }
+
+    /// Attempts to extract the last PHP exception captured by the interpreter.
+    ///
+    /// Note that the caller is responsible for freeing the memory here or it'll leak.
+    pub fn take_exception() -> Option<*mut ZendObject> {
+        let globals = Self::get_mut();
+
+        let mut exception_ptr = std::ptr::null_mut();
+        std::mem::swap(&mut exception_ptr, &mut globals.exception);
+
+        if !exception_ptr.is_null() {
+            Some(exception_ptr)
+        } else {
+            None
+        }
+    }
 }

src/php/types/object.rs

@@ -17,17 +17,19 @@ use std::{
 use crate::{
     bindings::{
         ext_php_rs_zend_object_alloc, ext_php_rs_zend_object_release, object_properties_init,
-        std_object_handlers, zend_is_true, zend_object, zend_object_handlers, zend_object_std_dtor,
-        zend_object_std_init, zend_objects_clone_members, zend_std_get_properties,
-        zend_std_has_property, zend_std_read_property, zend_std_write_property, zend_string,
-        HashTable, ZEND_ISEMPTY, ZEND_PROPERTY_EXISTS, ZEND_PROPERTY_ISSET,
+        std_object_handlers, zend_call_known_function, zend_is_true, zend_object,
+        zend_object_handlers, zend_object_std_dtor, zend_object_std_init,
+        zend_objects_clone_members, zend_std_get_properties, zend_std_has_property,
+        zend_std_read_property, zend_std_write_property, zend_string, HashTable, ZEND_ISEMPTY,
+        ZEND_PROPERTY_EXISTS, ZEND_PROPERTY_ISSET,
     },
     errors::{Error, Result},
     php::{
         class::ClassEntry,
         enums::DataType,
         exceptions::PhpResult,
         flags::ZvalTypeFlags,
+        globals::ExecutorGlobals,
         types::{array::OwnedHashTable, string::ZendString},
     },
 };
@@ -166,6 +168,68 @@ impl ZendObject {
     fn mut_ptr(&self) -> *mut Self {
         (self as *const Self) as *mut Self
     }
+
+    /// Extracts some type from a Zend object.
+    ///
+    /// This is a wrapper function around `FromZendObject::extract()`.
+    pub fn extract<'a, T>(&'a self) -> Result<T>
+    where
+        T: FromZendObject<'a>,
+    {
+        T::from_zend_object(self)
+    }
+}
+
+/// `FromZendObject` is implemented by types which can be extracted from a Zend object.
+///
+/// Normal usage is through the helper method `ZendObject::extract`:
+///
+/// ```rust,ignore
+/// let obj: ZendObject = ...;
+/// let repr: String = obj.extract();
+/// let props: HashMap = obj.extract();
+/// ```
+///
+/// Should be functionally equivalent to casting an object to another compatable type.
+pub trait FromZendObject<'a>: Sized {
+    /// Extracts `Self` from the source `ZendObject`.
+    fn from_zend_object(obj: &'a ZendObject) -> Result<Self>;
+}
+
+impl FromZendObject<'_> for String {
+    fn from_zend_object(obj: &ZendObject) -> Result<Self> {
+        let mut ret = Zval::new();
+        unsafe {
+            zend_call_known_function(
+                (*obj.ce).__tostring,
+                obj as *const _ as *mut _,
+                obj.ce,
+                &mut ret,
+                0,
+                std::ptr::null_mut(),
+                std::ptr::null_mut(),
+            );
+        }
+
+        if let Some(err) = ExecutorGlobals::take_exception() {
+            // TODO: become an error
+            let class_name = obj.get_class_name();
+            panic!(
+                "Uncaught exception during call to {}::__toString(): {:?}",
+                class_name.expect("unable to determine class name"),
+                err
+            );
+        } else if let Some(output) = ret.extract() {
+            Ok(output)
+        } else {
+            // TODO: become an error
+            let class_name = obj.get_class_name();
+            panic!(
+                "{}::__toString() must return a string",
+                class_name.expect("unable to determine class name"),
+            );
+        }
+    }
 }
 
 impl Debug for ZendObject {

src/php/types/zval.rs

@@ -461,6 +461,16 @@ impl Zval {
         unsafe { zval_ptr_dtor(self) };
         self.u1.type_info = ty.bits();
     }
+
+    /// Extracts some type from a `Zval`.
+    ///
+    /// This is a wrapper function around `TryFrom`.
+    pub fn extract<'a, T>(&'a self) -> Option<T>
+    where
+        T: FromZval<'a>,
+    {
+        FromZval::from_zval(self)
+    }
 }
 
 impl Debug for Zval {