Un-renamed trim and substr functions.

14 files changed, 78 insertions, 78 deletions

diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index 8a5ce1e6848..2eb44ba6815 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -268,7 +268,7 @@ fn run_debuginfo_test(config: config, props: TestProps, testfile: &Path) {
         // output (in order)
         let mut i = 0u;
         for str::lines(ProcRes.stdout).each |line| {
-            if props.check_lines[i].trim_DBGBRWD() == line.trim_DBGBRWD() {
+            if props.check_lines[i].trim() == line.trim() {
                 i += 1u;
             }
             if i == num_check_lines {
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index f133a1fbfa6..980e984f75b 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -313,7 +313,7 @@ pub fn unshift_char(s: &mut ~str, ch: char) {
  * * chars_to_trim - A vector of chars
  *
  */
-pub pure fn trim_left_chars_DBGBRWD(s: &'a str, chars_to_trim: &[char]) -> &'a str {
+pub pure fn trim_left_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str {
     if chars_to_trim.is_empty() { return s; }
 
     match find(s, |c| !chars_to_trim.contains(&c)) {
@@ -331,7 +331,7 @@ pub pure fn trim_left_chars_DBGBRWD(s: &'a str, chars_to_trim: &[char]) -> &'a s
  * * chars_to_trim - A vector of chars
  *
  */
-pub pure fn trim_right_chars_DBGBRWD(s: &'a str, chars_to_trim: &[char]) -> &'a str {
+pub pure fn trim_right_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str {
     if chars_to_trim.is_empty() { return s; }
 
     match rfind(s, |c| !chars_to_trim.contains(&c)) {
@@ -352,12 +352,12 @@ pub pure fn trim_right_chars_DBGBRWD(s: &'a str, chars_to_trim: &[char]) -> &'a
  * * chars_to_trim - A vector of chars
  *
  */
-pub pure fn trim_chars_DBGBRWD(s: &'a str, chars_to_trim: &[char]) -> &'a str {
-    trim_left_chars_DBGBRWD(trim_right_chars_DBGBRWD(s, chars_to_trim), chars_to_trim)
+pub pure fn trim_chars(s: &'a str, chars_to_trim: &[char]) -> &'a str {
+    trim_left_chars(trim_right_chars(s, chars_to_trim), chars_to_trim)
 }
 
 /// Returns a string with leading whitespace removed
-pub pure fn trim_left_DBGBRWD(s: &'a str) -> &'a str {
+pub pure fn trim_left(s: &'a str) -> &'a str {
     match find(s, |c| !char::is_whitespace(c)) {
       None => "",
       Some(first) => unsafe { raw::slice_bytes(s, first, len(s)) }
@@ -365,7 +365,7 @@ pub pure fn trim_left_DBGBRWD(s: &'a str) -> &'a str {
 }
 
 /// Returns a string with trailing whitespace removed
-pub pure fn trim_right_DBGBRWD(s: &'a str) -> &'a str {
+pub pure fn trim_right(s: &'a str) -> &'a str {
     match rfind(s, |c| !char::is_whitespace(c)) {
       None => "",
       Some(last) => {
@@ -376,7 +376,7 @@ pub pure fn trim_right_DBGBRWD(s: &'a str) -> &'a str {
 }
 
 /// Returns a string with leading and trailing whitespace removed
-pub pure fn trim_DBGBRWD(s: &'a str) -> &'a str { trim_left_DBGBRWD(trim_right_DBGBRWD(s)) }
+pub pure fn trim(s: &'a str) -> &'a str { trim_left(trim_right(s)) }
 
 /*
 Section: Transforming strings
@@ -421,7 +421,7 @@ pub pure fn chars(s: &str) -> ~[char] {
  * Returns a string containing `n` characters starting at byte offset
  * `begin`.
  */
-pub pure fn substr_DBGBRWD(s: &'a str, begin: uint, n: uint) -> &'a str {
+pub pure fn substr(s: &'a str, begin: uint, n: uint) -> &'a str {
     slice(s, begin, begin + count_bytes(s, begin, n))
 }
 
@@ -2275,17 +2275,17 @@ pub trait StrSlice {
     pure fn split_char(&self, sep: char) -> ~[~str];
     pure fn split_str(&self, sep: &'a str) -> ~[~str];
     pure fn starts_with(&self, needle: &'a str) -> bool;
-    pure fn substr_DBGBRWD(&self, begin: uint, n: uint) -> &'self str;
+    pure fn substr(&self, begin: uint, n: uint) -> &'self str;
     pure fn to_lower(&self) -> ~str;
     pure fn to_upper(&self) -> ~str;
     pure fn escape_default(&self) -> ~str;
     pure fn escape_unicode(&self) -> ~str;
-    pure fn trim_DBGBRWD(&self) -> &'self str;
-    pure fn trim_left_DBGBRWD(&self) -> &'self str;
-    pure fn trim_right_DBGBRWD(&self) -> &'self str;
-    pure fn trim_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str;
-    pure fn trim_left_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str;
-    pure fn trim_right_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str;
+    pure fn trim(&self) -> &'self str;
+    pure fn trim_left(&self) -> &'self str;
+    pure fn trim_right(&self) -> &'self str;
+    pure fn trim_chars(&self, chars_to_trim: &[char]) -> &'self str;
+    pure fn trim_left_chars(&self, chars_to_trim: &[char]) -> &'self str;
+    pure fn trim_right_chars(&self, chars_to_trim: &[char]) -> &'self str;
     pure fn to_owned(&self) -> ~str;
     pure fn to_managed(&self) -> @str;
     pure fn char_at(&self, i: uint) -> char;
@@ -2419,8 +2419,8 @@ impl StrSlice for &'self str {
      * `begin`.
      */
     #[inline]
-    pure fn substr_DBGBRWD(&self, begin: uint, n: uint) -> &'self str {
-        substr_DBGBRWD(*self, begin, n)
+    pure fn substr(&self, begin: uint, n: uint) -> &'self str {
+        substr(*self, begin, n)
     }
     /// Convert a string to lowercase
     #[inline]
@@ -2437,25 +2437,25 @@ impl StrSlice for &'self str {
 
     /// Returns a string with leading and trailing whitespace removed
     #[inline]
-    pure fn trim_DBGBRWD(&self) -> &'self str { trim_DBGBRWD(*self) }
+    pure fn trim(&self) -> &'self str { trim(*self) }
     /// Returns a string with leading whitespace removed
     #[inline]
-    pure fn trim_left_DBGBRWD(&self) -> &'self str { trim_left_DBGBRWD(*self) }
+    pure fn trim_left(&self) -> &'self str { trim_left(*self) }
     /// Returns a string with trailing whitespace removed
     #[inline]
-    pure fn trim_right_DBGBRWD(&self) -> &'self str { trim_right_DBGBRWD(*self) }
+    pure fn trim_right(&self) -> &'self str { trim_right(*self) }
 
     #[inline]
-    pure fn trim_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str {
-        trim_chars_DBGBRWD(*self, chars_to_trim)
+    pure fn trim_chars(&self, chars_to_trim: &[char]) -> &'self str {
+        trim_chars(*self, chars_to_trim)
     }
     #[inline]
-    pure fn trim_left_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str {
-        trim_left_chars_DBGBRWD(*self, chars_to_trim)
+    pure fn trim_left_chars(&self, chars_to_trim: &[char]) -> &'self str {
+        trim_left_chars(*self, chars_to_trim)
     }
     #[inline]
-    pure fn trim_right_chars_DBGBRWD(&self, chars_to_trim: &[char]) -> &'self str {
-        trim_right_chars_DBGBRWD(*self, chars_to_trim)
+    pure fn trim_right_chars(&self, chars_to_trim: &[char]) -> &'self str {
+        trim_right_chars(*self, chars_to_trim)
     }
 
 
@@ -2817,11 +2817,11 @@ mod tests {
     #[test]
     fn test_substr() {
         fn t(a: &str, b: &str, start: int) {
-            fail_unless!(substr_DBGBRWD(a, start as uint, len(b)) == b);
+            fail_unless!(substr(a, start as uint, len(b)) == b);
         }
         t("hello", "llo", 2);
         t("hello", "el", 1);
-        fail_unless!("ะเทศไท" == substr_DBGBRWD("ประเทศไทย中华Việt Nam", 6u, 6u));
+        fail_unless!("ะเทศไท" == substr("ประเทศไทย中华Việt Nam", 6u, 6u));
     }
 
     #[test]
@@ -3054,62 +3054,62 @@ mod tests {
 
     #[test]
     fn test_trim_left_chars() {
-        fail_unless!(trim_left_chars_DBGBRWD(" *** foo *** ", ~[]) ==
+        fail_unless!(trim_left_chars(" *** foo *** ", ~[]) ==
                      " *** foo *** ");
-        fail_unless!(trim_left_chars_DBGBRWD(" *** foo *** ", ~['*', ' ']) ==
+        fail_unless!(trim_left_chars(" *** foo *** ", ~['*', ' ']) ==
                      "foo *** ");
-        fail_unless!(trim_left_chars_DBGBRWD(" ***  *** ", ~['*', ' ']) == "");
-        fail_unless!(trim_left_chars_DBGBRWD("foo *** ", ~['*', ' ']) ==
+        fail_unless!(trim_left_chars(" ***  *** ", ~['*', ' ']) == "");
+        fail_unless!(trim_left_chars("foo *** ", ~['*', ' ']) ==
                      "foo *** ");
     }
 
     #[test]
     fn test_trim_right_chars() {
-        fail_unless!(trim_right_chars_DBGBRWD(" *** foo *** ", ~[]) ==
+        fail_unless!(trim_right_chars(" *** foo *** ", ~[]) ==
                      " *** foo *** ");
-        fail_unless!(trim_right_chars_DBGBRWD(" *** foo *** ", ~['*', ' ']) ==
+        fail_unless!(trim_right_chars(" *** foo *** ", ~['*', ' ']) ==
                      " *** foo");
-        fail_unless!(trim_right_chars_DBGBRWD(" ***  *** ", ~['*', ' ']) == "");
-        fail_unless!(trim_right_chars_DBGBRWD(" *** foo", ~['*', ' ']) ==
+        fail_unless!(trim_right_chars(" ***  *** ", ~['*', ' ']) == "");
+        fail_unless!(trim_right_chars(" *** foo", ~['*', ' ']) ==
                      " *** foo");
     }
 
     #[test]
     fn test_trim_chars() {
-        fail_unless!(trim_chars_DBGBRWD(" *** foo *** ", ~[]) == " *** foo *** ");
-        fail_unless!(trim_chars_DBGBRWD(" *** foo *** ", ~['*', ' ']) == "foo");
-        fail_unless!(trim_chars_DBGBRWD(" ***  *** ", ~['*', ' ']) == "");
-        fail_unless!(trim_chars_DBGBRWD("foo", ~['*', ' ']) == "foo");
+        fail_unless!(trim_chars(" *** foo *** ", ~[]) == " *** foo *** ");
+        fail_unless!(trim_chars(" *** foo *** ", ~['*', ' ']) == "foo");
+        fail_unless!(trim_chars(" ***  *** ", ~['*', ' ']) == "");
+        fail_unless!(trim_chars("foo", ~['*', ' ']) == "foo");
     }
 
     #[test]
     fn test_trim_left() {
-        fail_unless!((trim_left_DBGBRWD("") == ""));
-        fail_unless!((trim_left_DBGBRWD("a") == "a"));
-        fail_unless!((trim_left_DBGBRWD("    ") == ""));
-        fail_unless!((trim_left_DBGBRWD("     blah") == "blah"));
-        fail_unless!((trim_left_DBGBRWD("   \u3000  wut") == "wut"));
-        fail_unless!((trim_left_DBGBRWD("hey ") == "hey "));
+        fail_unless!((trim_left("") == ""));
+        fail_unless!((trim_left("a") == "a"));
+        fail_unless!((trim_left("    ") == ""));
+        fail_unless!((trim_left("     blah") == "blah"));
+        fail_unless!((trim_left("   \u3000  wut") == "wut"));
+        fail_unless!((trim_left("hey ") == "hey "));
     }
 
     #[test]
     fn test_trim_right() {
-        fail_unless!((trim_right_DBGBRWD("") == ""));
-        fail_unless!((trim_right_DBGBRWD("a") == "a"));
-        fail_unless!((trim_right_DBGBRWD("    ") == ""));
-        fail_unless!((trim_right_DBGBRWD("blah     ") == "blah"));
-        fail_unless!((trim_right_DBGBRWD("wut   \u3000  ") == "wut"));
-        fail_unless!((trim_right_DBGBRWD(" hey") == " hey"));
+        fail_unless!((trim_right("") == ""));
+        fail_unless!((trim_right("a") == "a"));
+        fail_unless!((trim_right("    ") == ""));
+        fail_unless!((trim_right("blah     ") == "blah"));
+        fail_unless!((trim_right("wut   \u3000  ") == "wut"));
+        fail_unless!((trim_right(" hey") == " hey"));
     }
 
     #[test]
     fn test_trim() {
-        fail_unless!((trim_DBGBRWD("") == ""));
-        fail_unless!((trim_DBGBRWD("a") == "a"));
-        fail_unless!((trim_DBGBRWD("    ") == ""));
-        fail_unless!((trim_DBGBRWD("    blah     ") == "blah"));
-        fail_unless!((trim_DBGBRWD("\nwut   \u3000  ") == "wut"));
-        fail_unless!((trim_DBGBRWD(" hey dude ") == "hey dude"));
+        fail_unless!((trim("") == ""));
+        fail_unless!((trim("a") == "a"));
+        fail_unless!((trim("    ") == ""));
+        fail_unless!((trim("    blah     ") == "blah"));
+        fail_unless!((trim("\nwut   \u3000  ") == "wut"));
+        fail_unless!((trim(" hey dude ") == "hey dude"));
     }
 
     #[test]
diff --git a/src/libcore/unstable/extfmt.rs b/src/libcore/unstable/extfmt.rs
index e3227cd265f..a5c22fe0ad3 100644
--- a/src/libcore/unstable/extfmt.rs
+++ b/src/libcore/unstable/extfmt.rs
@@ -325,7 +325,7 @@ pub mod ct {
             'o' as u8 => TyOctal,
             'f' as u8 => TyFloat,
             '?' as u8 => TyPoly,
-            _ => err(~"unknown type in conversion: " + s.substr_DBGBRWD(i, 1))
+            _ => err(~"unknown type in conversion: " + s.substr(i, 1))
         };
 
         Parsed::new(t, i + 1)
@@ -537,7 +537,7 @@ pub mod rt {
         let mut unpadded = match cv.precision {
           CountImplied => s.to_owned(),
           CountIs(max) => if (max as uint) < str::char_len(s) {
-            str::substr_DBGBRWD(s, 0, max as uint).to_owned()
+            str::substr(s, 0, max as uint).to_owned()
           } else {
             s.to_owned()
           }
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index dbf78b70c3b..b983fa316d3 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -543,7 +543,7 @@ pub fn build_session_options(+binary: ~str,
     let lint_dict = lint::get_lint_dict();
     for lint_levels.each |level| {
         let level_name = lint::level_to_str(*level);
-        let level_short = level_name.substr_DBGBRWD(0,1).to_upper();
+        let level_short = level_name.substr(0,1).to_upper();
         let flags = vec::append(getopts::opt_strs(matches, level_short),
                                 getopts::opt_strs(matches, level_name));
         for flags.each |lint_name| {
diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs
index ce3cc30642d..c9ca2cbc1d5 100644
--- a/src/librustc/middle/trans/expr.rs
+++ b/src/librustc/middle/trans/expr.rs
@@ -1851,5 +1851,5 @@ fn trans_assign_op(bcx: block,
 
 // NOTE: Mode neccessary here?
 fn shorten(+x: ~str) -> ~str {
-    if x.len() > 60 { x.substr_DBGBRWD(0, 60).to_owned() } else { x }
+    if x.len() > 60 { x.substr(0, 60).to_owned() } else { x }
 }
diff --git a/src/librustdoc/text_pass.rs b/src/librustdoc/text_pass.rs
index b43c88fe204..65e7228eeae 100644
--- a/src/librustdoc/text_pass.rs
+++ b/src/librustdoc/text_pass.rs
@@ -311,7 +311,7 @@ mod test {
             let doc = (attr_pass::mk_pass().f)(srv.clone(), doc);
             let doc = (desc_to_brief_pass::mk_pass().f)(srv.clone(), doc);
             let doc = (sectionalize_pass::mk_pass().f)(srv.clone(), doc);
-            (mk_pass(~"", |s| str::trim_DBGBRWD(s).to_owned() ).f)(srv.clone(), doc)
+            (mk_pass(~"", |s| str::trim(s).to_owned() ).f)(srv.clone(), doc)
         }
     }
 }
diff --git a/src/librustdoc/trim_pass.rs b/src/librustdoc/trim_pass.rs
index 3ad4c50ce30..0adaed35d08 100644
--- a/src/librustdoc/trim_pass.rs
+++ b/src/librustdoc/trim_pass.rs
@@ -21,7 +21,7 @@ use text_pass;
 use core::str;
 
 pub fn mk_pass() -> Pass {
-    text_pass::mk_pass(~"trim", |s| s.trim_DBGBRWD().to_owned() )
+    text_pass::mk_pass(~"trim", |s| s.trim().to_owned() )
 }
 
 #[test]
diff --git a/src/librustdoc/unindent_pass.rs b/src/librustdoc/unindent_pass.rs
index 17cf9dc2b0c..ecd72950468 100644
--- a/src/librustdoc/unindent_pass.rs
+++ b/src/librustdoc/unindent_pass.rs
@@ -78,7 +78,7 @@ fn unindent(s: &str) -> ~str {
     };
 
     if !lines.is_empty() {
-        let unindented = ~[lines.head().trim_DBGBRWD().to_owned()]
+        let unindented = ~[lines.head().trim().to_owned()]
             + do lines.tail().map |line| {
             if str::is_whitespace(*line) {
                 copy *line
diff --git a/src/librusti/rusti.rc b/src/librusti/rusti.rc
index 31e32cd062a..6a54dc7de10 100644
--- a/src/librusti/rusti.rc
+++ b/src/librusti/rusti.rc
@@ -283,7 +283,7 @@ fn run_cmd(repl: &mut Repl, _in: @io::Reader, _out: @io::Writer,
             for args.each |arg| {
                 let (crate, filename) =
                     if arg.ends_with(".rs") || arg.ends_with(".rc") {
-                    (arg.substr_DBGBRWD(0, arg.len() - 3).to_owned(), *arg)
+                    (arg.substr(0, arg.len() - 3).to_owned(), *arg)
                 } else {
                     (*arg, arg + ~".rs")
                 };
@@ -317,7 +317,7 @@ fn run_cmd(repl: &mut Repl, _in: @io::Reader, _out: @io::Writer,
                 match get_line(~"rusti| ") {
                     None => fail!(~"unterminated multiline command :{ .. :}"),
                     Some(line) => {
-                        if str::trim_DBGBRWD(line) == ~":}" {
+                        if str::trim(line) == ~":}" {
                             end_multiline = true;
                         } else {
                             multiline_cmd += line + ~"\n";
@@ -337,7 +337,7 @@ fn run_cmd(repl: &mut Repl, _in: @io::Reader, _out: @io::Writer,
 fn run_line(repl: &mut Repl, in: @io::Reader, out: @io::Writer, line: ~str)
     -> Option<Repl> {
     if line.starts_with(~":") {
-        let full = line.substr_DBGBRWD(1, line.len() - 1);
+        let full = line.substr(1, line.len() - 1);
         let split = str::words(full);
         let len = split.len();
 
diff --git a/src/libstd/bigint.rs b/src/libstd/bigint.rs
index d7bd5fe6f20..01153a4b78e 100644
--- a/src/libstd/bigint.rs
+++ b/src/libstd/bigint.rs
@@ -462,7 +462,7 @@ pub impl BigUint {
                 let s = uint::to_str_radix(*n as uint, radix);
                 str::from_chars(vec::from_elem(l - s.len(), '0')) + s
             }));
-            str::trim_left_chars_DBGBRWD(s, ['0']).to_owned()
+            str::trim_left_chars(s, ['0']).to_owned()
         }
     }
 
diff --git a/src/libstd/semver.rs b/src/libstd/semver.rs
index a5534e29161..e1e7f8ca924 100644
--- a/src/libstd/semver.rs
+++ b/src/libstd/semver.rs
@@ -223,7 +223,7 @@ pub fn parse(s: &str) -> Option<Version> {
     if ! str::is_ascii(s) {
         return None;
     }
-    let s = s.trim_DBGBRWD();
+    let s = s.trim();
     let mut bad = false;
     do bad_parse::cond.trap(|_| { debug!("bad"); bad = true }).in {
         do io::with_str_reader(s) |rdr| {
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 01a4265ca4d..6ebaa42357e 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -70,10 +70,10 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
     /// remove whitespace-only lines from the start/end of lines
     fn vertical_trim(lines: ~[~str]) -> ~[~str] {
         let mut i = 0u, j = lines.len();
-        while i < j && lines[i].trim_DBGBRWD().is_empty() {
+        while i < j && lines[i].trim().is_empty() {
             i += 1u;
         }
-        while j > i && lines[j - 1u].trim_DBGBRWD().is_empty() {
+        while j > i && lines[j - 1u].trim().is_empty() {
             j -= 1u;
         }
         return lines.slice(i, j).to_owned();
@@ -84,7 +84,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
 
         let mut i = max.get_or_default(uint::max_value);
         for lines.each |line| {
-            if line.trim_DBGBRWD().is_empty() {
+            if line.trim().is_empty() {
                 loop;
             }
             for line.each_chari |j, c| {
@@ -110,8 +110,8 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
 
     if comment.starts_with(~"//") {
         // FIXME #5475:
-        // return comment.slice(3u, comment.len()).trim_DBGBRWD().to_owned();
-        let r = comment.slice(3u, comment.len()); return r.trim_DBGBRWD().to_owned();
+        // return comment.slice(3u, comment.len()).trim().to_owned();
+        let r = comment.slice(3u, comment.len()); return r.trim().to_owned();
 
     }
 
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index 80be23d40f7..6cb4065935c 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -262,7 +262,7 @@ fn consume_whitespace_and_comments(rdr: @mut StringReader)
 }
 
 pub pure fn is_line_non_doc_comment(s: &str) -> bool {
-    s.trim_right_DBGBRWD().all(|ch| ch == '/')
+    s.trim_right().all(|ch| ch == '/')
 }
 
 // PRECONDITION: rdr.curr is not whitespace
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index d78aa51550a..ae92be6a4de 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -68,7 +68,7 @@ pub impl Sudoku {
         let mut g = vec::from_fn(10u, { |_i| ~[0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8] });
         while !reader.eof() {
             let line = reader.read_line();
-            let comps = str::split_char(line.trim_DBGBRWD(), ',');
+            let comps = str::split_char(line.trim(), ',');
             if vec::len(comps) == 3u {
                 let row     = uint::from_str(comps[0]).get() as u8;
                 let col     = uint::from_str(comps[1]).get() as u8;