Modify trait SetVal api.

Author: jmjoy

examples/hello/src/lib.rs

@@ -67,15 +67,16 @@ pub fn get_module(module: &mut Module) {
         "getFoo",
         |this: &mut Object, _: &mut [Val]| {
             let prop = this.get_property("foo");
-            Val::from_val(prop)
+            Val::new(prop.as_string())
         },
         vec![],
     );
     foo_class.add_method(
         "setFoo",
         |this: &mut Object, arguments: &mut [Val]| {
             let prop = this.get_property("foo");
-            prop.set(&mut arguments[0]);
+            // TODO add set_property method
+            // prop.set(&mut arguments[0]);
         },
         vec![Argument::by_val("foo")],
     );

phper-alloc/src/lib.rs

@@ -1,9 +1,11 @@
 #![warn(rust_2018_idioms, clippy::dbg_macro, clippy::print_stdout)]
 
 /// The Box which use php `emalloc` and `efree` to manage memory.
+///
 /// TODO now feature `allocator_api` is still unstable, using global allocator instead.
 pub type EBox<T> = Box<T>;
 
 /// The Vec which use php `emalloc` and `efree` to manage memory.
+///
 /// TODO now feature `allocator_api` is still unstable, using global allocator instead.
 pub type EVec<T> = Vec<T>;

phper-build/src/lib.rs

@@ -1,7 +1,3 @@
-//! cfg:
-//!
-//!
-
 use phper_sys::{PHP_DEBUG, PHP_MAJOR_VERSION, PHP_MINOR_VERSION, PHP_RELEASE_VERSION, USING_ZTS};
 
 /// Register useful rust cfg for project using phper.

phper-macros/src/lib.rs

@@ -5,16 +5,51 @@ mod utils;
 
 use proc_macro::TokenStream;
 
+/// C style string end with '\0'.
+///
+/// # Examples
+///
+/// ```no_test
+/// use std::ffi::CStr;
+///
+/// assert_eq!(c_str!("foo"), unsafe {
+///     CStr::from_ptr("foo\0".as_ptr().cast())
+/// });
+/// ```
 #[proc_macro]
 pub fn c_str(input: TokenStream) -> TokenStream {
     utils::c_str(input)
 }
 
+/// C style string end with '\0'.
+///
+/// # Examples
+///
+/// ```no_test
+/// assert_eq!(c_str_ptr!("foo"), "foo\0".as_ptr().cast());
+/// ```
 #[proc_macro]
 pub fn c_str_ptr(input: TokenStream) -> TokenStream {
     utils::c_str_ptr(input)
 }
 
+/// PHP module entry, wrap the `phper::modules::Module` write operation.
+///
+/// # Examples
+///
+/// ```no_test
+/// use phper::{php_get_module, modules::Module};
+///
+/// #[php_get_module]
+/// pub fn get_module(module: &mut Module) {
+///     // set module metadata
+///     module.set_name(env!("CARGO_PKG_NAME"));
+///     module.set_version(env!("CARGO_PKG_VERSION"));
+///     module.set_author(env!("CARGO_PKG_AUTHORS"));
+///
+///     // ...
+/// }
+/// ```
 #[proc_macro_attribute]
 pub fn php_get_module(attr: TokenStream, input: TokenStream) -> TokenStream {
     inner::php_get_module(attr, input)

phper/src/arrays.rs

@@ -23,10 +23,15 @@ impl Array {
         self.inner
     }
 
+    pub fn into_raw(mut self) -> *mut zend_array {
+        self.leak = true;
+        self.inner
+    }
+
     pub fn insert(&mut self, key: impl AsRef<str>, value: &mut Val) {
         let key = key.as_ref();
         unsafe {
-            phper_zend_hash_str_update(self.inner, key.as_ptr().cast(), key.len(), value.as_mut());
+            phper_zend_hash_str_update(self.inner, key.as_ptr().cast(), key.len(), value.as_mut_ptr());
         }
     }
 
@@ -41,10 +46,6 @@ impl Array {
     pub fn len(&mut self) -> usize {
         unsafe { zend_array_count(self.inner) as usize }
     }
-
-    pub(crate) fn leak(&mut self) -> &mut bool {
-        &mut self.leak
-    }
 }
 
 impl Drop for Array {

phper/src/classes.rs

@@ -136,13 +136,14 @@ impl ClassEntity {
     pub(crate) unsafe fn declare_properties(&mut self) {
         let properties = self.class.properties();
         for property in properties {
-            let mut val = Val::null();
-            val.set(&mut property.value);
+            // TODO Fix
+            // 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(),
-                val.as_mut(),
+                null_mut(),
                 Visibility::Public as c_int,
             );
         }

phper/src/errors.rs

@@ -2,8 +2,10 @@ use crate::{classes::ClassEntity, modules::read_global_module, Error::Other};
 use anyhow::anyhow;
 use std::{error, ffi::FromBytesWithNulError, io, str::Utf8Error};
 
+/// Type of [std::result::Result]<T, [crate::Error]>.
 pub type Result<T> = std::result::Result<T, self::Error>;
 
+/// Crate level Error, which also can become an exception in php.
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     #[error(transparent)]
@@ -20,12 +22,14 @@ pub enum Error {
 }
 
 impl Error {
+    /// An essy way to cause an anyhow::Error.
     pub fn other(message: impl ToString) -> Self {
         let message = message.to_string();
         Other(anyhow!(message))
     }
 }
 
+/// PHP Throwable, can cause throwing an exception when setting to [crate::values::Val].
 pub trait Throwable: error::Error {
     fn class_entity(&self) -> *const ClassEntity;
     fn code(&self) -> u64;

phper/src/macros.rs

@@ -1,31 +1,66 @@
+/// PHP echo.
+///
+/// # Examples
+///
+/// ```no_run
+/// phper::echo!("Hello, {}!", message)
+/// ```
 #[macro_export]
 macro_rules! echo {
     ($($arg:tt)*) => ({
         $crate::output::echo(std::format!($($arg)*))
     })
 }
 
+/// PHP error log, will exit the request.
+///
+/// # Examples
+///
+/// ```no_run
+/// phper::errro!("Hello, {}!", message)
+/// ```
 #[macro_export]
 macro_rules! error {
     ($($arg:tt)*) => ({
         $crate::output::log($crate::output::LogLevel::Error, std::format!($($arg)*))
     })
 }
 
+/// PHP warning log.
+///
+/// # Examples
+///
+/// ```no_run
+/// phper::warning!("Hello, {}!", message)
+/// ```
 #[macro_export]
 macro_rules! warning {
     ($($arg:tt)*) => ({
         $crate::output::log($crate::output::LogLevel::Warning, std::format!($($arg)*))
     })
 }
 
+/// PHP notice log.
+///
+/// # Examples
+///
+/// ```no_run
+/// phper::notice!("Hello, {}!", message)
+/// ```
 #[macro_export]
 macro_rules! notice {
     ($($arg:tt)*) => ({
         $crate::output::log($crate::output::LogLevel::Notice, std::format!($($arg)*))
     })
 }
 
+/// PHP deprecated log.
+///
+/// # Examples
+///
+/// ```no_run
+/// phper::deprecated!("Hello, {}!", message)
+/// ```
 #[macro_export]
 macro_rules! deprecated {
     ($($arg:tt)*) => ({

phper/src/values.rs

@@ -76,7 +76,7 @@ impl Val {
     }
 
     #[inline]
-    fn empty() -> Self {
+    pub(crate) fn empty() -> Self {
         Self {
             inner: unsafe { zeroed::<zval>() },
         }
@@ -94,13 +94,13 @@ impl Val {
         val
     }
 
-    pub fn from_val(other: &mut Val) -> Self {
+    pub fn from_val(other: Val) -> Self {
         let mut val = Self::empty();
         val.set(other);
         val
     }
 
-    pub fn as_mut(&mut self) -> *mut zval {
+    pub fn as_mut_ptr(&mut self) -> *mut zval {
         &mut self.inner
     }
 
@@ -127,93 +127,92 @@ impl Val {
 }
 
 pub trait SetVal {
-    fn set_val(&mut self, val: &mut Val);
+    fn set_val(self, val: &mut Val);
 }
 
 impl SetVal for () {
-    fn set_val(&mut self, val: &mut Val) {
+    fn set_val(self, val: &mut Val) {
         unsafe {
             *val.type_info() = IS_NULL;
         }
     }
 }
 
 impl SetVal for bool {
-    fn set_val(&mut self, val: &mut Val) {
+    fn set_val(self, val: &mut Val) {
         unsafe {
-            *val.type_info() = if *self { IS_TRUE } else { IS_FALSE };
+            *val.type_info() = if self { IS_TRUE } else { IS_FALSE };
         }
     }
 }
 
 impl SetVal for i32 {
-    fn set_val(&mut self, val: &mut Val) {
-        (*self as i64).set_val(val)
+    fn set_val(self, val: &mut Val) {
+        SetVal::set_val(self as i64, val)
     }
 }
 
 impl SetVal for u32 {
-    fn set_val(&mut self, val: &mut Val) {
-        (*self as i64).set_val(val)
+    fn set_val(self, val: &mut Val) {
+        SetVal::set_val(self as i64, val)
     }
 }
 
 impl SetVal for i64 {
-    fn set_val(&mut self, val: &mut Val) {
+    fn set_val(self, val: &mut Val) {
         unsafe {
-            (*val.as_mut()).value.lval = *self;
-            (*val.as_mut()).u1.type_info = IS_LONG;
+            (*val.as_mut_ptr()).value.lval = self;
+            (*val.as_mut_ptr()).u1.type_info = IS_LONG;
         }
     }
 }
 
 impl SetVal for f64 {
-    fn set_val(&mut self, val: &mut Val) {
+    fn set_val(self, val: &mut Val) {
         unsafe {
-            (*val.as_mut()).value.dval = *self;
-            (*val.as_mut()).u1.type_info = IS_DOUBLE;
+            (*val.as_mut_ptr()).value.dval = self;
+            (*val.as_mut_ptr()).u1.type_info = IS_DOUBLE;
         }
     }
 }
 
-impl SetVal for str {
-    fn set_val(&mut self, val: &mut Val) {
+impl SetVal for &str {
+    fn set_val(self, val: &mut Val) {
         unsafe {
-            phper_zval_stringl(val.as_mut(), self.as_ptr().cast(), self.len());
+            phper_zval_stringl(val.as_mut_ptr(), self.as_ptr().cast(), self.len());
         }
     }
 }
 
 impl SetVal for String {
-    fn set_val(&mut self, val: &mut Val) {
+    fn set_val(self, val: &mut Val) {
         unsafe {
-            phper_zval_stringl(val.as_mut(), self.as_ptr().cast(), self.len());
+            phper_zval_stringl(val.as_mut_ptr(), self.as_ptr().cast(), self.len());
         }
     }
 }
 
 impl SetVal for Array {
-    fn set_val(&mut self, val: &mut Val) {
+    fn set_val(self, val: &mut Val) {
         unsafe {
-            let mut new_val = zeroed::<zval>();
-            phper_zval_arr(&mut new_val, self.as_mut_ptr());
-            *self.leak() = true;
-            phper_zval_zval(val.as_mut(), &mut new_val, true.into(), false.into());
+            let mut new_val = Val::empty();
+            phper_zval_arr(new_val.as_mut_ptr(), self.into_raw());
+            phper_zval_zval(val.as_mut_ptr(), new_val.as_mut_ptr(), true.into(), false.into());
         }
     }
 }
 
 impl<T: SetVal> SetVal for Option<T> {
-    fn set_val(&mut self, val: &mut Val) {
+    fn set_val(self, val: &mut Val) {
         match self {
-            Some(t) => t.set_val(val),
-            None => ().set_val(val),
+            Some(t) => SetVal::set_val(t, val),
+            None => SetVal::set_val((), val),
         }
     }
 }
 
 impl<T: SetVal, E: Throwable> SetVal for Result<T, E> {
-    fn set_val(&mut self, val: &mut Val) {
+    fn set_val(self, val: &mut Val) {
         match self {
             Ok(t) => t.set_val(val),
             Err(e) => unsafe {
@@ -233,21 +232,9 @@ impl<T: SetVal, E: Throwable> SetVal for Result<T, E> {
 }
 
 impl SetVal for Val {
-    fn set_val(&mut self, val: &mut Val) {
+    fn set_val(mut self, val: &mut Val) {
         unsafe {
-            phper_zval_copy_value(val.as_mut(), &mut self.inner);
+            phper_zval_copy_value(val.as_mut_ptr(), self.as_mut_ptr());
         }
     }
 }
-
-impl<T: SetVal + ?Sized> SetVal for Box<T> {
-    fn set_val(&mut self, val: &mut Val) {
-        T::set_val(self, val)
-    }
-}
-
-impl<T: SetVal + ?Sized> SetVal for &mut T {
-    fn set_val(&mut self, val: &mut Val) {
-        T::set_val(self, val)
-    }
-}