---

yaml
---
r: 95899
b: refs/heads/dist-snap
c: 2fc337a
h: refs/heads/master
i:
  95897: e2aa212
  95895: 549d443
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: efaf730347fa7e01f8d1852be7c9a447f147763c
+refs/heads/dist-snap: 2fc337a7d6f9ee05c0e5cf7df6fd243a649aeb61
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/compiletest/compiletest.rs

@@ -220,19 +220,6 @@ pub fn mode_str(mode: mode) -> ~str {
 }
 
 pub fn run_tests(config: &config) {
-    if config.target == ~"arm-linux-androideabi" {
-        match config.mode{
-            mode_debug_info => {
-                println("arm-linux-androideabi debug-info \
-                        test uses tcp 5039 port. please reserve it");
-                //arm-linux-androideabi debug-info test uses remote debugger
-                //so, we test 1 task at once
-                os::setenv("RUST_TEST_TASKS","1");
-            }
-            _ =>{}
-        }
-    }
-
     let opts = test_opts(config);
     let tests = make_tests(config);
     // sadly osx needs some file descriptor limits raised for running tests in

branches/dist-snap/src/compiletest/procsrv.rs

@@ -67,26 +67,3 @@ pub fn run(lib_path: &str,
         err: str::from_utf8(output.error)
     }
 }
-
-pub fn run_background(lib_path: &str,
-           prog: &str,
-           args: &[~str],
-           env: ~[(~str, ~str)],
-           input: Option<~str>) -> run::Process {
-
-    let env = env + target_env(lib_path, prog);
-    let mut process = run::Process::new(prog, args, run::ProcessOptions {
-        env: Some(env),
-        dir: None,
-        in_fd: None,
-        out_fd: None,
-        err_fd: None
-    });
-
-    for input in input.iter() {
-        process.input().write(input.as_bytes());
-    }
-
-    return process;
-}
-

branches/dist-snap/src/compiletest/runtest.rs

@@ -26,10 +26,6 @@ use std::rt::io::File;
 use std::os;
 use std::str;
 use std::vec;
-use std::rt::io::net::tcp;
-use std::rt::io::net::ip::{Ipv4Addr, SocketAddr};
-use std::task;
-use std::rt::io::timer;
 
 use extra::test::MetricMap;
 
@@ -249,7 +245,6 @@ actual:\n\
 }
 
 fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
-
     // do not optimize debuginfo tests
     let mut config = match config.rustcflags {
         Some(ref flags) => config {
@@ -259,125 +254,39 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
         None => (*config).clone()
     };
     let config = &mut config;
+    let cmds = props.debugger_cmds.connect("\n");
     let check_lines = &props.check_lines;
-    let mut cmds = props.debugger_cmds.connect("\n");
 
     // compile test file (it shoud have 'compile-flags:-g' in the header)
     let mut ProcRes = compile_test(config, props, testfile);
     if ProcRes.status != 0 {
         fatal_ProcRes(~"compilation failed!", &ProcRes);
     }
 
+    // write debugger script
+    let script_str = [~"set charset UTF-8",
+                      cmds,
+                      ~"quit\n"].connect("\n");
+    debug!("script_str = {}", script_str);
+    dump_output_file(config, testfile, script_str, "debugger.script");
+
+    // run debugger script with gdb
+    #[cfg(windows)]
+    fn debugger() -> ~str { ~"gdb.exe" }
+    #[cfg(unix)]
+    fn debugger() -> ~str { ~"gdb" }
+    let debugger_script = make_out_name(config, testfile, "debugger.script");
     let exe_file = make_exe_name(config, testfile);
-
-    let mut ProcArgs;
-    match config.target {
-        ~"arm-linux-androideabi" => {
-            if (config.adb_device_status) {
-
-                cmds = cmds.replace("run","continue");
-
-                // write debugger script
-                let script_str = [~"set charset UTF-8",
-                    format!("file {}",exe_file.as_str().unwrap().to_owned()),
-                    ~"target remote :5039",
-                    cmds,
-                    ~"quit"].connect("\n");
-                debug!("script_str = {}", script_str);
-                dump_output_file(config, testfile, script_str, "debugger.script");
-
-
-                procsrv::run("", config.adb_path.clone(),
-                    [~"push", exe_file.as_str().unwrap().to_owned(), config.adb_test_dir.clone()],
-                    ~[(~"",~"")], Some(~""));
-
-                procsrv::run("", config.adb_path,
-                    [~"forward", ~"tcp:5039", ~"tcp:5039"],
-                    ~[(~"",~"")], Some(~""));
-
-                let adb_arg = format!("export LD_LIBRARY_PATH={}; gdbserver :5039 {}/{}",
-                         config.adb_test_dir.clone(), config.adb_test_dir.clone(),
-                         str::from_utf8(exe_file.filename().unwrap())).clone();
-
-                let mut process = procsrv::run_background("", config.adb_path.clone(),
-                        [~"shell",adb_arg.clone()],~[(~"",~"")], Some(~""));
-                loop {
-                    //waiting 1 second for gdbserver start
-                    timer::sleep(1000);
-                    let result = do task::try {
-                        tcp::TcpStream::connect(
-                        SocketAddr { ip: Ipv4Addr(127, 0, 0, 1), port: 5039 });
-                    };
-                    if result.is_err() {
-                        continue;
-                    }
-                    break;
-                }
-
-                let args = split_maybe_args(&config.rustcflags);
-                let mut tool_path:~str = ~"";
-                for arg in args.iter() {
-                    if arg.contains("--android-cross-path=") {
-                        tool_path = arg.replace("--android-cross-path=","");
-                        break;
-                    }
-                }
-
-                if tool_path.equals(&~"") {
-                    fatal(~"cannot found android cross path");
-                }
-
-                let debugger_script = make_out_name(config, testfile, "debugger.script");
-                // FIXME (#9639): This needs to handle non-utf8 paths
-                let debugger_opts = ~[~"-quiet", ~"-batch", ~"-nx",
-                    "-command=" + debugger_script.as_str().unwrap().to_owned()];
-
-                let procsrv::Result{ out, err, status }=
-                    procsrv::run("",
-                            tool_path.append("/bin/arm-linux-androideabi-gdb"),
-                            debugger_opts, ~[(~"",~"")], None);
-                let cmdline = {
-                    let cmdline = make_cmdline("", "arm-linux-androideabi-gdb", debugger_opts);
-                    logv(config, format!("executing {}", cmdline));
-                    cmdline
-                };
-
-                ProcRes = ProcRes {status: status,
-                    stdout: out,
-                    stderr: err,
-                    cmdline: cmdline};
-                process.force_destroy();
-            }
-        }
-
-        _=> {
-            // write debugger script
-            let script_str = [~"set charset UTF-8",
-                cmds,
-                ~"quit\n"].connect("\n");
-            debug!("script_str = {}", script_str);
-            dump_output_file(config, testfile, script_str, "debugger.script");
-
-            // run debugger script with gdb
-            #[cfg(windows)]
-            fn debugger() -> ~str { ~"gdb.exe" }
-            #[cfg(unix)]
-            fn debugger() -> ~str { ~"gdb" }
-
-            let debugger_script = make_out_name(config, testfile, "debugger.script");
-
-            // FIXME (#9639): This needs to handle non-utf8 paths
-            let debugger_opts = ~[~"-quiet", ~"-batch", ~"-nx",
-                "-command=" + debugger_script.as_str().unwrap().to_owned(),
-                exe_file.as_str().unwrap().to_owned()];
-            ProcArgs = ProcArgs {prog: debugger(), args: debugger_opts};
-            ProcRes = compose_and_run(config, testfile, ProcArgs, ~[], "", None);
-        }
-    }
-
+    // FIXME (#9639): This needs to handle non-utf8 paths
+    let debugger_opts = ~[~"-quiet", ~"-batch", ~"-nx",
+                          ~"-command=" + debugger_script.as_str().unwrap().to_owned(),
+                          exe_file.as_str().unwrap().to_owned()];
+    let ProcArgs = ProcArgs {prog: debugger(), args: debugger_opts};
+    ProcRes = compose_and_run(config, testfile, ProcArgs, ~[], "", None);
     if ProcRes.status != 0 {
         fatal(~"gdb failed to execute");
     }
+
     let num_check_lines = check_lines.len();
     if num_check_lines > 0 {
         // Allow check lines to leave parts unspecified (e.g., uninitialized
@@ -925,6 +834,7 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
     for tv in args.args.iter() {
         runargs.push(tv.to_owned());
     }
+
     procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""));
 
     // get exitcode of result

branches/dist-snap/src/librustc/back/rpath.rs

@@ -118,7 +118,7 @@ pub fn get_rpath_relative_to_output(os: session::Os,
     let prefix = match os {
         session::OsAndroid | session::OsLinux | session::OsFreebsd
                           => "$ORIGIN",
-        session::OsMacos => "@loader_path",
+        session::OsMacos => "@executable_path",
         session::OsWin32 => unreachable!()
     };
 
@@ -241,7 +241,7 @@ mod test {
         let res = get_rpath_relative_to_output(o,
                                                &Path::new("bin/rustc"),
                                                &Path::new("lib/libstd.so"));
-        assert_eq!(res.as_slice(), "@loader_path/../lib");
+        assert_eq!(res.as_slice(), "@executable_path/../lib");
     }
 
     #[test]

branches/dist-snap/src/libstd/fmt/parse.rs

@@ -180,7 +180,7 @@ impl<'self> Iterator<Piece<'self>> for Parser<'self> {
             }
             Some((_, '}')) if self.depth == 0 => {
                 self.cur.next();
-                self.err(~"unmatched `}` found");
+                self.err("unmatched `}` found");
                 None
             }
             Some((_, '}')) | None => { None }
@@ -204,8 +204,8 @@ impl<'self> Parser<'self> {
     /// Notifies of an error. The message doesn't actually need to be of type
     /// ~str, but I think it does when this eventually uses conditions so it
     /// might as well start using it now.
-    fn err(&self, msg: ~str) {
-        parse_error::cond.raise(msg);
+    fn err(&self, msg: &str) {
+        parse_error::cond.raise("invalid format string: " + msg);
     }
 
     /// Optionally consumes the specified character. If the character is not at
@@ -230,11 +230,11 @@ impl<'self> Parser<'self> {
                 self.cur.next();
             }
             Some((_, other)) => {
-                parse_error::cond.raise(
+                self.err(
                     format!("expected `{}` but found `{}`", c, other));
             }
             None => {
-                parse_error::cond.raise(
+                self.err(
                     format!("expected `{}` but string was terminated", c));
             }
         }
@@ -267,7 +267,7 @@ impl<'self> Parser<'self> {
                 c
             }
             None => {
-                self.err(~"expected an escape sequence, but format string was \
+                self.err("expected an escape sequence, but format string was \
                            terminated");
                 ' '
             }
@@ -411,7 +411,7 @@ impl<'self> Parser<'self> {
                 Some(self.plural())
             }
             "" => {
-                self.err(~"expected method after comma");
+                self.err("expected method after comma");
                 return None;
             }
             method => {
@@ -430,7 +430,7 @@ impl<'self> Parser<'self> {
             self.ws();
             let selector = self.word();
             if selector == "" {
-                self.err(~"cannot have an empty selector");
+                self.err("cannot have an empty selector");
                 break
             }
             self.must_consume('{');
@@ -440,7 +440,7 @@ impl<'self> Parser<'self> {
             self.must_consume('}');
             if selector == "other" {
                 if !other.is_none() {
-                    self.err(~"multiple `other` statements in `select");
+                    self.err("multiple `other` statements in `select");
                 }
                 other = Some(pieces);
             } else {
@@ -456,7 +456,7 @@ impl<'self> Parser<'self> {
         let other = match other {
             Some(arm) => { arm }
             None => {
-                self.err(~"`select` statement must provide an `other` case");
+                self.err("`select` statement must provide an `other` case");
                 ~[]
             }
         };
@@ -488,7 +488,7 @@ impl<'self> Parser<'self> {
                             match self.integer() {
                                 Some(i) => { offset = Some(i); }
                                 None => {
-                                    self.err(~"offset must be an integer");
+                                    self.err("offset must be an integer");
                                 }
                             }
                         }
@@ -506,8 +506,8 @@ impl<'self> Parser<'self> {
                 match self.integer() {
                     Some(i) => Right(i),
                     None => {
-                        self.err(~"plural `=` selectors must be followed by an \
-                                   integer");
+                        self.err("plural `=` selectors must be followed by an \
+                                  integer");
                         Right(0)
                     }
                 }
@@ -538,7 +538,7 @@ impl<'self> Parser<'self> {
             self.must_consume('}');
             if isother {
                 if !other.is_none() {
-                    self.err(~"multiple `other` statements in `select");
+                    self.err("multiple `other` statements in `select");
                 }
                 other = Some(pieces);
             } else {
@@ -554,7 +554,7 @@ impl<'self> Parser<'self> {
         let other = match other {
             Some(arm) => { arm }
             None => {
-                self.err(~"`plural` statement must provide an `other` case");
+                self.err("`plural` statement must provide an `other` case");
                 ~[]
             }
         };