Added ability to get and set properties (#39)

* Fixed adding properties to classes

* Removed unused function from wrapper header

* Moved property functions into `ZendObject`

* Introduced `ZendString` wrapper for raw pointer

* Set refcount of Zval to 0 when setting string properties

* Added ability to check if a property exists

Made some lifetimes explicit, check if property exists before attempting
to get.

* Removed unused file

* Removed unused lifetimes

Clippy was complaining, they were added to ensure that a `'static`
lifetime wasn't returned.

Author: davidcole1340

example/skel/src/lib.rs

@@ -9,11 +9,14 @@ use ext_php_rs::{
         enums::DataType,
         exceptions::throw,
         execution_data::ExecutionData,
-        flags::MethodFlags,
+        flags::{MethodFlags, PropertyFlags},
         function::FunctionBuilder,
         module::{ModuleBuilder, ModuleEntry},
         types::{
-            array::ZendHashTable, long::ZendLong, object::ZendClassObject, string::ZendString,
+            array::ZendHashTable,
+            long::ZendLong,
+            object::{PropertyQuery, ZendClassObject},
+            string::ZendString,
             zval::Zval,
         },
     },
@@ -57,7 +60,14 @@ impl Test {
 
     pub extern "C" fn get(execute_data: &mut ExecutionData, _retval: &mut Zval) {
         let x = ZendClassObject::<Test>::get(execute_data).unwrap();
-        dbg!(x.a);
+        //let param = execute_data.get_property("value");
+        let obj = execute_data.get_self().unwrap();
+        dbg!(obj.get_property("value"));
+        obj.set_property("value", "Hello");
+        // dbg!(param);
+        //execute_data.set_property("new_value", "New value...");
+        //execute_data.set_property("value", "Hello, world!");
+        // dbg!(execute_data.set_property("value", "Hello, world!"));
     }
 
     pub extern "C" fn call(execute_data: &mut ExecutionData, _retval: &mut Zval) {
@@ -107,7 +117,7 @@ pub extern "C" fn module_init(_type: i32, module_number: i32) -> i32 {
                 .build(),
             MethodFlags::Public,
         )
-        // .property("value", "world", PropertyFlags::Protected)
+        .property("value", "world", PropertyFlags::Public)
         .constant("TEST", "Hello world")
         .object_override::<Test>()
         .build();

example/skel/test.php

@@ -2,6 +2,12 @@
 
 include __DIR__.'/vendor/autoload.php';
 
-$x = pack('f*', 1234, 5678, 9012);
-var_dump(unpack('l*', skel_unpack($x)));
-dd($x);
+//$y = new \stdClass;
+//$y->hello = 'asdf';
+
+$x = new TestClass();
+var_dump($x);
+$x->get();
+var_dump($x);
+$x->value = null;
+$x->get();

src/errors.rs

@@ -7,7 +7,7 @@ pub type Result<T> = std::result::Result<T, Error>;
 
 /// The main error type which is passed by the library inside the custom
 /// [`Result`] type.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 #[non_exhaustive]
 pub enum Error {
     /// An incorrect number of arguments was given to a PHP function.
@@ -16,22 +16,26 @@ pub enum Error {
     /// number of arguments expected, and the second representing the number of
     /// arguments that were received.
     IncorrectArguments(u32, u32),
-
     /// There was an error converting a Zval into a primitive type.
     ///
     /// The enum carries the data type of the Zval.
     ZvalConversion(DataType),
-
     /// The type of the Zval is unknown.
     ///
     /// The enum carries the integer representation of the type of Zval.
-    UnknownDatatype(u8),
-
+    UnknownDatatype(u32),
     /// Attempted to convert a [`ZvalTypeFlags`] struct to a [`DataType`].
     /// The flags did not contain a datatype.
     ///
     /// The enum carries the flags that were attempted to be converted to a [`DataType`].
     InvalidTypeToDatatype(ZvalTypeFlags),
+    /// The function called was called in an invalid scope (calling class-related functions
+    /// inside of a non-class bound function).
+    InvalidScope,
+    /// The pointer inside a given type was invalid, either null or pointing to garbage.
+    InvalidPointer,
+    /// The given property name does not exist.
+    InvalidProperty,
 }
 
 impl Display for Error {
@@ -51,6 +55,9 @@ impl Display for Error {
             Error::InvalidTypeToDatatype(dt) => {
                 write!(f, "Type flags did not contain a datatype: {:?}", dt)
             }
+            Error::InvalidScope => write!(f, "Invalid scope."),
+            Error::InvalidPointer => write!(f, "Invalid pointer."),
+            Error::InvalidProperty => write!(f, "Property does not exist on object."),
         }
     }
 }

src/php/class.rs

@@ -5,7 +5,7 @@ use std::{mem, ptr};
 use crate::{
     bindings::{
         ext_php_rs_zend_string_release, zend_class_entry, zend_declare_class_constant,
-        zend_register_internal_class_ex,
+        zend_declare_property, zend_register_internal_class_ex,
     },
     functions::c_str,
 };
@@ -29,7 +29,7 @@ pub struct ClassBuilder<'a> {
     extends: *mut ClassEntry,
     methods: Vec<FunctionEntry>,
     object_override: Option<unsafe extern "C" fn(class_type: *mut ClassEntry) -> *mut ZendObject>,
-    // properties: Vec<(&'a str, Zval, PropertyFlags)>,
+    properties: Vec<(&'a str, Zval, PropertyFlags)>,
     constants: Vec<(&'a str, Zval)>,
 }
 
@@ -44,17 +44,21 @@ impl<'a> ClassBuilder<'a> {
     where
         N: AsRef<str>,
     {
-        let ptr = unsafe { libc::calloc(1, mem::size_of::<ClassEntry>()) } as *mut ClassEntry;
-        let self_ = Self {
-            ptr: unsafe { ptr.as_mut() }.unwrap(),
+        let ptr = unsafe {
+            (libc::calloc(1, mem::size_of::<ClassEntry>()) as *mut ClassEntry)
+                .as_mut()
+                .unwrap()
+        };
+        ptr.name = ZendString::new_interned(name).release();
+
+        Self {
+            ptr,
             extends: ptr::null_mut(),
             methods: vec![],
             object_override: None,
-            // properties: vec![],
+            properties: vec![],
             constants: vec![],
-        };
-        self_.ptr.name = ZendString::new_interned(name);
-        self_
+        }
     }
 
     /// Sets the class builder to extend another class.
@@ -79,8 +83,8 @@ impl<'a> ClassBuilder<'a> {
         self
     }
 
-    /// Adds a property to the class.
-    /// The type of the property is defined by the type of the given default.
+    /// Adds a property to the class. The initial type of the property is given by the type
+    /// of the given default. Note that the user can change the type.
     ///
     /// # Parameters
     ///
@@ -92,17 +96,16 @@ impl<'a> ClassBuilder<'a> {
     where
         T: Into<Zval>,
     {
-        panic!("Properties are currently not supported. See #16");
-        // let mut default = default.into();
+        let mut default = default.into();
 
-        // if default.is_string() {
-        //     let val = default.string().unwrap();
-        //     unsafe { ext_php_rs_zend_string_release(default.value.str_) };
-        //     default.set_persistent_string(val);
-        // }
+        if default.is_string() {
+            let val = default.string().unwrap();
+            unsafe { ext_php_rs_zend_string_release(default.value.str_) };
+            default.set_persistent_string(val);
+        }
 
-        // self.properties.push((name, default, flags));
-        // self
+        self.properties.push((name, default, flags));
+        self
     }
 
     /// Adds a constant to the class.
@@ -146,7 +149,10 @@ impl<'a> ClassBuilder<'a> {
     /// * `T` - The type which will override the Zend object. Must implement [`ZendObjectOverride`]
     /// which can be derived through the [`ZendObjectHandler`](ext_php_rs_derive::ZendObjectHandler)
     /// derive macro.
-    pub fn object_override<T: ZendObjectOverride>(mut self) -> Self {
+    pub fn object_override<T>(mut self) -> Self
+    where
+        T: ZendObjectOverride,
+    {
         self.object_override = Some(T::create_object);
         self
     }
@@ -165,18 +171,17 @@ impl<'a> ClassBuilder<'a> {
 
         unsafe { libc::free((self.ptr as *mut ClassEntry) as *mut libc::c_void) };
 
-        // DC: Commented out for now. Bug with properties.
-        // for (name, mut default, flags) in self.properties {
-        //     unsafe {
-        //         zend_declare_property(
-        //             class,
-        //             c_str(name),
-        //             name.len() as u64,
-        //             &mut default,
-        //             flags.bits() as i32,
-        //         );
-        //     }
-        // }
+        for (name, mut default, flags) in self.properties {
+            unsafe {
+                zend_declare_property(
+                    class,
+                    c_str(name),
+                    name.len() as _,
+                    &mut default,
+                    flags.bits() as _,
+                );
+            }
+        }
 
         for (name, value) in self.constants {
             let value = Box::into_raw(Box::new(value));

src/php/enums.rs

@@ -12,7 +12,7 @@ use crate::{
 };
 
 /// Valid data types for PHP.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
 #[repr(u32)]
 pub enum DataType {
     Undef = IS_UNDEF,
@@ -33,6 +33,17 @@ pub enum DataType {
     Void = IS_VOID,
 }
 
+// TODO: Ideally want something like this
+// pub struct Type {
+//     data_type: DataType,
+//     is_refcounted: bool,
+//     is_collectable: bool,
+//     is_immutable: bool,
+//     is_persistent: bool,
+// }
+//
+// impl From<u32> for Type { ... }
+
 impl TryFrom<ZvalTypeFlags> for DataType {
     type Error = Error;
 
@@ -64,12 +75,37 @@ impl TryFrom<ZvalTypeFlags> for DataType {
     }
 }
 
-impl TryFrom<u8> for DataType {
+impl TryFrom<u32> for DataType {
     type Error = Error;
 
-    fn try_from(value: u8) -> Result<Self> {
-        let flags = ZvalTypeFlags::from_bits(value.into()).ok_or(Error::UnknownDatatype(value))?;
-        DataType::try_from(flags)
+    #[allow(clippy::bad_bit_mask)]
+    fn try_from(value: u32) -> Result<Self> {
+        macro_rules! contains {
+            ($c: ident, $t: ident) => {
+                if (value & $c) == $c {
+                    return Ok(DataType::$t);
+                }
+            };
+        }
+
+        contains!(IS_VOID, Void);
+        contains!(IS_CALLABLE, Callable);
+        contains!(IS_CONSTANT_AST, ConstantExpression);
+        contains!(IS_CONSTANT_AST, ConstantExpression);
+        contains!(IS_CONSTANT_AST, ConstantExpression);
+        contains!(IS_REFERENCE, Reference);
+        contains!(IS_RESOURCE, Resource);
+        contains!(IS_OBJECT, Object);
+        contains!(IS_ARRAY, Array);
+        contains!(IS_STRING, String);
+        contains!(IS_DOUBLE, Double);
+        contains!(IS_LONG, Long);
+        contains!(IS_TRUE, True);
+        contains!(IS_FALSE, False);
+        contains!(IS_NULL, Null);
+        contains!(IS_UNDEF, Undef);
+
+        Err(Error::UnknownDatatype(value))
     }
 }
 
@@ -93,3 +129,47 @@ impl Display for DataType {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::DataType;
+    use crate::bindings::{
+        IS_ARRAY, IS_ARRAY_EX, IS_CALLABLE, IS_CONSTANT_AST, IS_CONSTANT_AST_EX, IS_DOUBLE,
+        IS_FALSE, IS_INTERNED_STRING_EX, IS_LONG, IS_NULL, IS_OBJECT, IS_OBJECT_EX, IS_REFERENCE,
+        IS_REFERENCE_EX, IS_RESOURCE, IS_RESOURCE_EX, IS_STRING, IS_STRING_EX, IS_TRUE, IS_UNDEF,
+        IS_VOID,
+    };
+    use std::convert::TryFrom;
+
+    #[test]
+    fn test_datatype() {
+        macro_rules! test {
+            ($c: ident, $t: ident) => {
+                assert_eq!(DataType::try_from($c), Ok(DataType::$t));
+            };
+        }
+
+        test!(IS_UNDEF, Undef);
+        test!(IS_NULL, Null);
+        test!(IS_FALSE, False);
+        test!(IS_TRUE, True);
+        test!(IS_LONG, Long);
+        test!(IS_DOUBLE, Double);
+        test!(IS_STRING, String);
+        test!(IS_ARRAY, Array);
+        test!(IS_OBJECT, Object);
+        test!(IS_RESOURCE, Resource);
+        test!(IS_REFERENCE, Reference);
+        test!(IS_CONSTANT_AST, ConstantExpression);
+        test!(IS_CALLABLE, Callable);
+        test!(IS_VOID, Void);
+
+        test!(IS_INTERNED_STRING_EX, String);
+        test!(IS_STRING_EX, String);
+        test!(IS_ARRAY_EX, Array);
+        test!(IS_OBJECT_EX, Object);
+        test!(IS_RESOURCE_EX, Resource);
+        test!(IS_REFERENCE_EX, Reference);
+        test!(IS_CONSTANT_AST_EX, ConstantExpression);
+    }
+}