merge

Author: catamorphism

Makefile.in

@@ -421,9 +421,9 @@ else
 TSREQS :=											\
 	$(foreach target,$(CFG_TARGET_TRIPLES),			\
 		$(SREQ3_T_$(target)_H_$(CFG_HOST_TRIPLE)))
-FUZZ := $(HBIN3_H_$(CFG_HOST_TRIPLE))/fuzzer$(X)
-CARGO := $(HBIN3_H_$(CFG_HOST_TRIPLE))/cargo$(X)
-RUSTDOC := $(HBIN3_H_$(CFG_HOST_TRIPLE))/rustdoc$(X)
+FUZZ := $(HBIN2_H_$(CFG_HOST_TRIPLE))/fuzzer$(X)
+CARGO := $(HBIN2_H_$(CFG_HOST_TRIPLE))/cargo$(X)
+RUSTDOC := $(HBIN2_H_$(CFG_HOST_TRIPLE))/rustdoc$(X)
 
 all: rustc $(GENERATED) docs $(FUZZ) $(CARGO) $(RUSTDOC)
 

src/cargo/cargo.rs

@@ -332,7 +332,7 @@ fn try_parse_sources(filename: str, sources: map::hashmap<str, source>) {
     }
 }
 
-fn load_one_source_package(&src: source, p: map::hashmap<str, json::json>) {
+fn load_one_source_package(&&src: source, p: map::hashmap<str, json::json>) {
     let name = alt p.find("name") {
         some(json::string(_n)) { _n }
         _ {
@@ -404,8 +404,8 @@ fn load_one_source_package(&src: source, p: map::hashmap<str, json::json>) {
     log(debug, "  loaded package: " + src.name + "/" + name);
 }
 
-fn load_source_packages(&c: cargo, &src: source) {
-    log(debug, "loading source: " + src.name);
+fn load_source_packages(&&c: cargo, &&src: source) {
+    log(debug, "Loading source: " + src.name);
     let dir = path::connect(c.sourcedir, src.name);
     let pkgfile = path::connect(dir, "packages.json");
     if !os::path_exists(pkgfile) { ret; }

src/libcore/cmp.rs

@@ -0,0 +1,10 @@
+#[doc="Interfaces used for comparison."]
+
+iface ord {
+    fn lt(&&other: self) -> bool;
+}
+
+iface eq {
+    fn eq(&&other: self) -> bool;
+}
+

src/libcore/core.rc

@@ -44,6 +44,7 @@ export extfmt;
 export tuple;
 export to_str;
 export dvec, dvec_iter;
+export cmp;
 
 // NDM seems to be necessary for resolve to work
 export option_iter;
@@ -152,6 +153,7 @@ mod tuple;
 
 // Ubiquitous-utility-type modules
 
+mod cmp;
 mod either;
 mod iter;
 mod logging;

src/libcore/dvec.rs

@@ -57,6 +57,11 @@ fn dvec<A>() -> dvec<A> {
     {mut data: [mut]}
 }
 
+#[doc = "Creates a new dvec with a single element"]
+fn from_elt<A>(+e: A) -> dvec<A> {
+    {mut data: [mut e]}
+}
+
 #[doc = "Creates a new dvec with the contents of a vector"]
 fn from_vec<A>(+v: [mut A]) -> dvec<A> {
     {mut data: v}
@@ -234,12 +239,19 @@ impl extensions<A:copy> for dvec<A> {
         self.data[idx] = a;
     }
 
-    #[doc = "Overwrites the contents of the element at `idx` with `a`"]
+    #[doc = "Overwrites the contents of the element at `idx` with `a`,
+    growing the vector if necessary.  New elements will be initialized
+    with `initval`"]
     fn grow_set_elt(idx: uint, initval: A, val: A) {
         self.swap { |v|
             let mut v <- v;
             vec::grow_set(v, idx, initval, val);
             v
         }
     }
+
+    #[doc = "Returns the last element, failing if the vector is empty"]
+    fn last() -> A {
+        self.get_elt(self.len() - 1u)
+    }
 }

src/libcore/future.rs

@@ -108,7 +108,7 @@ fn get<A:copy>(future: future<A>) -> A {
 fn with<A,B>(future: future<A>, blk: fn(A) -> B) -> B {
     #[doc = "Work with the value without copying it"];
 
-    let v = alt future.v {
+    let v = alt copy future.v {
       either::left(v) { v }
       either::right(f) {
         let v = @f();

src/libcore/int-template.rs

@@ -1,4 +1,5 @@
 import T = inst::T;
+import cmp::{eq, ord};
 
 export min_value, max_value;
 export min, max;
@@ -10,6 +11,7 @@ export range;
 export compl;
 export abs;
 export parse_buf, from_str, to_str, to_str_bytes, str;
+export ord, eq;
 
 const min_value: T = -1 as T << (inst::bits - 1 as T);
 const max_value: T = min_value - 1 as T;
@@ -108,6 +110,18 @@ fn to_str_bytes<U>(n: T, radix: uint, f: fn([u8]/&) -> U) -> U {
 #[doc = "Convert to a string"]
 fn str(i: T) -> str { ret to_str(i, 10u); }
 
+impl ord of ord for T {
+    fn lt(&&other: T) -> bool {
+        ret self < other;
+    }
+}
+
+impl eq of eq for T {
+    fn eq(&&other: T) -> bool {
+        ret self == other;
+    }
+}
+
 
 // FIXME: Has alignment issues on windows and 32-bit linux
 #[test]

src/libcore/io.rs

@@ -613,7 +613,7 @@ impl of writer for mem_buffer {
         // FIXME #2004--use memcpy here?
         let mut pos = self.pos, vpos = 0u;
         while vpos < vlen && pos < buf_len {
-            self.buf.set_elt(pos, v[vpos]);
+            self.buf.set_elt(pos, copy v[vpos]);
             pos += 1u;
             vpos += 1u;
         }

src/libcore/rand.rs

@@ -218,7 +218,7 @@ impl extensions for rng {
     }
 
     #[doc = "Shuffle a mutable vec in place"]
-    fn shuffle_mut<T>(&values: [mut T]) {
+    fn shuffle_mut<T>(&&values: [mut T]) {
         let mut i = values.len();
         while i >= 2u {
             // invariant: elements with index >= i have been locked in place.