From b06cc6c61d681dd4d208b8753456e8703a082a6d Mon Sep 17 00:00:00 2001
From: Ashe Connor <ashe@kivikakk.ee>
Date: Mon, 11 Sep 2017 15:59:56 +1000
Subject: [PATCH] Minor cleanups

---
 src/html.rs           | 27 ++++++++++++---------------
 src/parser/inlines.rs | 16 +++++++---------
 2 files changed, 19 insertions(+), 24 deletions(-)

diff --git a/src/html.rs b/src/html.rs
index db9bb900..840661d2 100644
--- a/src/html.rs
+++ b/src/html.rs
@@ -108,18 +108,17 @@ fn tagfilter(literal: &[u8]) -> bool {
 }
 
 fn tagfilter_block(input: &[u8], o: &mut Write) -> io::Result<()> {
-    let src = input;
-    let size = src.len();
+    let size = input.len();
     let mut i = 0;
 
     while i < size {
         let org = i;
-        while i < size && src[i] != b'<' {
+        while i < size && input[i] != b'<' {
             i += 1;
         }
 
         if i > org {
-            try!(o.write_all(&src[org..i]));
+            try!(o.write_all(&input[org..i]));
         }
 
         if i >= size {
@@ -154,25 +153,24 @@ impl<'o> HtmlFormatter<'o> {
     }
 
     fn escape(&mut self, buffer: &[u8]) -> io::Result<()> {
-        let src = buffer;
-        let size = src.len();
+        let size = buffer.len();
         let mut i = 0;
 
         while i < size {
             let org = i;
-            while i < size && !NEEDS_ESCAPED[src[i] as usize] {
+            while i < size && !NEEDS_ESCAPED[buffer[i] as usize] {
                 i += 1;
             }
 
             if i > org {
-                try!(self.output.write_all(&src[org..i]));
+                try!(self.output.write_all(&buffer[org..i]));
             }
 
             if i >= size {
                 break;
             }
 
-            match src[i] as char {
+            match buffer[i] as char {
                 '"' => {
                     try!(self.output.write_all(b"&quot;"));
                 }
@@ -208,32 +206,31 @@ impl<'o> HtmlFormatter<'o> {
             };
         }
 
-        let src = buffer;
-        let size = src.len();
+        let size = buffer.len();
         let mut i = 0;
 
         while i < size {
             let org = i;
-            while i < size && HREF_SAFE[src[i] as usize] {
+            while i < size && HREF_SAFE[buffer[i] as usize] {
                 i += 1;
             }
 
             if i > org {
-                try!(self.output.write_all(&src[org..i]));
+                try!(self.output.write_all(&buffer[org..i]));
             }
 
             if i >= size {
                 break;
             }
 
-            match src[i] as char {
+            match buffer[i] as char {
                 '&' => {
                     try!(self.output.write_all(b"&amp;"));
                 }
                 '\'' => {
                     try!(self.output.write_all(b"&#x27;"));
                 }
-                _ => try!(write!(self.output, "%{:02X}", src[i])),
+                _ => try!(write!(self.output, "%{:02X}", buffer[i])),
             }
 
             i += 1;
diff --git a/src/parser/inlines.rs b/src/parser/inlines.rs
index acd803bc..146bf35d 100644
--- a/src/parser/inlines.rs
+++ b/src/parser/inlines.rs
@@ -373,14 +373,12 @@ impl<'a, 'r, 'o, 'd, 'i> Subject<'a, 'r, 'o, 'd, 'i> {
         }
     }
 
-    pub fn take_while(&mut self, c: u8) -> Vec<u8> {
-        let mut v = Vec::with_capacity(10);
-        // TODO
+    pub fn take_while(&mut self, c: u8) -> usize {
+        let start_pos = self.pos;
         while self.peek_char() == Some(&c) {
-            v.push(self.input[self.pos]);
             self.pos += 1;
         }
-        v
+        self.pos - start_pos
     }
 
     pub fn scan_to_closing_backtick(&mut self, openticklength: usize) -> Option<usize> {
@@ -400,7 +398,7 @@ impl<'a, 'r, 'o, 'd, 'i> Subject<'a, 'r, 'o, 'd, 'i> {
                 self.scanned_for_backticks = true;
                 return None;
             }
-            let numticks = self.take_while(b'`').len();
+            let numticks = self.take_while(b'`');
             if numticks <= MAXBACKTICKS {
                 self.backticks[numticks] = self.pos - numticks;
             }
@@ -413,15 +411,15 @@ impl<'a, 'r, 'o, 'd, 'i> Subject<'a, 'r, 'o, 'd, 'i> {
     pub fn handle_backticks(&mut self) -> &'a AstNode<'a> {
         let openticks = self.take_while(b'`');
         let startpos = self.pos;
-        let endpos = self.scan_to_closing_backtick(openticks.len());
+        let endpos = self.scan_to_closing_backtick(openticks);
 
         match endpos {
             None => {
                 self.pos = startpos;
-                make_inline(self.arena, NodeValue::Text(openticks))
+                make_inline(self.arena, NodeValue::Text(vec![b'`'; openticks]))
             }
             Some(endpos) => {
-                let mut buf = &self.input[startpos..endpos - openticks.len()];
+                let mut buf = &self.input[startpos..endpos - openticks];
                 buf = strings::trim_slice(buf);
                 let buf = strings::normalize_whitespace(buf);
                 make_inline(self.arena, NodeValue::Code(buf))