---

yaml
---
r: 150734
b: refs/heads/try2
c: 65abf96
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: ee4c770f8ba364857b97a8c51c3eda14120b9ac5
+refs/heads/try2: 65abf96fb6630d7ddbcdc3b39f599c02ecfc2f1e
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/docs.mk

@@ -269,6 +269,7 @@ LIB_DOC_DEP_$(1) = $$(CRATEFILE_$(1)) $$(RSINPUTS_$(1))
 endif
 
 $(2) += doc/$(1)/index.html
+doc/$(1)/index.html: CFG_COMPILER_HOST_TRIPLE = $(CFG_TARGET)
 doc/$(1)/index.html: $$(LIB_DOC_DEP_$(1))
 	@$$(call E, rustdoc $$@)
 	$$(Q)$$(RUSTDOC) --cfg dox --cfg stage2 $$<

branches/try2/mk/main.mk

@@ -358,17 +358,13 @@ CFGFLAG$(1)_T_$(2)_H_$(3) = stage1
 endif
 endif
 
-ifdef CFG_DISABLE_RPATH
 ifeq ($$(OSTYPE_$(3)),apple-darwin)
   RPATH_VAR$(1)_T_$(2)_H_$(3) := \
       DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
 else
   RPATH_VAR$(1)_T_$(2)_H_$(3) := \
       LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
 endif
-else
-    RPATH_VAR$(1)_T_$(2)_H_$(3) :=
-endif
 
 STAGE$(1)_T_$(2)_H_$(3) := 						\
 	$$(Q)$$(RPATH_VAR$(1)_T_$(2)_H_$(3))                            \

branches/try2/src/compiletest/runtest.rs

@@ -31,6 +31,7 @@ use std::io::timer;
 use std::io;
 use std::os;
 use std::str;
+use std::strbuf::StrBuf;
 use std::task;
 use std::slice;
 use test::MetricMap;
@@ -328,10 +329,10 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
             }
 
             let args = split_maybe_args(&config.target_rustcflags);
-            let mut tool_path:~str = ~"";
+            let mut tool_path = StrBuf::new();
             for arg in args.iter() {
                 if arg.contains("android-cross-path=") {
-                    tool_path = arg.replace("android-cross-path=","");
+                    tool_path = StrBuf::from_str(arg.replace("android-cross-path=", ""));
                     break;
                 }
             }
@@ -348,7 +349,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
             let gdb_path = tool_path.append("/bin/arm-linux-androideabi-gdb");
             let procsrv::Result{ out, err, status }=
                 procsrv::run("",
-                             gdb_path,
+                             gdb_path.as_slice(),
                              debugger_opts.as_slice(),
                              vec!((~"",~"")),
                              None)
@@ -451,7 +452,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
         let options_to_remove = [~"-O", ~"-g", ~"--debuginfo"];
         let new_options = split_maybe_args(options).move_iter()
                                                    .filter(|x| !options_to_remove.contains(x))
-                                                   .collect::<~[~str]>()
+                                                   .collect::<Vec<~str>>()
                                                    .connect(" ");
         Some(new_options)
     }

branches/try2/src/doc/guide-ffi.md

@@ -496,3 +496,16 @@ NUL-terminated string for interoperability with C, you should use the `c_str::to
 
 The standard library includes type aliases and function definitions for the C standard library in
 the `libc` module, and Rust links against `libc` and `libm` by default.
+
+# The "nullable pointer optimization"
+
+Certain types are defined to not be `null`. This includes references (`&T`,
+`&mut T`), owning pointers (`~T`), and function pointers (`extern "abi"
+fn()`). When interfacing with C, pointers that might be null are often used.
+As a special case, a generic `enum` that contains exactly two variants, one of
+which contains no data and the other containing a single field, is eligible
+for the "nullable pointer optimization". When such an enum is instantiated
+with one of the non-nullable types, it is represented as a single pointer,
+and the non-data variant is represented as the null pointer. So
+`Option<extern "C" fn(c_int) -> c_int>` is how one represents a nullable
+function pointer using the C ABI.

branches/try2/src/doc/tutorial.md

@@ -1579,6 +1579,8 @@ allocated memory on the heap. A unique vector owns the elements it contains, so
 the elements are mutable if the vector is mutable.
 
 ~~~
+use std::strbuf::StrBuf;
+
 // A dynamically sized vector (unique vector)
 let mut numbers = ~[1, 2, 3];
 numbers.push(4);
@@ -1589,7 +1591,7 @@ let more_numbers: ~[int] = numbers;
 
 // The original `numbers` value can no longer be used, due to move semantics.
 
-let mut string = ~"fo";
+let mut string = StrBuf::from_str("fo");
 string.push_char('o');
 ~~~
 

branches/try2/src/libcollections/bitv.rs

@@ -15,8 +15,9 @@ use std::cmp;
 use std::iter::RandomAccessIterator;
 use std::iter::{Rev, Enumerate, Repeat, Map, Zip};
 use std::ops;
-use std::uint;
 use std::slice;
+use std::strbuf::StrBuf;
+use std::uint;
 
 #[deriving(Clone)]
 struct SmallBitv {
@@ -111,7 +112,7 @@ impl SmallBitv {
 
 #[deriving(Clone)]
 struct BigBitv {
-    storage: ~[uint]
+    storage: Vec<uint>
 }
 
 /**
@@ -131,7 +132,7 @@ fn big_mask(nbits: uint, elem: uint) -> uint {
 }
 
 impl BigBitv {
-    pub fn new(storage: ~[uint]) -> BigBitv {
+    pub fn new(storage: Vec<uint>) -> BigBitv {
         BigBitv {storage: storage}
     }
 
@@ -193,7 +194,7 @@ impl BigBitv {
     pub fn get(&self, i: uint) -> bool {
         let w = i / uint::BITS;
         let b = i % uint::BITS;
-        let x = 1 & self.storage[w] >> b;
+        let x = 1 & self.storage.get(w) >> b;
         x == 1
     }
 
@@ -202,15 +203,15 @@ impl BigBitv {
         let w = i / uint::BITS;
         let b = i % uint::BITS;
         let flag = 1 << b;
-        self.storage[w] = if x { self.storage[w] | flag }
-                          else { self.storage[w] & !flag };
+        *self.storage.get_mut(w) = if x { *self.storage.get(w) | flag }
+                          else { *self.storage.get(w) & !flag };
     }
 
     #[inline]
     pub fn equals(&self, b: &BigBitv, nbits: uint) -> bool {
         for (i, elt) in b.storage.iter().enumerate() {
             let mask = big_mask(nbits, i);
-            if mask & self.storage[i] != mask & *elt {
+            if mask & *self.storage.get(i) != mask & *elt {
                 return false;
             }
         }
@@ -278,13 +279,13 @@ impl Bitv {
             let s =
                 if init {
                     if exact {
-                        slice::from_elem(nelems, !0u)
+                        Vec::from_elem(nelems, !0u)
                     } else {
-                        let mut v = slice::from_elem(nelems-1, !0u);
+                        let mut v = Vec::from_elem(nelems-1, !0u);
                         v.push((1<<nbits % uint::BITS)-1);
                         v
                     }
-                } else { slice::from_elem(nelems, 0u)};
+                } else { Vec::from_elem(nelems, 0u)};
             Big(BigBitv::new(s))
         };
         Bitv {rep: rep, nbits: nbits}
@@ -451,8 +452,8 @@ impl Bitv {
      *
      * Each `uint` in the resulting vector has either value `0u` or `1u`.
      */
-    pub fn to_vec(&self) -> ~[uint] {
-        slice::from_fn(self.nbits, |x| self.init_to_vec(x))
+    pub fn to_vec(&self) -> Vec<uint> {
+        Vec::from_fn(self.nbits, |x| self.init_to_vec(x))
     }
 
     /**
@@ -461,7 +462,7 @@ impl Bitv {
      * size of the `Bitv` is not a multiple of 8 then trailing bits
      * will be filled-in with false/0
      */
-    pub fn to_bytes(&self) -> ~[u8] {
+    pub fn to_bytes(&self) -> Vec<u8> {
         fn bit (bitv: &Bitv, byte: uint, bit: uint) -> u8 {
             let offset = byte * 8 + bit;
             if offset >= bitv.nbits {
@@ -473,7 +474,7 @@ impl Bitv {
 
         let len = self.nbits/8 +
                   if self.nbits % 8 == 0 { 0 } else { 1 };
-        slice::from_fn(len, |i|
+        Vec::from_fn(len, |i|
             bit(self, i, 0) |
             bit(self, i, 1) |
             bit(self, i, 2) |
@@ -486,10 +487,10 @@ impl Bitv {
     }
 
     /**
-     * Transform `self` into a `[bool]` by turning each bit into a `bool`.
+     * Transform `self` into a `Vec<bool>` by turning each bit into a `bool`.
      */
-    pub fn to_bools(&self) -> ~[bool] {
-        slice::from_fn(self.nbits, |i| self[i])
+    pub fn to_bools(&self) -> Vec<bool> {
+        Vec::from_fn(self.nbits, |i| self[i])
     }
 
     /**
@@ -499,15 +500,15 @@ impl Bitv {
      * character is either '0' or '1'.
      */
      pub fn to_str(&self) -> ~str {
-        let mut rs = ~"";
+        let mut rs = StrBuf::new();
         for i in self.iter() {
             if i {
                 rs.push_char('1');
             } else {
                 rs.push_char('0');
             }
         };
-        rs
+        rs.into_owned()
      }
 
 
@@ -659,7 +660,7 @@ pub struct BitvSet {
 impl BitvSet {
     /// Creates a new bit vector set with initially no contents
     pub fn new() -> BitvSet {
-        BitvSet{ size: 0, bitv: BigBitv::new(~[0]) }
+        BitvSet{ size: 0, bitv: BigBitv::new(vec!(0)) }
     }
 
     /// Creates a new bit vector set from the given bit vector
@@ -673,7 +674,7 @@ impl BitvSet {
         match rep {
             Big(b) => BitvSet{ size: size, bitv: b },
             Small(SmallBitv{bits}) =>
-                BitvSet{ size: size, bitv: BigBitv{ storage: ~[bits] } },
+                BitvSet{ size: size, bitv: BigBitv{ storage: vec!(bits) } },
         }
     }
 
@@ -705,9 +706,9 @@ impl BitvSet {
             self.bitv.storage.grow(other.capacity() / uint::BITS, &0);
         }
         for (i, &w) in other.bitv.storage.iter().enumerate() {
-            let old = self.bitv.storage[i];
+            let old = *self.bitv.storage.get(i);
             let new = f(old, w);
-            self.bitv.storage[i] = new;
+            *self.bitv.storage.get_mut(i) = new;
             self.size += nbits(new) - nbits(old);
         }
     }
@@ -863,7 +864,7 @@ impl MutableSet<uint> for BitvSet {
 
         // Attempt to truncate our storage
         let mut i = self.bitv.storage.len();
-        while i > 1 && self.bitv.storage[i - 1] == 0 {
+        while i > 1 && *self.bitv.storage.get(i - 1) == 0 {
             i -= 1;
         }
         self.bitv.storage.truncate(i);
@@ -878,12 +879,12 @@ impl BitvSet {
     /// w1, w2) where the bit location is the number of bits offset so far,
     /// and w1/w2 are the words coming from the two vectors self, other.
     fn commons<'a>(&'a self, other: &'a BitvSet)
-        -> Map<'static, ((uint, &'a uint), &'a ~[uint]), (uint, uint, uint),
-               Zip<Enumerate<slice::Items<'a, uint>>, Repeat<&'a ~[uint]>>> {
+        -> Map<'static, ((uint, &'a uint), &'a Vec<uint>), (uint, uint, uint),
+               Zip<Enumerate<slice::Items<'a, uint>>, Repeat<&'a Vec<uint>>>> {
         let min = cmp::min(self.bitv.storage.len(), other.bitv.storage.len());
         self.bitv.storage.slice(0, min).iter().enumerate()
             .zip(Repeat::new(&other.bitv.storage))
-            .map(|((i, &w), o_store)| (i * uint::BITS, w, o_store[i]))
+            .map(|((i, &w), o_store)| (i * uint::BITS, w, *o_store.get(i)))
     }
 
     /// Visits each word in `self` or `other` that extends beyond the other. This
@@ -946,7 +947,6 @@ mod tests {
     use bitv;
 
     use std::uint;
-    use std::slice;
     use rand;
     use rand::Rng;
 
@@ -964,8 +964,8 @@ mod tests {
     #[test]
     fn test_0_elements() {
         let act = Bitv::new(0u, false);
-        let exp = slice::from_elem::<bool>(0u, false);
-        assert!(act.eq_vec(exp));
+        let exp = Vec::from_elem(0u, false);
+        assert!(act.eq_vec(exp.as_slice()));
     }
 
     #[test]
@@ -1299,12 +1299,12 @@ mod tests {
     fn test_to_bytes() {
         let mut bv = Bitv::new(3, true);
         bv.set(1, false);
-        assert_eq!(bv.to_bytes(), ~[0b10100000]);
+        assert_eq!(bv.to_bytes(), vec!(0b10100000));
 
         let mut bv = Bitv::new(9, false);
         bv.set(2, true);
         bv.set(8, true);
-        assert_eq!(bv.to_bytes(), ~[0b00100000, 0b10000000]);
+        assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000));
     }
 
     #[test]
@@ -1315,7 +1315,7 @@ mod tests {
 
     #[test]
     fn test_to_bools() {
-        let bools = ~[false, false, true, false, false, true, true, false];
+        let bools = vec!(false, false, true, false, false, true, true, false);
         assert_eq!(from_bytes([0b00100110]).to_bools(), bools);
     }
 
@@ -1334,8 +1334,8 @@ mod tests {
         let bools = [true, false, true, true];
         let bitv = BitvSet::from_bitv(from_bools(bools));
 
-        let idxs: ~[uint] = bitv.iter().collect();
-        assert_eq!(idxs, ~[0, 2, 3]);
+        let idxs: Vec<uint> = bitv.iter().collect();
+        assert_eq!(idxs, vec!(0, 2, 3));
     }
 
     #[test]
@@ -1579,7 +1579,7 @@ mod tests {
     #[bench]
     fn bench_big_bitv_small(b: &mut BenchHarness) {
         let mut r = rng();
-        let mut bitv = BigBitv::new(~[0]);
+        let mut bitv = BigBitv::new(vec!(0));
         b.iter(|| {
             bitv.set((r.next_u32() as uint) % uint::BITS, true);
             &bitv
@@ -1589,7 +1589,7 @@ mod tests {
     #[bench]
     fn bench_big_bitv_big(b: &mut BenchHarness) {
         let mut r = rng();
-        let mut storage = ~[];
+        let mut storage = vec!();
         storage.grow(BENCH_BITS / uint::BITS, &0u);
         let mut bitv = BigBitv::new(storage);
         b.iter(|| {