---

yaml
---
r: 114294
b: refs/heads/master
c: 8e9567d
h: refs/heads/master
v: v3

Author: aochagavia

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: ed156772bd95b8d621d50102922e5f5ac886d4a1
+refs/heads/master: 8e9567dad8289dab79c61438da9229409e07b735
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/mk/main.mk

@@ -349,45 +349,18 @@ CFGFLAG$(1)_T_$(2)_H_$(3) = stage$(1)
 endef
 
 # Same macro/variables as above, but defined in a separate loop so it can use
-# all the variables above for all archs. The RPATH_VAR setup sometimes needs to
+# all the varibles above for all archs. The RPATH_VAR setup sometimes needs to
 # reach across triples to get things in order.
-#
-# Defines (with the standard $(1)_T_$(2)_H_$(3) suffix):
-# * `LD_LIBRARY_PATH_ENV_NAME`: the name for the key to use in the OS
-#   environment to access or extend the lookup path for dynamic
-#   libraries.  Note on Windows, that key is `$PATH`, and thus not
-#   only conflates programs with dynamic libraries, but also often
-#   contains spaces which confuse make.
-# * `LD_LIBRARY_PATH_ENV_HOSTDIR`: the entry to add to lookup path for the host
-# * `LD_LIBRARY_PATH_ENV_TARGETDIR`: the entry to add to lookup path for target
-# 
-# Below that, HOST_RPATH_VAR and TARGET_RPATH_VAR are defined in terms of the
-# above settings.
-# 
 define SREQ_CMDS
 
 ifeq ($$(OSTYPE_$(3)),apple-darwin)
-  LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3) := DYLD_LIBRARY_PATH
-else
-ifeq ($$(CFG_WINDOWSY_$(2)),1)
-  LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3) := PATH
+  RPATH_VAR$(1)_T_$(2)_H_$(3) := \
+      DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
 else
-  LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3) := LD_LIBRARY_PATH
-endif
+  RPATH_VAR$(1)_T_$(2)_H_$(3) := \
+      LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
 endif
 
-LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3) := \
-    $$(CURDIR)/$$(HLIB$(1)_H_$(3))
-LD_LIBRARY_PATH_ENV_TARGETDIR$(1)_T_$(2)_H_$(3) := \
-    $$(CURDIR)/$$(TLIB1_T_$(2)_H_$(CFG_BUILD))
-
-HOST_RPATH_VAR$(1)_T_$(2)_H_$(3) := \
-  $$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))=$$$$$$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3)):$$(LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3))
-TARGET_RPATH_VAR$(1)_T_$(2)_H_$(3) := \
-  $$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))=$$$$$$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3)):$$(LD_LIBRARY_PATH_ENV_TARGETDIR$(1)_T_$(2)_H_$(3))
-
-RPATH_VAR$(1)_T_$(2)_H_$(3) := $$(HOST_RPATH_VAR$(1)_T_$(2)_H_$(3))
-
 # Pass --cfg stage0 only for the build->host part of stage0;
 # if you're building a cross config, the host->* parts are
 # effectively stage1, since it uses the just-built stage0.
@@ -403,7 +376,13 @@ ifeq ($(1),0)
 ifneq ($(strip $(CFG_BUILD)),$(strip $(3)))
 CFGFLAG$(1)_T_$(2)_H_$(3) = stage1
 
-RPATH_VAR$(1)_T_$(2)_H_$(3) := $$(TARGET_RPATH_VAR$(1)_T_$(2)_H_$(3))
+ifeq ($$(OSTYPE_$(3)),apple-darwin)
+  RPATH_VAR$(1)_T_$(2)_H_$(3) := \
+      DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(CURDIR)/$$(TLIB1_T_$(2)_H_$(CFG_BUILD))"
+else
+  RPATH_VAR$(1)_T_$(2)_H_$(3) := \
+      LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(CURDIR)/$$(TLIB1_T_$(2)_H_$(CFG_BUILD))"
+endif
 endif
 endif
 

trunk/mk/tests.mk

@@ -793,27 +793,8 @@ else
 CRATEDOCTESTDEP_$(1)_$(2)_$(3)_$(4) = $$(RSINPUTS_$(4))
 endif
 
-# (Issues #13732, #13983, #14000) The doc for the regex crate includes
-# uses of the `regex!` macro from the regex_macros crate.  There is
-# normally a dependence injected that makes the target's regex depend
-# upon the host's regex_macros (see #13845), but that dependency
-# injection is currently skipped for stage1 as a special case.
-#
-# Therefore, as a further special case, this conditional skips
-# attempting to run the doc tests for the regex crate atop stage1,
-# (since there is no regex_macros crate for the stage1 rustc to load).
-#
-# (Another approach for solving this would be to inject the desired
-# dependence for stage1 as well, by setting things up to generate a
-# regex_macros crate that was compatible with the stage1 rustc and
-# thus re-enable our ability to run this test.)
-ifeq (stage$(1)-crate-$(4),stage1-crate-regex)
-check-stage$(1)-T-$(2)-H-$(3)-doc-crate-$(4)-exec:
-	@$$(call E, skipping doc-crate-$(4) as it uses macros and cannot run at stage$(1))
-else
 check-stage$(1)-T-$(2)-H-$(3)-doc-crate-$(4)-exec: \
 	$$(call TEST_OK_FILE,$(1),$(2),$(3),doc-crate-$(4))
-endif
 
 ifeq ($(2),$$(CFG_BUILD))
 $$(call TEST_OK_FILE,$(1),$(2),$(3),doc-crate-$(4)): $$(CRATEDOCTESTDEP_$(1)_$(2)_$(3)_$(4))
@@ -970,10 +951,7 @@ $(3)/test/run-make/%-$(1)-T-$(2)-H-$(3).ok: \
 	    "$$(CC_$(3)) $$(CFG_GCCISH_CFLAGS_$(3))" \
 	    $$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3)) \
 	    "$$(TESTNAME)" \
-	    $$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3)) \
-	    "$$(LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3))" \
-	    "$$(LD_LIBRARY_PATH_ENV_TARGETDIR$(1)_T_$(2)_H_$(3))" \
-	    $(1)
+	    "$$(RPATH_VAR$(1)_T_$(2)_H_$(3))"
 	@touch $$@
 else
 # FIXME #11094 - The above rule doesn't work right for multiple targets

trunk/src/compiletest/procsrv.rs

@@ -11,31 +11,54 @@
 use std::os;
 use std::str;
 use std::io::process::{ProcessExit, Command, Process, ProcessOutput};
-use std::unstable::dynamic_lib::DynamicLibrary;
 
+#[cfg(target_os = "win32")]
 fn target_env(lib_path: &str, prog: &str) -> Vec<(StrBuf, StrBuf)> {
-    let prog = if cfg!(windows) {prog.slice_to(prog.len() - 4)} else {prog};
-    let aux_path = prog + ".libaux";
+    let env = os::env();
 
-    // Need to be sure to put both the lib_path and the aux path in the dylib
-    // search path for the child.
-    let mut path = DynamicLibrary::search_path();
-    path.insert(0, Path::new(aux_path));
-    path.insert(0, Path::new(lib_path));
+    // Make sure we include the aux directory in the path
+    assert!(prog.ends_with(".exe"));
+    let aux_path = prog.slice(0u, prog.len() - 4u).to_owned() + ".libaux";
 
-    // Remove the previous dylib search path var
-    let var = DynamicLibrary::envvar();
-    let mut env: Vec<(StrBuf,StrBuf)> =
-        os::env().move_iter().map(|(a,b)|(a.to_strbuf(), b.to_strbuf())).collect();
-    match env.iter().position(|&(ref k, _)| k.as_slice() == var) {
-        Some(i) => { env.remove(i); }
-        None => {}
+    let mut new_env: Vec<_> = env.move_iter().map(|(k, v)| {
+        let new_v = if "PATH" == k {
+            format_strbuf!("{};{};{}", v, lib_path, aux_path)
+        } else {
+            v.to_strbuf()
+        };
+        (k.to_strbuf(), new_v)
+    }).collect();
+    if prog.ends_with("rustc.exe") {
+        new_env.push(("RUST_THREADS".to_strbuf(), "1".to_strbuf()));
     }
+    return new_env;
+}
 
-    // Add the new dylib search path var
-    let newpath = DynamicLibrary::create_path(path.as_slice());
-    env.push((var.to_strbuf(),
-              str::from_utf8(newpath.as_slice()).unwrap().to_strbuf()));
+#[cfg(target_os = "linux")]
+#[cfg(target_os = "macos")]
+#[cfg(target_os = "freebsd")]
+fn target_env(lib_path: &str, prog: &str) -> Vec<(StrBuf,StrBuf)> {
+    // Make sure we include the aux directory in the path
+    let aux_path = prog + ".libaux";
+
+    let mut env: Vec<(StrBuf,StrBuf)> =
+        os::env().move_iter()
+                 .map(|(ref k, ref v)| (k.to_strbuf(), v.to_strbuf()))
+                 .collect();
+    let var = if cfg!(target_os = "macos") {
+        "DYLD_LIBRARY_PATH"
+    } else {
+        "LD_LIBRARY_PATH"
+    };
+    let prev = match env.iter().position(|&(ref k, _)| k.as_slice() == var) {
+        Some(i) => env.remove(i).unwrap().val1(),
+        None => "".to_strbuf(),
+    };
+    env.push((var.to_strbuf(), if prev.is_empty() {
+        format_strbuf!("{}:{}", lib_path, aux_path)
+    } else {
+        format_strbuf!("{}:{}:{}", lib_path, aux_path, prev)
+    }));
     return env;
 }
 

trunk/src/etc/maketest.py

@@ -30,21 +30,20 @@ def putenv(name, value):
         value = normalize_path(value)
     os.putenv(name, value)
 
-def convert_path_spec(name, value):
-    if os.name == 'nt' and name != 'PATH':
-        value = ":".join(normalize_path(v) for v in value.split(";"))
-    return value
 
 make = sys.argv[2]
 putenv('RUSTC', os.path.abspath(sys.argv[3]))
 putenv('TMPDIR', os.path.abspath(sys.argv[4]))
 putenv('CC', sys.argv[5])
 putenv('RUSTDOC', os.path.abspath(sys.argv[6]))
 filt = sys.argv[7]
-putenv('LD_LIB_PATH_ENVVAR', sys.argv[8]);
-putenv('HOST_RPATH_DIR', os.path.abspath(sys.argv[9]));
-putenv('TARGET_RPATH_DIR', os.path.abspath(sys.argv[10]));
-putenv('RUST_BUILD_STAGE', sys.argv[11])
+ldpath = sys.argv[8]
+if ldpath != '':
+    name = ldpath.split('=')[0]
+    value = ldpath.split('=')[1]
+    if os.name == 'nt' and name != 'PATH':
+        value = ":".join(normalize_path(v) for v in value.split(";"))
+    os.putenv(name, value)
 
 if not filt in sys.argv[1]:
     sys.exit(0)

trunk/src/libcollections/priority_queue.rs

@@ -22,17 +22,17 @@ pub struct PriorityQueue<T> {
     data: Vec<T>,
 }
 
-impl<T:Ord> Container for PriorityQueue<T> {
+impl<T: TotalOrd> Container for PriorityQueue<T> {
     /// Returns the length of the queue
     fn len(&self) -> uint { self.data.len() }
 }
 
-impl<T:Ord> Mutable for PriorityQueue<T> {
+impl<T: TotalOrd> Mutable for PriorityQueue<T> {
     /// Drop all items from the queue
     fn clear(&mut self) { self.data.truncate(0) }
 }
 
-impl<T:Ord> PriorityQueue<T> {
+impl<T: TotalOrd> PriorityQueue<T> {
     /// An iterator visiting all values in underlying vector, in
     /// arbitrary order.
     pub fn iter<'a>(&'a self) -> Items<'a, T> {
@@ -197,15 +197,15 @@ impl<'a, T> Iterator<&'a T> for Items<'a, T> {
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
-impl<T: Ord> FromIterator<T> for PriorityQueue<T> {
+impl<T: TotalOrd> FromIterator<T> for PriorityQueue<T> {
     fn from_iter<Iter: Iterator<T>>(iter: Iter) -> PriorityQueue<T> {
         let mut q = PriorityQueue::new();
         q.extend(iter);
         q
     }
 }
 
-impl<T: Ord> Extendable<T> for PriorityQueue<T> {
+impl<T: TotalOrd> Extendable<T> for PriorityQueue<T> {
     fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
         let (lower, _) = iter.size_hint();
 

trunk/src/libcollections/treemap.rs

@@ -12,7 +12,6 @@
 //! trees. The only requirement for the types is that the key implements
 //! `TotalOrd`.
 
-use std::iter;
 use std::iter::{Peekable};
 use std::cmp::Ordering;
 use std::mem::{replace, swap};
@@ -619,12 +618,6 @@ impl<T: TotalOrd> TreeSet<T> {
         RevSetItems{iter: self.map.rev_iter()}
     }
 
-    /// Get a lazy iterator that consumes the set.
-    #[inline]
-    pub fn move_iter(self) -> MoveSetItems<T> {
-        self.map.move_iter().map(|(value, _)| value)
-    }
-
     /// Get a lazy iterator pointing to the first value not less than `v` (greater or equal).
     /// If all elements in the set are less than `v` empty iterator is returned.
     #[inline]
@@ -672,9 +665,6 @@ pub struct RevSetItems<'a, T> {
     iter: RevEntries<'a, T, ()>
 }
 
-/// Lazy forward iterator over a set that consumes the set while iterating
-pub type MoveSetItems<T> = iter::Map<'static, (T, ()), T, MoveEntries<T, ()>>;
-
 /// Lazy iterator producing elements in the set difference (in-order)
 pub struct DifferenceItems<'a, T> {
     a: Peekable<&'a T, SetItems<'a, T>>,
@@ -1552,33 +1542,6 @@ mod test_set {
         }
     }
 
-    #[test]
-    fn test_move_iter() {
-        let s: TreeSet<int> = range(0, 5).collect();
-
-        let mut n = 0;
-        for x in s.move_iter() {
-            assert_eq!(x, n);
-            n += 1;
-        }
-    }
-
-    #[test]
-    fn test_move_iter_size_hint() {
-        let s: TreeSet<int> = vec!(0, 1).move_iter().collect();
-
-        let mut it = s.move_iter();
-
-        assert_eq!(it.size_hint(), (2, Some(2)));
-        assert!(it.next() != None);
-
-        assert_eq!(it.size_hint(), (1, Some(1)));
-        assert!(it.next() != None);
-
-        assert_eq!(it.size_hint(), (0, Some(0)));
-        assert_eq!(it.next(), None);
-    }
-
     #[test]
     fn test_clone_eq() {
       let mut m = TreeSet::new();

trunk/src/libcore/fmt/mod.rs

@@ -43,44 +43,16 @@ pub mod rt;
 
 pub type Result = result::Result<(), FormatError>;
 
-/// The error type which is returned from formatting a message into a stream.
-///
-/// This type does not support transmission of an error other than that an error
-/// occurred. Any extra information must be arranged to be transmitted through
-/// some other means.
+/// dox
 pub enum FormatError {
-    /// A generic write error occurred during formatting, no other information
-    /// is transmitted via this variant.
+    /// dox
     WriteError,
 }
 
-/// A collection of methods that are required to format a message into a stream.
-///
-/// This trait is the type which this modules requires when formatting
-/// information. This is similar to the standard library's `io::Writer` trait,
-/// but it is only intended for use in libcore.
-///
-/// This trait should generally not be implemented by consumers of the standard
-/// library. The `write!` macro accepts an instance of `io::Writer`, and the
-/// `io::Writer` trait is favored over implementing this trait.
+/// dox
 pub trait FormatWriter {
-    /// Writes a slice of bytes into this writer, returning whether the write
-    /// succeeded.
-    ///
-    /// This method can only succeed if the entire byte slice was successfully
-    /// written, and this method will not return until all data has been
-    /// written or an error occurs.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an instance of `FormatError` on error.
+    /// dox
     fn write(&mut self, bytes: &[u8]) -> Result;
-
-    /// Glue for usage of the `write!` macro with implementors of this trait.
-    ///
-    /// This method should generally not be invoked manually, but rather through
-    /// the `write!` macro itself.
-    fn write_fmt(&mut self, args: &Arguments) -> Result { write(self, args) }
 }
 
 /// A struct to represent both where to emit formatting strings to and how they

trunk/src/libcore/ptr.rs

@@ -359,7 +359,7 @@ impl<T> RawPtr<T> for *T {
         if self.is_null() {
             None
         } else {
-            Some(&**self)
+            Some(mem::transmute(*self))
         }
     }
 }
@@ -384,7 +384,7 @@ impl<T> RawPtr<T> for *mut T {
         if self.is_null() {
             None
         } else {
-            Some(&**self)
+            Some(mem::transmute(*self))
         }
     }
 }