---

yaml
---
r: 15291
b: refs/heads/try
c: 632a4c9
h: refs/heads/master
i:
  15289: 854db83
  15287: 5262c35
v: v3

Author: jamorton

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: bef72447e75b7e37f43d3a82ce40e419c7f747d2
+refs/heads/try: 632a4c9326561de2bd9d9ded19a82f22678a0cf4
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/AUTHORS.txt

@@ -71,6 +71,7 @@ Stefan Plantikow <[email protected]>
 Taras Shpot <[email protected]>
 Ted Horst <[email protected]>
 Tim Chevalier <[email protected]>
+Tom Lee <[email protected]>
 Tomoki Aonuma <[email protected]>
 Tycho Sci <[email protected]>
 Wade Mealing <[email protected]>

branches/try/doc/tutorial.md

@@ -919,7 +919,7 @@ for the parameter list, as in `{|| ...}`.
 Partial application is done using the `bind` keyword in Rust.
 
 ~~~~
-let daynum = bind vec::position_elem(["mo", "tu", "we", "do",
+let daynum = bind vec::position_elem(["mo", "tu", "we", "th",
                                       "fr", "sa", "su"], _);
 ~~~~
 
@@ -1551,7 +1551,7 @@ programs that just can't be typed.
 
 ~~~~
 let n = option::none;
-# option::may(n, fn&(&&x:int) {})
+# option::with_option_do(n, fn&(&&x:int) {})
 ~~~~
 
 If you never do anything else with `n`, the compiler will not be able

branches/try/mk/rt.mk

@@ -64,7 +64,6 @@ RUNTIME_CS_$(1) := \
               rt/rust_port_selector.cpp \
               rt/circular_buffer.cpp \
               rt/isaac/randport.cpp \
-              rt/rust_srv.cpp \
               rt/rust_kernel.cpp \
               rt/rust_shape.cpp \
               rt/rust_abi.cpp \

branches/try/src/cargo/cargo.rs

@@ -478,14 +478,13 @@ fn install_one_crate(c: cargo, path: str, cf: str) {
             (exec_suffix == "" && !str::starts_with(path::basename(ct),
                                                     "lib")) {
             #debug("  bin: %s", ct);
-            // FIXME: need libstd os::copy or something (Issue #1983)
-            run::run_program("cp", [ct, c.bindir]);
+            copy_warn(ct, c.bindir);
             if c.opts.mode == system_mode {
                 install_one_crate_to_sysroot(ct, "bin");
             }
         } else {
             #debug("  lib: %s", ct);
-            run::run_program("cp", [ct, c.libdir]);
+            copy_warn(ct, c.bindir);
             if c.opts.mode == system_mode {
                 install_one_crate_to_sysroot(ct, libdir());
             }
@@ -499,10 +498,7 @@ fn install_one_crate_to_sysroot(ct: str, target: str) {
             let path = [_path, "..", target];
             check vec::is_not_empty(path);
             let target_dir = path::normalize(path::connect_many(path));
-            let p = run::program_output("cp", [ct, target_dir]);
-            if p.status != 0 {
-                warn(#fmt["Copying %s to %s is failed", ct, target_dir]);
-            }
+            copy_warn(ct, target_dir);
         }
         none { }
     }
@@ -772,7 +768,7 @@ fn sync_one(c: cargo, name: str, src: source) {
             info(#fmt["no signature for source %s", name]);
         }
     }
-    run::run_program("cp", [pkgfile, destpkgfile]);
+    copy_warn(pkgfile, destpkgfile);
 }
 
 fn cmd_sync(c: cargo) {
@@ -812,7 +808,7 @@ fn cmd_init(c: cargo) {
     } else {
         info(#fmt["signature ok for sources.json"]);
     }
-    run::run_program("cp", [srcfile, destsrcfile]);
+    copy_warn(srcfile, destsrcfile);
 
     info(#fmt["Initialized .cargo in %s", c.root]);
 }
@@ -853,6 +849,12 @@ fn cmd_search(c: cargo) {
     info(#fmt["Found %d packages.", n]);
 }
 
+fn copy_warn(src: str, dest: str) {
+  if !os::copy_file(src, dest) {
+      warn(#fmt["Copying %s to %s failed", src, dest]);
+  }
+}
+
 fn cmd_usage() {
     print("Usage: cargo <verb> [options] [args...]" +
           "

branches/try/src/compiletest/header.rs

@@ -40,7 +40,7 @@ fn load_props(testfile: str) -> test_props {
             pp_exact = parse_pp_exact(ln, testfile);
         }
 
-        option::may(parse_aux_build(ln)) {|ab|
+        option::with_option_do(parse_aux_build(ln)) {|ab|
             aux_builds += [ab];
         }
     };

branches/try/src/etc/snapshot.py

@@ -34,7 +34,7 @@ def scrub(b):
               "lib/libcore-*.dylib",
               "lib/libstd-*.dylib",
               "lib/librustc-*.dylib",
-              "lib/librustsyntax-*.so",
+              "lib/librustsyntax-*.dylib",
               "lib/librustrt.dylib",
               "lib/librustllvm.dylib"],
     "winnt": ["bin/rustc.exe",

branches/try/src/libcore/iter.rs

@@ -29,7 +29,7 @@ impl<A> of iterable<A> for [A] {
 
 impl<A> of iterable<A> for option<A> {
     fn iter(blk: fn(A)) {
-        option::may(self, blk)
+        option::with_option_do(self, blk)
     }
 }
 

branches/try/src/libcore/libc.rs

@@ -1155,6 +1155,9 @@ mod funcs {
             fn CreateDirectoryW(lpPathName: LPCWSTR,
                                 lpSecurityAttributes:
                                 LPSECURITY_ATTRIBUTES) -> BOOL;
+            fn CopyFileW(lpExistingFileName: LPCWSTR,
+                         lpNewFileName: LPCWSTR,
+                         bFailIfExists: BOOL) -> BOOL;
             fn DeleteFileW(lpPathName: LPCWSTR) -> BOOL;
             fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;
             fn SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL;

branches/try/src/libcore/option.rs

@@ -52,19 +52,19 @@ pure fn is_some<T>(opt: option<T>) -> bool {
     !is_none(opt)
 }
 
-pure fn from_maybe<T: copy>(opt: option<T>, def: T) -> T {
+pure fn get_or_default<T: copy>(opt: option<T>, def: T) -> T {
     #[doc = "Returns the contained value or a default"];
 
     alt opt { some(x) { x } none { def } }
 }
 
-fn maybe<T, U: copy>(opt: option<T>, def: U, f: fn(T) -> U) -> U {
+fn with_option<T, U: copy>(opt: option<T>, def: U, f: fn(T) -> U) -> U {
     #[doc = "Applies a function to the contained value or returns a default"];
 
     alt opt { none { def } some(t) { f(t) } }
 }
 
-fn may<T>(opt: option<T>, f: fn(T)) {
+fn with_option_do<T>(opt: option<T>, f: fn(T)) {
     #[doc = "Performs an operation on the contained value or does nothing"];
 
     alt opt { none { } some(t) { f(t); } }
@@ -94,11 +94,12 @@ impl extensions<T:copy> for option<T> {
     "]
     fn chain<U>(f: fn(T) -> option<U>) -> option<U> { chain(self, f) }
     #[doc = "Returns the contained value or a default"]
-    fn from_maybe(def: T) -> T { from_maybe(self, def) }
+    fn get_or_default(def: T) -> T { get_or_default(self, def) }
     #[doc = "Applies a function to the contained value or returns a default"]
-    fn maybe<U: copy>(def: U, f: fn(T) -> U) -> U { maybe(self, def, f) }
+    fn with_option<U: copy>(def: U, f: fn(T) -> U) -> U
+        { with_option(self, def, f) }
     #[doc = "Performs an operation on the contained value or does nothing"]
-    fn may(f: fn(T)) { may(self, f) }
+    fn with_option_do(f: fn(T)) { with_option_do(self, f) }
     #[doc = "
     Gets the value out of an option
 

branches/try/src/libcore/os.rs

@@ -30,7 +30,8 @@ export env, getenv, setenv, fdopen, pipe;
 export getcwd, dll_filename, self_exe_path;
 export exe_suffix, dll_suffix, sysname;
 export homedir, list_dir, list_dir_path, path_is_dir, path_exists,
-       make_absolute, make_dir, remove_dir, change_dir, remove_file;
+       make_absolute, make_dir, remove_dir, change_dir, remove_file,
+       copy_file;
 
 // FIXME: move these to str perhaps?
 export as_c_charp, fill_charp_buf;
@@ -534,13 +535,76 @@ fn change_dir(p: path) -> bool {
     }
 }
 
+#[doc = "Copies a file from one location to another"]
+fn copy_file(from: path, to: path) -> bool {
+    ret do_copy_file(from, to);
+
+    #[cfg(target_os = "win32")]
+    fn do_copy_file(from: path, to: path) -> bool {
+        // FIXME: remove imports when export globs work properly.
+        import libc::funcs::extra::kernel32::*;
+        import libc::types::os::arch::extra::*;
+        import win32::*;
+        ret as_utf16_p(from) {|fromp|
+            as_utf16_p(to) {|top|
+                CopyFileW(fromp, top, (0 as BOOL)) != (0 as BOOL)
+            }
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    #[cfg(target_os = "macos")]
+    #[cfg(target_os = "freebsd")]
+    fn do_copy_file(from: path, to: path) -> bool unsafe {
+        let istream = as_c_charp(from) {|fromp|
+            as_c_charp("rb") {|modebuf|
+                libc::fopen(fromp, modebuf)
+            }
+        };
+        if istream as uint == 0u {
+            ret false;
+        }
+        let ostream = as_c_charp(to) {|top|
+            as_c_charp("w+b") {|modebuf|
+                libc::fopen(top, modebuf)
+            }
+        };
+        if ostream as uint == 0u {
+            fclose(istream);
+            ret false;
+        }
+        let mut buf : [mut u8] = [mut];
+        let bufsize = 8192u;
+        vec::reserve(buf, bufsize);
+        let mut done = false;
+        let mut ok = true;
+        while !done {
+          vec::as_mut_buf(buf) {|b|
+            let nread = libc::fread(b as *mut c_void, 1u, bufsize, istream);
+              if nread > 0 as size_t {
+                 if libc::fwrite(b as *c_void, 1u, nread, ostream) != nread {
+                    ok = false;
+                    done = true;
+                 }
+              } else {
+                    done = true;
+              }
+           }
+        }
+        fclose(istream);
+        fclose(ostream);
+        ret ok;
+    }
+}
+
 #[doc = "Deletes an existing file"]
 fn remove_file(p: path) -> bool {
     ret unlink(p);
 
     #[cfg(target_os = "win32")]
     fn unlink(p: path) -> bool {
         // FIXME: remove imports when export globs work properly.
+        // (similar to Issue #2006)
         import libc::funcs::extra::kernel32::*;
         import libc::types::os::arch::extra::*;
         import win32::*;
@@ -702,7 +766,7 @@ mod tests {
         setenv("HOME", "");
         assert os::homedir() == none;
 
-        option::may(oldhome, {|s| setenv("HOME", s)});
+        option::with_option_do(oldhome, {|s| setenv("HOME", s)});
     }
 
     #[test]
@@ -732,8 +796,9 @@ mod tests {
         setenv("USERPROFILE", "/home/PaloAlto");
         assert os::homedir() == some("/home/MountainView");
 
-        option::may(oldhome, {|s| setenv("HOME", s)});
-        option::may(olduserprofile, {|s| setenv("USERPROFILE", s)});
+        option::with_option_do(oldhome, {|s| setenv("HOME", s)});
+        option::with_option_do(olduserprofile,
+                               {|s| setenv("USERPROFILE", s)});
     }
 
     // Issue #712
@@ -761,4 +826,42 @@ mod tests {
         assert (!os::path_exists("test/nonexistent-bogus-path"));
     }
 
+    #[test]
+    fn copy_file_does_not_exist() {
+      assert !os::copy_file("test/nonexistent-bogus-path",
+                           "test/other-bogus-path");
+      assert !os::path_exists("test/other-bogus-path");
+    }
+
+    #[test]
+    fn copy_file_ok() {
+      let tempdir = getcwd(); // would like to use $TMPDIR,
+                              // doesn't seem to work on Linux
+      assert (str::len(tempdir) > 0u);
+      let in = tempdir + path::path_sep() + "in.txt";
+      let out = tempdir + path::path_sep() + "out.txt";
+
+      /* Write the temp input file */
+      let ostream = as_c_charp(in) {|fromp|
+            as_c_charp("w+b") {|modebuf|
+                libc::fopen(fromp, modebuf)
+            }
+      };
+      assert (ostream as uint != 0u);
+      let s = "hello";
+      let mut buf = str::bytes(s) + [0 as u8];
+      vec::as_mut_buf(buf) {|b|
+         assert (libc::fwrite(b as *c_void, 1u, str::len(s) + 1u, ostream) ==
+                 buf.len())};
+      assert (libc::fclose(ostream) == (0u as c_int));
+      let rs = os::copy_file(in, out);
+      if (!os::path_exists(in)) {
+        fail (#fmt("%s doesn't exist", in));
+      }
+      assert(rs);
+      let rslt = run::run_program("diff", [in, out]);
+      assert (rslt == 0);
+      assert (remove_file(in));
+      assert (remove_file(out));
+    }
 }

branches/try/src/libcore/result.rs

@@ -20,10 +20,9 @@ If the result is an error
 pure fn get<T: copy, U>(res: result<T, U>) -> T {
     alt res {
       ok(t) { t }
-      err(_) {
-        // FIXME: Serialize the error value
-        // and include it in the fail message (maybe just note it)
-        fail "get called on error result";
+      err(the_err) {
+        // FIXME: have a run-fail test for this
+        unchecked{ fail #fmt("get called on error result: %?", the_err); }
       }
     }
 }