Switched over a bunch of splitting funktions to non-allocating iterators

src/libcore/num/strconv.rs

@@ -132,10 +132,10 @@ impl_NumStrConv_Integer!(u64)
 
 
 // Special value strings as [u8] consts.
-const inf_buf:          [u8*3] = ['i' as u8, 'n' as u8, 'f' as u8];
+static inf_buf:          [u8*3] = ['i' as u8, 'n' as u8, 'f' as u8];
-const positive_inf_buf: [u8*4] = ['+' as u8, 'i' as u8, 'n' as u8, 'f' as u8];
+static positive_inf_buf: [u8*4] = ['+' as u8, 'i' as u8, 'n' as u8, 'f' as u8];
-const negative_inf_buf: [u8*4] = ['-' as u8, 'i' as u8, 'n' as u8, 'f' as u8];
+static negative_inf_buf: [u8*4] = ['-' as u8, 'i' as u8, 'n' as u8, 'f' as u8];
-const nan_buf:          [u8*3] = ['N' as u8, 'a' as u8, 'N' as u8];
+static nan_buf:          [u8*3] = ['N' as u8, 'a' as u8, 'N' as u8];
 
 /**
  * Converts a number to its string representation as a byte vector.

src/libcore/os.rs

@@ -218,7 +218,8 @@ pub fn env() -> ~[(~str,~str)] {
         fn env_convert(input: ~[~str]) -> ~[(~str, ~str)] {
             let mut pairs = ~[];
             for input.each |p| {
-                let vs = str::splitn_char(*p, '=', 1);
+                let mut vs = ~[];
+                for str::each_splitn_char(*p, '=', 1) |s| { vs.push(s.to_owned()) }
                 debug!("splitting: len: %u",
                     vs.len());
                 fail_unless!(vs.len() == 2);

src/libcore/path.rs

@@ -381,7 +381,8 @@ impl ToStr for PosixPath {
 impl GenericPath for PosixPath {
 
     fn from_str(s: &str) -> PosixPath {
-        let mut components = str::split_nonempty(s, |c| c == '/');
+        let mut components = ~[];
+        for str::each_split_nonempty(s, |c| c == '/') |s| { components.push(s.to_owned()) }
         let is_absolute = (s.len() != 0 && s[0] == '/' as u8);
         return PosixPath { is_absolute: is_absolute,
                            components: components }
@@ -504,9 +505,10 @@ impl GenericPath for PosixPath {
     fn push_many(&self, cs: &[~str]) -> PosixPath {
         let mut v = copy self.components;
         for cs.each |e| {
-            let mut ss = str::split_nonempty(
+            let mut ss = ~[];
-                *e,
+            for str::each_split_nonempty(*e, |c| windows::is_sep(c as u8)) |s| {
-                |c| windows::is_sep(c as u8));
+                ss.push(s.to_owned())
+            }
             unsafe { v.push_all_move(ss); }
         }
         PosixPath { is_absolute: self.is_absolute,
@@ -515,7 +517,10 @@ impl GenericPath for PosixPath {
 
     fn push(&self, s: &str) -> PosixPath {
         let mut v = copy self.components;
-        let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
+        let mut ss = ~[];
+        for str::each_split_nonempty(s, |c| windows::is_sep(c as u8)) |s| {
+            ss.push(s.to_owned())
+        }
         unsafe { v.push_all_move(ss); }
         PosixPath { components: v, ..copy *self }
     }
@@ -590,8 +595,10 @@ impl GenericPath for WindowsPath {
           }
         }
 
-        let mut components =
+        let mut components = ~[];
-            str::split_nonempty(rest, |c| windows::is_sep(c as u8));
+        for str::each_split_nonempty(rest, |c| windows::is_sep(c as u8)) |s| {
+            components.push(s.to_owned())
+        }
         let is_absolute = (rest.len() != 0 && windows::is_sep(rest[0]));
         return WindowsPath { host: host,
                              device: device,
@@ -759,9 +766,10 @@ impl GenericPath for WindowsPath {
     fn push_many(&self, cs: &[~str]) -> WindowsPath {
         let mut v = copy self.components;
         for cs.each |e| {
-            let mut ss = str::split_nonempty(
+            let mut ss = ~[];
-                *e,
+            for str::each_split_nonempty(*e, |c| windows::is_sep(c as u8)) |s| {
-                |c| windows::is_sep(c as u8));
+                ss.push(s.to_owned())
+            }
             unsafe { v.push_all_move(ss); }
         }
         // tedious, but as-is, we can't use ..self
@@ -775,7 +783,10 @@ impl GenericPath for WindowsPath {
 
     fn push(&self, s: &str) -> WindowsPath {
         let mut v = copy self.components;
-        let mut ss = str::split_nonempty(s, |c| windows::is_sep(c as u8));
+        let mut ss = ~[];
+        for str::each_split_nonempty(s, |c| windows::is_sep(c as u8)) |s| {
+            ss.push(s.to_owned())
+        }
         unsafe { v.push_all_move(ss); }
         return WindowsPath { components: v, ..copy *self }
     }

src/libcore/rand.rs

@@ -327,7 +327,9 @@ impl RngUtil for @Rng {
      */
     fn gen_char_from(&self, chars: &str) -> char {
         fail_unless!(!chars.is_empty());
-        self.choose(str::chars(chars))
+        let mut cs = ~[];
+        for str::each_char(chars) |c| { cs.push(c) }
+        self.choose(cs)
     }
 
     /// Return a random bool

src/libcore/str.rs

@@ -463,7 +463,7 @@ pub fn each_split_char_nonempty(s: &str, sep: char, it: &fn(&str) -> bool) {
 }
 
 fn each_split_char_inner(s: &str, sep: char, count: uint, allow_empty: bool,
-                         allow_trailing_empty: bool), it: &fn(&str) -> bool) {
+                         allow_trailing_empty: bool, it: &fn(&str) -> bool) {
     if sep < 128u as char {
         let b = sep as u8, l = len(s);
         let mut done = 0u;
@@ -513,8 +513,8 @@ pub fn each_split_nonempty(s: &str, sepfn: &fn(char) -> bool, it: &fn(&str) -> b
     each_split_inner(s, sepfn, len(s), false, false, it)
 }
 
-pure fn each_split_inner(s: &str, sepfn: &fn(cc: char) -> bool, count: uint,
+fn each_split_inner(s: &str, sepfn: &fn(cc: char) -> bool, count: uint,
-               allow_empty: bool, allow_trailing_empty: bool), it: &fn(&str) -> bool) {
+               allow_empty: bool, allow_trailing_empty: bool, it: &fn(&str) -> bool) {
     let l = len(s);
     let mut i = 0u, start = 0u, done = 0u;
     while i < l && done < count {
@@ -534,7 +534,7 @@ pure fn each_split_inner(s: &str, sepfn: &fn(cc: char) -> bool, count: uint,
 }
 
 // See Issue #1932 for why this is a naive search
-fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
+fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint) -> bool) {
     let sep_len = len(sep), l = len(s);
     fail_unless!(sep_len > 0u);
     let mut i = 0u, match_start = 0u, match_i = 0u;
@@ -545,7 +545,7 @@ fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
             match_i += 1u;
             // Found a match
             if match_i == sep_len {
-                f(match_start, i + 1u);
+                if !f(match_start, i + 1u) { return; }
                 match_i = 0u;
             }
             i += 1u;
@@ -561,10 +561,10 @@ fn iter_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
     }
 }
 
-fn iter_between_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
+fn iter_between_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint) -> bool) {
     let mut last_end = 0u;
-    do iter_matches(s, sep) |from, to| {
+    for iter_matches(s, sep) |from, to| {
-        f(last_end, from);
+        if !f(last_end, from) { return; }
         last_end = to;
     }
     f(last_end, len(s));
@@ -580,13 +580,13 @@ fn iter_between_matches(s: &'a str, sep: &'b str, f: &fn(uint, uint)) {
  * ~~~
  */
 pub fn each_split_str(s: &'a str, sep: &'b str, it: &fn(&str) -> bool) {
-    do iter_between_matches(s, sep) |from, to| {
+    for iter_between_matches(s, sep) |from, to| {
         if !it( unsafe { raw::slice_bytes(s, from, to) } ) { return; }
     }
 }
 
 pub fn each_split_str_nonempty(s: &'a str, sep: &'b str, it: &fn(&str) -> bool) {
-    do iter_between_matches(s, sep) |from, to| {
+    for iter_between_matches(s, sep) |from, to| {
         if to > from {
             if !it( unsafe { raw::slice_bytes(s, from, to) } ) { return; }
         }
@@ -630,7 +630,7 @@ pub fn levdistance(s: &str, t: &str) -> uint {
 /**
  * Splits a string into a vector of the substrings separated by LF ('\n').
  */
-pub fn each_line(s: &str, it: &fn(&str) -> bool) { each_split_char(s, '\n', it) }
+pub fn each_line(s: &str, it: &fn(&str) -> bool) { each_split_char_no_trailing(s, '\n', it) }
 
 /**
  * Splits a string into a vector of the substrings separated by LF ('\n')
@@ -656,52 +656,56 @@ pub fn each_word(s: &str, it: &fn(&str) -> bool) {
  *  each of which is less bytes long than a limit
  */
 pub fn each_split_within(ss: &str, lim: uint, it: &fn(&str) -> bool) {
-    let words = str::words(ss);
+    // Just for fun, let's write this as an automaton
-
+    enum SplitWithinState {
-    // empty?
+        A, // Leading whitespace, initial state
-    if words == ~[] { return ~[]; }
+        B, // Words
-
+        C, // Internal and trailing whitespace
-    let mut rows : ~[~str] = ~[];
-    let mut row  : ~str    = ~"";
-
-    for words.each |wptr| {
-        let word = copy *wptr;
-
-        // if adding this word to the row would go over the limit,
-        // then start a new row
-        if row.len() + word.len() + 1 > lim {
-            rows.push(copy row); // save previous row
-            row = word;    // start a new one
-        } else {
-            if row.len() > 0 { row += ~" " } // separate words
-            row += word;  // append to this row
-        }
     }
+    enum Whitespace { Ws, Cr }
+    enum LengthLimit { UnderLim, OverLim }
 
-    // save the last row
+    let mut slice_start = 0;
-    if row != ~"" { rows.push(row); }
+    let mut last_start = 0;
+    let mut last_end = 0;
+    let mut state = A;
 
-    rows
+    let mut cont = true;
-    // NOTE: Finish change here
+    let slice = || { cont = it(ss.slice(slice_start, last_end)) };
 
-    let mut last_slice_i = 0, last_word_i = 0, word_start = true;
+    let machine = |i: uint, c: char| {
-    for each_chari(s) |i, c| {
+        let whitespace = if char::is_whitespace(c)       { Ws }       else { Cr };
-        if (i - last_slice_i) <= lim {
+        let limit      = if (i - slice_start + 1) <= lim { UnderLim } else { OverLim };
-            if char::is_whitespace(c) {
 
-            } else {
+        state = match (state, whitespace, limit) {
+            (A, Ws, _)        => { A }
+            (A, Cr, _)        => { slice_start = i; last_start = i; B }
 
-            }
+            (B, Cr, UnderLim) => { B }
-        } else {
+            (B, Cr, OverLim)  if (i - last_start + 1) > lim
+                              => { fail!(~"word longer than limit!") }
+            (B, Cr, OverLim)  => { slice(); slice_start = last_start; B }
+            (B, Ws, UnderLim) => { last_end = i; C }
+            (B, Ws, OverLim)  => { last_end = i; slice(); A }
 
-        }
+            (C, Cr, UnderLim) => { last_start = i; B }
+            (C, Cr, OverLim)  => { slice(); slice_start = i; last_start = i; last_end = i; B }
+            (C, Ws, OverLim)  => { slice(); A }
+            (C, Ws, UnderLim) => { C }
+        };
+        cont
+    };
 
+    str::each_chari(ss, machine);
 
+    // Let the automaton 'run out'
+    let mut fake_i = ss.len();
+    while cont && match state { B | C => true, A => false } {
+        machine(fake_i, ' ');
+        fake_i += 1;
     }
 }
 
-
-
 /// Convert a string to lowercase. ASCII only
 pub fn to_lower(s: &str) -> ~str {
     map(s,
@@ -731,7 +735,7 @@ pub fn to_upper(s: &str) -> ~str {
  */
 pub fn replace(s: &str, from: &str, to: &str) -> ~str {
     let mut result = ~"", first = true;
-    do iter_between_matches(s, from) |start, end| {
+    for iter_between_matches(s, from) |start, end| {
         if first {
             first = false;
         } else {
@@ -2286,9 +2290,9 @@ pub trait StrSlice {
     fn len(&self) -> uint;
     fn char_len(&self) -> uint;
     fn slice(&self, begin: uint, end: uint) -> &'self str;
-    fn split(&self, sepfn: &fn(char) -> bool) -> ~[~str];
+    fn each_split(&self, sepfn: &fn(char) -> bool, it: &fn(&str) -> bool);
-    fn split_char(&self, sep: char) -> ~[~str];
+    fn each_split_char(&self, sep: char, it: &fn(&str) -> bool);
-    fn split_str(&self, sep: &'a str) -> ~[~str];
+    fn each_split_str(&self, sep: &'a str, it: &fn(&str) -> bool);
     fn starts_with(&self, needle: &'a str) -> bool;
     fn substr(&self, begin: uint, n: uint) -> &'self str;
     fn to_lower(&self) -> ~str;
@@ -2408,20 +2412,24 @@ impl StrSlice for &'self str {
     }
     /// Splits a string into substrings using a character function
     #[inline]
-    fn split(&self, sepfn: &fn(char) -> bool) -> ~[~str] {
+    fn each_split(&self, sepfn: &fn(char) -> bool, it: &fn(&str) -> bool) {
-        split(*self, sepfn)
+        each_split(*self, sepfn, it)
     }
     /**
      * Splits a string into substrings at each occurrence of a given character
      */
     #[inline]
-    fn split_char(&self, sep: char) -> ~[~str] { split_char(*self, sep) }
+    fn each_split_char(&self, sep: char, it: &fn(&str) -> bool) {
+        each_split_char(*self, sep, it)
+    }
     /**
      * Splits a string into a vector of the substrings separated by a given
      * string
      */
     #[inline]
-    fn split_str(&self, sep: &'a str) -> ~[~str] { split_str(*self, sep) }
+    fn each_split_str(&self, sep: &'a str, it: &fn(&str) -> bool)  {
+        each_split_str(*self, sep, it)
+    }
     /// Returns true if one string starts with another
     #[inline]
     fn starts_with(&self, needle: &'a str) -> bool {

src/librustc/metadata/cstore.rs

@@ -120,7 +120,9 @@ pub fn get_used_libraries(cstore: @mut CStore) -> ~[~str] {
 }
 
 pub fn add_used_link_args(cstore: @mut CStore, args: &str) {
-    cstore.used_link_args.push_all(args.split_char(' '));
+    for args.each_split_char(' ') |s| {
+        cstore.used_link_args.push(s.to_owned());
+    }
 }
 
 pub fn get_used_link_args(cstore: @mut CStore) -> ~[~str] {

src/librustc/middle/resolve.rs

@@ -76,7 +76,7 @@ use syntax::visit::{visit_mod, visit_ty, vt};
 use syntax::opt_vec::OptVec;
 
 use core::option::{Some, get, is_some, is_none};
-use core::str::{connect, split_str};
+use core::str::{connect, each_split_str};
 use core::hashmap::linear::LinearMap;
 use std::oldmap::HashMap;
 
@@ -1696,7 +1696,8 @@ pub impl Resolver {
                         entry: %s (%?)",
                     path_string, def_like);
 
-            let mut pieces = split_str(path_string, ~"::");
+            let mut pieces = ~[];
+            for each_split_str(path_string, "::") |s| { pieces.push(s.to_owned()) }
             let final_ident_str = pieces.pop();
             let final_ident = self.session.ident_of(final_ident_str);
 

src/libstd/base64.rs

@@ -16,12 +16,16 @@ pub trait ToBase64 {
     fn to_base64(&self) -> ~str;
 }
 
+static CHARS: &'static[char] = &[
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
+];
+
 impl ToBase64 for &'self [u8] {
     fn to_base64(&self) -> ~str {
-        let chars = str::chars(
-          ~"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-        );
-
         let mut s = ~"";
         unsafe {
             let len = self.len();
@@ -35,10 +39,10 @@ impl ToBase64 for &'self [u8] {
                         (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 >> 18u) & 63u]);
-                str::push_char(&mut s, chars[(n >> 12u) & 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 >> 6u) & 63u]);
-                str::push_char(&mut s, chars[n & 63u]);
+                str::push_char(&mut s, CHARS[n & 63u]);
 
                 i += 3u;
             }
@@ -49,17 +53,17 @@ impl ToBase64 for &'self [u8] {
               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 >> 18u) & 63u]);
-                str::push_char(&mut s, chars[(n >> 12u) & 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 >> 18u) & 63u]);
-                str::push_char(&mut s, chars[(n >> 12u) & 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 >> 6u) & 63u]);
                 str::push_char(&mut s, '=');
               }
               _ => fail!(~"Algebra is broken, please alert the math police")

src/libstd/getopts.rs

@@ -244,7 +244,8 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
                 let mut i_arg = None;
                 if cur[1] == '-' as u8 {
                     let tail = str::slice(cur, 2, curlen).to_owned();
-                    let tail_eq = str::splitn_char(tail, '=', 1);
+                    let mut tail_eq = ~[];
+                    for str::each_splitn_char(tail, '=', 1) |s| { tail_eq.push(s.to_owned()) }
                     if tail_eq.len() <= 1 {
                         names = ~[Long(tail)];
                     } else {
@@ -627,16 +628,16 @@ pub mod groups {
             };
 
             // Normalize desc to contain words seperated by one space character
-            let mut desc_normalized_whitespace = ~str
+            let mut desc_normalized_whitespace = ~"";
-            for desc.each_word |word| {
+            for str::each_word(desc) |word| {
                 desc_normalized_whitespace.push_str(word);
                 desc_normalized_whitespace.push_char(' ');
             }
 
             // FIXME: #5516
-            let mut desc_rows: ~[~str] = ~[];
+            let mut desc_rows = ~[];
-            for desc_normalized_whitespace.each_split_within(54) |substr| {
+            for str::each_split_within(desc_normalized_whitespace, 54) |substr| {
-                desc_rows.push(~substr);
+                desc_rows.push(substr.to_owned());
             }
 
             // FIXME: #5516

src/libstd/json.rs

@@ -806,7 +806,8 @@ impl serialize::Decoder for Decoder<'self> {
     }
 
     fn read_char(&self) -> char {
-        let v = str::chars(self.read_owned_str());
+        let mut v = ~[];
+        for str::each_char(self.read_owned_str()) |c| { v.push(c) }
         if v.len() != 1 { fail!(~"string must have one character") }
         v[0]
     }

src/libstd/net_ip.rs

@@ -197,7 +197,9 @@ pub mod v4 {
         }
     }
     pub fn parse_to_ipv4_rep(ip: &str) -> result::Result<Ipv4Rep, ~str> {
-        let parts = vec::map(str::split_char(ip, '.'), |s| {
+        let mut parts = ~[];
+        for str::each_split_char(ip, '.') |s| { parts.push(s.to_owned()) }
+        let parts = vec::map(parts, |s| {
             match uint::from_str(*s) {
               Some(n) if n <= 255 => n,
               _ => 256

src/libstd/net_url.rs

@@ -344,8 +344,8 @@ fn userinfo_to_str(userinfo: &UserInfo) -> ~str {
 fn query_from_str(rawquery: &str) -> Query {
     let mut query: Query = ~[];
     if str::len(rawquery) != 0 {
-        for str::split_char(rawquery, '&').each |p| {
+        for str::each_split_char(rawquery, '&') |p| {
-            let (k, v) = split_char_first(*p, '=');
+            let (k, v) = split_char_first(p, '=');
             // FIXME(#3722): unsafe only because decode_inner does (string) IO
             unsafe {query.push((decode_component(k), decode_component(v)));}
         };

src/libsyntax/parse/comments.rs

@@ -99,7 +99,8 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
         }
 
         return do lines.map |line| {
-            let chars = str::chars(*line);
+            let mut chars = ~[];
+            for str::each_char(*line) |c| { chars.push(c) }
             if i > chars.len() {
                 ~""
             } else {
@@ -116,7 +117,10 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
     }
 
     if comment.starts_with(~"/*") {
-        let lines = str::lines_any(comment.slice(3u, comment.len() - 2u).to_owned());
+        let mut lines = ~[];
+        for str::each_line_any(comment.slice(3u, comment.len() - 2u)) |line| {
+            lines.push(line.to_owned())
+        }
         let lines = vertical_trim(lines);
         let lines = block_trim(lines, ~"\t ", None);
         let lines = block_trim(lines, ~"*", Some(1u));