Make m_dataBuf an owned Box instead of a raw pointer

Author: rinon

src/lib/xmlparse.rs

@@ -64,6 +64,7 @@ pub use ::libc::INT_MAX;
 use libc::{c_char, c_int, c_long, c_uint, c_ulong, c_ushort, c_void, size_t, ptrdiff_t, memcpy, memcmp, memmove, memset};
 use num_traits::{ToPrimitive,FromPrimitive};
 
+use std::collections::TryReserveError;
 use fallible_collections::FallibleBox;
 
 use std::alloc::{self, Layout};
@@ -224,6 +225,12 @@ impl<'a, T> ops::DerefMut for ExpatBufRefMut<'a, T> {
     }
 }
 
+impl<'a, T> From<&'a mut [T]> for ExpatBufRefMut<'a, T> {
+    fn from(s: &'a mut [T]) -> ExpatBufRefMut<'a, T> {
+        ExpatBufRefMut(s)
+    }
+}
+
 /// Create a null-terminated XML_Char array from ASCII_ literals
 macro_rules! XML_STR {
     [$($char:ident),* $(,)*] => {
@@ -778,8 +785,8 @@ pub struct XML_ParserStruct<'scf> {
     m_parseEndByteIndex: usize,
     // Index in m_buffer after last character that has been parsed
     m_parseEndIdx: usize,
-    pub m_dataBuf: *mut XML_Char, // Box<[XML_Char; INIT_DATA_BUF_SIZE]>
-    pub m_dataBufEnd: *mut XML_Char,
+    // Temporary scratch buffer
+    m_dataBuf: Box<[XML_Char; INIT_DATA_BUF_SIZE as usize]>,
 
     // Handlers should be trait, with native C callback instance
     m_handlers: CXmlHandlers<'scf>,
@@ -1455,8 +1462,9 @@ pub unsafe extern "C" fn XML_ParserCreate_MM(
 }
 
 impl<'scf> XML_ParserStruct<'scf> {
-    fn new(use_namespaces: bool) -> Self {
-        Self {
+    fn new(use_namespaces: bool) -> Result<Self, TryReserveError> {
+        let m_dataBuf = Box::try_new([0; INIT_DATA_BUF_SIZE as usize])?;
+        Ok(Self {
             m_userData: ptr::null_mut(),
             m_buffer: Vec::new(),
             // index of first character to be parsed
@@ -1465,8 +1473,7 @@ impl<'scf> XML_ParserStruct<'scf> {
             m_bufferEnd: 0,
             m_parseEndByteIndex: 0,
             m_parseEndIdx: 0,
-            m_dataBuf: ptr::null_mut(), // Box<[XML_Char; INIT_DATA_BUF_SIZE]>
-            m_dataBufEnd: ptr::null_mut(),
+            m_dataBuf,
 
             m_handlers: Default::default(),
 
@@ -1539,7 +1546,7 @@ impl<'scf> XML_ParserStruct<'scf> {
 
             #[cfg(feature = "mozilla")]
             m_mismatch: ptr::null(),
-        }
+        })
     }
 
     unsafe fn create(
@@ -1548,9 +1555,8 @@ impl<'scf> XML_ParserStruct<'scf> {
         mut dtd: *mut DTD,
     ) -> XML_Parser {
         let use_namespaces = !nameSep.is_null();
-        let mut parser = XML_ParserStruct::new(use_namespaces);
 
-        let mut parser = match Box::try_new(parser) {
+        let mut parser = match XML_ParserStruct::new(use_namespaces).and_then(Box::try_new) {
             Ok(p) => p,
             Err(_) => return ptr::null_mut(),
         };
@@ -1996,7 +2002,6 @@ impl<'scf> Drop for XML_ParserStruct<'scf> {
                 dtdDestroy(self.m_dtd);
             }
             FREE!(self.m_groupConnector);
-            FREE!(self.m_dataBuf);
             if self.m_unknownEncodingRelease.is_some() {
                 self.m_unknownEncodingRelease
                     .expect("non-null function pointer")(self.m_unknownEncodingData);
@@ -3510,11 +3515,11 @@ unsafe extern "C" fn externalEntityContentProcessor(
 }
 
 impl<'scf> XML_ParserStruct<'scf> {
-    unsafe fn doContent(
-        &mut self,
+    unsafe fn doContent<'a, 'b: 'a>(
+        &'b mut self,
         startTagLevel: c_int,
         enc_type: EncodingType,
-        mut buf: ExpatBufRef,
+        mut buf: ExpatBufRef<'a>,
         nextPtr: *mut *const c_char,
         haveMore: XML_Bool,
     ) -> XML_Error {
@@ -4022,14 +4027,12 @@ impl<'scf> XML_ParserStruct<'scf> {
                     }
                     if self.m_handlers.hasCharacterData() {
                         if MUST_CONVERT!(enc, buf.as_ptr()) {
-                            let mut dataPtr = ExpatBufRefMut::new(
-                                self.m_dataBuf as *mut ICHAR,
-                                self.m_dataBufEnd as *mut ICHAR,
-                            );
+                            let dataStart = self.m_dataBuf.as_ptr();
+                            let mut dataPtr = (&mut self.m_dataBuf[..]).into();
                             XmlConvert!(enc, &mut buf, &mut dataPtr);
                             self.m_handlers.characterData(
                                 &ExpatBufRef::new(
-                                    self.m_dataBuf,
+                                    dataStart,
                                     dataPtr.as_ptr(),
                                 ),
                             );
@@ -4059,18 +4062,19 @@ impl<'scf> XML_ParserStruct<'scf> {
                         if MUST_CONVERT!(enc, buf.as_ptr()) {
                             loop {
                                 let mut from_buf = buf.with_end(next);
-                                let mut to_buf = ExpatBufRefMut::new(
-                                    self.m_dataBuf as *mut ICHAR,
-                                    self.m_dataBufEnd as *mut ICHAR,
-                                );
+                                let dataStart = self.m_dataBuf.as_ptr();
+                                let mut to_buf = (&mut self.m_dataBuf[..]).into();
                                 let convert_res_0: super::xmltok::XML_Convert_Result = XmlConvert!(
                                     enc,
                                     &mut from_buf,
                                     &mut to_buf,
                                 );
                                 buf = buf.with_start(from_buf.as_ptr());
                                 *eventEndPP = buf.as_ptr();
-                                let data_buf = ExpatBufRef::new(self.m_dataBuf, to_buf.as_ptr());
+                                let data_buf = ExpatBufRef::new(
+                                    dataStart,
+                                    to_buf.as_ptr(),
+                                );
                                 handlers.characterData(&data_buf);
                                 if convert_res_0 == super::xmltok::XML_Convert_Result::COMPLETED
                                     || convert_res_0 == super::xmltok::XML_Convert_Result::INPUT_INCOMPLETE
@@ -4926,10 +4930,7 @@ unsafe extern "C" fn doCdataSection(
                     if MUST_CONVERT!(enc, buf.as_ptr()) {
                         loop {
                             let mut from_buf = buf.with_end(next);
-                            let mut to_buf = ExpatBufRefMut::new(
-                                (*parser).m_dataBuf as *mut ICHAR,
-                                (*parser).m_dataBufEnd as *mut ICHAR,
-                            );
+                            let mut to_buf = (&mut (*parser).m_dataBuf[..]).into();
                             let convert_res: super::xmltok::XML_Convert_Result = XmlConvert!(
                                 enc,
                                 &mut from_buf,
@@ -4939,7 +4940,7 @@ unsafe extern "C" fn doCdataSection(
                             *eventEndPP = next;
                             handlers.characterData(
                                 &ExpatBufRef::new(
-                                    (*parser).m_dataBuf,
+                                    (*parser).m_dataBuf.as_ptr(),
                                     to_buf.as_ptr(),
                                 ),
                             );
@@ -7724,16 +7725,13 @@ unsafe extern "C" fn reportDefault(
             eventEndPP = &mut (*parser).m_eventEndPtr
         }
         loop {
-            let mut data_buf = ExpatBufRefMut::new(
-                (*parser).m_dataBuf as *mut ICHAR,
-                (*parser).m_dataBufEnd as *mut ICHAR,
-            );
+            let mut data_buf = (&mut (*parser).m_dataBuf[..]).into();
             convert_res = XmlConvert!(enc, &mut buf, &mut data_buf);
             *eventEndPP = buf.as_ptr();
 
             let defaultRan = (*parser).m_handlers.default(
-                (*parser).m_dataBuf,
-                data_buf.as_ptr().wrapping_offset_from((*parser).m_dataBuf).try_into().unwrap(),
+                (*parser).m_dataBuf.as_ptr(),
+                data_buf.as_ptr().wrapping_offset_from((*parser).m_dataBuf.as_ptr()).try_into().unwrap(),
             );
 
             // Previously unwrapped an Option