---

yaml
---
r: 145265
b: refs/heads/try2
c: 5ab843f
h: refs/heads/master
i:
  145263: 76900c6
v: v3

Author: erickt

[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: 068e04231ded7fccca349babb1ba58ab3d796f40
+refs/heads/try2: 5ab843fbc3924fc7706f8adf281da7aff3dced31
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/RELEASES.txt

@@ -1,148 +1,3 @@
-Version 0.8 (October 2013)
---------------------------
-
-   * ~2100 changes, numerous bugfixes
-
-   * Language
-      * The `for` loop syntax has changed to work with the `Iterator` trait.
-      * At long last, unwinding works on Windows.
-      * Default methods definitely mostly work.
-      * Many trait inheritance bugs fixed.
-      * Owned and borrowed trait objects work more reliably.
-      * `copy` is no longer a keyword. It has been replaced by the `Clone` trait.
-      * rustc no longer emits code for the `debug!` macro unless it is passed
-        `--cfg debug`
-      * mod.rs is now "blessed". When loading `mod foo;`, rustc will now look
-        for foo.rs, then foo/mod.rs, and will generate an error when both are
-        present.
-      * Strings no longer contain trailing nulls. The new `std::c_str` module
-        provides new mechanisms for converting to C strings.
-      * The type of foreign functions is now `extern "C" fn` instead of `*u8'.
-      * The FFI has been overhauled such that foreign functions are called directly,
-        instead of through a stack-switching wrapper.
-      * Calling a foreign function must be done through a Rust function with the
-        `#[fixed_stack_segment]` attribute.
-      * The `externfn!` macro can be used to declare both a foreign function and
-        a `#[fixed_stack_segment]` wrapper at once.
-      * `pub` and `priv` modifiers on `extern` blocks are no longer parsed.
-      * `unsafe` is no longer allowed on extern fns - they are all unsafe.
-      * `priv` is disallowed everywhere except for struct fields and enum variants.
-      * `&T` (besides `&'static T`) is no longer allowed in `@T`.
-      * `ref` bindings in irrefutable patterns work correctly now.
-      * `char` is now prevented from containing invalid code points.
-      * Casting to `bool` is no longer allowed.
-      * `yield` is a reserved keyword.
-      * `typeof` is a reserved keyword.
-      * Crates may be imported by URL with `extern mod foo = "url";`.
-      * Explicit enum discriminants may be given as uints as in `enum E { V = 0u }`
-      * Static vectors can be initialized with repeating elements,
-        e.g. `static foo: [u8, .. 100]: [0, .. 100];`.
-      * Static structs can be initialized with functional record update,
-        e.g. `static foo: Foo = Foo { a: 5, .. bar };`.
-      * `cfg!` can be used to conditionally execute code based on the crate
-        configuration, similarly to `#[cfg(...)]`.
-      * The `unnecessary_qualification` lint detects unneeded module
-        prefixes (default: allow).
-      * Arithmetic operations have been implemented on the SIMD types in
-        `std::unstable::simd`.
-      * Exchange allocation headers were removed, reducing memory usage.
-      * `format!` implements a completely new, extensible, and higher-performance
-        string formatting system. It will replace `fmt!`.
-      * `print!` and `println!` write formatted strings (using the `format!`
-        extension) to stdout.
-      * `write!` and `writeln!` write formatted strings (using the `format!`
-        extension) to the new Writers in `std::rt::io`.
-      * The library section in which a function or static is placed may
-        be specified with `#[link_section = "..."]`.
-      * The `proto!` syntax extension for defining bounded message protocols
-        was removed.
-      * `macro_rules!` is hygenic for `let` declarations.
-      * The `#[export_name]` attribute specifies the name of a symbol.
-      * `unreachable!` can be used to indicate unreachable code, and fails
-        if executed.
-
-   * Libraries
-      * std: Transitioned to the new runtime, written in Rust.
-      * std: Added an experimental I/O library, `rt::io`, based on the new
-        runtime.
-      * std: A new generic `range` function was added to the prelude, replacing
-        `uint::range` and friends.
-      * std: `range_rev` no longer exists. Since range is an iterator it can be
-        reversed with `range(lo, hi).invert()`.
-      * std: The `chain` method on option renamed to `and_then`; `unwrap_or_default`
-        renamed to `unwrap_or`.
-      * std: The `iterator` module was renamed to `iter`.
-      * std: Integral types now support the `checked_add`, `checked_sub`, and
-        `checked_mul` operations for detecting overflow.
-      * std: Many methods in `str`, `vec`, `option, `result` were renamed for
-        consistency.
-      * std: Methods are standardizing on conventions for casting methods:
-        `to_foo` for copying, `into_foo` for moving, `as_foo` for temporary
-        and cheap casts.
-      * std: The `CString` type in `c_str` provides new ways to convert to and
-        from C strings.
-      * std: `DoubleEndedIterator` can yield elements in two directions.
-      * std: The `mut_split` method on vectors partitions an `&mut [T]` into
-        two splices.
-      * std: `str::from_bytes` renamed to `str::from_utf8`.
-      * std: `pop_opt` and `shift_opt` methods added to vectors.
-      * std: The task-local data interface no longer uses @, and keys are
-        no longer function pointers.
-      * std: The `swap_unwrap` method of `Option` renamed to `take_unwrap`.
-      * std: Added `SharedPort` to `comm`.
-      * std: `Eq` has a default method for `ne`; only `eq` is required
-        in implementations.
-      * std: `Ord` has default methods for `le`, `gt` and `le`; only `lt`
-        is required in implementations.
-      * std: `is_utf8` performance is improved, impacting many string functions.
-      * std: `os::MemoryMap` provides cross-platform mmap.
-      * std: `ptr::offset` is now unsafe, but also more optimized. Offsets that
-        are not 'in-bounds' are considered undefined.
-      * std: Many freestanding functions in `vec` removed in favor of methods.
-      * std: Many freestanding functions on scalar types removed in favor of
-        methods.
-      * std: Many options to task builders were removed since they don't make
-        sense in the new scheduler design.
-      * std: More containers implement `FromIterator` so can be created by the
-        `collect` method.
-      * std: More complete atomic types in `unstable::atomics`.
-      * std: `comm::PortSet` removed.
-      * std: Mutating methods in the `Set` and `Map` traits have been moved into
-        the `MutableSet` and `MutableMap` traits. `Container::is_empty`,
-        `Map::contains_key`, `MutableMap::insert`, and `MutableMap::remove` have
-        default implementations.
-      * extra: `dlist`, the doubly-linked list was modernized.
-      * extra: Added a `hex` module with `ToHex` and `FromHex` traits.
-      * extra: Added `glob` module, replacing `std::os::glob`.
-      * extra: `rope` was removed.
-      * extra: `deque` was renamed to `ringbuf`. `RingBuf` implements `Deque`.
-      * extra: `net`, and `timer` were removed. The experimental replacements
-        are `std::rt::io::net` and `std::rt::io::timer`.
-      * extra: Iterators implemented for `SmallIntMap`.
-      * extra: Iterators implemented for `Bitv` and `BitvSet`.
-      * extra: `SmallIntSet` removed. Use `BitvSet`.
-      * extra: Performance of JSON parsing greatly improved.
-      * extra: `semver` updated to SemVer 2.0.0.
-      * extra: `term` handles more terminals correctly.
-      * extra: `dbg` module removed.
-
-   * Other
-      * rustc's debug info generation (`-Z debug-info`) is greatly improved.
-      * rustc accepts `--target-cpu` to compile to a specific CPU architecture,
-        similarly to gcc's `--march` flag.
-      * rustpkg has received many improvements.
-      * rustpkg supports git tags as package IDs.
-      * rustpkg builds into target-specific directories so it can be used for
-        cross-compiling.
-      * The number of concurrent test tasks is controlled by the environment
-        variable RUST_TEST_TASKS.
-      * The test harness can now report metrics for benchmarks.
-      * All tools have man pages.
-      * Programs compiled with `--test` now support the `-h` and `--help` flags.
-      * The runtime uses jemalloc for allocations.
-      * Segmented stacks are temporarily disabled as part of the transition to
-        the new runtime. Stack overflows are possible!
-
 Version 0.7 (July 2013)
 -----------------------
 

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 \