---

yaml
---
r: 145261
b: refs/heads/try2
c: 040f1c0
h: refs/heads/master
i:
  145259: 63196e7
v: v3

Author: alexcrichton

[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: 99ec14dbb0c6017106f2378bedd35ac256aa0006
+refs/heads/try2: 040f1c06bc7c1c5fa37477513227114d343b3ec3
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -248,7 +248,7 @@ string_body : non_double_quote
             | '\x5c' [ '\x22' | common_escape ] ;
 
 common_escape : '\x5c'
-              | 'n' | 'r' | 't' | '0'
+              | 'n' | 'r' | 't'
               | 'x' hex_digit 2
               | 'u' hex_digit 4
               | 'U' hex_digit 8 ;
@@ -962,76 +962,24 @@ parameters to allow methods with that trait to be called on values
 of that type.
 
 
-#### Unsafety
+#### Unsafe functions
 
-Unsafe operations are those that potentially violate the memory-safety guarantees of Rust's static semantics.
+Unsafe functions are those containing unsafe operations that are not contained in an [`unsafe` block](#unsafe-blocks).
+Such a function must be prefixed with the keyword `unsafe`.
 
-The following language level features cannot be used in the safe subset of Rust:
+Unsafe operations are those that potentially violate the memory-safety guarantees of Rust's static semantics.
+Specifically, the following operations are considered unsafe:
 
   - Dereferencing a [raw pointer](#pointer-types).
-  - Calling an unsafe function (including an intrinsic or foreign function).
-
-##### Unsafe functions
-
-Unsafe functions are functions that are not safe in all contexts and/or for all possible inputs.
-Such a function must be prefixed with the keyword `unsafe`.
+  - Casting a [raw pointer](#pointer-types) to a safe pointer type.
+  - Calling an unsafe function.
 
 ##### Unsafe blocks
 
-A block of code can also be prefixed with the `unsafe` keyword, to permit calling `unsafe` functions
-or dereferencing raw pointers within a safe function.
-
-When a programmer has sufficient conviction that a sequence of potentially unsafe operations is
-actually safe, they can encapsulate that sequence (taken as a whole) within an `unsafe` block. The
-compiler will consider uses of such code safe, in the surrounding context.
-
-Unsafe blocks are used to wrap foreign libraries, make direct use of hardware or implement features
-not directly present in the language. For example, Rust provides the language features necessary to
-implement memory-safe concurrency in the language but the implementation of tasks and message
-passing is in the standard library.
-
-Rust's type system is a conservative approximation of the dynamic safety requirements, so in some
-cases there is a performance cost to using safe code.  For example, a doubly-linked list is not a
-tree structure and can only be represented with managed or reference-counted pointers in safe code.
-By using `unsafe` blocks to represent the reverse links as raw pointers, it can be implemented with
-only owned pointers.
-
-##### Behavior considered unsafe
-
-This is a list of behavior which is forbidden in all Rust code. Type checking provides the guarantee
-that these issues are never caused by safe code. An `unsafe` block or function is responsible for
-never invoking this behaviour or exposing an API making it possible for it to occur in safe code.
-
-* Data races
-* Dereferencing a null/dangling raw pointer
-* Mutating an immutable value/reference, if it is not marked as non-`Freeze`
-* Reads of [undef](http://llvm.org/docs/LangRef.html#undefined-values) (uninitialized) memory
-* Breaking the [pointer aliasing rules](http://llvm.org/docs/LangRef.html#pointer-aliasing-rules)
-  with raw pointers (a subset of the rules used by C)
-* Invoking undefined behavior via compiler intrinsics:
-    * Indexing outside of the bounds of an object with `std::ptr::offset` (`offset` intrinsic), with
-      the exception of one byte past the end which is permitted.
-    * Using `std::ptr::copy_nonoverlapping_memory` (`memcpy32`/`memcpy64` instrinsics) on
-      overlapping buffers
-* Invalid values in primitive types, even in private fields/locals:
-    * Dangling/null pointers in non-raw pointers, or slices
-    * A value other than `false` (0) or `true` (1) in a `bool`
-    * A discriminant in an `enum` not included in the type definition
-    * A value in a `char` which is a surrogate or above `char::MAX`
-    * non-UTF-8 byte sequences in a `str`
-
-##### Behaviour not considered unsafe
-
-This is a list of behaviour not considered *unsafe* in Rust terms, but that may be undesired.
-
-* Deadlocks
-* Reading data from private fields (`std::repr`, `format!("{:?}", x)`)
-* Leaks due to reference count cycles, even in the global heap
-* Exiting without calling destructors
-* Sending signals
-* Accessing/modifying the file system
-* Unsigned integer overflow (well-defined as wrapping)
-* Signed integer overflow (well-defined as two's complement representation wrapping)
+A block of code can also be prefixed with the `unsafe` keyword, to permit a sequence of unsafe operations in an otherwise-safe function.
+This facility exists because the static semantics of Rust are a necessary approximation of the dynamic semantics.
+When a programmer has sufficient conviction that a sequence of unsafe operations is actually safe, they can encapsulate that sequence (taken as a whole) within an `unsafe` block. The compiler will consider uses of such code "safe", to the surrounding context.
+
 
 #### Diverging functions
 

branches/try2/mk/llvm.mk

@@ -28,7 +28,7 @@ LLVM_STAMP_$(1) = $$(CFG_LLVM_BUILD_DIR_$(1))/llvm-auto-clean-stamp
 
 $$(LLVM_CONFIG_$(1)): $$(LLVM_DEPS) $$(LLVM_STAMP_$(1))
 	@$$(call E, make: llvm)
-	$$(Q)$$(MAKE) -C $$(CFG_LLVM_BUILD_DIR_$(1)) $$(CFG_LLVM_BUILD_ENV_$(1))
+	$$(Q)$$(MAKE) -C $$(CFG_LLVM_BUILD_DIR_$(1)) $$(CFG_LLVM_BUILD_ENV)
 	$$(Q)touch $$(LLVM_CONFIG_$(1))
 endif
 

branches/try2/mk/platform.mk

@@ -343,7 +343,6 @@ CFG_PATH_MUNGE_mips-unknown-linux-gnu := true
 CFG_LDPATH_mips-unknown-linux-gnu :=
 CFG_RUN_mips-unknown-linux-gnu=
 CFG_RUN_TARG_mips-unknown-linux-gnu=
-RUSTC_FLAGS_mips-unknown-linux-gnu := --linker=$(CXX_mips-unknown-linux-gnu) --target-cpu mips32r2 --target-feature +mips32r2,+o32
 
 # i686-pc-mingw32 configuration
 CC_i686-pc-mingw32=$(CC)
@@ -353,7 +352,7 @@ AR_i686-pc-mingw32=$(AR)
 CFG_LIB_NAME_i686-pc-mingw32=$(1).dll
 CFG_LIB_GLOB_i686-pc-mingw32=$(1)-*.dll
 CFG_LIB_DSYM_GLOB_i686-pc-mingw32=$(1)-*.dylib.dSYM
-CFG_GCCISH_CFLAGS_i686-pc-mingw32 := -Wall -Werror -g -m32 -march=i686 -D_WIN32_WINNT=0x0600 -I$(CFG_SRC_DIR)src/etc/mingw-fix-include
+CFG_GCCISH_CFLAGS_i686-pc-mingw32 := -Wall -Werror -g -m32 -march=i686 -D_WIN32_WINNT=0x0600
 CFG_GCCISH_CXXFLAGS_i686-pc-mingw32 := -fno-rtti
 CFG_GCCISH_LINK_FLAGS_i686-pc-mingw32 := -shared -fPIC -g -m32
 CFG_GCCISH_DEF_FLAG_i686-pc-mingw32 :=
@@ -362,7 +361,6 @@ CFG_GCCISH_POST_LIB_FLAGS_i686-pc-mingw32 :=
 CFG_DEF_SUFFIX_i686-pc-mingw32 := .mingw32.def
 CFG_INSTALL_NAME_i686-pc-mingw32 =
 CFG_LIBUV_LINK_FLAGS_i686-pc-mingw32 := -lWs2_32 -lpsapi -liphlpapi
-CFG_LLVM_BUILD_ENV_i686-pc-mingw32 := CPATH=$(CFG_SRC_DIR)src/etc/mingw-fix-include
 CFG_EXE_SUFFIX_i686-pc-mingw32 := .exe
 CFG_WINDOWSY_i686-pc-mingw32 := 1
 CFG_UNIXY_i686-pc-mingw32 :=
@@ -481,7 +479,7 @@ define CFG_MAKE_TOOLCHAIN
         $$(CFG_GCCISH_DEF_FLAG_$(1))$$(3) $$(2)        \
         $$(call CFG_INSTALL_NAME_$(1),$$(4))
 
-  ifeq ($$(findstring $(HOST_$(1)),arm mips),)
+  ifneq ($(HOST_$(1)),arm)
 
   # We're using llvm-mc as our assembler because it supports
   # .cfi pseudo-ops on mac
@@ -493,7 +491,7 @@ define CFG_MAKE_TOOLCHAIN
                     -o=$$(1)
   else
 
-  # For the ARM and MIPS crosses, use the toolchain assembler
+  # For the ARM crosses, use the toolchain assembler
   # XXX: We should be able to use the LLVM assembler
   CFG_ASSEMBLE_$(1)=$$(CC_$(1)) $$(CFG_DEPEND_FLAGS) $$(2) -c -o $$(1)
 

branches/try2/mk/rt.mk

@@ -24,7 +24,7 @@
 # working under these assumptions).
 
 # Hack for passing flags into LIBUV, see below.
-LIBUV_FLAGS_i386 = -m32 -fPIC -I$(S)src/etc/mingw-fix-include
+LIBUV_FLAGS_i386 = -m32 -fPIC
 LIBUV_FLAGS_x86_64 = -m64 -fPIC
 ifeq ($(OSTYPE_$(1)), linux-androideabi)
 LIBUV_FLAGS_arm = -fPIC -DANDROID -std=gnu99
@@ -71,6 +71,7 @@ RUNTIME_CXXS_$(1)_$(2) := \
               rt/sync/lock_and_signal.cpp \
               rt/sync/rust_thread.cpp \
               rt/rust_builtin.cpp \
+              rt/rust_run_program.cpp \
               rt/rust_rng.cpp \
               rt/rust_upcall.cpp \
               rt/rust_uv.cpp \

branches/try2/src/compiletest/compiletest.rs

@@ -17,6 +17,7 @@ extern mod extra;
 
 use std::os;
 use std::rt;
+use std::f64;
 
 use extra::getopts;
 use extra::getopts::groups::{optopt, optflag, reqopt};
@@ -91,62 +92,64 @@ pub fn parse_config(args: ~[~str]) -> config {
     let matches =
         &match getopts::groups::getopts(args_, groups) {
           Ok(m) => m,
-          Err(f) => fail!(f.to_err_msg())
+          Err(f) => fail!(getopts::fail_str(f))
         };
 
-    if matches.opt_present("h") || matches.opt_present("help") {
+    if getopts::opt_present(matches, "h") || getopts::opt_present(matches, "help") {
         let message = fmt!("Usage: %s [OPTIONS]  [TESTNAME...]", argv0);
         println(getopts::groups::usage(message, groups));
         println("");
         fail!()
     }
 
     fn opt_path(m: &getopts::Matches, nm: &str) -> Path {
-        Path(m.opt_str(nm).unwrap())
+        Path(getopts::opt_str(m, nm))
     }
 
     config {
-        compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
-        run_lib_path: matches.opt_str("run-lib-path").unwrap(),
+        compile_lib_path: getopts::opt_str(matches, "compile-lib-path"),
+        run_lib_path: getopts::opt_str(matches, "run-lib-path"),
         rustc_path: opt_path(matches, "rustc-path"),
-        clang_path: matches.opt_str("clang-path").map_move(|s| Path(s)),
-        llvm_bin_path: matches.opt_str("llvm-bin-path").map_move(|s| Path(s)),
+        clang_path: getopts::opt_maybe_str(matches, "clang-path").map_move(|s| Path(s)),
+        llvm_bin_path: getopts::opt_maybe_str(matches, "llvm-bin-path").map_move(|s| Path(s)),
         src_base: opt_path(matches, "src-base"),
         build_base: opt_path(matches, "build-base"),
         aux_base: opt_path(matches, "aux-base"),
-        stage_id: matches.opt_str("stage-id").unwrap(),
-        mode: str_mode(matches.opt_str("mode").unwrap()),
-        run_ignored: matches.opt_present("ignored"),
+        stage_id: getopts::opt_str(matches, "stage-id"),
+        mode: str_mode(getopts::opt_str(matches, "mode")),
+        run_ignored: getopts::opt_present(matches, "ignored"),
         filter:
             if !matches.free.is_empty() {
                  Some(matches.free[0].clone())
             } else {
                 None
             },
-        logfile: matches.opt_str("logfile").map_move(|s| Path(s)),
-        save_metrics: matches.opt_str("save-metrics").map_move(|s| Path(s)),
+        logfile: getopts::opt_maybe_str(matches, "logfile").map_move(|s| Path(s)),
+        save_metrics: getopts::opt_maybe_str(matches, "save-metrics").map_move(|s| Path(s)),
         ratchet_metrics:
-            matches.opt_str("ratchet-metrics").map_move(|s| Path(s)),
+            getopts::opt_maybe_str(matches, "ratchet-metrics").map_move(|s| Path(s)),
         ratchet_noise_percent:
-            matches.opt_str("ratchet-noise-percent").and_then(|s| from_str::<f64>(s)),
-        runtool: matches.opt_str("runtool"),
-        rustcflags: matches.opt_str("rustcflags"),
-        jit: matches.opt_present("jit"),
-        target: opt_str2(matches.opt_str("target")).to_str(),
-        adb_path: opt_str2(matches.opt_str("adb-path")).to_str(),
+            getopts::opt_maybe_str(matches,
+                                   "ratchet-noise-percent").map_move(|s|
+                                                                     f64::from_str(s).unwrap()),
+        runtool: getopts::opt_maybe_str(matches, "runtool"),
+        rustcflags: getopts::opt_maybe_str(matches, "rustcflags"),
+        jit: getopts::opt_present(matches, "jit"),
+        target: opt_str2(getopts::opt_maybe_str(matches, "target")).to_str(),
+        adb_path: opt_str2(getopts::opt_maybe_str(matches, "adb-path")).to_str(),
         adb_test_dir:
-            opt_str2(matches.opt_str("adb-test-dir")).to_str(),
+            opt_str2(getopts::opt_maybe_str(matches, "adb-test-dir")).to_str(),
         adb_device_status:
-            if (opt_str2(matches.opt_str("target")) ==
+            if (opt_str2(getopts::opt_maybe_str(matches, "target")) ==
                 ~"arm-linux-androideabi") {
-                if (opt_str2(matches.opt_str("adb-test-dir")) !=
+                if (opt_str2(getopts::opt_maybe_str(matches, "adb-test-dir")) !=
                     ~"(none)" &&
-                    opt_str2(matches.opt_str("adb-test-dir")) !=
+                    opt_str2(getopts::opt_maybe_str(matches, "adb-test-dir")) !=
                     ~"") { true }
                 else { false }
             } else { false },
-        test_shard: test::opt_shard(matches.opt_str("test-shard")),
-        verbose: matches.opt_present("verbose")
+        test_shard: test::opt_shard(getopts::opt_maybe_str(matches, "test-shard")),
+        verbose: getopts::opt_present(matches, "verbose")
     }
 }