Add generic for Class and Object.

Author: jmjoy

examples/hello/src/lib.rs

@@ -1,7 +1,7 @@
 use phper::{
     alloc::EBox,
     arrays::Array,
-    classes::StdClass,
+    classes::DynamicClass,
     functions::Argument,
     ini::Policy,
     modules::{Module, ModuleArgs},
@@ -63,19 +63,19 @@ pub fn get_module() -> Module {
     );
 
     // register classes
-    let mut foo_class = StdClass::new();
+    let mut foo_class = DynamicClass::new();
     foo_class.add_property("foo", "100".to_string());
     foo_class.add_method(
         "getFoo",
-        |this: &mut Object, _: &mut [Val]| -> phper::Result<Val> {
+        |this: &mut Object<()>, _: &mut [Val]| -> phper::Result<Val> {
             let prop = this.get_property("foo");
             Ok(Val::new(prop.as_string_value()?))
         },
         vec![],
     );
     foo_class.add_method(
         "setFoo",
-        |this: &mut Object, arguments: &mut [Val]| -> phper::Result<()> {
+        |this: &mut Object<()>, arguments: &mut [Val]| -> phper::Result<()> {
             this.set_property("foo", Val::new(arguments[0].as_string_value()?));
             Ok(())
         },

examples/hello/tests/php/test.php

@@ -6,11 +6,9 @@
 
 assert_eq(hello_say_hello("world"), "Hello, world!\n");
 
-assert_eq(class_exists("Phper\\OtherException"), true);
-
 try {
     hello_throw_exception();
-} catch (Phper\OtherException $e) {
+} catch (ErrorException $e) {
     assert_eq($e->getMessage(), "I am sorry");
 }
 

examples/http-client/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "mini-curl"
+name = "http-client"
 version = "0.0.0"
 authors = ["jmjoy <[email protected]>"]
 edition = "2018"

examples/http-client/src/lib.rs

@@ -1,4 +1,4 @@
-use phper::{classes::StdClass, modules::Module, php_get_module};
+use phper::{classes::DynamicClass, modules::Module, php_get_module};
 
 pub mod http_client;
 
@@ -11,7 +11,7 @@ pub fn get_module() -> Module {
     );
 
     // let client = HttpClient::new();
-    let client_class = StdClass::new();
+    let client_class: DynamicClass<()> = DynamicClass::new();
     module.add_class("HttpClient", client_class);
 
     module

examples/logging/tests/integration.rs

@@ -8,7 +8,7 @@ fn test_php() {
         .join("php");
 
     test_php_scripts_with_condition(
-        env!("CARGO_BIN_EXE_log"),
+        env!("CARGO_BIN_EXE_logging"),
         &[
             (&base_dir.join("test_php_say.php"), &|output| {
                 let stdout = str::from_utf8(&output.stdout).unwrap();

phper-build/src/lib.rs

@@ -10,7 +10,7 @@ Add this crate in your `[build-dependencies]` and using in `build.rs`.
 [Unlicense](https://github.com/jmjoy/phper/blob/master/LICENSE).
 */
 
-use phper_sys::{PHP_DEBUG, PHP_MAJOR_VERSION, PHP_MINOR_VERSION, PHP_RELEASE_VERSION, USING_ZTS};
+use phper_sys::*;
 
 /// Register useful rust cfg for project using phper.
 pub fn register_configures() {

phper-sys/php_wrapper.c

@@ -74,8 +74,12 @@ void phper_zend_string_release(zend_string *s) {
     return zend_string_release(s);
 }
 
-void phper_zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval *pData) {
-    zend_hash_str_update(ht, key, len, pData);
+zval *phper_zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval *pData) {
+    return zend_hash_str_update(ht, key, len, pData);
+}
+
+zval* phper_zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData) {
+    return zend_hash_index_update(ht, h, pData);
 }
 
 void phper_array_init(zval *arg) {
@@ -86,10 +90,6 @@ void *phper_zend_hash_str_find_ptr(const HashTable *ht, const char *str, size_t
     return zend_hash_str_find_ptr(ht, str, len);
 }
 
-zval* phper_zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData) {
-    return zend_hash_index_update(ht, h, pData);
-}
-
 void phper_zend_hash_merge_with_key(HashTable *target, HashTable *source) {
     uint32_t idx;
     Bucket *p;
@@ -116,6 +116,32 @@ void phper_zval_obj(zval *z, zend_object *o) {
     ZVAL_OBJ(z, o);
 }
 
-int phper_z_type_info_refcounted(uint32_t t) {
-    return Z_TYPE_INFO_REFCOUNTED(t);
-}
+static zend_string *phper_zend_string_concat3(
+        const char *str1, size_t str1_len,
+        const char *str2, size_t str2_len,
+        const char *str3, size_t str3_len)
+{
+    size_t len = str1_len + str2_len + str3_len;
+    zend_string *res = zend_string_alloc(len, 0);
+
+    memcpy(ZSTR_VAL(res), str1, str1_len);
+    memcpy(ZSTR_VAL(res) + str1_len, str2, str2_len);
+    memcpy(ZSTR_VAL(res) + str1_len + str2_len, str3, str3_len);
+    ZSTR_VAL(res)[len] = '\0';
+
+    return res;
+}
+
+zend_string *phper_get_function_or_method_name(const zend_function *func) {
+    #if PHP_VERSION_ID >= 80000
+    return get_function_or_method_name(func);
+    #else
+    if (func->common.scope) {
+        return phper_zend_string_concat3(
+                ZSTR_VAL(func->common.scope->name), ZSTR_LEN(func->common.scope->name),
+                "::", sizeof("::") - 1,
+                ZSTR_VAL(func->common.function_name), ZSTR_LEN(func->common.function_name));
+    }
+    return func->common.function_name ? zend_string_copy(func->common.function_name) : zend_string_init("main", sizeof("main") - 1, 0);
+    #endif
+}

phper-sys/php_wrapper.h

@@ -32,15 +32,15 @@ zend_string *phper_zend_string_init(const char *str, size_t len, int persistent)
 zend_string *phper_zend_string_alloc(size_t len, int persistent);
 void phper_zend_string_release(zend_string *s);
 
-void phper_zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval *pData);
+zval *phper_zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval *pData);
+zval* phper_zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData);
 
 void phper_array_init(zval *arg);
 void *phper_zend_hash_str_find_ptr(const HashTable *ht, const char *str, size_t len);
-zval* phper_zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData);
 void phper_zend_hash_merge_with_key(HashTable *target, HashTable *source);
 
 void phper_zval_obj(zval *z, zend_object *o);
 
-int phper_z_type_info_refcounted(uint32_t t);
+zend_string *phper_get_function_or_method_name(const zend_function *func);
 
 #endif //PHPER_PHP_WRAPPER_H

phper/src/arrays.rs

@@ -61,7 +61,7 @@ impl Array {
         unsafe {
             match key {
                 Key::Index(i) => {
-                    zend_hash_index_update(&mut self.inner, i, EBox::into_raw(value).cast());
+                    phper_zend_hash_index_update(&mut self.inner, i, EBox::into_raw(value).cast());
                 }
                 Key::Str(s) => {
                     phper_zend_hash_str_update(

phper/src/classes.rs

@@ -3,47 +3,51 @@
 use crate::{
     errors::ClassNotFoundError,
     functions::{Argument, Callable, FunctionEntity, FunctionEntry, Method},
+    objects::Object,
     sys::*,
     utils::ensure_end_with_zero,
+    values::{SetVal, Val},
 };
 use once_cell::sync::OnceCell;
 use std::{
+    marker::PhantomData,
     mem::zeroed,
     os::raw::c_int,
     ptr::null_mut,
     sync::atomic::{AtomicPtr, Ordering},
 };
 
-pub trait Class: Send + Sync {
+pub trait Classifiable {
     fn methods(&mut self) -> &mut [FunctionEntity];
     fn properties(&mut self) -> &mut [PropertyEntity];
     fn parent(&self) -> Option<&str>;
 }
 
-pub struct StdClass {
+pub struct DynamicClass<T: Send + Sync + 'static> {
     pub(crate) method_entities: Vec<FunctionEntity>,
     pub(crate) property_entities: Vec<PropertyEntity>,
     pub(crate) parent: Option<String>,
+    _p: PhantomData<T>,
 }
 
-impl StdClass {
+impl<T: Send + Sync + 'static> DynamicClass<T> {
     pub fn new() -> Self {
         Self {
             method_entities: Vec::new(),
             property_entities: Vec::new(),
             parent: None,
+            _p: Default::default(),
         }
     }
 
-    pub fn add_method(
-        &mut self,
-        name: impl ToString,
-        handler: impl Method + 'static,
-        arguments: Vec<Argument>,
-    ) {
+    pub fn add_method<F, R>(&mut self, name: impl ToString, handler: F, arguments: Vec<Argument>)
+    where
+        F: Fn(&mut Object<T>, &mut [Val]) -> R + Send + Sync + 'static,
+        R: SetVal + 'static,
+    {
         self.method_entities.push(FunctionEntity::new(
             name,
-            Callable::Method(Box::new(handler), AtomicPtr::new(null_mut())),
+            Box::new(Method::new(handler)),
             arguments,
         ));
     }
@@ -59,7 +63,7 @@ impl StdClass {
     }
 }
 
-impl Class for StdClass {
+impl<T: Send + Sync> Classifiable for DynamicClass<T> {
     fn methods(&mut self) -> &mut [FunctionEntity] {
         &mut self.method_entities
     }
@@ -117,12 +121,12 @@ fn find_global_class_entry_ptr(name: impl AsRef<str>) -> *mut zend_class_entry {
 pub struct ClassEntity {
     pub(crate) name: String,
     pub(crate) entry: AtomicPtr<ClassEntry>,
-    pub(crate) class: Box<dyn Class>,
+    pub(crate) class: Box<dyn Classifiable>,
     pub(crate) function_entries: OnceCell<AtomicPtr<FunctionEntry>>,
 }
 
 impl ClassEntity {
-    pub(crate) unsafe fn new(name: impl ToString, class: impl Class + 'static) -> Self {
+    pub(crate) unsafe fn new(name: impl ToString, class: impl Classifiable + 'static) -> Self {
         Self {
             name: name.to_string(),
             entry: AtomicPtr::new(null_mut()),
@@ -138,26 +142,28 @@ impl ClassEntity {
             self.function_entries().load(Ordering::SeqCst).cast(),
         );
 
-        let parent = self.class.parent().map(|s| match s {
-            "Exception" | "\\Exception" => zend_ce_exception,
-            _ => todo!(),
-        });
+        let parent = self
+            .class
+            .parent()
+            .map(|s| ClassEntry::from_globals(s).unwrap());
 
         let ptr = match parent {
-            Some(parent) => zend_register_internal_class_ex(&mut class_ce, parent).cast(),
+            Some(parent) => {
+                zend_register_internal_class_ex(&mut class_ce, parent.as_ptr() as *mut _).cast()
+            }
             None => zend_register_internal_class(&mut class_ce).cast(),
         };
         self.entry.store(ptr, Ordering::SeqCst);
 
-        let methods = self.class.methods();
-        for method in methods {
-            match &method.handler {
-                Callable::Method(_, class) => {
-                    class.store(ptr, Ordering::SeqCst);
-                }
-                _ => unreachable!(),
-            }
-        }
+        // let methods = self.class.methods();
+        // for method in methods {
+        //     match &method.handler {
+        //         Callable::Method(_, class) => {
+        //             class.store(ptr, Ordering::SeqCst);
+        //         }
+        //         _ => unreachable!(),
+        //     }
+        // }
     }
 
     pub(crate) unsafe fn declare_properties(&mut self) {