Merge pull request #19 from jmjoy/0.2.0-alpha.3-dev

Author: jmjoy

examples/http-client/src/client.rs

@@ -49,8 +49,8 @@ pub fn make_client_builder_class() -> DynamicClass<ClientBuilder> {
         |this, _arguments| {
             let state = this.as_mut_state();
             let client = replace_and_get(state, ClientBuilder::new(), ClientBuilder::build)?;
-            let mut object =
-                ClassEntry::<Option<Client>>::from_globals(HTTP_CLIENT_CLASS_NAME)?.new_object();
+            let mut object = ClassEntry::<Option<Client>>::from_globals(HTTP_CLIENT_CLASS_NAME)?
+                .new_object_without_construct();
             *object.as_mut_state() = Some(client);
             Ok::<_, HttpClientError>(object)
         },
@@ -79,7 +79,7 @@ pub fn make_client_class() -> DynamicClass<Option<Client>> {
             let request_builder = client.get(url);
             let mut object =
                 ClassEntry::<Option<RequestBuilder>>::from_globals(REQUEST_BUILDER_CLASS_NAME)?
-                    .new_object();
+                    .new_object_without_construct();
             *object.as_mut_state() = Some(request_builder);
             Ok::<_, HttpClientError>(object)
         },
@@ -95,7 +95,7 @@ pub fn make_client_class() -> DynamicClass<Option<Client>> {
             let request_builder = client.post(url);
             let mut object =
                 ClassEntry::<Option<RequestBuilder>>::from_globals(REQUEST_BUILDER_CLASS_NAME)?
-                    .new_object();
+                    .new_object_without_construct();
             *object.as_mut_state() = Some(request_builder);
             Ok::<_, HttpClientError>(object)
         },

examples/http-client/src/request.rs

@@ -23,8 +23,8 @@ pub fn make_request_builder_class() -> DynamicClass<Option<RequestBuilder>> {
         |this, _arguments| {
             let state = this.as_mut_state();
             let response = replace_and_get(state, None, |builder| builder.unwrap().send())?;
-            let mut object =
-                ClassEntry::<Option<Response>>::from_globals(RESPONSE_CLASS_NAME)?.new_object();
+            let mut object = ClassEntry::<Option<Response>>::from_globals(RESPONSE_CLASS_NAME)?
+                .new_object_without_construct();
             *object.as_mut_state() = Some(response);
             Ok::<_, HttpClientError>(object)
         },

phper-alloc/src/lib.rs

@@ -27,7 +27,7 @@ pub trait EAllocatable {
 
 /// The Box which use php `emalloc` and `efree` to manage memory.
 ///
-/// TODO now feature `allocator_api` is still unstable, implement myself.
+/// TODO now feature `allocator_api` is still unstable, implement myself, use Box<T, Alloc> later.
 pub struct EBox<T: EAllocatable> {
     ptr: *mut T,
 }

phper-macros/src/derives.rs

@@ -127,10 +127,14 @@ fn parse_throwable_input(
             })
             .into())
         }
-        Data::Struct(_) => Err(syn::Error::new_spanned(
-            &input,
-            "struct auto derive Throwable is not supported",
-        )),
+        Data::Struct(_) => Ok((quote! {
+            impl #crate_ident::errors::Throwable for #input_ident {
+                fn class_entry(&self) -> &#crate_ident::classes::StatelessClassEntry {
+                    ClassEntry::from_globals(#exception).unwrap()
+                }
+            }
+        })
+        .into()),
         Data::Union(_) => Err(syn::Error::new_spanned(
             &input,
             "union auto derive Throwable is not supported",

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
 ///
@@ -90,7 +90,7 @@ pub fn php_get_module(attr: TokenStream, input: TokenStream) -> TokenStream {
 /// }
 /// ```
 ///
-/// TODO Support struct, attbiute `throwable` with `code` and `message`.
+/// TODO Support attribute `throwable` with `code` and `message`, integration tests.
 #[proc_macro_derive(Throwable, attributes(throwable, throwable_crate))]
 pub fn derive_throwable(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);

phper-sys/php_wrapper.c

@@ -147,3 +147,16 @@ void *phper_zend_object_alloc(size_t obj_size, zend_class_entry *ce) {
 zend_object* (**phper_get_create_object(zend_class_entry *ce))(zend_class_entry *class_type) {
     return &ce->create_object;
 }
+
+bool phper_call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[]) {
+    function_table = function_table;
+    return call_user_function(function_table, object, function_name, retval_ptr, param_count, params) == SUCCESS;
+}
+
+bool phper_zend_hash_str_exists(const HashTable *ht, const char *str, size_t len) {
+    return zend_hash_str_exists(ht, str, len) != 0;
+}
+
+bool phper_zend_hash_index_exists(const HashTable *ht, zend_ulong h) {
+    return zend_hash_index_exists(ht, h) != 0;
+}

phper-sys/php_wrapper.h

@@ -1,6 +1,7 @@
 #ifndef PHPER_PHP_WRAPPER_H
 #define PHPER_PHP_WRAPPER_H
 
+#include <stdbool.h>
 #include <php.h>
 #include <php_ini.h>
 #include <ext/standard/info.h>
@@ -50,4 +51,9 @@ void *phper_zend_object_alloc(size_t obj_size, zend_class_entry *ce);
 
 zend_object* (**phper_get_create_object(zend_class_entry *ce))(zend_class_entry *class_type);
 
+bool phper_call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, uint32_t param_count, zval params[]);
+
+bool phper_zend_hash_str_exists(const HashTable *ht, const char *str, size_t len);
+bool phper_zend_hash_index_exists(const HashTable *ht, zend_ulong h);
+
 #endif //PHPER_PHP_WRAPPER_H

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))
     }
 }
 
@@ -45,7 +53,12 @@ impl Array {
         }
     }
 
-    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_array) -> &'a mut Array {
+    pub unsafe fn from_ptr<'a>(ptr: *const zend_array) -> &'a Array {
+        let ptr = ptr as *const Array;
+        ptr.as_ref().expect("ptr shouldn't be null")
+    }
+
+    pub unsafe fn from_mut_ptr<'a>(ptr: *mut zend_array) -> &'a mut Array {
         let ptr = ptr as *mut Array;
         ptr.as_mut().expect("ptr shouldn't be null")
     }
@@ -100,13 +113,34 @@ impl Array {
         unsafe { zend_array_count(&mut self.inner) as usize }
     }
 
+    pub fn exists<'a>(&self, key: impl Into<Key<'a>>) -> bool {
+        let key = key.into();
+        unsafe {
+            match key {
+                Key::Index(i) => phper_zend_hash_index_exists(&self.inner, i),
+                Key::Str(s) => phper_zend_hash_str_exists(
+                    &self.inner,
+                    s.as_ref().as_ptr().cast(),
+                    s.as_ref().len(),
+                ),
+            }
+        }
+    }
+
     pub fn clone(&self) -> EBox<Self> {
         let mut other = Self::new();
         unsafe {
             zend_hash_copy(other.as_mut_ptr(), self.as_ptr() as *mut _, None);
         }
         other
     }
+
+    pub fn iter(&self) -> Iter<'_> {
+        Iter {
+            index: 0,
+            array: &self,
+        }
+    }
 }
 
 impl EAllocatable for Array {
@@ -115,6 +149,8 @@ impl EAllocatable for Array {
             if (*ptr).inner.gc.refcount == 0 {
                 zend_hash_destroy(ptr.cast());
                 _efree(ptr.cast());
+            } else {
+                (*ptr).inner.gc.refcount -= 1;
             }
         }
     }
@@ -125,3 +161,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

@@ -2,9 +2,11 @@
 
 use crate::{
     alloc::EBox,
+    arrays::Array,
     errors::{ClassNotFoundError, StateTypeError},
     functions::{Argument, Function, FunctionEntity, FunctionEntry, Method},
     objects::{ExtendObject, Object},
+    strings::ZendString,
     sys::*,
     types::Scalar,
     values::{SetVal, Val},
@@ -171,6 +173,14 @@ impl<T: Send> Classifiable for DynamicClass<T> {
 pub type StatelessClassEntry = ClassEntry<()>;
 
 /// Wrapper of [crate::sys::zend_class_entry].
+///
+/// # Generic
+///
+/// 1. Any `zend_class_entry` can be make into `ClassEntry<()>`, alias as [StatelessClassEntry].
+///
+/// 2. Only the `zend_class_entry` created by [crate::modules::Module::add_class] can be make into
+/// `ClassEntry<T>`, where `T` is the type defined by [Classifiable::state_type_id], as the inner
+/// state of `ClassEntry<T>` and `Object<T>`.
 #[repr(transparent)]
 pub struct ClassEntry<T: 'static> {
     inner: zend_class_entry,
@@ -190,7 +200,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(());
         }
@@ -217,12 +227,38 @@ impl<T: 'static> ClassEntry<T> {
         &mut self.inner
     }
 
-    pub fn new_object(&self) -> EBox<Object<T>> {
+    /// Create the object from class and call `__construct` with arguments.
+    pub fn new_object(&self, arguments: &mut [Val]) -> crate::Result<EBox<Object<T>>> {
         unsafe {
             let ptr = self.as_ptr() as *mut _;
             let f = (*phper_get_create_object(ptr)).unwrap_or(zend_objects_new);
             let object = f(ptr);
-            EBox::from_raw(object.cast())
+            let mut object: EBox<Object<T>> = EBox::from_raw(object.cast());
+            let _ = object.call_construct(arguments)?;
+            Ok(object)
+        }
+    }
+
+    /// Create the object from class, without calling `__construct`, be careful when `__construct`
+    /// is necessary.
+    pub fn new_object_without_construct(&self) -> EBox<Object<T>> {
+        unsafe {
+            let ptr = self.as_ptr() as *mut _;
+            let f = (*phper_get_create_object(ptr)).unwrap_or(zend_objects_new);
+            let object = f(ptr);
+            let object: EBox<Object<T>> = EBox::from_raw(object.cast());
+            object
+        }
+    }
+
+    pub fn get_name(&self) -> &ZendString {
+        ZendString::from_ptr(self.inner.name)
+    }
+
+    pub fn has_method(&self, method_name: &str) -> bool {
+        unsafe {
+            let function_table = Array::from_ptr(&self.inner.function_table);
+            function_table.exists(method_name)
         }
     }
 }