Add some ZendString methods.

Author: jmjoy

phper/src/cmd.rs

@@ -28,7 +28,8 @@ struct InstallCommand {}
 /// Make.
 ///
 /// # Examples
-/// ```
+///
+/// ```no_run
 /// use phper::cmd::make;
 ///
 /// fn main() {

phper/src/objects.rs

@@ -60,7 +60,7 @@ impl Object {
                     &self.inner as *const _ as *mut _,
                     name.as_ptr().cast(),
                     name.len(),
-                    false.into(),
+                    true.into(),
                     null_mut(),
                 )
             }
@@ -73,7 +73,7 @@ impl Object {
                     &mut zv,
                     name.as_ptr().cast(),
                     name.len(),
-                    false.into(),
+                    true.into(),
                     null_mut(),
                 )
             }

phper/src/strings.rs

@@ -1,5 +1,8 @@
-use crate::{alloc::EBox, sys::*};
-use std::{slice::from_raw_parts, str::Utf8Error};
+use crate::{
+    alloc::{EAllocatable, EBox},
+    sys::*,
+};
+use std::{ffi::CString, os::raw::c_char, slice::from_raw_parts, str, str::Utf8Error};
 
 /// Wrapper of [crate::sys::zend_string].
 #[repr(transparent)]
@@ -8,11 +11,18 @@ pub struct ZendString {
 }
 
 impl ZendString {
-    // TODO Remove dead_code tag
-    #[allow(dead_code)]
-    pub(crate) unsafe fn from_mut_ptr<'a>(ptr: *mut zend_string) -> &'a mut Self {
-        let ptr = ptr as *mut Self;
-        ptr.as_mut().expect("ptr shouldn't be null")
+    pub fn new(s: &str) -> EBox<Self> {
+        unsafe {
+            let ptr = phper_zend_string_init(s.as_ptr().cast(), s.len(), false.into()).cast();
+            EBox::from_raw(ptr)
+        }
+    }
+
+    pub(crate) fn from_ptr<'a>(ptr: *mut zend_string) -> &'a Self {
+        unsafe {
+            let ptr = ptr as *mut Self;
+            ptr.as_ref().unwrap()
+        }
     }
 
     pub fn as_ptr(&self) -> *const zend_string {
@@ -22,4 +32,29 @@ impl ZendString {
     pub fn as_mut_ptr(&mut self) -> *mut zend_string {
         &mut self.inner
     }
+
+    pub fn as_string(&self) -> Result<String, Utf8Error> {
+        unsafe {
+            let buf = from_raw_parts(
+                &self.inner.val as *const c_char as *const u8,
+                self.inner.len,
+            );
+            let string = str::from_utf8(buf)?.to_string();
+            Ok(string)
+        }
+    }
+}
+
+impl EAllocatable for ZendString {
+    fn free(ptr: *mut Self) {
+        unsafe {
+            phper_zend_string_release(ptr.cast());
+        }
+    }
+}
+
+impl Drop for ZendString {
+    fn drop(&mut self) {
+        unreachable!("Allocation on the stack is not allowed")
+    }
 }

phper/src/values.rs

@@ -6,6 +6,7 @@ use crate::{
     errors::{Throwable, TypeError},
     functions::ZendFunction,
     objects::Object,
+    strings::ZendString,
     sys::*,
     types::{get_type_by_const, Type},
     utils::ensure_end_with_zero,
@@ -162,10 +163,8 @@ impl Val {
     pub fn as_string(&self) -> crate::Result<String> {
         if self.get_type().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)
+                let zs = ZendString::from_ptr(self.inner.value.str);
+                Ok(zs.as_string()?)
             }
         } else {
             Err(self.must_be_type_error("string").into())
@@ -175,10 +174,8 @@ impl Val {
     pub fn as_string_value(&self) -> Result<String, Utf8Error> {
         unsafe {
             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 result = str::from_utf8(buf).map(ToString::to_string);
-            phper_zend_string_release(s);
-            result
+            let zs = EBox::from_raw(s as *mut ZendString);
+            zs.as_string()
         }
     }
 
@@ -218,12 +215,8 @@ impl Val {
             Err(e) => e.into(),
         }
     }
-}
-
-impl EAllocatable for Val {}
 
-impl Drop for Val {
-    fn drop(&mut self) {
+    fn drop_me(&mut self) {
         let t = self.get_type();
         unsafe {
             if t.is_string() {
@@ -237,6 +230,21 @@ impl Drop for Val {
     }
 }
 
+impl EAllocatable for Val {
+    fn free(ptr: *mut Self) {
+        unsafe {
+            ptr.as_mut().unwrap().drop_me();
+            _efree(ptr.cast());
+        }
+    }
+}
+
+impl Drop for Val {
+    fn drop(&mut self) {
+        self.drop_me();
+    }
+}
+
 /// The trait for setting the value of [Val], mainly as the return value of
 /// [crate::functions::Function] and [crate::functions::Method], and initializer of [Val].
 pub trait SetVal {

tests/integration/src/lib.rs

@@ -3,6 +3,7 @@
 mod arguments;
 mod arrays;
 mod objects;
+mod strings;
 mod values;
 
 use phper::{modules::Module, php_get_module};
@@ -19,6 +20,7 @@ pub fn get_module() -> Module {
     arrays::integrate(&mut module);
     objects::integrate(&mut module);
     values::integrate(&mut module);
+    strings::integrate(&mut module);
 
     module
 }

tests/integration/src/objects.rs

@@ -6,6 +6,22 @@ pub fn integrate(module: &mut Module) {
         |arguments: &mut [Val]| -> phper::Result<()> {
             let o = Object::new_by_std_class();
             drop(o);
+            Ok(())
+        },
+        vec![],
+    );
+
+    module.add_function(
+        "integrate_objects_get_set",
+        |arguments: &mut [Val]| -> phper::Result<()> {
+            let mut o = Object::new_by_std_class();
+
+            o.set_property("foo", Val::new("bar"));
+            let foo = o.get_property("foo");
+            assert_eq!(foo.as_string()?, "bar");
+
+            let not_exists = o.get_property("no_exists");
+            not_exists.as_null()?;
 
             Ok(())
         },

tests/integration/src/strings.rs

@@ -0,0 +1,13 @@
+use phper::{modules::Module, strings::ZendString, values::Val};
+
+pub fn integrate(module: &mut Module) {
+    module.add_function(
+        "integrate_strings_as_string",
+        |arguments: &mut [Val]| -> phper::Result<()> {
+            let zs = ZendString::new("hello");
+            assert_eq!(zs.as_string()?, "hello");
+            Ok(())
+        },
+        vec![],
+    );
+}

tests/integration/tests/integration.rs

@@ -13,6 +13,7 @@ fn test_php() {
             &tests_php_dir.join("arguments.php"),
             &tests_php_dir.join("arrays.php"),
             &tests_php_dir.join("objects.php"),
+            &tests_php_dir.join("strings.php"),
             &tests_php_dir.join("values.php"),
         ],
     );

tests/integration/tests/php/objects.php

@@ -3,3 +3,4 @@
 require_once __DIR__ . '/_common.php';
 
 integrate_objects_new_drop();
+integrate_objects_get_set();

tests/integration/tests/php/strings.php

@@ -0,0 +1,5 @@
+<?php
+
+require_once __DIR__ . '/_common.php';
+
+integrate_strings_as_string();