Refactoring Class and Object.

Author: jmjoy

examples/http-client/src/client.rs

@@ -8,7 +8,7 @@ use phper::functions::Argument;
 const HTTP_CLIENT_CLASS_NAME: &'static str = "HttpClient\\HttpClient";
 
 pub fn make_client_class() -> DynamicClass<Client> {
-    let mut http_client_class = DynamicClass::new_with_constructor(HTTP_CLIENT_CLASS_NAME, |_| {
+    let mut http_client_class = DynamicClass::new_with_constructor(HTTP_CLIENT_CLASS_NAME, || {
         let client = ClientBuilder::new()
             .timeout(Duration::from_secs(15))
             .build()?;

examples/http-client/tests/integration.rs

@@ -0,0 +1,13 @@
+use phper_test::test_php_scripts;
+use std::{env, path::Path};
+
+#[test]
+fn test_php() {
+    test_php_scripts(
+        env!("CARGO_BIN_EXE_http-client"),
+        &[&Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("tests")
+            .join("php")
+            .join("test.php")],
+    );
+}

examples/http-client/tests/php/test.php

@@ -1,7 +1,10 @@
 <?php
 
+use HttpClient\HttpClient;
+
 ini_set("display_errors", "On");
 ini_set("display_startup_errors", "On");
 error_reporting(E_ALL);
 
-phpinfo();
+$client = new HttpClient();
+var_dump($client);

phper-sys/php_wrapper.c

@@ -132,4 +132,8 @@ void phper_zval_ptr_dtor(zval *pDest) {
 
 size_t phper_zend_object_properties_size(zend_class_entry *ce) {
     return zend_object_properties_size(ce);
-}
+}
+
+void *phper_zend_object_alloc(size_t obj_size, zend_class_entry *ce) {
+    return zend_object_alloc(obj_size, ce);
+}

phper-sys/php_wrapper.h

@@ -46,4 +46,6 @@ void phper_zval_ptr_dtor(zval *pDest);
 
 size_t phper_zend_object_properties_size(zend_class_entry *ce);
 
+void *phper_zend_object_alloc(size_t obj_size, zend_class_entry *ce);
+
 #endif //PHPER_PHP_WRAPPER_H

phper-test/src/lib.rs

@@ -161,14 +161,16 @@ fn get_lib_path(exe_path: impl AsRef<Path>) -> PathBuf {
     let exe_path = exe_path.as_ref();
     let exe_stem = exe_path
         .file_stem()
-        .expect("failed to get current exe stem");
+        .expect("failed to get current exe stem")
+        .to_str()
+        .expect("failed to convert to utf-8 str");
     let target_dir = exe_path
         .parent()
         .expect("failed to get current exe directory");
 
     let mut ext_name = OsString::new();
     ext_name.push("lib");
-    ext_name.push(exe_stem);
+    ext_name.push(exe_stem.replace('-', "_"));
     ext_name.push(".so");
 
     target_dir.join(ext_name)

phper/Cargo.toml

@@ -15,6 +15,7 @@ keywords = ["php", "binding", "extension"]
 [dependencies]
 anyhow = "1.0.40"
 clap = "3.0.0-beta.2"
+dashmap = "4.0.2"
 indexmap = "1.6.2"
 num-derive = "0.3"
 num-traits = "0.2"

phper/src/classes.rs

@@ -1,14 +1,5 @@
 //! Apis relate to [crate::sys::zend_class_entry].
 
-use crate::{
-    errors::{ClassNotFoundError, Throwable},
-    functions::{Argument, FunctionEntity, FunctionEntry, Method},
-    objects::Object,
-    sys::*,
-    utils::ensure_end_with_zero,
-    values::{SetVal, Val},
-};
-use once_cell::sync::OnceCell;
 use std::{
     convert::Infallible,
     marker::PhantomData,
@@ -17,17 +8,43 @@ use std::{
     ptr::null_mut,
     sync::atomic::{AtomicPtr, Ordering},
 };
+use std::any::Any;
+use std::collections::HashMap;
+use std::mem::{ManuallyDrop, size_of};
+use std::sync::Arc;
+
+use dashmap::DashMap;
+use once_cell::sync::OnceCell;
+
+use phper_alloc::EBox;
+
+use crate::{
+    errors::{ClassNotFoundError, Throwable},
+    functions::{Argument, FunctionEntity, FunctionEntry, Method},
+    objects::Object,
+    sys::*,
+    utils::ensure_end_with_zero,
+    values::{SetVal, Val},
+};
+use crate::objects::ExtendObject;
 
 pub trait Classifiable {
+    fn state_constructor(&self) -> Box<StateConstructor<Box<dyn Any>>>;
     fn class_name(&self) -> &str;
     fn methods(&mut self) -> &mut [FunctionEntity];
     fn properties(&mut self) -> &mut [PropertyEntity];
     fn parent(&self) -> Option<&str>;
 }
 
+// TODO Let pointer address as a field of Object isn't safe, will choose another plan later.
+pub(crate) const DATA_CONSTRUCTOR_PROPERTY_NAME: &'static str = "__very_important_do_not_modify_data_constructor__";
+pub(crate) const DATA_PROPERTY_NAME: &'static str = "__very_important_do_not_modify_data__";
+
+pub type StateConstructor<T> = dyn Fn() -> Result<T, Box<dyn Throwable>> + Send + Sync;
+
 pub struct DynamicClass<T: Send + Sync + 'static> {
     class_name: String,
-    data_constructor: Box<dyn FnOnce(&mut Object<T>) -> Result<T, Box<dyn Throwable>>>,
+    // data_constructor: Box<DataConstructor<T>>,
     pub(crate) method_entities: Vec<FunctionEntity>,
     pub(crate) property_entities: Vec<PropertyEntity>,
     pub(crate) parent: Option<String>,
@@ -36,30 +53,35 @@ pub struct DynamicClass<T: Send + Sync + 'static> {
 
 impl DynamicClass<()> {
     pub fn new(class_name: impl ToString) -> Self {
-        Self::new_with_constructor(class_name, |_| Ok::<_, Infallible>(()))
+        Self::new_with_constructor(class_name, || Ok::<_, Infallible>(()))
     }
 }
 
 impl<T: Default + Send + Sync + 'static> DynamicClass<T> {
     pub fn new_with_default(class_name: impl ToString) -> Self {
-        Self::new_with_constructor(class_name, |_| Ok::<_, Infallible>(Default::default()))
+        Self::new_with_constructor(class_name, || Ok::<_, Infallible>(Default::default()))
     }
 }
 
 impl<T: Send + Sync + 'static> DynamicClass<T> {
     pub fn new_with_constructor<F, E>(class_name: impl ToString, data_constructor: F) -> Self
     where
-        F: FnOnce(&mut Object<T>) -> Result<T, E> + 'static,
+        F: Fn() -> Result<T, E> + Send + Sync + 'static,
         E: Throwable + 'static,
     {
-        Self {
+        let mut dyn_class = Self {
             class_name: class_name.to_string(),
-            data_constructor: Box::new(|o| data_constructor(o).map_err(|e| Box::new(e) as _)),
+            // data_constructor: Box::new(|| data_constructor().map_err(|e| Box::new(e) as _)),
             method_entities: Vec::new(),
             property_entities: Vec::new(),
             parent: None,
             _p: Default::default(),
-        }
+        };
+
+        // let ptr = &dyn_class.data_constructor as *const _ as usize;
+        // dyn_class.add_property(DATA_CONSTRUCTOR_PROPERTY_NAME, ptr.to_string());
+
+        dyn_class
     }
 
     pub fn add_method<F, R>(&mut self, name: impl ToString, handler: F, arguments: Vec<Argument>)
@@ -86,6 +108,10 @@ impl<T: Send + Sync + 'static> DynamicClass<T> {
 }
 
 impl<T: Send + Sync> Classifiable for DynamicClass<T> {
+    fn state_constructor(&self) -> Box<StateConstructor<Box<dyn Any>>> {
+        Box::new(|| Ok(Box::new(())))
+    }
+
     fn class_name(&self) -> &str {
         &self.class_name
     }
@@ -147,16 +173,16 @@ 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 Classifiable>,
+    pub(crate) classifiable: Box<dyn Classifiable>,
     pub(crate) function_entries: OnceCell<AtomicPtr<FunctionEntry>>,
 }
 
 impl ClassEntity {
-    pub(crate) unsafe fn new(class: impl Classifiable + 'static) -> Self {
+    pub(crate) unsafe fn new(classifiable: impl Classifiable + 'static) -> Self {
         Self {
-            name: class.class_name().to_string(),
+            name: classifiable.class_name().to_string(),
             entry: AtomicPtr::new(null_mut()),
-            class: Box::new(class),
+            classifiable: Box::new(classifiable),
             function_entries: Default::default(),
         }
     }
@@ -169,17 +195,22 @@ impl ClassEntity {
         );
 
         let parent = self
-            .class
+            .classifiable
             .parent()
             .map(|s| ClassEntry::from_globals(s).unwrap());
 
-        let ptr = match parent {
+        let class: *mut ClassEntry = match parent {
             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);
+        self.entry.store(class, Ordering::SeqCst);
+
+        (*class).inner.__bindgen_anon_2.create_object = Some(create_object);
+
+        // let classifiable = self.classifiable.clone();
+        // get_class_constructor_map().insert(class as usize, Box::new(move || classifiable.state_constructor()));
 
         // let methods = self.class.methods();
         // for method in methods {
@@ -193,7 +224,7 @@ impl ClassEntity {
     }
 
     pub(crate) unsafe fn declare_properties(&mut self) {
-        let properties = self.class.properties();
+        let properties = self.classifiable.properties();
         for property in properties {
             let value = ensure_end_with_zero(property.value.clone());
             zend_declare_property_string(
@@ -207,18 +238,32 @@ impl ClassEntity {
     }
 
     unsafe fn function_entries(&mut self) -> &AtomicPtr<FunctionEntry> {
-        let methods = &*self.class.methods();
+        let last_entry = self.take_classifiable_into_function_entry();
+        let methods = &*self.classifiable.methods();
 
         self.function_entries.get_or_init(|| {
             let mut methods = methods
                 .iter()
                 .map(|method| method.entry())
                 .collect::<Vec<_>>();
+
             methods.push(zeroed::<zend_function_entry>());
+
+            // Store the classifiable pointer to zend_class_entry
+            methods.push(last_entry);
+
             let entry = Box::into_raw(methods.into_boxed_slice()).cast();
             AtomicPtr::new(entry)
         })
     }
+
+    unsafe fn take_classifiable_into_function_entry(&self) -> zend_function_entry {
+        let mut entry = zeroed::<zend_function_entry>();
+        let ptr = &mut entry as *mut _ as *mut ManuallyDrop<Box<StateConstructor<Box<Any>>>>;
+        let state_constructor = ManuallyDrop::new(self.classifiable.state_constructor());
+        ptr.write(state_constructor);
+        entry
+    }
 }
 
 pub struct PropertyEntity {
@@ -243,3 +288,46 @@ pub enum Visibility {
     Protected = ZEND_ACC_PROTECTED,
     Private = ZEND_ACC_PRIVATE,
 }
+
+fn get_object_handlers() -> &'static zend_object_handlers {
+    static OBJECT_HANDLERS: OnceCell<zend_object_handlers> = OnceCell::new();
+    OBJECT_HANDLERS.get_or_init(|| unsafe {
+        let mut handlers = std_object_handlers;
+        handlers.offset = ExtendObject::offset() as c_int;
+        handlers.free_obj = Some(destroy_object);
+        handlers
+    })
+}
+
+unsafe extern "C" fn create_object(ce: *mut zend_class_entry) -> *mut zend_object {
+    // Alloc more memory size to store state data.
+    let extend_object: *mut ExtendObject = phper_zend_object_alloc(size_of::<ExtendObject>(), ce).cast();
+
+    // Common initialize process.
+    let object = &mut (*extend_object).object;
+    zend_object_std_init(object, ce);
+    object_properties_init(object, ce);
+    rebuild_object_properties(object);
+    object.handlers = get_object_handlers();
+
+    // Get state constructor.
+    let mut func_ptr = (*ce).info.internal.builtin_functions;
+    while !(*func_ptr).fname.is_null() {
+        func_ptr = func_ptr.offset(1);
+    }
+    func_ptr = func_ptr.offset(1);
+    let state_constructor = func_ptr as *const ManuallyDrop<Box<StateConstructor<Box<Any>>>>;
+    let state_constructor = state_constructor.read();
+
+    // Call the state constructor.
+    // TODO Throw an exception rather than unwrap.
+    let data: Box<dyn Any> = state_constructor().unwrap();
+    (*extend_object).state = ManuallyDrop::new(data);
+
+    object
+}
+
+unsafe extern "C" fn destroy_object(object: *mut zend_object) {
+    // Original destroy call.
+    zend_object_std_dtor(object);
+}