---

yaml
---
r: 139118
b: refs/heads/try2
c: fe74a1c
h: refs/heads/master
v: v3

Author: erickt

[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: 51da7d4bc7a100f5343bc727fb2fb87b05e35c84
+refs/heads/try2: fe74a1c9a2ebd40028a4f389dc10c82f37fb0fe2
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/libc.rs

@@ -1221,8 +1221,9 @@ pub mod funcs {
         #[nolink]
         #[abi = "cdecl"]
         pub mod fcntl {
-            use libc::types::os::arch::c95::{c_int, c_char};
             pub extern {
+                use libc::types::os::arch::c95::{c_int, c_char};
+
                 #[link_name = "_open"]
                 unsafe fn open(path: *c_char, oflag: c_int, mode: c_int)
                             -> c_int;
@@ -1561,11 +1562,11 @@ pub mod funcs {
     #[cfg(target_os = "macos")]
     #[cfg(target_os = "freebsd")]
     pub mod bsd44 {
-        use libc::types::common::c95::{c_void};
-        use libc::types::os::arch::c95::{c_char, c_int, c_uint, size_t};
-
         #[abi = "cdecl"]
         pub extern {
+            use libc::types::common::c95::{c_void};
+            use libc::types::os::arch::c95::{c_char, c_int, c_uint, size_t};
+
             unsafe fn sysctl(name: *c_int, namelen: c_uint,
                       oldp: *mut c_void, oldlenp: *mut size_t,
                       newp: *c_void, newlen: size_t) -> c_int;

branches/try2/src/libcore/rt/env.rs

@@ -44,4 +44,4 @@ pub fn get() -> &Environment {
 
 extern {
     fn rust_get_rt_env() -> &Environment;
-}
+}

branches/try2/src/libcore/rt/sched.rs

@@ -70,7 +70,7 @@ enum CleanupJob {
 
 pub impl Scheduler {
 
-    static pub fn new(event_loop: ~EventLoopObject) -> Scheduler {
+    static fn new(event_loop: ~EventLoopObject) -> Scheduler {
         Scheduler {
             event_loop: event_loop,
             task_queue: WorkQueue::new(),
@@ -296,7 +296,7 @@ pub struct Task {
 }
 
 impl Task {
-    static pub fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task {
+    static fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task {
         // XXX: Putting main into a ~ so it's a thin pointer and can
         // be passed to the spawn function.  Another unfortunate
         // allocation

branches/try2/src/libcore/rt/stack.rs

@@ -37,7 +37,8 @@ pub impl StackSegment {
 pub struct StackPool(());
 
 impl StackPool {
-    static pub fn new() -> StackPool { StackPool(()) }
+
+    static fn new() -> StackPool { StackPool(()) }
 
     fn take_segment(&self, min_size: uint) -> StackSegment {
         StackSegment::new(min_size)

branches/try2/src/libcore/rt/thread.rs

@@ -20,7 +20,7 @@ struct Thread {
 }
 
 impl Thread {
-    static pub fn start(main: ~fn()) -> Thread {
+    static fn start(main: ~fn()) -> Thread {
         fn substart(main: &fn()) -> *raw_thread {
             unsafe { rust_raw_thread_start(&main) }
         }

branches/try2/src/libcore/task/rt.rs

@@ -30,7 +30,7 @@ pub type rust_task = libc::c_void;
 #[allow(non_camel_case_types)] // runtime type
 pub type rust_closure = libc::c_void;
 
-pub extern {
+extern {
     #[rust_stack]
     fn rust_task_yield(task: *rust_task) -> bool;
 

branches/try2/src/libcore/vec.rs

@@ -1005,7 +1005,7 @@ pub pure fn foldl<T, U>(z: T, v: &[U], p: &fn(t: T, u: &U) -> T) -> T {
  */
 pub pure fn foldr<T, U: Copy>(v: &[T], z: U, p: &fn(t: &T, u: U) -> U) -> U {
     let mut accum = z;
-    for rev_each(v) |elt| {
+    for v.each_reverse |elt| {
         accum = p(elt, accum);
     }
     accum
@@ -1411,8 +1411,8 @@ pub pure fn eachi<T>(v: &'r [T], f: &fn(uint, v: &'r T) -> bool) {
  * Return true to continue, false to break.
  */
 #[inline(always)]
-pub pure fn rev_each<T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) {
-    rev_eachi(v, |_i, v| blk(v))
+pub pure fn each_reverse<T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) {
+    eachi_reverse(v, |_i, v| blk(v))
 }
 
 /**
@@ -1421,7 +1421,7 @@ pub pure fn rev_each<T>(v: &'r [T], blk: &fn(v: &'r T) -> bool) {
  * Return true to continue, false to break.
  */
 #[inline(always)]
-pub pure fn rev_eachi<T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) {
+pub pure fn eachi_reverse<T>(v: &'r [T], blk: &fn(i: uint, v: &'r T) -> bool) {
     let mut i = v.len();
     while i > 0 {
         i -= 1;
@@ -1736,6 +1736,8 @@ pub trait ImmutableVector<T> {
     pure fn initn(&self, n: uint) -> &'self [T];
     pure fn last(&self) -> &'self T;
     pure fn last_opt(&self) -> Option<&'self T>;
+    pure fn each_reverse(&self, blk: &fn(&T) -> bool);
+    pure fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool);
     pure fn foldr<U: Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U;
     pure fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U];
     pure fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U];
@@ -1785,6 +1787,18 @@ impl<T> ImmutableVector<T> for &'self [T] {
     #[inline]
     pure fn last_opt(&self) -> Option<&'self T> { last_opt(*self) }
 
+    /// Iterates over a vector's elements in reverse.
+    #[inline]
+    pure fn each_reverse(&self, blk: &fn(&T) -> bool) {
+        each_reverse(*self, blk)
+    }
+
+    /// Iterates over a vector's elements and indices in reverse.
+    #[inline]
+    pure fn eachi_reverse(&self, blk: &fn(uint, &T) -> bool) {
+        eachi_reverse(*self, blk)
+    }
+
     /// Reduce a vector from right to left
     #[inline]
     pure fn foldr<U:Copy>(&self, z: U, p: &fn(t: &T, u: U) -> U) -> U {
@@ -3131,33 +3145,42 @@ mod tests {
     }
 
     #[test]
-    fn test_reach_empty() {
-        for rev_each::<int>(~[]) |_v| {
+    fn test_each_reverse_empty() {
+        let v: ~[int] = ~[];
+        for v.each_reverse |_v| {
             fail!(); // should never execute
         }
     }
 
     #[test]
-    fn test_reach_nonempty() {
+    fn test_each_reverse_nonempty() {
         let mut i = 0;
-        for rev_each(~[1, 2, 3]) |v| {
+        for each_reverse(~[1, 2, 3]) |v| {
             if i == 0 { fail_unless!(*v == 3); }
             i += *v
         }
         fail_unless!(i == 6);
     }
 
     #[test]
-    fn test_reachi() {
+    fn test_eachi_reverse() {
         let mut i = 0;
-        for rev_eachi(~[0, 1, 2]) |j, v| {
+        for eachi_reverse(~[0, 1, 2]) |j, v| {
             if i == 0 { fail_unless!(*v == 2); }
             fail_unless!(j == *v as uint);
             i += *v;
         }
         fail_unless!(i == 3);
     }
 
+    #[test]
+    fn test_eachi_reverse_empty() {
+        let v: ~[int] = ~[];
+        for v.eachi_reverse |_i, _v| {
+            fail!(); // should never execute
+        }
+    }
+
     #[test]
     fn test_each_permutation() {
         let mut results: ~[~[int]];

branches/try2/src/librustc/back/link.rs

@@ -167,18 +167,15 @@ pub mod write {
     use back::link::{output_type_assembly, output_type_bitcode};
     use back::link::{output_type_exe, output_type_llvm_assembly};
     use back::link::{output_type_object};
-    use back::link::output_type;
     use driver::session::Session;
     use driver::session;
     use lib::llvm::llvm;
     use lib::llvm::{False, True, ModuleRef, mk_pass_manager, mk_target_data};
     use lib;
 
-    use core::prelude::*;
     use core::libc::{c_char, c_int, c_uint};
     use core::path::Path;
     use core::str;
-    use core::run;
 
     pub fn is_object_or_assembly_or_exe(ot: output_type) -> bool {
         if ot == output_type_assembly || ot == output_type_object ||
@@ -188,13 +185,13 @@ pub mod write {
         return false;
     }
 
-    pub fn run_passes(sess: Session, llmod: ModuleRef,
-            output_type: output_type, output: &Path) {
+    pub fn run_passes(sess: Session, llmod: ModuleRef, output: &Path) {
         unsafe {
             let opts = sess.opts;
             if sess.time_llvm_passes() { llvm::LLVMRustEnableTimePasses(); }
             let mut pm = mk_pass_manager();
-            let td = mk_target_data(sess.targ_cfg.target_strs.data_layout);
+            let td = mk_target_data(
+                /*bad*/copy sess.targ_cfg.target_strs.data_layout);
             llvm::LLVMAddTargetData(td.lltd, pm.llpm);
             // FIXME (#2812): run the linter here also, once there are llvm-c
             // bindings for it.
@@ -204,7 +201,7 @@ pub mod write {
 
 
             if opts.save_temps {
-                match output_type {
+                match opts.output_type {
                   output_type_bitcode => {
                     if opts.optimize != session::No {
                         let filename = output.with_filetype("no-opt.bc");
@@ -265,7 +262,7 @@ pub mod write {
                 llvm::LLVMPassManagerBuilderDispose(MPMB);
             }
             if !sess.no_verify() { llvm::LLVMAddVerifierPass(pm.llpm); }
-            if is_object_or_assembly_or_exe(output_type) || opts.jit {
+            if is_object_or_assembly_or_exe(opts.output_type) || opts.jit {
                 let LLVMOptNone       = 0 as c_int; // -O0
                 let LLVMOptLess       = 1 as c_int; // -O1
                 let LLVMOptDefault    = 2 as c_int; // -O2, -Os
@@ -293,8 +290,8 @@ pub mod write {
                 }
 
                 let mut FileType;
-                if output_type == output_type_object ||
-                       output_type == output_type_exe {
+                if opts.output_type == output_type_object ||
+                       opts.output_type == output_type_exe {
                    FileType = lib::llvm::ObjectFile;
                 } else { FileType = lib::llvm::AssemblyFile; }
                 // Write optimized bitcode if --save-temps was on.
@@ -310,7 +307,7 @@ pub mod write {
                     pm = mk_pass_manager();
                     // Save the assembly file if -S is used
 
-                    if output_type == output_type_assembly {
+                    if opts.output_type == output_type_assembly {
                         let _: () = str::as_c_str(
                             sess.targ_cfg.target_strs.target_triple,
                             |buf_t| {
@@ -331,8 +328,8 @@ pub mod write {
 
                     // Save the object file for -c or --save-temps alone
                     // This .o is needed when an exe is built
-                    if output_type == output_type_object ||
-                           output_type == output_type_exe {
+                    if opts.output_type == output_type_object ||
+                           opts.output_type == output_type_exe {
                         let _: () = str::as_c_str(
                             sess.targ_cfg.target_strs.target_triple,
                             |buf_t| {
@@ -378,7 +375,7 @@ pub mod write {
                 return;
             }
 
-            if output_type == output_type_llvm_assembly {
+            if opts.output_type == output_type_llvm_assembly {
                 // Given options "-S --emit-llvm": output LLVM assembly
                 str::as_c_str(output.to_str(), |buf_o| {
                     llvm::LLVMRustAddPrintModulePass(pm.llpm, llmod, buf_o)});
@@ -394,34 +391,6 @@ pub mod write {
             if sess.time_llvm_passes() { llvm::LLVMRustPrintPassTimings(); }
         }
     }
-
-    pub fn run_ndk(sess: Session, assembly: &Path, object: &Path) {
-        let cc_prog: ~str = match &sess.opts.android_cross_path {
-            &Some(copy path) => {
-                fmt!("%s/bin/arm-linux-androideabi-gcc", path)
-            }
-            &None => {
-                sess.fatal(~"need Android NDK path for building \
-                             (--android-cross-path)")
-            }
-        };
-        let mut cc_args = ~[];
-        cc_args.push(~"-c");
-        cc_args.push(~"-o");
-        cc_args.push(object.to_str());
-        cc_args.push(assembly.to_str());
-
-        let prog = run::program_output(cc_prog, cc_args);
-
-        if prog.status != 0 {
-            sess.err(fmt!("building with `%s` failed with code %d",
-                        cc_prog, prog.status));
-            sess.note(fmt!("%s arguments: %s",
-                        cc_prog, str::connect(cc_args, ~" ")));
-            sess.note(prog.err + prog.out);
-            sess.abort_if_errors();
-        }
-    }
 }
 
 
@@ -865,9 +834,8 @@ pub fn link_binary(sess: Session,
     // to be found at compile time so it is still entirely up to outside
     // forces to make sure that library can be found at runtime.
 
-    for sess.opts.addl_lib_search_paths.each |path| {
-        cc_args.push(~"-L" + path.to_str());
-    }
+    let addl_paths = /*bad*/copy sess.opts.addl_lib_search_paths;
+    for addl_paths.each |path| { cc_args.push(~"-L" + path.to_str()); }
 
     // The names of the extern libraries
     let used_libs = cstore::get_used_libraries(cstore);

branches/try2/src/librustc/back/rpath.rs

@@ -45,8 +45,8 @@ pub fn get_rpath_flags(sess: session::Session, out_filename: &Path)
     // where rustrt is and we know every rust program needs it
     let libs = vec::append_one(libs, get_sysroot_absolute_rt_lib(sess));
 
-    let rpaths = get_rpaths(os, &sysroot, output, libs,
-                            sess.opts.target_triple);
+    let target_triple = /*bad*/copy sess.opts.target_triple;
+    let rpaths = get_rpaths(os, &sysroot, output, libs, target_triple);
     rpaths_to_flags(rpaths)
 }
 
@@ -140,8 +140,8 @@ pub fn get_relative_to(abs1: &Path, abs2: &Path) -> Path {
     let abs2 = abs2.normalize();
     debug!("finding relative path from %s to %s",
            abs1.to_str(), abs2.to_str());
-    let split1: &[~str] = abs1.components;
-    let split2: &[~str] = abs2.components;
+    let split1 = /*bad*/copy abs1.components;
+    let split2 = /*bad*/copy abs2.components;
     let len1 = vec::len(split1);
     let len2 = vec::len(split2);
     fail_unless!(len1 > 0);