---

yaml
---
r: 89683
b: refs/heads/master
c: e6dde28
h: refs/heads/master
i:
  89681: 1743f7a
  89679: 0f7d408
v: v3

Author: niftynif

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: acbcb9ed2e24137040a4c0a4f87034e943036ecb
+refs/heads/master: e6dde28c95b66a46a0dc05bfc9a5586b64e08575
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8

trunk/doc/po/ja/rust.md.po

@@ -678,13 +678,6 @@ msgid ""
 "and continues as any mixture hex digits and underscores."
 msgstr ""
 
-#. type: Bullet: '  * '
-#: doc/rust.md:326
-msgid ""
-"An _octal literal_ starts with the character sequence `U+0030` `U+006F` (`0o`) "
-"and continues as any mixture octal digits and underscores."
-msgstr ""
-
 #. type: Bullet: '  * '
 #: doc/rust.md:326
 msgid ""
@@ -747,7 +740,6 @@ msgid ""
 "123u;                              // type uint\n"
 "123_u;                             // type uint\n"
 "0xff_u8;                           // type u8\n"
-"0o70_i16;                          // type i16\n"
 "0b1111_1111_1001_0000_i32;         // type i32\n"
 "~~~~\n"
 msgstr ""

trunk/doc/po/ja/tutorial.md.po

@@ -849,7 +849,7 @@ msgstr "## プリミティブ型とリテラル"
 msgid ""
 "There are general signed and unsigned integer types, `int` and `uint`, as "
 "well as 8-, 16-, 32-, and 64-bit variants, `i8`, `u16`, etc.  Integers can "
-"be written in decimal (`144`), hexadecimal (`0x90`), octal (`0o70`), or binary "
+"be written in decimal (`144`), hexadecimal (`0x90`), or binary "
 "(`0b10010000`) base. Each integral type has a corresponding literal suffix "
 "that can be used to indicate the type of a literal: `i` for `int`, `u` for "
 "`uint`, `i8` for the `i8` type."

trunk/doc/po/rust.md.pot

@@ -661,7 +661,7 @@ msgstr ""
 
 #. type: Plain text
 #: doc/rust.md:319
-msgid "An _integer literal_ has one of four forms:"
+msgid "An _integer literal_ has one of three forms:"
 msgstr ""
 
 #. type: Bullet: '  * '
@@ -678,13 +678,6 @@ msgid ""
 "and continues as any mixture hex digits and underscores."
 msgstr ""
 
-#. type: Bullet: '  * '
-#: doc/rust.md:326
-msgid ""
-"An _octal literal_ starts with the character sequence `U+0030` `U+006F` (`0o`) "
-"and continues as any mixture octal digits and underscores."
-msgstr ""
-
 #. type: Bullet: '  * '
 #: doc/rust.md:326
 msgid ""
@@ -747,7 +740,6 @@ msgid ""
 "123u;                              // type uint\n"
 "123_u;                             // type uint\n"
 "0xff_u8;                           // type u8\n"
-"0o70_i16;                          // type i16\n"
 "0b1111_1111_1001_0000_i32;         // type i32\n"
 "~~~~\n"
 msgstr ""

trunk/doc/po/tutorial.md.pot

@@ -646,7 +646,7 @@ msgstr ""
 msgid ""
 "There are general signed and unsigned integer types, `int` and `uint`, as "
 "well as 8-, 16-, 32-, and 64-bit variants, `i8`, `u16`, etc.  Integers can "
-"be written in decimal (`144`), hexadecimal (`0x90`), octal (`0o70`), or binary "
+"be written in decimal (`144`), hexadecimal (`0x90`), or binary "
 "(`0b10010000`) base. Each integral type has a corresponding literal suffix "
 "that can be used to indicate the type of a literal: `i` for `int`, `u` for "
 "`uint`, `i8` for the `i8` type."

trunk/doc/rust.md

@@ -340,14 +340,12 @@ as they are differentiated by suffixes.
 
 ##### Integer literals
 
-An _integer literal_ has one of four forms:
+An _integer literal_ has one of three forms:
 
   * A _decimal literal_ starts with a *decimal digit* and continues with any
     mixture of *decimal digits* and _underscores_.
   * A _hex literal_ starts with the character sequence `U+0030` `U+0078`
     (`0x`) and continues as any mixture hex digits and underscores.
-  * An _octal literal_ starts with the character sequence `U+0030` `U+006F`
-    (`0o`) and continues as any mixture octal digits and underscores.
   * A _binary literal_ starts with the character sequence `U+0030` `U+0062`
     (`0b`) and continues as any mixture binary digits and underscores.
 
@@ -378,7 +376,6 @@ Examples of integer literals of various forms:
 123u;                              // type uint
 123_u;                             // type uint
 0xff_u8;                           // type u8
-0o70_i16;                          // type i16
 0b1111_1111_1001_0000_i32;         // type i32
 ~~~~
 

trunk/doc/tutorial.md

@@ -305,7 +305,7 @@ fn is_four(x: int) -> bool {
 
 There are general signed and unsigned integer types, `int` and `uint`,
 as well as 8-, 16-, 32-, and 64-bit variants, `i8`, `u16`, etc.
-Integers can be written in decimal (`144`), hexadecimal (`0x90`), octal (`0o70`), or
+Integers can be written in decimal (`144`), hexadecimal (`0x90`), or
 binary (`0b10010000`) base. Each integral type has a corresponding literal
 suffix that can be used to indicate the type of a literal: `i` for `int`,
 `u` for `uint`, `i8` for the `i8` type.

trunk/mk/platform.mk

@@ -195,8 +195,8 @@ CFG_RUN_TARG_i686-unknown-linux-gnu=$(call CFG_RUN_i686-unknown-linux-gnu,,$(2))
 
 # arm-apple-darwin configuration
 ifeq ($(CFG_OSTYPE),apple-darwin)
-CFG_IOS_SDK = $(shell xcrun --show-sdk-path -sdk iphoneos 2>/dev/null)
-CFG_IOS_FLAGS = -target arm-apple-darwin -isysroot $(CFG_IOS_SDK) -I$(CFG_IOS_SDK)/usr/include -I$(CFG_IOS_SDK)/usr/include/c++/4.2.1
+CFG_IOS_SDK = $(shell xcrun --show-sdk-path -sdk iphoneos)
+CFG_IOS_FLAGS = -target arm-apple-darwin -isysroot $(CFG_IOS_SDK) -I $(CFG_IOS_SDK)/usr/include -I $(CFG_IOS_SDK)/usr/include/c++/4.2.1 -I /usr/include
 CC_arm-apple-darwin = $(shell xcrun -find -sdk iphoneos clang)
 CXX_arm-apple-darwin = $(shell xcrun -find -sdk iphoneos clang++)
 CPP_arm-apple-darwin = $(shell xcrun -find -sdk iphoneos clang++)

trunk/mk/rt.mk

@@ -28,13 +28,6 @@ LIBUV_FLAGS_i386 = -m32 -fPIC -I$(S)src/etc/mingw-fix-include
 LIBUV_FLAGS_x86_64 = -m64 -fPIC
 ifeq ($(OSTYPE_$(1)), linux-androideabi)
 LIBUV_FLAGS_arm = -fPIC -DANDROID -std=gnu99
-else ifeq ($(OSTYPE_$(1)), apple-darwin)
-  ifeq ($(HOST_$(1)), arm)
-    IOS_SDK := $(shell xcrun --show-sdk-path -sdk iphoneos 2>/dev/null)
-    LIBUV_FLAGS_arm := -fPIC -std=gnu99 -I$(IOS_SDK)/usr/include -I$(IOS_SDK)/usr/include/c++/4.2.1
-  else
-    LIBUV_FLAGS_arm := -fPIC -std=gnu99
-  endif
 else
 LIBUV_FLAGS_arm = -fPIC -std=gnu99
 endif
@@ -91,6 +84,7 @@ endif
 
 RUNTIME_CXXS_$(1)_$(2) := \
               rt/sync/lock_and_signal.cpp \
+              rt/sync/rust_thread.cpp \
               rt/rust_builtin.cpp \
               rt/rust_upcall.cpp \
               rt/miniz.cpp \

trunk/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

trunk/src/compiletest/errors.rs

@@ -52,8 +52,10 @@ fn parse_expected(line_num: uint, line: ~str) -> ~[ExpectedError] {
     let start_kind = idx;
     while idx < len && line[idx] != (' ' as u8) { idx += 1u; }
 
+    // FIXME: #4318 Instead of to_ascii and to_str_ascii, could use
+    // to_ascii_consume and to_str_consume to not do a unnecessary copy.
     let kind = line.slice(start_kind, idx);
-    let kind = kind.to_ascii().to_lower().into_str();
+    let kind = kind.to_ascii().to_lower().to_str_ascii();
 
     // Extract msg:
     while idx < len && line[idx] == (' ' as u8) { idx += 1u; }

trunk/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;
-}
-

trunk/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

trunk/src/etc/gedit/share/gtksourceview-3.0/language-specs/rust.lang

@@ -224,18 +224,13 @@
       [0-9a-fA-F]
     </define-regex>
 
-    <define-regex id="oct_digit" extended="true">
-      [0-7]
-    </define-regex>
-
     <context id="number" style-ref="number">
       <match extended="true">
         ((?&lt;=\.\.)|(?&lt;![\w\.]))
         (
         [1-9][0-9_]*\%{num_suffix}?|
         0[0-9_]*\%{num_suffix}?|
         0b[01_]+\%{int_suffix}?|
-        0o(\%{oct_digit}|_)+\%{int_suffix}?|
         0x(\%{hex_digit}|_)+\%{int_suffix}?
         )
         ((?![\w\.].)|(?=\.\.))