Refactor TransformIniValue.

Author: jmjoy

.github/workflows/ci.yml

@@ -33,6 +33,9 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v2
 
+      - name: Install libclang
+        run: sudo apt-get install -y libclang-10-dev
+
       - name: Setup PHP
         uses: shivammathur/setup-php@v2
         with:

examples/hello/src/lib.rs

@@ -63,14 +63,13 @@ pub fn get_module() -> Module {
 
     // register classes
     let mut foo_class = DynamicClass::new("FooClass");
-    // foo_class.add_property("foo", Visibility::Public, 100);
-    foo_class.add_property("foo", Visibility::Public, 100);
+    foo_class.add_property("foo", Visibility::Private, 100);
     foo_class.add_method(
         "getFoo",
         Visibility::Public,
-        |this: &mut Object<()>, _: &mut [Val]| -> phper::Result<Val> {
+        |this: &mut Object<()>, _: &mut [Val]| {
             let prop = this.get_property("foo");
-            Ok(Val::new(prop.as_string_value()?))
+            Ok::<_, phper::Error>(prop.as_string_value()?)
         },
         vec![],
     );

examples/hello/tests/php/test.php

@@ -12,16 +12,13 @@
     assert_eq($e->getMessage(), "I am sorry");
 }
 
-var_dump(ini_get_all());
-die();
-
 assert_eq(hello_get_all_ini(), [
     "hello.enable" => false,
     "hello.description" => "hello world.",
 ]);
 
 $foo = new FooClass();
-assert_eq($foo->getFoo(), 100);
+assert_eq($foo->getFoo(), "100");
 
 $foo->setFoo("Hello");
 assert_eq($foo->getFoo(), "Hello");

phper-macros/src/lib.rs

@@ -8,6 +8,8 @@ The proc-macros for [phper](https://crates.io/crates/phper).
 [Unlicense](https://github.com/jmjoy/phper/blob/master/LICENSE).
 */
 
+// TODO Write a bridge macro for easy usage about register functions and classes.
+
 mod alloc;
 mod inner;
 mod log;

phper/src/classes.rs

@@ -347,7 +347,7 @@ impl PropertyEntity {
                     zend_declare_property_bool(ce, name, name_length, *b as zend_long, access_type);
                 }
                 Scalar::I64(i) => {
-                    zend_declare_property_bool(ce, name, name_length, *i, access_type);
+                    zend_declare_property_long(ce, name, name_length, *i, access_type);
                 }
                 Scalar::F64(f) => {
                     zend_declare_property_double(ce, name, name_length, *f, access_type);

phper/src/ini.rs

@@ -79,104 +79,104 @@ pub enum Policy {
     System = PHP_INI_SYSTEM,
 }
 
-pub trait TransformIniValue: ToString + 'static {
-    fn on_modify(&self) -> OnModify;
+/// The Type which can transform to an ini value.
+///
+/// Be careful that the size of `arg2` must litter than size of `usize`.
+///
+/// TODO Add a size compare with usize trait bound, after const generic supports.
+pub trait TransformIniValue: Sized + ToString + 'static {
+    fn on_modify() -> OnModify;
 
-    unsafe fn transform(&self, data: usize) -> Option<*mut c_void>;
+    unsafe fn transform(data: usize) -> Option<Self>;
 
-    fn arg2_type(&self) -> TypeId;
+    fn arg2_type() -> TypeId;
 
-    fn arg2_size(&self) -> usize;
+    fn arg2_size() -> usize;
 
     fn to_text(&self) -> String {
         self.to_string()
     }
 }
 
 impl TransformIniValue for bool {
-    fn on_modify(&self) -> OnModify {
+    fn on_modify() -> OnModify {
         Some(OnUpdateBool)
     }
 
-    unsafe fn transform(&self, data: usize) -> Option<*mut c_void> {
-        let b = data != 0;
-        Some(Box::into_raw(Box::new(b)).cast())
+    unsafe fn transform(data: usize) -> Option<Self> {
+        Some(data != 0)
     }
 
-    fn arg2_type(&self) -> TypeId {
+    fn arg2_type() -> TypeId {
         TypeId::of::<bool>()
     }
 
-    fn arg2_size(&self) -> usize {
+    fn arg2_size() -> usize {
         size_of::<bool>()
     }
 }
 
 impl TransformIniValue for i64 {
-    fn on_modify(&self) -> OnModify {
+    fn on_modify() -> OnModify {
         Some(OnUpdateLong)
     }
 
-    unsafe fn transform(&self, data: usize) -> Option<*mut c_void> {
-        let i = data as i64;
-        Some(Box::into_raw(Box::new(i)).cast())
+    unsafe fn transform(data: usize) -> Option<Self> {
+        Some(data as i64)
     }
 
-    fn arg2_type(&self) -> TypeId {
+    fn arg2_type() -> TypeId {
         TypeId::of::<i64>()
     }
 
-    fn arg2_size(&self) -> usize {
+    fn arg2_size() -> usize {
         size_of::<i64>()
     }
 }
 
 impl TransformIniValue for f64 {
-    fn on_modify(&self) -> OnModify {
+    fn on_modify() -> OnModify {
         Some(OnUpdateReal)
     }
 
-    unsafe fn transform(&self, data: usize) -> Option<*mut c_void> {
-        let f = data as f64;
-        Some(Box::into_raw(Box::new(f)).cast())
+    unsafe fn transform(data: usize) -> Option<Self> {
+        Some(data as f64)
     }
 
-    fn arg2_type(&self) -> TypeId {
+    fn arg2_type() -> TypeId {
         TypeId::of::<i64>()
     }
 
-    fn arg2_size(&self) -> usize {
+    fn arg2_size() -> usize {
         size_of::<i64>()
     }
 }
 
 impl TransformIniValue for String {
-    fn on_modify(&self) -> OnModify {
+    fn on_modify() -> OnModify {
         Some(OnUpdateString)
     }
 
-    unsafe fn transform(&self, data: usize) -> Option<*mut c_void> {
+    unsafe fn transform(data: usize) -> Option<Self> {
         let ptr = data as *mut c_char;
-        CStr::from_ptr(ptr)
-            .to_str()
-            .ok()
-            .map(|s| Box::into_raw(Box::new(s.to_owned())).cast())
+        CStr::from_ptr(ptr).to_str().ok().map(|s| s.to_owned())
     }
 
-    fn arg2_type(&self) -> TypeId {
+    fn arg2_type() -> TypeId {
         TypeId::of::<*mut c_char>()
     }
 
-    fn arg2_size(&self) -> usize {
+    fn arg2_size() -> usize {
         size_of::<*mut c_char>()
     }
 }
 
 pub(crate) struct IniEntity {
     name: String,
     value: usize,
+    value_type_id: TypeId,
     default_value: String,
-    transform: Box<dyn TransformIniValue>,
+    on_modify: OnModify,
     policy: Policy,
 }
 
@@ -186,35 +186,30 @@ impl IniEntity {
         default_value: T,
         policy: Policy,
     ) -> Self {
-        assert!(default_value.arg2_size() <= size_of::<usize>());
+        assert!(<T>::arg2_size() <= size_of::<usize>());
         Self {
             name: name.to_string(),
             value: 0,
+            value_type_id: <T>::arg2_type(),
             default_value: default_value.to_text(),
-            transform: Box::new(default_value),
+            on_modify: <T>::on_modify(),
             policy,
         }
     }
 
     pub(crate) fn value<T: TransformIniValue>(&self) -> Option<T> {
-        if self.transform.arg2_type() != TypeId::of::<T>() {
+        if self.value_type_id != <T>::arg2_type() {
             None
         } else {
-            unsafe {
-                let ptr = self.transform.transform(self.value);
-                ptr.map(|ptr| {
-                    let b = Box::from_raw(ptr as *mut T);
-                    *b
-                })
-            }
+            unsafe { <T>::transform(self.value) }
         }
     }
 
     pub(crate) fn entry(&mut self) -> zend_ini_entry_def {
         create_ini_entry_ex(
             &self.name,
             &self.default_value,
-            self.transform.on_modify(),
+            self.on_modify,
             self.policy as u32,
             &mut self.value as *mut _ as *mut c_void,
         )

phper/src/types.rs

@@ -5,6 +5,7 @@ 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]
@@ -83,8 +84,9 @@ impl From<u32> for Type {
     }
 }
 
-pub(crate) fn get_type_by_const(t: u32) -> crate::Result<String> {
+pub(crate) fn get_type_by_const(mut t: u32) -> crate::Result<String> {
     unsafe {
+        t &= !(IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT);
         let s = zend_get_type_by_const(t as c_int);
         let mut s = CStr::from_ptr(s).to_str()?.to_string();