Add support for Zval IS_INDIRECT

As mentioned in #219, I believe we're making incorrect use of IS_CALLABLE on Zval types right now. Zval type bits are never actually stored as IS_CALLABLE, which overlaps with the _actual_ type value of IS_INDIRECT. IS_INDIRECT is almost the same as IS_REFERENCE, but is a direct reference to another Zval rather than reference object. As `Zval::is_callable()` and `Zval::callable()` don't actually make use of `IS_CALLABLE` then I think it's safe to switch this out.

Author: joehoyle

allowed_bindings.rs

@@ -121,6 +121,7 @@ bind! {
     IS_CONSTANT_AST_EX,
     IS_DOUBLE,
     IS_FALSE,
+    IS_INDIRECT,
     IS_INTERNED_STRING_EX,
     IS_LONG,
     IS_MIXED,
@@ -141,6 +142,7 @@ bind! {
     IS_PTR,
     MAY_BE_ANY,
     MAY_BE_BOOL,
+    PHP_INI_PERDIR,
     USING_ZTS,
     ZEND_ACC_ABSTRACT,
     ZEND_ACC_ANON_CLASS,

docsrs_bindings.rs

@@ -19,6 +19,7 @@ pub const IS_CONSTANT_AST: u32 = 11;
 pub const IS_CALLABLE: u32 = 12;
 pub const IS_VOID: u32 = 14;
 pub const IS_MIXED: u32 = 16;
+pub const IS_INDIRECT: u32 = 12;
 pub const IS_PTR: u32 = 13;
 pub const _IS_BOOL: u32 = 18;
 pub const Z_TYPE_FLAGS_SHIFT: u32 = 8;

src/flags.rs

@@ -6,8 +6,8 @@ use bitflags::bitflags;
 use crate::ffi::ZEND_ACC_REUSE_GET_ITERATOR;
 use crate::ffi::{
     CONST_CS, CONST_DEPRECATED, CONST_NO_FILE_CACHE, CONST_PERSISTENT, IS_ARRAY, IS_CALLABLE,
-    IS_CONSTANT_AST, IS_DOUBLE, IS_FALSE, IS_LONG, IS_MIXED, IS_NULL, IS_OBJECT, IS_PTR,
-    IS_REFERENCE, IS_RESOURCE, IS_STRING, IS_TRUE, IS_TYPE_COLLECTABLE, IS_TYPE_REFCOUNTED,
+    IS_CONSTANT_AST, IS_DOUBLE, IS_FALSE, IS_INDIRECT, IS_LONG, IS_MIXED, IS_NULL, IS_OBJECT,
+    IS_PTR, IS_REFERENCE, IS_RESOURCE, IS_STRING, IS_TRUE, IS_TYPE_COLLECTABLE, IS_TYPE_REFCOUNTED,
     IS_UNDEF, IS_VOID, ZEND_ACC_ABSTRACT, ZEND_ACC_ANON_CLASS, ZEND_ACC_CALL_VIA_TRAMPOLINE,
     ZEND_ACC_CHANGED, ZEND_ACC_CLOSURE, ZEND_ACC_CONSTANTS_UPDATED, ZEND_ACC_CTOR,
     ZEND_ACC_DEPRECATED, ZEND_ACC_DONE_PASS_TWO, ZEND_ACC_EARLY_BINDING, ZEND_ACC_FAKE_CLOSURE,
@@ -185,6 +185,7 @@ pub enum DataType {
     Mixed,
     Bool,
     Ptr,
+    Indirect,
 }
 
 impl Default for DataType {
@@ -208,6 +209,7 @@ impl DataType {
             DataType::Object(_) => IS_OBJECT,
             DataType::Resource => IS_RESOURCE,
             DataType::Reference => IS_RESOURCE,
+            DataType::Indirect => IS_INDIRECT,
             DataType::Callable => IS_CALLABLE,
             DataType::ConstantExpression => IS_CONSTANT_AST,
             DataType::Void => IS_VOID,
@@ -275,7 +277,7 @@ impl From<u32> for DataType {
         }
 
         contains!(IS_VOID, Void);
-        contains!(IS_CALLABLE, Callable);
+        contains!(IS_INDIRECT, Indirect);
         contains!(IS_CONSTANT_AST, ConstantExpression);
         contains!(IS_REFERENCE, Reference);
         contains!(IS_RESOURCE, Resource);
@@ -318,6 +320,7 @@ impl Display for DataType {
             DataType::Bool => write!(f, "Bool"),
             DataType::Mixed => write!(f, "Mixed"),
             DataType::Ptr => write!(f, "Pointer"),
+            DataType::Indirect => write!(f, "Indirect"),
         }
     }
 }
@@ -327,9 +330,9 @@ mod tests {
     use super::DataType;
     use crate::ffi::{
         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,
+        IS_FALSE, IS_INDIRECT, 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;
 
@@ -353,7 +356,7 @@ mod tests {
         test!(IS_RESOURCE, Resource);
         test!(IS_REFERENCE, Reference);
         test!(IS_CONSTANT_AST, ConstantExpression);
-        test!(IS_CALLABLE, Callable);
+        test!(IS_INDIRECT, Indirect);
         test!(IS_VOID, Void);
 
         test!(IS_INTERNED_STRING_EX, String);

src/types/zval.rs

@@ -206,6 +206,24 @@ impl Zval {
         }
     }
 
+    /// Returns the value of the zval if it is an internal indirect reference.
+    pub fn indirect(&self) -> Option<&Zval> {
+        if self.is_indirect() {
+            Some(unsafe { &*(self.value.zv as *mut Zval) })
+        } else {
+            None
+        }
+    }
+
+    /// Returns a mutable reference to the zval if it is an internal indirect reference.
+    pub fn indirect_mut(&self) -> Option<&mut Zval> {
+        if self.is_indirect() {
+            Some(unsafe { &mut *(self.value.zv as *mut Zval) })
+        } else {
+            None
+        }
+    }
+
     /// Returns the value of the zval if it is a reference.
     pub fn reference(&self) -> Option<&Zval> {
         if self.is_reference() {
@@ -321,6 +339,11 @@ impl Zval {
         self.get_type() == DataType::Reference
     }
 
+    /// Returns true if the zval is a reference, false otherwise.
+    pub fn is_indirect(&self) -> bool {
+        self.get_type() == DataType::Indirect
+    }
+
     /// Returns true if the zval is callable, false otherwise.
     pub fn is_callable(&self) -> bool {
         let ptr: *const Self = self;
@@ -593,6 +616,7 @@ impl Debug for Zval {
             DataType::ConstantExpression => field!(Option::<()>::None),
             DataType::Void => field!(Option::<()>::None),
             DataType::Bool => field!(self.bool()),
+            DataType::Indirect => field!(self.indirect()),
             // SAFETY: We are not accessing the pointer.
             DataType::Ptr => field!(unsafe { self.ptr::<c_void>() }),
         };