---

yaml
---
r: 114159
b: refs/heads/master
c: 7798755
h: refs/heads/master
i:
  114157: 3a6edaf
  114155: 943df8f
  114151: ca59fca
  114143: 0400f43
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f2c4c88ff1236e381ec20f5444abe098b7873180
+refs/heads/master: 779875591681eea522e780f44ef5e30c429f513f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/man/rustc.1

@@ -138,6 +138,9 @@ A space-separated list of arguments to pass through to LLVM.
 If specified, the compiler will save more files (.bc, .o, .no-opt.bc) generated
 throughout compilation in the output directory.
 .TP
+\fBandroid-cross-path\fR=path/to/ndk/bin
+Directory to find the Android NDK cross-compilation tools
+.TP
 \fBno-rpath\fR
 If specified, then the rpath value for dynamic libraries will not be set in
 either dynamic library or executable outputs.

trunk/mk/docs.mk

@@ -30,7 +30,7 @@ DOCS := index intro tutorial guide-ffi guide-macros guide-lifetimes \
 	guide-tasks guide-container guide-pointers guide-testing \
 	guide-runtime complement-bugreport complement-cheatsheet \
 	complement-lang-faq complement-project-faq rust rustdoc \
-	guide-unsafe not_found
+	guide-unsafe
 
 PDF_DOCS := tutorial rust
 

trunk/mk/platform.mk

@@ -307,7 +307,7 @@ CFG_LDPATH_arm-linux-androideabi :=
 CFG_RUN_arm-linux-androideabi=
 CFG_RUN_TARG_arm-linux-androideabi=
 RUSTC_FLAGS_arm-linux-androideabi :=
-RUSTC_CROSS_FLAGS_arm-linux-androideabi :=
+RUSTC_CROSS_FLAGS_arm-linux-androideabi :=-C android-cross-path=$(CFG_ANDROID_CROSS_PATH)
 
 # arm-unknown-linux-gnueabihf configuration
 CROSS_PREFIX_arm-unknown-linux-gnueabihf=arm-linux-gnueabihf-

trunk/mk/tests.mk

@@ -601,7 +601,6 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) :=						\
         --stage-id stage$(1)-$(2)							\
         --target $(2)                                       \
         --host $(3)                                       \
-        --android-cross-path=$(CFG_ANDROID_CROSS_PATH)    \
         --adb-path=$(CFG_ADB)                          \
         --adb-test-dir=$(CFG_ADB_TEST_DIR)                  \
         --host-rustcflags "$(RUSTC_FLAGS_$(3)) $$(CTEST_RUSTC_FLAGS) -L $$(RT_OUTPUT_DIR_$(3))" \

trunk/src/compiletest/common.rs

@@ -8,52 +8,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::from_str::FromStr;
-use std::fmt;
-
 #[deriving(Clone, Eq)]
-pub enum Mode {
-    CompileFail,
-    RunFail,
-    RunPass,
-    Pretty,
-    DebugInfoGdb,
-    DebugInfoLldb,
-    Codegen
-}
-
-impl FromStr for Mode {
-    fn from_str(s: &str) -> Option<Mode> {
-        match s {
-          "compile-fail" => Some(CompileFail),
-          "run-fail" => Some(RunFail),
-          "run-pass" => Some(RunPass),
-          "pretty" => Some(Pretty),
-          "debuginfo-lldb" => Some(DebugInfoLldb),
-          "debuginfo-gdb" => Some(DebugInfoGdb),
-          "codegen" => Some(Codegen),
-          _ => None,
-        }
-    }
-}
-
-impl fmt::Show for Mode {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let msg = match *self {
-          CompileFail => "compile-fail",
-          RunFail => "run-fail",
-          RunPass => "run-pass",
-          Pretty => "pretty",
-          DebugInfoGdb => "debuginfo-gdb",
-          DebugInfoLldb => "debuginfo-lldb",
-          Codegen => "codegen",
-        };
-        write!(f.buf, "{}", msg)
-    }
+pub enum mode {
+    mode_compile_fail,
+    mode_run_fail,
+    mode_run_pass,
+    mode_pretty,
+    mode_debug_info_gdb,
+    mode_debug_info_lldb,
+    mode_codegen
 }
 
 #[deriving(Clone)]
-pub struct Config {
+pub struct config {
     // The library paths required for running the compiler
     pub compile_lib_path: ~str,
 
@@ -82,7 +49,7 @@ pub struct Config {
     pub stage_id: ~str,
 
     // The test mode, compile-fail, run-fail, run-pass
-    pub mode: Mode,
+    pub mode: mode,
 
     // Run ignored tests
     pub run_ignored: bool,
@@ -126,9 +93,6 @@ pub struct Config {
     // Host triple for the compiler being invoked
     pub host: ~str,
 
-    // Path to the android tools
-    pub android_cross_path: Path,
-
     // Extra parameter to run adb on arm-linux-androideabi
     pub adb_path: ~str,
 

trunk/src/compiletest/compiletest.rs

@@ -14,6 +14,7 @@
 // we use our own (green) start below; do not link in libnative; issue #13247.
 #![no_start]
 
+#![allow(non_camel_case_types)]
 #![deny(warnings)]
 
 extern crate test;
@@ -26,10 +27,9 @@ extern crate rustuv;
 use std::os;
 use std::io;
 use std::io::fs;
-use std::from_str::FromStr;
 use getopts::{optopt, optflag, reqopt};
-use common::Config;
-use common::{Pretty, DebugInfoGdb, Codegen};
+use common::{config, mode_run_pass, mode_run_fail, mode_compile_fail, mode_pretty,
+             mode_debug_info_gdb, mode_debug_info_lldb, mode_codegen, mode};
 use util::logv;
 
 pub mod procsrv;
@@ -51,7 +51,7 @@ pub fn main() {
     run_tests(&config);
 }
 
-pub fn parse_config(args: Vec<~str> ) -> Config {
+pub fn parse_config(args: Vec<~str> ) -> config {
 
     let groups : Vec<getopts::OptGroup> =
         vec!(reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"),
@@ -79,7 +79,6 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
           optflag("", "jit", "run tests under the JIT"),
           optopt("", "target", "the target to build for", "TARGET"),
           optopt("", "host", "the host to build for", "HOST"),
-          optopt("", "android-cross-path", "Android NDK standalone path", "PATH"),
           optopt("", "adb-path", "path to the android debugger", "PATH"),
           optopt("", "adb-test-dir", "path to tests for the android debugger", "PATH"),
           optopt("", "lldb-python-dir", "directory containing LLDB's python module", "PATH"),
@@ -113,7 +112,7 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
         Path::new(m.opt_str(nm).unwrap())
     }
 
-    Config {
+    config {
         compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
         run_lib_path: matches.opt_str("run-lib-path").unwrap(),
         rustc_path: opt_path(matches, "rustc-path"),
@@ -123,7 +122,7 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
         build_base: opt_path(matches, "build-base"),
         aux_base: opt_path(matches, "aux-base"),
         stage_id: matches.opt_str("stage-id").unwrap(),
-        mode: FromStr::from_str(matches.opt_str("mode").unwrap()).expect("invalid mode"),
+        mode: str_mode(matches.opt_str("mode").unwrap()),
         run_ignored: matches.opt_present("ignored"),
         filter:
             if !matches.free.is_empty() {
@@ -143,7 +142,6 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
         jit: matches.opt_present("jit"),
         target: opt_str2(matches.opt_str("target")).to_str(),
         host: opt_str2(matches.opt_str("host")).to_str(),
-        android_cross_path: opt_path(matches, "android-cross-path"),
         adb_path: opt_str2(matches.opt_str("adb-path")).to_str(),
         adb_test_dir:
             opt_str2(matches.opt_str("adb-test-dir")).to_str(),
@@ -152,13 +150,12 @@ pub fn parse_config(args: Vec<~str> ) -> Config {
             "(none)" != opt_str2(matches.opt_str("adb-test-dir")) &&
             !opt_str2(matches.opt_str("adb-test-dir")).is_empty(),
         lldb_python_dir: matches.opt_str("lldb-python-dir"),
-        test_shard: test::opt_shard(matches.opt_str("test-shard")
-                                           .map(|x| x.to_strbuf())),
+        test_shard: test::opt_shard(matches.opt_str("test-shard")),
         verbose: matches.opt_present("verbose")
     }
 }
 
-pub fn log_config(config: &Config) {
+pub fn log_config(config: &config) {
     let c = config;
     logv(c, format!("configuration:"));
     logv(c, format!("compile_lib_path: {}", config.compile_lib_path));
@@ -167,7 +164,7 @@ pub fn log_config(config: &Config) {
     logv(c, format!("src_base: {}", config.src_base.display()));
     logv(c, format!("build_base: {}", config.build_base.display()));
     logv(c, format!("stage_id: {}", config.stage_id));
-    logv(c, format!("mode: {}", config.mode));
+    logv(c, format!("mode: {}", mode_str(config.mode)));
     logv(c, format!("run_ignored: {}", config.run_ignored));
     logv(c, format!("filter: {}", opt_str(&config.filter)));
     logv(c, format!("runtool: {}", opt_str(&config.runtool)));
@@ -176,7 +173,6 @@ pub fn log_config(config: &Config) {
     logv(c, format!("jit: {}", config.jit));
     logv(c, format!("target: {}", config.target));
     logv(c, format!("host: {}", config.host));
-    logv(c, format!("android-cross-path: {}", config.android_cross_path.display()));
     logv(c, format!("adb_path: {}", config.adb_path));
     logv(c, format!("adb_test_dir: {}", config.adb_test_dir));
     logv(c, format!("adb_device_status: {}", config.adb_device_status));
@@ -202,10 +198,35 @@ pub fn opt_str2(maybestr: Option<~str>) -> ~str {
     match maybestr { None => "(none)".to_owned(), Some(s) => { s } }
 }
 
-pub fn run_tests(config: &Config) {
+pub fn str_mode(s: ~str) -> mode {
+    match s.as_slice() {
+        "compile-fail" => mode_compile_fail,
+        "run-fail" => mode_run_fail,
+        "run-pass" => mode_run_pass,
+        "pretty" => mode_pretty,
+        "debuginfo-gdb" => mode_debug_info_gdb,
+        "debuginfo-lldb" => mode_debug_info_lldb,
+        "codegen" => mode_codegen,
+        s => fail!("invalid mode: " + s)
+    }
+}
+
+pub fn mode_str(mode: mode) -> ~str {
+    match mode {
+      mode_compile_fail => "compile-fail".to_owned(),
+      mode_run_fail => "run-fail".to_owned(),
+      mode_run_pass => "run-pass".to_owned(),
+      mode_pretty => "pretty".to_owned(),
+      mode_debug_info_gdb => "debuginfo-gdb".to_owned(),
+      mode_debug_info_lldb => "debuginfo-lldb".to_owned(),
+      mode_codegen => "codegen".to_owned(),
+    }
+}
+
+pub fn run_tests(config: &config) {
     if config.target == "arm-linux-androideabi".to_owned() {
-        match config.mode {
-            DebugInfoGdb => {
+        match config.mode{
+            mode_debug_info_gdb => {
                 println!("arm-linux-androideabi debug-info \
                          test uses tcp 5039 port. please reserve it");
             }
@@ -234,12 +255,9 @@ pub fn run_tests(config: &Config) {
     }
 }
 
-pub fn test_opts(config: &Config) -> test::TestOpts {
+pub fn test_opts(config: &config) -> test::TestOpts {
     test::TestOpts {
-        filter: match config.filter {
-            None => None,
-            Some(ref filter) => Some(filter.to_strbuf()),
-        },
+        filter: config.filter.clone(),
         run_ignored: config.run_ignored,
         logfile: config.logfile.clone(),
         run_tests: true,
@@ -252,7 +270,7 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
     }
 }
 
-pub fn make_tests(config: &Config) -> Vec<test::TestDescAndFn> {
+pub fn make_tests(config: &config) -> Vec<test::TestDescAndFn> {
     debug!("making tests from {}",
            config.src_base.display());
     let mut tests = Vec::new();
@@ -263,7 +281,7 @@ pub fn make_tests(config: &Config) -> Vec<test::TestDescAndFn> {
         if is_test(config, &file) {
             let t = make_test(config, &file, || {
                 match config.mode {
-                    Codegen => make_metrics_test_closure(config, &file),
+                    mode_codegen => make_metrics_test_closure(config, &file),
                     _ => make_test_closure(config, &file)
                 }
             });
@@ -273,11 +291,11 @@ pub fn make_tests(config: &Config) -> Vec<test::TestDescAndFn> {
     tests
 }
 
-pub fn is_test(config: &Config, testfile: &Path) -> bool {
+pub fn is_test(config: &config, testfile: &Path) -> bool {
     // Pretty-printer does not work with .rc files yet
     let valid_extensions =
         match config.mode {
-          Pretty => vec!(".rs".to_owned()),
+          mode_pretty => vec!(".rs".to_owned()),
           _ => vec!(".rc".to_owned(), ".rs".to_owned())
         };
     let invalid_prefixes = vec!(".".to_owned(), "#".to_owned(), "~".to_owned());
@@ -296,7 +314,7 @@ pub fn is_test(config: &Config, testfile: &Path) -> bool {
     return valid;
 }
 
-pub fn make_test(config: &Config, testfile: &Path, f: || -> test::TestFn)
+pub fn make_test(config: &config, testfile: &Path, f: || -> test::TestFn)
                  -> test::TestDescAndFn {
     test::TestDescAndFn {
         desc: test::TestDesc {
@@ -308,7 +326,7 @@ pub fn make_test(config: &Config, testfile: &Path, f: || -> test::TestFn)
     }
 }
 
-pub fn make_test_name(config: &Config, testfile: &Path) -> test::TestName {
+pub fn make_test_name(config: &config, testfile: &Path) -> test::TestName {
 
     // Try to elide redundant long paths
     fn shorten(path: &Path) -> ~str {
@@ -318,19 +336,19 @@ pub fn make_test_name(config: &Config, testfile: &Path) -> test::TestName {
         format!("{}/{}", dir.unwrap_or(""), filename.unwrap_or(""))
     }
 
-    test::DynTestName(format_strbuf!("[{}] {}",
-                                     config.mode,
-                                     shorten(testfile)))
+    test::DynTestName(format!("[{}] {}",
+                              mode_str(config.mode),
+                              shorten(testfile)))
 }
 
-pub fn make_test_closure(config: &Config, testfile: &Path) -> test::TestFn {
+pub fn make_test_closure(config: &config, testfile: &Path) -> test::TestFn {
     let config = (*config).clone();
     // FIXME (#9639): This needs to handle non-utf8 paths
     let testfile = testfile.as_str().unwrap().to_owned();
     test::DynTestFn(proc() { runtest::run(config, testfile) })
 }
 
-pub fn make_metrics_test_closure(config: &Config, testfile: &Path) -> test::TestFn {
+pub fn make_metrics_test_closure(config: &config, testfile: &Path) -> test::TestFn {
     let config = (*config).clone();
     // FIXME (#9639): This needs to handle non-utf8 paths
     let testfile = testfile.as_str().unwrap().to_owned();