Pass the hello examples.

jmjoy · jmjoy · commit 6918134bd922 · 2021-04-17T00:20:04.000+08:00
diff --git a/examples/hello/src/lib.rs b/examples/hello/src/lib.rs
@@ -1,5 +1,5 @@
-use std::{fs::OpenOptions, io::Write};
 use phper::{
+    arrays::Array,
     c_str_ptr,
     classes::{Class, StdClass, This},
     functions::{create_zend_arg_info, Argument},
@@ -10,11 +10,10 @@ use phper::{
         php_info_print_table_end, php_info_print_table_row, php_info_print_table_start,
         zend_function_entry, OnUpdateBool, PHP_INI_SYSTEM,
     },
-    values::{ExecuteData, Val},
+    values::{ExecuteData, SetVal, Val},
     Throwable,
 };
-use phper::arrays::Array;
-use phper::values::SetVal;
+use std::{fs::OpenOptions, io::Write};
 
 fn module_init(_args: ModuleArgs) -> bool {
     true
@@ -70,14 +69,23 @@ pub extern "C" fn get_module(module: &mut Module) {
     );
 
     // register classes
-    let mut std_class = StdClass::new();
-    std_class.add_property("foo", 100);
-    std_class.add_method(
-        "test1",
-        |_: &mut This, _: &mut [Val]| {
-            println!("hello test1");
+    let mut foo_class = StdClass::new();
+    foo_class.add_property("foo", 100);
+    foo_class.add_method(
+        "getFoo",
+        |this: &mut This, _: &mut [Val]| {
+            let prop = this.get_property("foo");
+            Val::from_val(prop)
         },
         vec![],
     );
-    module.add_class("Test1", std_class);
+    foo_class.add_method(
+        "setFoo",
+        |this: &mut This, arguments: &mut [Val]| {
+            let prop = this.get_property("foo");
+            prop.set(&arguments[0]);
+        },
+        vec![Argument::by_val("foo")],
+    );
+    module.add_class("FooClass", foo_class);
 }
diff --git a/phper-sys/php_wrapper.c b/phper-sys/php_wrapper.c
@@ -38,6 +38,14 @@ void phper_zval_zval(zval *return_value, zval *zv, int copy, int dtor) {
     ZVAL_ZVAL(return_value, zv, copy, dtor);
 }
 
+void phper_zval_dup(zval *return_value, zval *zv) {
+    ZVAL_DUP(return_value, zv);
+}
+
+void phper_zval_copy(zval *return_value, zval *zv) {
+    ZVAL_COPY(return_value, zv);
+}
+
 zend_string *phper_zval_get_string(zval *op) {
     return zval_get_string(op);
 }
diff --git a/phper-sys/php_wrapper.h b/phper-sys/php_wrapper.h
@@ -17,6 +17,8 @@ void phper_zval_stringl(zval *return_value, const char *s, size_t len);
 char *phper_z_strval_p(const zval *v);
 zval *phper_get_this(zend_execute_data *execute_data);
 void phper_zval_zval(zval *return_value, zval *zv, int copy, int dtor);
+void phper_zval_dup(zval *return_value, zval *zv);
+void phper_zval_copy(zval *return_value, zval *zv);
 zend_string *phper_zval_get_string(zval *op);
 void phper_zend_string_release(zend_string *s);
 zend_long phper_zval_get_long(zval *op);
diff --git a/phper/src/arrays.rs b/phper/src/arrays.rs
@@ -1,8 +1,9 @@
-use crate::sys::*;
-use std::ptr::null_mut;
-use std::mem::zeroed;
-use crate::values::Val;
-use std::ops::{Deref, DerefMut};
+use crate::{sys::*, values::Val};
+use std::{
+    mem::zeroed,
+    ops::{Deref, DerefMut},
+    ptr::null_mut,
+};
 
 pub struct Array {
     inner: Box<zend_array>,
@@ -14,15 +15,18 @@ impl Array {
         unsafe {
             _zend_hash_init(&mut *inner, 0, None, 1);
         }
-        Self {
-            inner,
-        }
+        Self { inner }
     }
 
     pub fn insert(&mut self, key: impl AsRef<str>, value: &mut Val) {
         let key = key.as_ref();
         unsafe {
-            zend_hash_str_update(&mut *self.inner, key.as_ptr().cast(), key.len(), value.as_mut());
+            zend_hash_str_update(
+                &mut *self.inner,
+                key.as_ptr().cast(),
+                key.len(),
+                value.as_mut(),
+            );
         }
     }
 
@@ -35,9 +39,7 @@ impl Array {
     }
 
     pub fn len(&mut self) -> usize {
-        unsafe {
-            zend_array_count(&mut *self.inner) as usize
-        }
+        unsafe { zend_array_count(&mut *self.inner) as usize }
     }
 }
 
@@ -59,4 +61,4 @@ impl Drop for Array {
             zend_hash_destroy(&mut *self.inner);
         }
     }
-}
+}
diff --git a/phper/src/classes.rs b/phper/src/classes.rs
@@ -1,7 +1,7 @@
 use crate::{
     functions::{invoke, Argument, Callable, FunctionEntity, FunctionEntry, Method},
     sys::*,
-    values::Val,
+    values::{SetVal, Val},
 };
 use once_cell::sync::OnceCell;
 use std::{
@@ -15,8 +15,8 @@ use std::{
 };
 
 pub trait Class: Send + Sync {
-    fn methods(&self) -> &[FunctionEntity];
-    fn properties(&self) -> &[PropertyEntity];
+    fn methods(&mut self) -> &mut [FunctionEntity];
+    fn properties(&mut self) -> &mut [PropertyEntity];
     fn parent(&self) -> Option<&str>;
 }
 
@@ -43,12 +43,16 @@ impl StdClass {
     ) {
         self.method_entities.push(FunctionEntity::new(
             name,
-            Callable::Method(Box::new(handler)),
+            Callable::Method(Box::new(handler), AtomicPtr::new(null_mut())),
             arguments,
         ));
     }
 
-    pub fn add_property(&mut self, name: impl ToString, value: i32) {
+    pub fn add_property(
+        &mut self,
+        name: impl ToString,
+        value: impl SetVal + Send + Sync + 'static,
+    ) {
         self.property_entities
             .push(PropertyEntity::new(name, value));
     }
@@ -60,12 +64,12 @@ impl StdClass {
 }
 
 impl Class for StdClass {
-    fn methods(&self) -> &[FunctionEntity] {
-        &self.method_entities
+    fn methods(&mut self) -> &mut [FunctionEntity] {
+        &mut self.method_entities
     }
 
-    fn properties(&self) -> &[PropertyEntity] {
-        &self.property_entities
+    fn properties(&mut self) -> &mut [PropertyEntity] {
+        &mut self.property_entities
     }
 
     fn parent(&self) -> Option<&str> {
@@ -88,7 +92,6 @@ pub struct ClassEntity {
     pub(crate) name: String,
     pub(crate) entry: AtomicPtr<ClassEntry>,
     pub(crate) class: Box<dyn Class>,
-    pub(crate) init_once: Once,
     pub(crate) function_entries: OnceCell<AtomicPtr<FunctionEntry>>,
 }
 
@@ -98,50 +101,59 @@ impl ClassEntity {
             name: name.to_string(),
             entry: AtomicPtr::new(null_mut()),
             class: Box::new(class),
-            init_once: Once::new(),
             function_entries: Default::default(),
         }
     }
 
-    pub(crate) unsafe fn init(&self) {
-        self.init_once.call_once(|| {
-            let mut class_ce = phper_init_class_entry_ex(
-                self.name.as_ptr().cast(),
-                self.name.len(),
-                self.function_entries().load(Ordering::SeqCst).cast(),
-            );
+    pub(crate) unsafe fn init(&mut self) {
+        let mut class_ce = phper_init_class_entry_ex(
+            self.name.as_ptr().cast(),
+            self.name.len(),
+            self.function_entries().load(Ordering::SeqCst).cast(),
+        );
 
-            let parent = self.class.parent().map(|s| match s {
-                "Exception" | "\\Exception" => zend_ce_exception,
-                _ => todo!(),
-            });
-
-            let ptr = match parent {
-                Some(parent) => zend_register_internal_class_ex(&mut class_ce, parent).cast(),
-                None => zend_register_internal_class(&mut class_ce).cast(),
-            };
-            self.entry.store(ptr, Ordering::SeqCst);
+        let parent = self.class.parent().map(|s| match s {
+            "Exception" | "\\Exception" => zend_ce_exception,
+            _ => todo!(),
         });
+
+        let ptr = match parent {
+            Some(parent) => zend_register_internal_class_ex(&mut class_ce, parent).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!(),
+            }
+        }
     }
 
-    pub(crate) unsafe fn declare_properties(&self) {
+    pub(crate) unsafe fn declare_properties(&mut self) {
         let properties = self.class.properties();
         for property in properties {
-            zend_declare_property_long(
+            let mut val = Val::null();
+            val.set(&property.value);
+            zend_declare_property(
                 self.entry.load(Ordering::SeqCst).cast(),
                 property.name.as_ptr().cast(),
                 property.name.len(),
-                property.value.into(),
+                val.as_mut(),
                 Visibility::Public as c_int,
             );
         }
     }
 
-    unsafe fn function_entries(&self) -> &AtomicPtr<FunctionEntry> {
+    unsafe fn function_entries(&mut self) -> &AtomicPtr<FunctionEntry> {
+        let methods = &*self.class.methods();
+
         self.function_entries.get_or_init(|| {
-            let mut methods = self
-                .class
-                .methods()
+            let mut methods = methods
                 .iter()
                 .map(|method| method.entry())
                 .collect::<Vec<_>>();
@@ -152,29 +164,44 @@ impl ClassEntity {
     }
 }
 
-#[repr(transparent)]
 pub struct This {
-    inner: zval,
+    val: *mut Val,
+    class: *mut ClassEntry,
 }
 
 impl This {
-    #[inline]
-    pub unsafe fn from_mut<'a>(ptr: *mut zval) -> &'a mut Self {
-        assert!(!ptr.is_null(), "ptr should not be null");
-        &mut *(ptr as *mut Self)
+    pub(crate) fn new<'a>(val: *mut Val, class: *mut ClassEntry) -> This {
+        assert!(!val.is_null());
+        assert!(!class.is_null());
+        Self { val, class }
+    }
+
+    pub fn get_property(&self, name: impl AsRef<str>) -> &mut Val {
+        let name = name.as_ref();
+        unsafe {
+            let prop = zend_read_property(
+                self.class as *mut _,
+                self.val as *mut _,
+                name.as_ptr().cast(),
+                name.len(),
+                0,
+                null_mut(),
+            );
+            Val::from_mut(prop)
+        }
     }
 }
 
 pub struct PropertyEntity {
     name: String,
-    value: i32,
+    value: Box<dyn SetVal + Send + Sync>,
 }
 
 impl PropertyEntity {
-    pub fn new(name: impl ToString, value: i32) -> Self {
+    pub fn new(name: impl ToString, value: impl SetVal + Send + Sync + 'static) -> Self {
         Self {
             name: name.to_string(),
-            value,
+            value: Box::new(value),
         }
     }
 }
diff --git a/phper/src/functions.rs b/phper/src/functions.rs
@@ -1,5 +1,5 @@
 use crate::{
-    classes::This,
+    classes::{ClassEntry, This},
     errors::Throwable,
     ini::create_ini_entry_ex,
     sys::*,
@@ -11,6 +11,7 @@ use std::{
     mem::{size_of, transmute, zeroed},
     os::raw::{c_char, c_int},
     ptr::{null, null_mut},
+    sync::atomic::{AtomicPtr, Ordering},
 };
 
 pub trait Function: Send + Sync {
@@ -45,7 +46,7 @@ where
 
 pub(crate) enum Callable {
     Function(Box<dyn Function>),
-    Method(Box<dyn Method>),
+    Method(Box<dyn Method>, AtomicPtr<ClassEntry>),
 }
 
 #[repr(transparent)]
@@ -173,7 +174,7 @@ pub(crate) unsafe extern "C" fn invoke(
             execute_data.num_args()
         );
         php_error_docref(null(), E_WARNING as i32, s.as_ptr().cast());
-        ().set_val(return_value);
+        return_value.set(());
         return;
     }
 
@@ -183,8 +184,9 @@ pub(crate) unsafe extern "C" fn invoke(
         Callable::Function(f) => {
             f.call(&mut arguments, return_value);
         }
-        Callable::Method(m) => {
-            m.call(execute_data.get_this(), &mut arguments, return_value);
+        Callable::Method(m, class) => {
+            let mut this = This::new(execute_data.get_this(), class.load(Ordering::SeqCst));
+            m.call(&mut this, &mut arguments, return_value);
         }
     }
 }
diff --git a/phper/src/lib.rs b/phper/src/lib.rs
@@ -26,16 +26,16 @@ Now the library don't support `ZTS`, the template is using `thread_local!` inste
 Version `0.1.x` will be a preview version.
 */
 
-mod errors;
-mod utils;
 pub mod arrays;
 pub mod classes;
 pub mod cmd;
+mod errors;
 pub mod functions;
 pub mod ini;
 pub mod logs;
 pub mod modules;
 pub mod strings;
+mod utils;
 pub mod values;
 
 pub use crate::errors::*;
diff --git a/phper/src/modules.rs b/phper/src/modules.rs
diff --git a/phper/src/strings.rs b/phper/src/strings.rs
diff --git a/phper/src/values.rs b/phper/src/values.rs

Original file line number	Diff line number	Diff line change
`@@ -38,6 +38,14 @@ void phper_zval_zval(zval return_value, zval zv, int copy, int dtor) {`
`38`	`38`	`ZVAL_ZVAL(return_value, zv, copy, dtor);`
`39`	`39`	`}`
`40`	`40`
	`41`	`+void phper_zval_dup(zval return_value, zval zv) {`
	`42`	`+ ZVAL_DUP(return_value, zv);`
	`43`	`+}`
	`44`	`+`
	`45`	`+void phper_zval_copy(zval return_value, zval zv) {`
	`46`	`+ ZVAL_COPY(return_value, zv);`
	`47`	`+}`
	`48`	`+`
`41`	`49`	`zend_string phper_zval_get_string(zval op) {`
`42`	`50`	`return zval_get_string(op);`
`43`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,9 @@`
`1`		`-use crate::sys::*;`
`2`		`-use std::ptr::null_mut;`
`3`		`-use std::mem::zeroed;`
`4`		`-use crate::values::Val;`
`5`		`-use std::ops::{Deref, DerefMut};`
	`1`	`+use crate::{sys::*, values::Val};`
	`2`	`+use std::{`
	`3`	`+ mem::zeroed,`
	`4`	`+ ops::{Deref, DerefMut},`
	`5`	`+ ptr::null_mut,`
	`6`	`+};`
`6`	`7`
`7`	`8`	`pub struct Array {`
`8`	`9`	`inner: Box<zend_array>,`
`@@ -14,15 +15,18 @@ impl Array {`
`14`	`15`	`unsafe {`
`15`	`16`	`_zend_hash_init(&mut *inner, 0, None, 1);`
`16`	`17`	`}`
`17`		`- Self {`
`18`		`- inner,`
`19`		`- }`
	`18`	`+ Self { inner }`
`20`	`19`	`}`
`21`	`20`
`22`	`21`	`pub fn insert(&mut self, key: impl AsRef<str>, value: &mut Val) {`
`23`	`22`	`let key = key.as_ref();`
`24`	`23`	`unsafe {`
`25`		`- zend_hash_str_update(&mut *self.inner, key.as_ptr().cast(), key.len(), value.as_mut());`
	`24`	`+ zend_hash_str_update(`
	`25`	`+ &mut *self.inner,`
	`26`	`+ key.as_ptr().cast(),`
	`27`	`+ key.len(),`
	`28`	`+ value.as_mut(),`
	`29`	`+ );`
`26`	`30`	`}`
`27`	`31`	`}`
`28`	`32`
`@@ -35,9 +39,7 @@ impl Array {`
`35`	`39`	`}`
`36`	`40`
`37`	`41`	`pub fn len(&mut self) -> usize {`
`38`		`- unsafe {`
`39`		`- zend_array_count(&mut *self.inner) as usize`
`40`		`- }`
	`42`	`+ unsafe { zend_array_count(&mut *self.inner) as usize }`
`41`	`43`	`}`
`42`	`44`	`}`
`43`	`45`
`@@ -59,4 +61,4 @@ impl Drop for Array {`
`59`	`61`	`zend_hash_destroy(&mut *self.inner);`
`60`	`62`	`}`
`61`	`63`	`}`
`62`		`-}`
	`64`	`+}`