Update most utilities for latest Rust

base64/base64.rs

@@ -82,7 +82,10 @@ fn main() {
 }
 
 fn decode(input: &mut Reader, ignore_garbage: bool) {
-    let mut to_decode = str::from_utf8_owned(input.read_to_end()).unwrap();
+    let mut to_decode = str::from_utf8_owned(match input.read_to_end() {
+        Ok(m) => m,
+        Err(f) => fail!(f.to_str())
+    }).unwrap();
 
     to_decode = str::replace(to_decode, "\n", "");
 
@@ -120,7 +123,10 @@ fn encode(input: &mut Reader, line_wrap: uint) {
             _ => Some(line_wrap)
         }
     };
-    let to_encode = input.read_to_end();
+    let to_encode = match input.read_to_end() {
+        Ok(m) => m,
+        Err(f) => fail!(f.to_str())
+    };
     let mut encoded = to_encode.to_base64(b64_conf);
 
     // To my knowledge, RFC 3548 does not specify which line endings to use. It

env/env.rs

@@ -191,12 +191,12 @@ fn main() {
     match opts.program {
         [ref prog, ..args] => {
             match std::run::process_status(prog.as_slice(), args.as_slice()) {
-                Some(exit) =>
+                Ok(exit) =>
                     std::os::set_exit_status(match exit {
                         std::io::process::ExitStatus(s) => s,
                         _ => 1
                     }),
-                None => std::os::set_exit_status(1)
+                Err(_) => std::os::set_exit_status(1)
             }
         }
 

mkdir/mkdir.rs

@@ -12,7 +12,7 @@
 extern mod extra;
 
 use std::os;
-use std::io::{fs, result, stderr};
+use std::io::{fs, stderr};
 use std::num::strconv;
 use extra::getopts::groups;
 
@@ -149,7 +149,7 @@ fn exec(dirs: ~[~str], mk_parents: bool, mode: u32, verbose: bool) {
  * Wrapper to catch errors, return false if failed
  */
 fn mkdir(path: &Path, mode: u32) -> bool {
-    match result(|| fs::mkdir(path, mode)) {
+    match fs::mkdir(path, mode) {
         Ok(_) => true,
         Err(e) => {
             writeln!(&mut stderr() as &mut Writer,

rm/rm.rs

@@ -12,7 +12,7 @@
 extern mod extra;
 
 use std::os;
-use std::io::{print,stdin,stderr,stdio,fs,BufferedReader,io_error};
+use std::io::{print,stdin,stderr,stdio,fs,BufferedReader};
 use extra::getopts::groups;
 
 #[deriving(Eq)]
@@ -127,7 +127,16 @@ fn remove(files: &[~str], force: bool, interactive: InteractiveMode, one_fs: boo
         if file.exists() {
             if file.is_dir() {
                 if recursive && (*filename != ~"/" || !preserve_root) {
-                    remove(fs::walk_dir(&file).map(|x| x.as_str().unwrap().to_owned()).to_owned_vec(), force, interactive, one_fs, preserve_root, recursive, dir, verbose);
+                    let walk_dir = match fs::walk_dir(&file) {
+                        Ok(m) => m,
+                        Err(f) => {
+                            writeln!(&mut stderr() as &mut Writer,
+                                     "{}", f.to_str());
+                            os::set_exit_status(1);
+                            return;
+                        }
+                    };
+                    remove(walk_dir.map(|x| x.as_str().unwrap().to_owned()).to_owned_vec(), force, interactive, one_fs, preserve_root, recursive, dir, verbose);
                     remove_dir(&file, *filename, interactive, verbose);
                 } else if dir && (*filename != ~"/" || !preserve_root) {
                     remove_dir(&file, *filename, interactive, verbose);
@@ -162,16 +171,14 @@ fn remove_dir(path: &Path, name: &str, interactive: InteractiveMode, verbose: bo
             true
         };
     if response {
-        io_error::cond.trap(|_| {
+        match fs::rmdir(path) {
-            writeln!(&mut stderr() as &mut Writer,
+            Ok(_) => if verbose { println!("Removed '{}'", name); },
-                     "Could not remove directory '{}'", name);
+            Err(f) => {
-            os::set_exit_status(1);
+                writeln!(&mut stderr() as &mut Writer,
-        }).inside(|| {
+                         "{}", f.to_str());
-            fs::rmdir(path);
+                os::set_exit_status(1);
-            if verbose {
-                println!("Removed '{}'", name);
             }
-        });
+        }
     }
 }
 
@@ -183,16 +190,14 @@ fn remove_file(path: &Path, name: &str, interactive: InteractiveMode, verbose: b
             true
         };
     if response {
-        io_error::cond.trap(|_| {
+        match fs::unlink(path) {
-            writeln!(&mut stderr() as &mut Writer,
+            Ok(_) => if verbose { println!("Removed '{}'", name); },
-                     "Could not remove file '{}'", name);
+            Err(f) => {
-            os::set_exit_status(1);
+                writeln!(&mut stderr() as &mut Writer,
-        }).inside(|| {
+                         "{}", f.to_str());
-            fs::unlink(path);
+                os::set_exit_status(1);
-            if verbose {
-                println!("Removed '{}'", name);
             }
-        });
+        }
     }
 }
 
@@ -212,7 +217,7 @@ fn prompt(msg: &str) -> bool {
 fn read_prompt() -> bool {
     stdio::flush();
     match BufferedReader::new(stdin()).read_line() {
-        Some(line) => {
+        Ok(line) => {
             match line.char_at(0) {
                 'y' | 'Y' => true,
                 'n' | 'N' => false,
@@ -222,7 +227,7 @@ fn read_prompt() -> bool {
                 }
             }
         }
-        None => true
+        Err(_) => true
     }
 }
 

rmdir/rmdir.rs

@@ -12,7 +12,7 @@
 extern mod extra;
 
 use std::os;
-use std::io::{print, stderr, io_error, fs};
+use std::io::{print, stderr, fs};
 use extra::getopts::groups;
 
 fn main() {
@@ -77,23 +77,34 @@ fn remove(dirs: &[~str], ignore: bool, parents: bool, verbose: bool) {
 }
 
 fn remove_dir(path: &Path, dir: &~str, ignore: bool, parents: bool, verbose: bool) {
-    if fs::walk_dir(path).next() == None {
+    let mut walk_dir = match fs::walk_dir(path) {
-        io_error::cond.trap(|_| {
+        Ok(m) => m,
+        Err(f) => {
             writeln!(&mut stderr() as &mut Writer,
-                     "Failed to remove directory '{}'", *dir);
+                     "{}", f.to_str());
             os::set_exit_status(1);
-        }).inside(|| {
+            return;
-            fs::rmdir(path);
+        }
-            if verbose {
+    };
-                println!("Removed directory '{}'", *dir);
+    if walk_dir.next() == None {
-            }
+        match fs::rmdir(path) {
-            if parents {
+            Ok(_) => {
-                let dirname = path.dirname_str().unwrap();
+                if verbose {
-                if dirname != "." {
+                    println!("Removed directory '{}'", *dir);
-                    remove_dir(&Path::new(dirname), &dirname.to_owned(), ignore, parents, verbose);
+                }
+                if parents {
+                    let dirname = path.dirname_str().unwrap();
+                    if dirname != "." {
+                        remove_dir(&Path::new(dirname), &dirname.to_owned(), ignore, parents, verbose);
+                    }
                 }
             }
-        });
+            Err(f) => {
+                writeln!(&mut stderr() as &mut Writer,
+                         "{}", f.to_str());
+                os::set_exit_status(1);
+            }
+        }
     } else if !ignore {
         writeln!(&mut stderr() as &mut Writer,
                  "Failed to remove directory '{}' (non-empty)", *dir);

sleep/sleep.rs

@@ -28,7 +28,7 @@ fn main() {
     let matches = match groups::getopts(args.tail(), opts) {
         Ok(m) => m,
         Err(f) => {
-            writeln!(&mut stderr() as &mut Writer, "{}", f.to_err_msg())
+            writeln!(&mut stderr() as &mut Writer, "{}", f.to_err_msg());
             os::set_exit_status(1);
             return
         }