Reduce code size

Author: kornelski

src/reader/parser.rs

@@ -288,35 +288,34 @@ impl PullParser {
             // While lexer gives us Ok(maybe_token) -- we loop.
             // Upon having a complete XML-event -- we return from the whole function.
             match self.lexer.next_token(r) {
-                Ok(maybe_token) =>
-                    match maybe_token {
-                        None => break,
-                        Some(token) =>
-                            match self.dispatch_token(token) {
-                                None => {} // continue
-                                Some(Ok(XmlEvent::EndDocument)) =>
-                                    return {
-                                        self.next_pos();
-                                        self.set_final_result(Ok(XmlEvent::EndDocument))
-                                    },
-                                Some(Ok(xml_event)) =>
-                                    return {
-                                        self.next_pos();
-                                        Ok(xml_event)
-                                    },
-                                Some(Err(xml_error)) =>
-                                    return {
-                                        self.next_pos();
-                                        self.set_final_result(Err(xml_error))
-                                    },
-                            }
-                    },
+                Ok(Some(token)) => {
+                    match self.dispatch_token(token) {
+                        None => {} // continue
+                        Some(Ok(XmlEvent::EndDocument)) => {
+                            self.next_pos();
+                            return self.set_final_result(Ok(XmlEvent::EndDocument))
+                        },
+                        Some(Ok(xml_event)) => {
+                            self.next_pos();
+                            return Ok(xml_event)
+                        },
+                        Some(Err(xml_error)) => {
+                            self.next_pos();
+                            return self.set_final_result(Err(xml_error))
+                        },
+                    }
+                },
+                Ok(None) => break,
                 Err(lexer_error) =>
                     return self.set_final_result(Err(lexer_error)),
             }
         }
 
-        // Handle end of stream
+        self.handle_eof()
+    }
+
+    /// Handle end of stream
+    fn handle_eof(&mut self) -> std::result::Result<XmlEvent, super::Error> {
         // Forward pos to the lexer head
         self.next_pos();
         let ev = if self.depth() == 0 {
@@ -339,6 +338,7 @@ impl PullParser {
 
     // This function is to be called when a terminal event is reached.
     // The function sets up the `self.final_result` into `Some(result)` and return `result`.
+    #[inline]
     fn set_final_result(&mut self, result: Result) -> Result {
         self.final_result = Some(result.clone());
         result
@@ -363,6 +363,7 @@ impl PullParser {
         self.pos.push(self.lexer.position());
     }
 
+    #[inline(never)]
     fn dispatch_token(&mut self, t: Token) -> Option<Result> {
         match self.st {
             State::OutsideTag                     => self.outside_tag(t),

src/reader/parser/inside_reference.rs

@@ -64,9 +64,9 @@ impl PullParser {
 
     pub(crate) fn numeric_reference_from_str(&self, num_str: &str) -> std::result::Result<char, String> {
         let val = if let Some(hex) = num_str.strip_prefix('x') {
-            u32::from_str_radix(hex, 16).map_err(|_| format!("Invalid hexadecimal character number in an entity: {num_str}"))?
+            u32::from_str_radix(hex, 16).map_err(move |_| format!("Invalid hexadecimal character number in an entity: {num_str}"))?
         } else {
-            u32::from_str_radix(num_str, 10).map_err(|_| format!("Invalid character number in an entity: {num_str}"))?
+            u32::from_str_radix(num_str, 10).map_err(move |_| format!("Invalid character number in an entity: {num_str}"))?
         };
         match char::from_u32(val) {
             Some('\0') => Err("NUL character entity is not allowed".into()),

src/util.rs

@@ -57,17 +57,23 @@ pub enum Encoding {
     Unknown,
 }
 
+// Rustc inlines eq_ignore_ascii_case and creates kilobytes of code!
+#[inline(never)]
+fn icmp(lower: &str, varcase: &str) -> bool {
+    lower.bytes().zip(varcase.bytes()).all(|(l, v)| l == v.to_ascii_lowercase())
+}
+
 impl FromStr for Encoding {
     type Err = &'static str;
 
     fn from_str(val: &str) -> Result<Self, Self::Err> {
-        if ["utf-8", "utf8"].iter().any(|label| label.eq_ignore_ascii_case(val)) {
+        if ["utf-8", "utf8"].into_iter().any(move |label| icmp(label, val)) {
             Ok(Encoding::Utf8)
-        } else if ["iso-8859-1", "latin1"].iter().any(|label| label.eq_ignore_ascii_case(val)) {
+        } else if ["iso-8859-1", "latin1"].into_iter().any(move |label| icmp(label, val)) {
             Ok(Encoding::Latin1)
-        } else if ["utf-16", "utf16"].iter().any(|label| label.eq_ignore_ascii_case(val)) {
+        } else if ["utf-16", "utf16"].into_iter().any(move |label| icmp(label, val)) {
             Ok(Encoding::Utf16)
-        } else if ["ascii", "us-ascii"].iter().any(|label| label.eq_ignore_ascii_case(val)) {
+        } else if ["ascii", "us-ascii"].into_iter().any(move |label| icmp(label, val)) {
             Ok(Encoding::Ascii)
         } else {
             Err("unknown encoding name")