Modify ensure_end_with_zero to use CString. (#80)

Author: jmjoy

phper/src/exceptions.rs

@@ -8,6 +8,8 @@
 // NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 // See the Mulan PSL v2 for more details.
 
+//! Apis relate to [crate::sys::zend_throw_exception].
+
 use crate::{classes::ClassEntry, errors::Throwable, sys::*};
 use derive_more::Constructor;
 

phper/src/functions.rs

@@ -26,6 +26,7 @@ use crate::{
 use phper_alloc::ToRefOwned;
 use std::{
     convert::TryInto,
+    ffi::{CStr, CString},
     marker::PhantomData,
     mem::{size_of, transmute, zeroed},
     os::raw::c_char,
@@ -131,7 +132,7 @@ impl FunctionEntry {
 
     /// Will leak memory
     unsafe fn entry(
-        name: &str, arguments: &[Argument], handler: Rc<dyn Callable>,
+        name: &CStr, arguments: &[Argument], handler: Rc<dyn Callable>,
         visibility: Option<Visibility>, r#static: Option<bool>,
     ) -> zend_function_entry {
         let mut infos = Vec::new();
@@ -173,74 +174,79 @@ impl FunctionEntry {
 }
 
 pub struct FunctionEntity {
-    name: String,
+    name: CString,
     handler: Rc<dyn Callable>,
     arguments: Vec<Argument>,
 }
 
 impl FunctionEntity {
+    #[inline]
     pub(crate) fn new(name: impl Into<String>, handler: Rc<dyn Callable>) -> Self {
-        let name = ensure_end_with_zero(name);
         FunctionEntity {
-            name,
+            name: ensure_end_with_zero(name),
             handler,
             arguments: Default::default(),
         }
     }
 
+    #[inline]
     pub fn argument(&mut self, argument: Argument) -> &mut Self {
         self.arguments.push(argument);
         self
     }
 
+    #[inline]
     pub fn arguments(&mut self, arguments: impl IntoIterator<Item = Argument>) -> &mut Self {
         self.arguments.extend(arguments);
         self
     }
 }
 
 pub struct MethodEntity {
-    name: String,
+    name: CString,
     handler: Rc<dyn Callable>,
     arguments: Vec<Argument>,
     visibility: Visibility,
     r#static: bool,
 }
 
 impl MethodEntity {
+    #[inline]
     pub(crate) fn new(
         name: impl Into<String>, handler: Rc<dyn Callable>, visibility: Visibility,
     ) -> Self {
-        let name = ensure_end_with_zero(name);
         Self {
-            name,
+            name: ensure_end_with_zero(name),
             handler,
             visibility,
             arguments: Default::default(),
             r#static: false,
         }
     }
 
+    #[inline]
     pub(crate) fn r#static(&mut self, s: bool) -> &mut Self {
         self.r#static = s;
         self
     }
 
+    #[inline]
     pub fn argument(&mut self, argument: Argument) -> &mut Self {
         self.arguments.push(argument);
         self
     }
 
+    #[inline]
     pub fn arguments(&mut self, arguments: impl IntoIterator<Item = Argument>) -> &mut Self {
         self.arguments.extend(arguments);
         self
     }
 }
 
 pub struct Argument {
-    pub(crate) name: String,
-    pub(crate) pass_by_ref: bool,
-    pub(crate) required: bool,
+    name: CString,
+    pass_by_ref: bool,
+    required: bool,
 }
 
 impl Argument {

phper/src/modules.rs

@@ -22,6 +22,7 @@ use crate::{
     values::ZVal,
 };
 use std::{
+    ffi::CString,
     mem::{replace, size_of, take, zeroed},
     os::raw::{c_int, c_uchar, c_uint, c_ushort},
     ptr::{null, null_mut},
@@ -91,10 +92,10 @@ unsafe extern "C" fn request_shutdown(r#type: c_int, request_number: c_int) -> c
 unsafe extern "C" fn module_info(zend_module: *mut zend_module_entry) {
     read_global_module(|module| {
         php_info_print_table_start();
-        if !module.version.is_empty() {
+        if !module.version.as_bytes().is_empty() {
             php_info_print_table_row(2, c_str_ptr!("version"), module.version.as_ptr());
         }
-        if !module.author.is_empty() {
+        if !module.author.as_bytes().is_empty() {
             php_info_print_table_row(2, c_str_ptr!("authors"), module.author.as_ptr());
         }
         php_info_print_table_end();
@@ -103,9 +104,9 @@ unsafe extern "C" fn module_info(zend_module: *mut zend_module_entry) {
 }
 
 pub struct Module {
-    name: String,
-    version: String,
-    author: String,
+    name: CString,
+    version: CString,
+    author: CString,
     module_init: Option<Box<dyn FnOnce(ModuleContext) -> bool + Send + Sync>>,
     module_shutdown: Option<Box<dyn FnOnce(ModuleContext) -> bool + Send + Sync>>,
     request_init: Option<Box<dyn Fn(ModuleContext) -> bool + Send + Sync>>,
@@ -188,8 +189,11 @@ impl Module {
     /// Leak memory to generate `zend_module_entry` pointer.
     #[doc(hidden)]
     pub unsafe fn module_entry(self) -> *const zend_module_entry {
-        assert!(!self.name.is_empty(), "module name must be set");
-        assert!(!self.version.is_empty(), "module version must be set");
+        assert!(!self.name.as_bytes().is_empty(), "module name must be set");
+        assert!(
+            !self.version.as_bytes().is_empty(),
+            "module version must be set"
+        );
 
         let entry: Box<zend_module_entry> = Box::new(zend_module_entry {
             size: size_of::<zend_module_entry>() as c_ushort,

phper/src/output.rs

@@ -11,7 +11,7 @@
 //! Logs and echo facilities.
 
 use crate::{sys::*, utils::ensure_end_with_zero};
-use std::{convert::TryInto, ptr::null};
+use std::ptr::null;
 
 #[repr(u32)]
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -40,7 +40,7 @@ pub fn echo(message: impl Into<String>) {
     unsafe {
         zend_write.expect("function zend_write can't be null")(
             message.as_ptr().cast(),
-            (message.len() - 1).try_into().unwrap(),
+            message.as_bytes().len().try_into().unwrap(),
         );
     }
 }

phper/src/utils.rs

@@ -10,10 +10,8 @@
 
 //! Internal useful utils.
 
-pub(crate) fn ensure_end_with_zero(s: impl Into<String>) -> String {
-    let mut s = s.into();
-    if !s.ends_with('\0') {
-        s.push('\0');
-    }
-    s
+use std::ffi::CString;
+
+pub(crate) fn ensure_end_with_zero(s: impl Into<String>) -> CString {
+    CString::new(s.into()).expect("CString::new failed")
 }