Refactor Type, and add Array Iterator.

Author: jmjoy

phper-macros/src/lib.rs

@@ -73,7 +73,7 @@ pub fn php_get_module(attr: TokenStream, input: TokenStream) -> TokenStream {
     inner::php_get_module(attr, input)
 }
 
-/// Auto derive for [phper::errors::Throwable].
+/// Auto derive for `phper::errors::Throwable`.
 ///
 /// # Examples
 ///

phper/Cargo.toml

@@ -18,8 +18,8 @@ clap = "3.0.0-beta.2"
 dashmap = "4.0.2"
 derive_more = "0.99.13"
 indexmap = "1.6.2"
-num-derive = "0.3"
-num-traits = "0.2"
+#num-derive = "0.3"
+#num-traits = "0.2"
 once_cell = "1.7.2"
 phper-alloc = { version = "0.2.0-alpha.3", path = "../phper-alloc" }
 phper-macros = { version = "0.2.0-alpha.3", path = "../phper-macros" }

phper/src/arrays.rs

@@ -2,15 +2,17 @@
 
 use crate::{
     alloc::{EAllocatable, EBox},
+    strings::ZendString,
     sys::*,
     values::Val,
 };
-use std::mem::zeroed;
+use std::{borrow::Cow, mem::zeroed};
 
 /// Key for [Array].
+#[derive(Debug, Clone, PartialEq)]
 pub enum Key<'a> {
     Index(u64),
-    Str(&'a str),
+    Str(Cow<'a, str>),
 }
 
 impl From<u64> for Key<'_> {
@@ -21,7 +23,13 @@ impl From<u64> for Key<'_> {
 
 impl<'a> From<&'a str> for Key<'a> {
     fn from(s: &'a str) -> Self {
-        Key::Str(s)
+        Key::Str(Cow::Borrowed(s))
+    }
+}
+
+impl From<String> for Key<'_> {
+    fn from(s: String) -> Self {
+        Key::Str(Cow::Owned(s))
     }
 }
 
@@ -107,6 +115,13 @@ impl Array {
         }
         other
     }
+
+    pub fn iter(&self) -> Iter<'_> {
+        Iter {
+            index: 0,
+            array: &self,
+        }
+    }
 }
 
 impl EAllocatable for Array {
@@ -125,3 +140,45 @@ impl Drop for Array {
         unreachable!("Allocation on the stack is not allowed")
     }
 }
+
+pub struct Iter<'a> {
+    index: isize,
+    array: &'a Array,
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = (Key<'a>, &'a Val);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            if self.index >= self.array.inner.nNumUsed as isize {
+                break None;
+            }
+
+            unsafe {
+                let bucket = self.array.inner.arData.offset(self.index);
+
+                let key = if (*bucket).key.is_null() {
+                    Key::Index((*bucket).h)
+                } else {
+                    let s = ZendString::from_ptr((*bucket).key);
+                    let s = s.to_string().unwrap();
+                    Key::Str(Cow::Owned(s))
+                };
+
+                let val = &mut (*bucket).val;
+                let mut val = Val::from_mut_ptr(val);
+                if val.get_type().is_indirect() {
+                    val = Val::from_mut_ptr((*val.as_mut_ptr()).value.zv);
+                }
+
+                self.index += 1;
+
+                if val.get_type().is_undef() {
+                    continue;
+                }
+                break Some((key, val));
+            }
+        }
+    }
+}

phper/src/classes.rs

@@ -190,7 +190,7 @@ impl<T: 'static> ClassEntry<T> {
         r
     }
 
-    fn check_type_id(this: *mut Self) -> Result<(), StateTypeError> {
+    pub(crate) fn check_type_id(this: *const Self) -> Result<(), StateTypeError> {
         if TypeId::of::<T>() == TypeId::of::<()>() {
             return Ok(());
         }

phper/src/functions.rs

@@ -79,8 +79,6 @@ where
     fn call(&self, execute_data: &mut ExecuteData, arguments: &mut [Val], return_value: &mut Val) {
         unsafe {
             let this = execute_data.get_this::<T>().unwrap();
-            // TODO Fix the object type assertion.
-            // assert!(this.get_type().is_object());
             let r = (self.f)(this, arguments);
             r.set_val(return_value);
         }

phper/src/lib.rs

@@ -87,9 +87,6 @@ See [examples](https://github.com/jmjoy/phper/tree/master/examples).
 [Unlicense](https://github.com/jmjoy/phper/blob/master/LICENSE).
 */
 
-#[macro_use]
-extern crate num_derive;
-
 #[macro_use]
 mod macros;
 

phper/src/objects.rs

@@ -136,6 +136,10 @@ impl<T: 'static> Object<T> {
             EBox::from_raw(new_obj)
         }
     }
+
+    pub fn get_class(&self) -> &ClassEntry<T> {
+        ClassEntry::from_ptr(self.inner.ce)
+    }
 }
 
 impl Object<()> {

phper/src/types.rs

@@ -2,91 +2,136 @@
 
 use crate::sys::*;
 use derive_more::From;
-use num_traits::cast::FromPrimitive;
 use std::{ffi::CStr, os::raw::c_int};
 
-/// TODO Refactor to a struct rather than enum, because it's so complex than the type have bit flag.
-#[derive(FromPrimitive, PartialEq, Clone, Copy)]
-#[repr(u32)]
-#[non_exhaustive]
-pub enum Type {
-    Undef = IS_UNDEF,
-    Null = IS_NULL,
-    False = IS_FALSE,
-    True = IS_TRUE,
-    Long = IS_LONG,
-    Double = IS_DOUBLE,
-    String = IS_STRING,
-    StringEx = IS_STRING_EX,
-    Array = IS_ARRAY,
-    ArrayEx = IS_ARRAY_EX,
-    Object = IS_OBJECT,
-    ObjectEx = IS_OBJECT_EX,
-    Resource = IS_RESOURCE,
-    Reference = IS_REFERENCE,
-    ConstantAst = IS_CONSTANT_AST,
-    IsCallable = IS_CALLABLE,
+/// Wrapper of PHP type.
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub struct Type {
+    t: u32,
 }
 
 impl Type {
+    pub const fn from_raw(t: u32) -> Self {
+        Self { t }
+    }
+
+    pub const fn into_raw(self) -> u32 {
+        self.t
+    }
+
+    #[inline]
+    pub fn null() -> Type {
+        Self::from_raw(IS_NULL)
+    }
+
+    #[inline]
+    pub fn bool(b: bool) -> Type {
+        Self::from_raw(if b { IS_TRUE } else { IS_FALSE })
+    }
+
+    #[inline]
+    pub fn long() -> Type {
+        Self::from_raw(IS_LONG)
+    }
+
+    #[inline]
+    pub fn double() -> Type {
+        Self::from_raw(IS_DOUBLE)
+    }
+
+    #[inline]
+    pub fn array() -> Type {
+        Self::from_raw(IS_ARRAY)
+    }
+
+    #[inline]
+    pub fn array_ex() -> Type {
+        Self::from_raw(IS_ARRAY_EX)
+    }
+
+    #[inline]
+    pub fn object() -> Type {
+        Self::from_raw(IS_OBJECT)
+    }
+
+    #[inline]
+    pub fn object_ex() -> Type {
+        Self::from_raw(IS_OBJECT_EX)
+    }
+
+    #[inline]
+    pub fn is_undef(self) -> bool {
+        self.t == IS_UNDEF
+    }
+
     #[inline]
     pub fn is_null(self) -> bool {
-        self == Type::Null
+        self.t == IS_NULL
     }
 
     #[inline]
     pub fn is_bool(self) -> bool {
-        matches!(self, Type::True | Type::False)
+        self.is_true() || self.is_false()
     }
 
     #[inline]
     pub fn is_true(self) -> bool {
-        self == Type::True
+        get_base_type_by_raw(self.t) == IS_TRUE
     }
 
     #[inline]
     pub fn is_false(self) -> bool {
-        self == Type::False
+        get_base_type_by_raw(self.t) == IS_FALSE
     }
 
     #[inline]
     pub fn is_long(self) -> bool {
-        self == Type::Long
+        get_base_type_by_raw(self.t) == IS_LONG
     }
 
     #[inline]
     pub fn is_double(self) -> bool {
-        self == Type::Double
+        get_base_type_by_raw(self.t) == IS_DOUBLE
     }
 
     #[inline]
     pub fn is_string(self) -> bool {
-        matches!(self, Type::String | Type::StringEx)
+        get_base_type_by_raw(self.t) == IS_STRING
     }
 
     #[inline]
     pub fn is_array(self) -> bool {
-        matches!(self, Type::Array | Type::ArrayEx)
+        get_base_type_by_raw(self.t) == IS_ARRAY
     }
 
     #[inline]
     pub fn is_object(self) -> bool {
-        matches!(self, Type::Object | Type::ObjectEx)
+        get_base_type_by_raw(self.t) == IS_OBJECT
+    }
+
+    #[inline]
+    pub fn is_indirect(self) -> bool {
+        self.t == IS_INDIRECT
+    }
+
+    pub fn get_base_type(self) -> Type {
+        Self::from_raw(get_base_type_by_raw(self.t))
+    }
+
+    pub fn get_base_type_name(self) -> crate::Result<String> {
+        get_type_by_const(self.t)
     }
 }
 
 impl From<u32> for Type {
     fn from(n: u32) -> Self {
-        match FromPrimitive::from_u32(n) {
-            Some(t) => t,
-            None => unreachable!("Type is not exhaustive, should contains: {}", n),
-        }
+        Self::from_raw(n)
     }
 }
 
 pub(crate) fn get_type_by_const(mut t: u32) -> crate::Result<String> {
     unsafe {
-        t &= !(IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT);
+        t = get_base_type_by_raw(t);
         let s = zend_get_type_by_const(t as c_int);
         let mut s = CStr::from_ptr(s).to_str()?.to_string();
 
@@ -101,6 +146,21 @@ pub(crate) fn get_type_by_const(mut t: u32) -> crate::Result<String> {
     }
 }
 
+#[inline]
+pub fn get_base_type_by_raw(mut t: u32) -> u32 {
+    t &= !(IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT);
+
+    #[cfg(any(
+        phper_major_version = "8",
+        all(phper_major_version = "7", phper_minor_version = "4")
+    ))]
+    {
+        t &= !(IS_TYPE_COLLECTABLE << Z_TYPE_FLAGS_SHIFT);
+    }
+
+    t
+}
+
 #[derive(From)]
 pub enum Scalar {
     Null,