Adjust values and arrays.

Author: jmjoy

examples/hello/src/lib.rs

@@ -24,7 +24,9 @@ fn module_init(_args: ModuleContext) -> bool {
 }
 
 fn say_hello(arguments: &mut [ZVal]) -> phper::Result<String> {
-    let name = arguments[0].as_string_value()?;
+    let name = &mut arguments[0];
+    name.convert_to_string();
+    let name = name.as_z_str().unwrap().to_str()?;
     Ok(format!("Hello, {}!\n", name))
 }
 
@@ -79,15 +81,15 @@ pub fn get_module() -> Module {
         Visibility::Public,
         |this: &mut Object<()>, _: &mut [ZVal]| {
             let prop = this.get_property("foo");
-            Ok::<_, phper::Error>(prop.as_string_value()?)
+            Ok::<_, phper::Error>(prop.clone())
         },
         vec![],
     );
     foo_class.add_method(
         "setFoo",
         Visibility::Public,
         |this: &mut Object<()>, arguments: &mut [ZVal]| -> phper::Result<()> {
-            this.set_property("foo", ZVal::from(arguments[0].as_string_value()?));
+            this.set_property("foo", arguments[0].clone());
             Ok(())
         },
         vec![Argument::by_val("foo")],

examples/logging/Cargo.toml

@@ -13,6 +13,7 @@ license = "MulanPSL-2.0"
 crate-type = ["cdylib"]
 
 [dependencies]
+anyhow = "1.0.57"
 phper = { version = "0.4.0-alpha.2", path = "../../phper" }
 
 [dev-dependencies]

examples/logging/src/lib.rs

@@ -8,6 +8,7 @@
 // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 // See the Mulan PSL v2 for more details.
 
+use anyhow::Context;
 use phper::{
     deprecated, echo, error, functions::Argument, modules::Module, notice, php_get_module,
     values::ZVal, warning,
@@ -24,7 +25,8 @@ pub fn get_module() -> Module {
     module.add_function(
         "log_say",
         |params: &mut [ZVal]| -> phper::Result<()> {
-            let message = params[0].as_string_value()?;
+            params[0].convert_to_string();
+            let message = params[0].as_z_str().unwrap().to_str().context("to str")?;
             echo!("Hello, {}!", message);
             Ok(())
         },
@@ -34,7 +36,8 @@ pub fn get_module() -> Module {
     module.add_function(
         "log_notice",
         |params: &mut [ZVal]| -> phper::Result<()> {
-            let message = params[0].as_string_value()?;
+            params[0].convert_to_string();
+            let message = params[0].as_z_str().unwrap().to_str().context("to str")?;
             notice!("Something happened: {}", message);
             Ok(())
         },
@@ -44,7 +47,8 @@ pub fn get_module() -> Module {
     module.add_function(
         "log_warning",
         |params: &mut [ZVal]| -> phper::Result<()> {
-            let message = params[0].as_string_value()?;
+            params[0].convert_to_string();
+            let message = params[0].as_z_str().unwrap().to_str().context("to str")?;
             warning!("Something warning: {}", message);
             Ok(())
         },
@@ -54,7 +58,8 @@ pub fn get_module() -> Module {
     module.add_function(
         "log_error",
         |params: &mut [ZVal]| -> phper::Result<()> {
-            let message = params[0].as_string_value()?;
+            params[0].convert_to_string();
+            let message = params[0].as_z_str().unwrap().to_str().context("to str")?;
             error!("Something gone failed: {}", message);
             Ok(())
         },
@@ -64,7 +69,8 @@ pub fn get_module() -> Module {
     module.add_function(
         "log_deprecated",
         |params: &mut [ZVal]| -> phper::Result<()> {
-            let message = params[0].as_string_value()?;
+            params[0].convert_to_string();
+            let message = params[0].as_z_str().unwrap().to_str().context("to str")?;
             deprecated!("Something deprecated: {}", message);
             Ok(())
         },

phper-sys/php_wrapper.c

@@ -297,3 +297,11 @@ zend_string *phper_zend_string_copy(zend_string *s) {
 const char *phper_get_zend_module_build_id() {
     return ZEND_MODULE_BUILD_ID;
 }
+
+void phper_convert_to_long(zval *op) {
+    convert_to_long(op);
+}
+
+void phper_convert_to_string(zval *op) {
+    convert_to_string(op);
+}

phper-sys/src/lib.rs

@@ -17,6 +17,4 @@
 #![allow(clippy::all)]
 #![doc = include_str!("../README.md")]
 
-use std::os::raw::c_char;
-
 include!(concat!(env!("OUT_DIR"), "/php_bindings.rs"));

phper/src/arrays.rs

@@ -31,6 +31,8 @@ use std::{
 pub enum Key<'a> {
     Index(u64),
     Str(&'a str),
+    Bytes(&'a [u8]),
+    ZStr(&'a ZStr),
 }
 
 /// Insert key for [Array].
@@ -39,6 +41,8 @@ pub enum InsertKey<'a> {
     NextIndex,
     Index(u64),
     Str(&'a str),
+    Bytes(&'a [u8]),
+    ZStr(&'a ZStr),
 }
 
 #[repr(transparent)]
@@ -65,27 +69,50 @@ impl ZArr {
         &mut self.inner
     }
 
+    #[inline]
+    pub fn is_empty(&mut self) -> bool {
+        self.len() == 0
+    }
+
+    // Get items length.
+    #[inline]
+    pub fn len(&mut self) -> usize {
+        unsafe { zend_array_count(self.as_mut_ptr()).try_into().unwrap() }
+    }
+
     /// Add or update item by key.
     pub fn insert<'a>(&mut self, key: impl Into<InsertKey<'a>>, value: ZVal) {
         let key = key.into();
-        let value = EBox::new(value);
         unsafe {
             match key {
                 InsertKey::NextIndex => {
-                    phper_zend_hash_next_index_insert(
-                        &mut self.inner,
-                        EBox::into_raw(value).cast(),
-                    );
+                    phper_zend_hash_next_index_insert(self.as_mut_ptr(), value.into_raw());
                 }
                 InsertKey::Index(i) => {
-                    phper_zend_hash_index_update(&mut self.inner, i, EBox::into_raw(value).cast());
+                    phper_zend_hash_index_update(self.as_mut_ptr(), i, value.into_raw());
                 }
                 InsertKey::Str(s) => {
                     phper_zend_hash_str_update(
-                        &mut self.inner,
+                        self.as_mut_ptr(),
                         s.as_ptr().cast(),
                         s.len().try_into().unwrap(),
-                        EBox::into_raw(value).cast(),
+                        value.into_raw(),
+                    );
+                }
+                InsertKey::Bytes(b) => {
+                    phper_zend_hash_str_update(
+                        self.as_mut_ptr(),
+                        b.as_ptr().cast(),
+                        b.len().try_into().unwrap(),
+                        value.into_raw(),
+                    );
+                }
+                InsertKey::ZStr(s) => {
+                    phper_zend_hash_str_update(
+                        self.as_mut_ptr(),
+                        s.as_c_str_ptr().cast(),
+                        s.len().try_into().unwrap(),
+                        value.into_raw(),
                     );
                 }
             }
@@ -94,30 +121,31 @@ impl ZArr {
 
     // Get item by key.
     pub fn get<'a>(&self, key: impl Into<Key<'a>>) -> Option<&ZVal> {
-        let key = key.into();
-        unsafe {
-            let value = match key {
-                Key::Index(i) => zend_hash_index_find(&self.inner, i),
-                Key::Str(s) => {
-                    zend_hash_str_find(&self.inner, s.as_ptr().cast(), s.len().try_into().unwrap())
-                }
-            };
-            if value.is_null() {
-                None
-            } else {
-                Some(ZVal::from_mut_ptr(value))
-            }
-        }
+        self.inner_get(key).map(|v| &*v)
     }
 
     // Get item by key.
     pub fn get_mut<'a>(&mut self, key: impl Into<Key<'a>>) -> Option<&mut ZVal> {
+        self.inner_get(key)
+    }
+
+    fn inner_get<'a>(&self, key: impl Into<Key<'a>>) -> Option<&mut ZVal> {
         let key = key.into();
         unsafe {
             let value = match key {
-                Key::Index(i) => zend_hash_index_find(&self.inner, i),
-                Key::Str(s) => {
-                    zend_hash_str_find(&self.inner, s.as_ptr().cast(), s.len().try_into().unwrap())
+                Key::Index(i) => zend_hash_index_find(self.as_ptr(), i),
+                Key::Str(s) => zend_hash_str_find(
+                    self.as_ptr(),
+                    s.as_ptr().cast(),
+                    s.len().try_into().unwrap(),
+                ),
+                Key::Bytes(b) => zend_hash_str_find(
+                    self.as_ptr(),
+                    b.as_ptr().cast(),
+                    b.len().try_into().unwrap(),
+                ),
+                Key::ZStr(s) => {
+                    zend_hash_str_find(self.as_ptr(), s.as_c_str_ptr(), s.len().try_into().unwrap())
                 }
             };
             if value.is_null() {
@@ -128,15 +156,6 @@ impl ZArr {
         }
     }
 
-    // Get items length.
-    pub fn len(&mut self) -> usize {
-        unsafe { zend_array_count(&mut self.inner) as usize }
-    }
-
-    pub fn is_empty(&mut self) -> bool {
-        self.len() == 0
-    }
-
     pub fn exists<'a>(&self, key: impl Into<Key<'a>>) -> bool {
         let key = key.into();
         unsafe {
@@ -147,6 +166,16 @@ impl ZArr {
                     s.as_ptr().cast(),
                     s.len().try_into().unwrap(),
                 ),
+                Key::Bytes(b) => phper_zend_hash_str_exists(
+                    &self.inner,
+                    b.as_ptr().cast(),
+                    b.len().try_into().unwrap(),
+                ),
+                Key::ZStr(s) => phper_zend_hash_str_exists(
+                    &self.inner,
+                    s.to_bytes().as_ptr().cast(),
+                    s.len().try_into().unwrap(),
+                ),
             }
         }
     }
@@ -161,10 +190,22 @@ impl ZArr {
                     s.as_ptr().cast(),
                     s.len().try_into().unwrap(),
                 ),
+                Key::Bytes(b) => zend_hash_str_del(
+                    &mut self.inner,
+                    b.as_ptr().cast(),
+                    b.len().try_into().unwrap(),
+                ),
+                Key::ZStr(s) => zend_hash_str_del(
+                    &mut self.inner,
+                    s.as_c_str_ptr().cast(),
+                    s.len().try_into().unwrap(),
+                ),
             }) == ZEND_RESULT_CODE_SUCCESS
         }
     }
 
+    pub fn clear(&mut self) {}
+
     pub fn iter(&self) -> Iter<'_> {
         Iter {
             index: 0,
@@ -204,9 +245,16 @@ pub struct ZArray {
 }
 
 impl ZArray {
+    #[inline]
     pub fn new() -> Self {
+        Self::with_capacity(0)
+    }
+
+    /// Note that the actual capacity is always a power of two, so if you have
+    /// 12 elements in a hashtable the actual table capacity will be 16.
+    pub fn with_capacity(n: usize) -> Self {
         unsafe {
-            let ptr = phper_zend_new_array(0);
+            let ptr = phper_zend_new_array(n.try_into().unwrap());
             Self::from_raw(ptr)
         }
     }
@@ -266,14 +314,21 @@ impl Drop for ZArray {
     }
 }
 
+/// Iterator key for [Iter].
+#[derive(Debug, Clone, PartialEq, From)]
+pub enum IterKey<'a> {
+    Index(u64),
+    ZStr(&'a ZStr),
+}
+
 /// Iter created by [Array::iter].
 pub struct Iter<'a> {
     index: isize,
     array: &'a ZArr,
 }
 
 impl<'a> Iterator for Iter<'a> {
-    type Item = (Key<'a>, &'a ZVal);
+    type Item = (IterKey<'a>, &'a ZVal);
 
     fn next(&mut self) -> Option<Self::Item> {
         loop {
@@ -285,11 +340,10 @@ impl<'a> Iterator for Iter<'a> {
                 let bucket = self.array.inner.arData.offset(self.index);
 
                 let key = if (*bucket).key.is_null() {
-                    Key::Index((*bucket).h)
+                    IterKey::Index((*bucket).h)
                 } else {
                     let s = ZStr::from_ptr((*bucket).key);
-                    let s = s.to_str().unwrap();
-                    Key::Str(s)
+                    IterKey::ZStr(s)
                 };
 
                 let val = &mut (*bucket).val;