Add some Val as_* apis.

jmjoy · jmjoy · commit 8746e202c4e3 · 2021-04-30T18:45:21.000+08:00
diff --git a/examples/hello/src/lib.rs b/examples/hello/src/lib.rs
@@ -13,9 +13,9 @@ fn module_init(_args: ModuleArgs) -> bool {
     true
 }
 
-fn say_hello(arguments: &mut [Val]) -> impl SetVal {
-    let name = arguments[0].as_string();
-    format!("Hello, {}!\n", name)
+fn say_hello(arguments: &mut [Val]) -> phper::Result<String> {
+    let name = arguments[0].as_string_value()?;
+    Ok(format!("Hello, {}!\n", name))
 }
 
 fn throw_exception(_: &mut [Val]) -> phper::Result<()> {
@@ -66,9 +66,9 @@ pub fn get_module() -> Module {
     foo_class.add_property("foo", 100);
     foo_class.add_method(
         "getFoo",
-        |this: &mut Object, _: &mut [Val]| {
+        |this: &mut Object, _: &mut [Val]| -> phper::Result<Val> {
             let prop = this.get_property("foo");
-            Val::new(prop.as_string())
+            Ok(Val::new(prop.as_string_value()?))
         },
         vec![],
     );
diff --git a/examples/http-client/Cargo.toml b/examples/http-client/Cargo.toml
@@ -13,6 +13,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 phper = { version = "0.2.0-alpha.2", path = "../../phper" }
+reqwest = { version = "0.11.3", features = ["blocking"] }
 
 [dev-dependencies]
 phper-test = { version = "0.2.0-alpha.2", path = "../../phper-test" }
diff --git a/examples/http-client/LICENSE b/examples/http-client/LICENSE
@@ -0,0 +1 @@
+../../LICENSE
diff --git a/examples/http-client/README.md b/examples/http-client/README.md
@@ -0,0 +1,32 @@
+# hello
+
+Http client example.
+
+## Environment
+
+```bash
+# Specify if php isn't installed globally.
+export PHP_CONFIG = <Your path of php-config>
+```
+
+## Build
+
+```bash
+cargo build --release
+```
+
+## Test
+
+```bash
+cargo test --release
+```
+
+## Install
+
+```bash
+cargo run --release -- install
+```
+
+## License
+
+[Unlicense](https://github.com/jmjoy/phper/blob/master/LICENSE).
diff --git a/examples/http-client/src/http_client.rs b/examples/http-client/src/http_client.rs
@@ -0,0 +1,15 @@
+use reqwest::blocking::{Client, ClientBuilder};
+use std::time::Duration;
+
+pub struct HttpClient {
+    client: Client,
+}
+
+impl HttpClient {
+    pub fn new() -> reqwest::Result<Self> {
+        let client = ClientBuilder::new()
+            .timeout(Duration::from_secs(15))
+            .build()?;
+        Ok(Self { client })
+    }
+}
diff --git a/examples/http-client/src/lib.rs b/examples/http-client/src/lib.rs
@@ -1,4 +1,7 @@
-use phper::{modules::Module, php_get_module};
+use crate::http_client::HttpClient;
+use phper::{classes::StdClass, modules::Module, php_get_module};
+
+pub mod http_client;
 
 #[php_get_module]
 pub fn get_module() -> Module {
@@ -8,7 +11,9 @@ pub fn get_module() -> Module {
         env!("CARGO_PKG_AUTHORS"),
     );
 
-    // ...
+    let client = HttpClient::new();
+    let client_class = StdClass::new();
+    module.add_class("HttpClient", client_class);
 
     module
 }
diff --git a/examples/log/src/lib.rs b/examples/log/src/lib.rs
@@ -13,45 +13,50 @@ pub fn get_module() -> Module {
 
     module.add_function(
         "log_say",
-        |params: &mut [Val]| {
-            let message = params[0].as_string();
+        |params: &mut [Val]| -> phper::Result<()> {
+            let message = params[0].as_string_value()?;
             echo!("Hello, {}!", message);
+            Ok(())
         },
         vec![Argument::by_val("message")],
     );
 
     module.add_function(
         "log_notice",
-        |params: &mut [Val]| {
-            let message = params[0].as_string();
+        |params: &mut [Val]| -> phper::Result<()> {
+            let message = params[0].as_string_value()?;
             notice!("Something happened: {}", message);
+            Ok(())
         },
         vec![Argument::by_val("message")],
     );
 
     module.add_function(
         "log_warning",
-        |params: &mut [Val]| {
-            let message = params[0].as_string();
+        |params: &mut [Val]| -> phper::Result<()> {
+            let message = params[0].as_string_value()?;
             warning!("Something warning: {}", message);
+            Ok(())
         },
         vec![Argument::by_val("message")],
     );
 
     module.add_function(
         "log_error",
-        |params: &mut [Val]| {
-            let message = params[0].as_string();
+        |params: &mut [Val]| -> phper::Result<()> {
+            let message = params[0].as_string_value()?;
             error!("Something gone failed: {}", message);
+            Ok(())
         },
         vec![Argument::by_val("message")],
     );
 
     module.add_function(
         "log_deprecated",
-        |params: &mut [Val]| {
-            let message = params[0].as_string();
+        |params: &mut [Val]| -> phper::Result<()> {
+            let message = params[0].as_string_value()?;
             deprecated!("Something deprecated: {}", message);
+            Ok(())
         },
         vec![Argument::by_val("message")],
     );
diff --git a/phper-macros/src/inner.rs b/phper-macros/src/inner.rs
@@ -22,6 +22,7 @@ pub(crate) fn php_get_module(_attr: TokenStream, input: TokenStream) -> TokenStr
 
     let result = quote! {
         #[no_mangle]
+        #[doc(hidden)]
         #(#attrs)*
         #vis extern "C" fn #name() -> *const ::phper::sys::zend_module_entry {
             fn internal(#inputs) #ret {
diff --git a/phper/src/errors.rs b/phper/src/errors.rs
@@ -17,6 +17,9 @@ pub enum Error {
     #[error(transparent)]
     FromBytesWithNul(#[from] FromBytesWithNulError),
 
+    #[error(transparent)]
+    TypeError(#[from] TypeError),
+
     #[error(transparent)]
     Other(#[from] anyhow::Error),
 }
@@ -29,6 +32,19 @@ impl Error {
     }
 }
 
+/// PHP type error.
+#[derive(thiserror::Error, Debug)]
+#[error("{message}")]
+pub struct TypeError {
+    message: String,
+}
+
+impl TypeError {
+    pub fn new(message: String) -> Self {
+        Self { 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;
diff --git a/phper/src/lib.rs b/phper/src/lib.rs
@@ -135,6 +135,7 @@ pub mod modules;
 pub mod objects;
 pub mod output;
 pub mod strings;
+pub mod types;
 mod utils;
 pub mod values;
 
diff --git a/phper/src/types.rs b/phper/src/types.rs
@@ -0,0 +1,10 @@
+use crate::sys::*;
+use std::{ffi::CStr, os::raw::c_int};
+
+pub(crate) fn get_type_by_const(t: u32) -> crate::Result<String> {
+    unsafe {
+        let s = zend_get_type_by_const(t as c_int);
+        let s = CStr::from_ptr(s).to_str()?.to_string();
+        Ok(s)
+    }
+}
diff --git a/phper/src/values.rs b/phper/src/values.rs
@@ -1,5 +1,15 @@
-use crate::{arrays::Array, errors::Throwable, sys::*, utils::ensure_end_with_zero};
-use std::{mem::zeroed, slice::from_raw_parts, str, sync::atomic::Ordering};
+use crate::{
+    arrays::Array, errors::Throwable, sys::*, types::get_type_by_const,
+    utils::ensure_end_with_zero, TypeError,
+};
+use std::{
+    mem::zeroed,
+    os::raw::{c_char, c_int},
+    slice::from_raw_parts,
+    str,
+    str::Utf8Error,
+    sync::atomic::Ordering,
+};
 
 #[repr(transparent)]
 pub struct ExecuteData {
@@ -45,7 +55,7 @@ impl ExecuteData {
         phper_get_this(&mut self.inner).cast()
     }
 
-    pub unsafe fn get_parameters_array(&mut self) -> Vec<Val> {
+    pub(crate) unsafe fn get_parameters_array(&mut self) -> Vec<Val> {
         let num_args = self.num_args();
         let mut arguments = vec![zeroed::<zval>(); num_args as usize];
         _zend_get_parameters_array_ex(num_args.into(), arguments.as_mut_ptr());
@@ -108,21 +118,80 @@ impl Val {
         v.set_val(self);
     }
 
-    unsafe fn type_info(&mut self) -> &mut u32 {
+    #[inline]
+    fn type_info(&self) -> u32 {
+        unsafe { self.inner.u1.type_info }
+    }
+
+    fn type_name(&self) -> crate::Result<String> {
+        get_type_by_const(unsafe { self.type_info() })
+    }
+
+    unsafe fn type_info_mut(&mut self) -> &mut u32 {
         &mut self.inner.u1.type_info
     }
 
-    pub fn as_string(&mut self) -> String {
+    pub fn as_bool(&self) -> crate::Result<bool> {
+        match self.type_info() {
+            IS_TRUE => Ok(true),
+            IS_FALSE => Ok(false),
+            _ => Err(self.must_be_type_error("bool").into()),
+        }
+    }
+
+    pub fn as_i64(&self) -> crate::Result<i64> {
+        if self.type_info() == IS_LONG {
+            unsafe { Ok(self.inner.value.lval) }
+        } else {
+            Err(self.must_be_type_error("long").into())
+        }
+    }
+
+    pub fn as_i64_value(&self) -> i64 {
+        unsafe { phper_zval_get_long(&self.inner as *const _ as *mut _) }
+    }
+
+    pub fn as_f64(&self) -> crate::Result<f64> {
+        if self.type_info() == IS_DOUBLE {
+            unsafe { Ok(self.inner.value.dval) }
+        } else {
+            Err(self.must_be_type_error("float").into())
+        }
+    }
+
+    pub fn as_string(&self) -> crate::Result<String> {
+        if self.type_info() == IS_STRING {
+            unsafe {
+                let s = self.inner.value.str;
+                let buf = from_raw_parts(&(*s).val as *const c_char as *const u8, (*s).len);
+                let string = str::from_utf8(buf)?.to_string();
+                Ok(string)
+            }
+        } else {
+            Err(self.must_be_type_error("string").into())
+        }
+    }
+
+    pub fn as_string_value(&self) -> Result<String, Utf8Error> {
         unsafe {
-            let s = phper_zval_get_string(&mut self.inner);
-            let buf = from_raw_parts(&(*s).val as *const i8 as *const u8, (*s).len);
+            let s = phper_zval_get_string(&self.inner as *const _ as *mut _);
+            let buf = from_raw_parts(&(*s).val as *const c_char as *const u8, (*s).len);
+            let string = str::from_utf8(buf)?.to_string();
             phper_zend_string_release(s);
-            str::from_utf8(buf).unwrap().to_string()
+            Ok(string)
         }
     }
 
-    pub fn as_i64(&mut self) -> i64 {
-        unsafe { phper_zval_get_long(&mut self.inner) }
+    pub fn as_array(&self) {}
+
+    fn must_be_type_error(&self, expect_type: &str) -> crate::Error {
+        match self.type_name() {
+            Ok(type_name) => {
+                let message = format!("must be of type {}, {} given", expect_type, type_name);
+                TypeError::new(message).into()
+            }
+            Err(e) => e.into(),
+        }
     }
 }
 
@@ -133,15 +202,15 @@ pub trait SetVal {
 impl SetVal for () {
     fn set_val(self, val: &mut Val) {
         unsafe {
-            *val.type_info() = IS_NULL;
+            *val.type_info_mut() = IS_NULL;
         }
     }
 }
 
 impl SetVal for bool {
     fn set_val(self, val: &mut Val) {
         unsafe {
-            *val.type_info() = if self { IS_TRUE } else { IS_FALSE };
+            *val.type_info_mut() = if self { IS_TRUE } else { IS_FALSE };
         }
     }
 }
