---

yaml
---
r: 130269
b: refs/heads/auto
c: 968b128
h: refs/heads/master
i:
  130267: 09f9396
v: v3

Author: treeman

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: b7d456dfea5487c13ff0389c905693aad85f775f
+refs/heads/auto: 968b1280e34848f7cf37358c9fd76af18cac2ec7
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -515,13 +515,6 @@ probe CFG_LUALATEX         lualatex
 probe CFG_GDB              gdb
 probe CFG_LLDB             lldb
 
-if [ ! -z "$CFG_GDB" ]
-then
-    # Extract the version
-    CFG_GDB_VERSION=$($CFG_GDB --version 2>/dev/null | head -1)
-    putvar CFG_GDB_VERSION
-fi
-
 if [ ! -z "$CFG_LLDB" ]
 then
     # If CFG_LLDB_PYTHON_DIR is not already set from the outside and valid, try to read it from

branches/auto/mk/tests.mk

@@ -623,7 +623,6 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) := \
         --stage-id stage$(1)-$(2) \
         --target $(2) \
         --host $(3) \
-        --gdb-version="$(CFG_GDB_VERSION)" \
         --android-cross-path=$(CFG_ANDROID_CROSS_PATH) \
         --adb-path=$(CFG_ADB) \
         --adb-test-dir=$(CFG_ADB_TEST_DIR) \

branches/auto/src/compiletest/common.rs

@@ -130,9 +130,6 @@ pub struct Config {
     // Host triple for the compiler being invoked
     pub host: String,
 
-    // Version of GDB
-    pub gdb_version: Option<String>,
-
     // Path to the android tools
     pub android_cross_path: Path,
 

branches/auto/src/compiletest/compiletest.rs

@@ -81,7 +81,6 @@ pub fn parse_config(args: Vec<String> ) -> 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("", "gdb-version", "the version of GDB used", "MAJOR.MINOR"),
           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"),
@@ -158,7 +157,6 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         jit: matches.opt_present("jit"),
         target: opt_str2(matches.opt_str("target")),
         host: opt_str2(matches.opt_str("host")),
-        gdb_version: extract_gdb_version(matches.opt_str("gdb-version")),
         android_cross_path: opt_path(matches, "android-cross-path"),
         adb_path: opt_str2(matches.opt_str("adb-path")),
         adb_test_dir: opt_str2(matches.opt_str("adb-test-dir")),
@@ -378,26 +376,3 @@ pub fn make_metrics_test_closure(config: &Config, testfile: &Path) -> test::Test
         runtest::run_metrics(config, testfile, mm)
     })
 }
-
-fn extract_gdb_version(full_version_line: Option<String>) -> Option<String> {
-    match full_version_line {
-        Some(ref full_version_line)
-          if full_version_line.as_slice().trim().len() > 0 => {
-            let full_version_line = full_version_line.as_slice().trim();
-
-            let re = Regex::new(r"(^|[^0-9])([0-9]\.[0-9])([^0-9]|$)").unwrap();
-
-            match re.captures(full_version_line) {
-                Some(captures) => {
-                    Some(captures.at(2).to_string())
-                }
-                None => {
-                    println!("Could not extract GDB version from line '{}'",
-                             full_version_line);
-                    None
-                }
-            }
-        },
-        _ => None
-    }
-}

branches/auto/src/compiletest/header.rs

@@ -12,8 +12,6 @@ use common::Config;
 use common;
 use util;
 
-use std::from_str::FromStr;
-
 pub struct TestProps {
     // Lines that should be expected, in order, on standard out
     pub error_patterns: Vec<String> ,
@@ -144,42 +142,23 @@ pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
         format!("ignore-{}",
                 config.stage_id.as_slice().split('-').next().unwrap())
     }
-    fn ignore_gdb(config: &Config, line: &str) -> bool {
-        if config.mode != common::DebugInfoGdb {
-            return false;
-        }
-
-        if parse_name_directive(line, "ignore-gdb") {
-            return true;
-        }
-
-        match config.gdb_version {
-            Some(ref actual_version) => {
-                if line.contains("min-gdb-version") {
-                    let min_version = line.trim()
-                                          .split(' ')
-                                          .last()
-                                          .expect("Malformed GDB version directive");
-                    // Ignore if actual version is smaller the minimum required
-                    // version
-                    gdb_version_to_int(actual_version.as_slice()) <
-                        gdb_version_to_int(min_version.as_slice())
-                } else {
-                    false
-                }
-            }
-            None => false
-        }
-    }
 
     let val = iter_header(testfile, |ln| {
-        !parse_name_directive(ln, "ignore-test") &&
-        !parse_name_directive(ln, ignore_target(config).as_slice()) &&
-        !parse_name_directive(ln, ignore_stage(config).as_slice()) &&
-        !(config.mode == common::Pretty && parse_name_directive(ln, "ignore-pretty")) &&
-        !(config.target != config.host && parse_name_directive(ln, "ignore-cross-compile")) &&
-        !ignore_gdb(config, ln) &&
-        !(config.mode == common::DebugInfoLldb && parse_name_directive(ln, "ignore-lldb"))
+        if parse_name_directive(ln, "ignore-test") {
+            false
+        } else if parse_name_directive(ln, ignore_target(config).as_slice()) {
+            false
+        } else if parse_name_directive(ln, ignore_stage(config).as_slice()) {
+            false
+        } else if config.mode == common::Pretty &&
+                parse_name_directive(ln, "ignore-pretty") {
+            false
+        } else if config.target != config.host &&
+                parse_name_directive(ln, "ignore-cross-compile") {
+            false
+        } else {
+            true
+        }
     });
 
     !val
@@ -299,21 +278,3 @@ pub fn parse_name_value_directive(line: &str, directive: &str)
         None => None
     }
 }
-
-pub fn gdb_version_to_int(version_string: &str) -> int {
-    let error_string = format!(
-        "Encountered GDB version string with unexpected format: {}",
-        version_string);
-    let error_string = error_string.as_slice();
-
-    let components: Vec<&str> = version_string.trim().split('.').collect();
-
-    if components.len() != 2 {
-        fail!("{}", error_string);
-    }
-
-    let major: int = FromStr::from_str(components[0]).expect(error_string);
-    let minor: int = FromStr::from_str(components[1]).expect(error_string);
-
-    return major * 1000 + minor;
-}

branches/auto/src/compiletest/runtest.rs

@@ -323,12 +323,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
     };
 
     let config = &mut config;
-    let DebuggerCommands {
-        commands,
-        check_lines,
-        use_gdb_pretty_printer,
-        ..
-    } = parse_debugger_commands(testfile, "gdb");
+    let DebuggerCommands { commands, check_lines, .. } = parse_debugger_commands(testfile, "gdb");
     let mut cmds = commands.connect("\n");
 
     // compile test file (it should have 'compile-flags:-g' in the header)
@@ -339,6 +334,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
 
     let exe_file = make_exe_name(config, testfile);
 
+    let mut proc_args;
     let debugger_run_result;
     match config.target.as_slice() {
         "arm-linux-androideabi" => {
@@ -458,65 +454,18 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
         }
 
         _=> {
-            let rust_src_root = find_rust_src_root(config)
-                .expect("Could not find Rust source root");
-            let rust_pp_module_rel_path = Path::new("./src/etc");
-            let rust_pp_module_abs_path = rust_src_root.join(rust_pp_module_rel_path)
-                                                       .as_str()
-                                                       .unwrap()
-                                                       .to_string();
             // write debugger script
-            let mut script_str = String::with_capacity(2048);
-
-            script_str.push_str("set charset UTF-8\n");
-            script_str.push_str("show version\n");
-
-            match config.gdb_version {
-                Some(ref version) => {
-                    println!("NOTE: compiletest thinks it is using GDB version {}",
-                             version.as_slice());
-
-                    if header::gdb_version_to_int(version.as_slice()) >
-                        header::gdb_version_to_int("7.4") {
-                        // Add the directory containing the pretty printers to
-                        // GDB's script auto loading safe path ...
-                        script_str.push_str(
-                            format!("add-auto-load-safe-path {}\n",
-                                    rust_pp_module_abs_path.as_slice())
-                                .as_slice());
-                        // ... and also the test directory
-                        script_str.push_str(
-                            format!("add-auto-load-safe-path {}\n",
-                                    config.build_base.as_str().unwrap())
-                                .as_slice());
-                    }
-                }
-                _ => {
-                    println!("NOTE: compiletest does not know which version of \
-                              GDB it is using");
-                }
-            }
-
-            // Load the target executable
-            script_str.push_str(format!("file {}\n",
-                                        exe_file.as_str().unwrap())
-                                    .as_slice());
-
-            script_str.push_str(cmds.as_slice());
-            script_str.push_str("quit\n");
-
+            let script_str = [
+                "set charset UTF-8".to_string(),
+                cmds,
+                "quit\n".to_string()
+            ].connect("\n");
             debug!("script_str = {}", script_str);
             dump_output_file(config,
                              testfile,
                              script_str.as_slice(),
                              "debugger.script");
 
-            if use_gdb_pretty_printer {
-                // Only emit the gdb auto-loading script if pretty printers
-                // should actually be loaded
-                dump_gdb_autoload_script(config, testfile);
-            }
-
             // run debugger script with gdb
             #[cfg(windows)]
             fn debugger() -> String {
@@ -534,19 +483,16 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                 vec!("-quiet".to_string(),
                      "-batch".to_string(),
                      "-nx".to_string(),
-                     format!("-command={}", debugger_script.as_str().unwrap()));
-
-            let proc_args = ProcArgs {
+                     format!("-command={}", debugger_script.as_str().unwrap()),
+                     exe_file.as_str().unwrap().to_string());
+            proc_args = ProcArgs {
                 prog: debugger(),
                 args: debugger_opts,
             };
-
-            let environment = vec![("PYTHONPATH".to_string(), rust_pp_module_abs_path)];
-
             debugger_run_result = compose_and_run(config,
                                                   testfile,
                                                   proc_args,
-                                                  environment,
+                                                  Vec::new(),
                                                   config.run_lib_path.as_slice(),
                                                   None,
                                                   None);
@@ -558,32 +504,6 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
     }
 
     check_debugger_output(&debugger_run_result, check_lines.as_slice());
-
-    fn dump_gdb_autoload_script(config: &Config, testfile: &Path) {
-        let mut script_path = output_base_name(config, testfile);
-        let mut script_file_name = script_path.filename().unwrap().to_vec();
-        script_file_name.push_all("-gdb.py".as_bytes());
-        script_path.set_filename(script_file_name.as_slice());
-
-        let script_content = "import gdb_rust_pretty_printing\n\
-                              gdb_rust_pretty_printing.register_printers(gdb.current_objfile())\n"
-                             .as_bytes();
-
-        File::create(&script_path).write(script_content).unwrap();
-    }
-}
-
-fn find_rust_src_root(config: &Config) -> Option<Path> {
-    let mut path = config.src_base.clone();
-    let path_postfix = Path::new("src/etc/lldb_batchmode.py");
-
-    while path.pop() {
-        if path.join(path_postfix.clone()).is_file() {
-            return Some(path);
-        }
-    }
-
-    return None;
 }
 
 fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path) {
@@ -613,8 +533,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
     let DebuggerCommands {
         commands,
         check_lines,
-        breakpoint_lines,
-        ..
+        breakpoint_lines
     } = parse_debugger_commands(testfile, "lldb");
 
     // Write debugger script:
@@ -700,7 +619,6 @@ struct DebuggerCommands {
     commands: Vec<String>,
     check_lines: Vec<String>,
     breakpoint_lines: Vec<uint>,
-    use_gdb_pretty_printer: bool
 }
 
 fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str)
@@ -713,7 +631,6 @@ fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str)
     let mut breakpoint_lines = vec!();
     let mut commands = vec!();
     let mut check_lines = vec!();
-    let mut use_gdb_pretty_printer = false;
     let mut counter = 1;
     let mut reader = BufferedReader::new(File::open(file_path).unwrap());
     for line in reader.lines() {
@@ -723,10 +640,6 @@ fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str)
                     breakpoint_lines.push(counter);
                 }
 
-                if line.as_slice().contains("gdb-use-pretty-printer") {
-                    use_gdb_pretty_printer = true;
-                }
-
                 header::parse_name_value_directive(
                         line.as_slice(),
                         command_directive.as_slice()).map(|cmd| {
@@ -750,8 +663,7 @@ fn parse_debugger_commands(file_path: &Path, debugger_prefix: &str)
     DebuggerCommands {
         commands: commands,
         check_lines: check_lines,
-        breakpoint_lines: breakpoint_lines,
-        use_gdb_pretty_printer: use_gdb_pretty_printer,
+        breakpoint_lines: breakpoint_lines
     }
 }
 

branches/auto/src/doc/complement-lang-faq.md

@@ -83,7 +83,7 @@ We want to maintain the option to parametrize at runtime. We may eventually chan
 
 ## Why aren't values type-parametric? Why only items?
 
-Doing so would make type inference much more complex, and require the implementation strategy of runtime parameterization.
+Doing so would make type inference much more complex, and require the implementation strategy of runtime parametrization.
 
 ## Why are enumerations nominal and closed?
 

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

@@ -477,7 +477,7 @@ extern crate libc;
 
 #[cfg(target_os = "win32", target_arch = "x86")]
 #[link(name = "kernel32")]
-#[allow(non_snake_case)]
+#[allow(non_snake_case_functions)]
 extern "stdcall" {
     fn SetEnvironmentVariableA(n: *const u8, v: *const u8) -> libc::c_int;
 }
@@ -528,8 +528,8 @@ 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`), boxes (`Box<T>`), and function pointers (`extern "abi" fn()`).
-When interfacing with C, pointers that might be null are often used.
+`&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