Made more stuff pure.

escape functions in char, io.with_str_reader, base64 and md5sum, cell.empty_cell
and is_empty.

1 files changed, 88 insertions, 86 deletions

diff --git a/src/libstd/base64.rs b/src/libstd/base64.rs
index 9bad4d39750..177074de8f6 100644
--- a/src/libstd/base64.rs
+++ b/src/libstd/base64.rs
@@ -2,72 +2,73 @@
 use io::Reader;
 
 pub trait ToBase64 {
-    fn to_base64() -> ~str;
+    pure fn to_base64() -> ~str;
 }
 
 impl &[u8]: ToBase64 {
-    fn to_base64() -> ~str {
+    pure fn to_base64() -> ~str {
         let chars = str::chars(
           ~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
         );
 
-        let len = self.len();
         let mut s = ~"";
-        str::reserve(&mut s, ((len + 3u) / 4u) * 3u);
-
-        let mut i = 0u;
-
-        while i < len - (len % 3u) {
-            let n = (self[i] as uint) << 16u |
-                    (self[i + 1u] as uint) << 8u |
-                    (self[i + 2u] as uint);
-
-            // This 24-bit number gets separated into four 6-bit numbers.
-            str::push_char(&mut s, chars[(n >> 18u) & 63u]);
-            str::push_char(&mut s, chars[(n >> 12u) & 63u]);
-            str::push_char(&mut s, chars[(n >> 6u) & 63u]);
-            str::push_char(&mut s, chars[n & 63u]);
-
-            i += 3u;
-        }
-
-        // Heh, would be cool if we knew this was exhaustive
-        // (the dream of bounded integer types)
-        match len % 3 {
-          0 => (),
-          1 => {
-            let n = (self[i] as uint) << 16u;
-            str::push_char(&mut s, chars[(n >> 18u) & 63u]);
-            str::push_char(&mut s, chars[(n >> 12u) & 63u]);
-            str::push_char(&mut s, '=');
-            str::push_char(&mut s, '=');
-          }
-          2 => {
-            let n = (self[i] as uint) << 16u | (self[i + 1u] as uint) << 8u;
-            str::push_char(&mut s, chars[(n >> 18u) & 63u]);
-            str::push_char(&mut s, chars[(n >> 12u) & 63u]);
-            str::push_char(&mut s, chars[(n >> 6u) & 63u]);
-            str::push_char(&mut s, '=');
-          }
-          _ => fail ~"Algebra is broken, please alert the math police"
+        unsafe {
+            let len = self.len();
+            str::reserve(&mut s, ((len + 3u) / 4u) * 3u);
+    
+            let mut i = 0u;
+    
+            while i < len - (len % 3u) {
+                let n = (self[i] as uint) << 16u |
+                        (self[i + 1u] as uint) << 8u |
+                        (self[i + 2u] as uint);
+    
+                // This 24-bit number gets separated into four 6-bit numbers.
+                str::push_char(&mut s, chars[(n >> 18u) & 63u]);
+                str::push_char(&mut s, chars[(n >> 12u) & 63u]);
+                str::push_char(&mut s, chars[(n >> 6u) & 63u]);
+                str::push_char(&mut s, chars[n & 63u]);
+    
+                i += 3u;
+            }
+    
+            // Heh, would be cool if we knew this was exhaustive
+            // (the dream of bounded integer types)
+            match len % 3 {
+              0 => (),
+              1 => {
+                let n = (self[i] as uint) << 16u;
+                str::push_char(&mut s, chars[(n >> 18u) & 63u]);
+                str::push_char(&mut s, chars[(n >> 12u) & 63u]);
+                str::push_char(&mut s, '=');
+                str::push_char(&mut s, '=');
+              }
+              2 => {
+                let n = (self[i] as uint) << 16u | (self[i + 1u] as uint) << 8u;
+                str::push_char(&mut s, chars[(n >> 18u) & 63u]);
+                str::push_char(&mut s, chars[(n >> 12u) & 63u]);
+                str::push_char(&mut s, chars[(n >> 6u) & 63u]);
+                str::push_char(&mut s, '=');
+              }
+              _ => fail ~"Algebra is broken, please alert the math police"
+            }
         }
-
         s
     }
 }
 
 impl &str: ToBase64 {
-    fn to_base64() -> ~str {
+    pure fn to_base64() -> ~str {
         str::to_bytes(self).to_base64()
     }
 }
 
 pub trait FromBase64 {
-    fn from_base64() -> ~[u8];
+    pure fn from_base64() -> ~[u8];
 }
 
 impl ~[u8]: FromBase64 {
-    fn from_base64() -> ~[u8] {
+    pure fn from_base64() -> ~[u8] {
         if self.len() % 4u != 0u { fail ~"invalid base64 length"; }
 
         let len = self.len();
@@ -80,55 +81,56 @@ impl ~[u8]: FromBase64 {
 
         let mut r = vec::with_capacity((len / 4u) * 3u - padding);
 
-        let mut i = 0u;
-        while i < len {
-            let mut n = 0u;
-
-            for iter::repeat(4u) {
-                let ch = self[i] as char;
-                n <<= 6u;
-
-                if ch >= 'A' && ch <= 'Z' {
-                    n |= (ch as uint) - 0x41u;
-                } else if ch >= 'a' && ch <= 'z' {
-                    n |= (ch as uint) - 0x47u;
-                } else if ch >= '0' && ch <= '9' {
-                    n |= (ch as uint) + 0x04u;
-                } else if ch == '+' {
-                    n |= 0x3Eu;
-                } else if ch == '/' {
-                    n |= 0x3Fu;
-                } else if ch == '=' {
-                    match len - i {
-                      1u => {
-                        r.push(((n >> 16u) & 0xFFu) as u8);
-                        r.push(((n >> 8u ) & 0xFFu) as u8);
-                        return copy r;
-                      }
-                      2u => {
-                        r.push(((n >> 10u) & 0xFFu) as u8);
-                        return copy r;
-                      }
-                      _ => fail ~"invalid base64 padding"
+        unsafe {
+            let mut i = 0u;
+            while i < len {
+                let mut n = 0u;
+    
+                for iter::repeat(4u) {
+                    let ch = self[i] as char;
+                    n <<= 6u;
+    
+                    if ch >= 'A' && ch <= 'Z' {
+                        n |= (ch as uint) - 0x41u;
+                    } else if ch >= 'a' && ch <= 'z' {
+                        n |= (ch as uint) - 0x47u;
+                    } else if ch >= '0' && ch <= '9' {
+                        n |= (ch as uint) + 0x04u;
+                    } else if ch == '+' {
+                        n |= 0x3Eu;
+                    } else if ch == '/' {
+                        n |= 0x3Fu;
+                    } else if ch == '=' {
+                        match len - i {
+                          1u => {
+                            r.push(((n >> 16u) & 0xFFu) as u8);
+                            r.push(((n >> 8u ) & 0xFFu) as u8);
+                            return copy r;
+                          }
+                          2u => {
+                            r.push(((n >> 10u) & 0xFFu) as u8);
+                            return copy r;
+                          }
+                          _ => fail ~"invalid base64 padding"
+                        }
+                    } else {
+                        fail ~"invalid base64 character";
                     }
-                } else {
-                    fail ~"invalid base64 character";
-                }
-
-                i += 1u;
-            };
-
-            r.push(((n >> 16u) & 0xFFu) as u8);
-            r.push(((n >> 8u ) & 0xFFu) as u8);
-            r.push(((n       ) & 0xFFu) as u8);
+    
+                    i += 1u;
+                };
+    
+                r.push(((n >> 16u) & 0xFFu) as u8);
+                r.push(((n >> 8u ) & 0xFFu) as u8);
+                r.push(((n       ) & 0xFFu) as u8);
+            }
         }
-
         r
     }
 }
 
 impl ~str: FromBase64 {
-    fn from_base64() -> ~[u8] {
+    pure fn from_base64() -> ~[u8] {
         str::to_bytes(self).from_base64()
     }
 }