---

yaml
---
r: 89234
b: refs/heads/snap-stage3
c: 3249de8
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: deeca5d586bfaa4aa60246f671a8d611d38f6248
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 645bb327dbd1fab65a87d2f0bd6ca8c3ec620422
+refs/heads/snap-stage3: 3249de8c4f5d4c7cf34a4bda5e98f047b6b72263
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/RELEASES.txt

@@ -1,10 +1,156 @@
-Version 0.9 (XXX 2013)
+Version 0.9 (January 2014)
 --------------------------
 
-   * ~XXX changes, numerous bugfixes
+   * ~1600 changes, numerous bugfixes
+
+   * Language
+      * The `float` type has been removed. Use `f32` or `f64` instead.
+      * A new facility for enabling experimental features (feature gating) has
+        been added, using the crate-level `#[feature(foo)]` attribute.
+      * Managed boxes (@) are now behind a feature gate
+        (`#[feature(managed_boxes)]`) in preperation for future removal. Use the
+        standard library's `Gc` or `Rc` types instead.
+      * `@mut` has been removed. Use `std::cell::{Cell, RefCell}` instead.
+      * Jumping back to the top of a loop is now done with `continue` instead of
+        `loop`.
+      * Strings can no longer be mutated through index assignment.
+      * Raw strings can be created via the basic `r"foo"` syntax or with matched
+        hash delimiters, as in `r###"foo"###`.
+      * `~fn` is now written `proc (args) -> retval { ... }` and may only be
+        called once.
+      * The `&fn` type is now written `|args| -> ret` to match the literal form.
+      * `@fn`s have been removed.
+      * `do` only works with procs in order to make it obvious what the cost
+        of `do` is.
+      * The `#[link(...)]` attribute has been replaced with
+        `#[crate_id = "name#vers"]`.
+      * Empty `impl`s must be terminated with empty braces and may not be
+        terminated with a semicolon.
+      * Keywords are no longer allowed as lifetime names; the `self` lifetime
+        no longer has any special meaning.
+      * The old `fmt!` string formatting macro has been removed.
+      * `printf!` and `printfln!` (old-style formatting) removed in favor of
+        `print!` and `println!`.
+      * `mut` works in patterns now, as in `let (mut x, y) = (1, 2);`.
+      * New reserved keywords: `alignof`, `offsetof`, `sizeof`.
+      * Macros can have attributes.
+      * Macros can expand to items with attributes.
+      * Macros can expand to multiple items.
+      * The `asm!` macro is feature-gated (`#[feature(asm)]`).
+      * Comments may be nested.
+      * Values automatically coerce to trait objects they implement, without
+        an explicit `as`.
+      * Enum discriminants are no longer an entire word but as small as needed to
+        contain all the variants. The `repr` attribute can be used to override
+        the discriminant size, as in `#[repr(int)]` for integer-sized, and
+        `#[repr(C)]` to match C enums.
+      * Non-string literals are not allowed in attributes (they never worked).
+      * The FFI now supports variadic functions.
+      * Octal numeric literals, as in `0o7777`.
+      * The `concat!` syntax extension performs compile-time string concatenation.
+      * The `#[fixed_stack_segment]` and `#[rust_stack]` attributes have been
+        removed as Rust no longer uses segmented stacks.
+      * Non-ascii identifiers are feature-gated (`#[feature(non_ascii_idents)]`).
+      * Ignoring all fields of an enum variant or tuple-struct is done with `..`,
+        not `*`; ignoring remaining fields of a struct is also done with `..`,
+        not `_`; ignoring a slice of a vector is done with `..`, not `.._`.
+      * `rustc` supports the "win64" calling convention via `extern "win64"`.
+      * `rustc` supports the "system" calling convention, which defaults to the
+        preferred convention for the target platform, "stdcall" on 32-bit Windows,
+        "C" elsewhere.
+      * The `type_overflow` lint (default: warn) checks literals for overflow.
+      * The `unsafe_block` lint (default: allow) checks for usage of `unsafe`.
+      * The `attribute_usage` lint (default: warn) warns about unknown
+        attributes.
+      * The `unknown_features` lint (default: warn) warns about unknown
+        feature gates.
+      * The `dead_code` lint (default: warn) checks for dead code.
+      * Rust libraries can be linked statically to one another
+      * `#[link_args]` is behind the `link_args` feature gate.
+      * Native libraries are now linked with `#[link(name = "foo")]`
+      * Native libraries can be statically linked to a rust crate
+        (`#[link(name = "foo", kind = "static")]`).
+      * Native OS X frameworks are now officially supported
+        (`#[link(name = "foo", kind = "framework")]`).
+      * The `#[thread_local]` attribute creates thread-local (not task-local)
+        variables. Currently behind the `thread_local` feature gate.
+      * The `return` keyword may be used in closures.
+      * Types that can be copied via a memcpy implement the `Pod` kind.
+
+   * Libraries
+      * std: The `option` and `result` API's have been overhauled to make them
+        simpler, more consistent, and more composable.
+      * std: The entire `std::io` module has been replaced with one that is
+        more comprehensive and that properly interfaces with the underlying
+        scheduler. File, TCP, UDP, Unix sockets, pipes, and timers are all
+        implemented.
+      * std: `io::util` contains a number of useful implementations of
+        `Reader` and `Writer`, including `NullReader`, `NullWriter`,
+        `ZeroReader`, `TeeReader`.
+      * std: The reference counted pointer type `extra::rc` moved into std.
+      * std: The `Gc` type in the `gc` module will replace `@` (it is currently
+        just a wrapper around it).
+      * std: `fmt::Default` can be implemented for any type to provide default
+        formatting to the `format!` macro, as in `format!("{}", myfoo)`.
+      * std: The `rand` API continues to be tweaked.
+      * std: Functions dealing with type size and alignment have moved from the
+        `sys` module to the `mem` module.
+      * std: The `path` module was written and API changed.
+      * std: `str::from_utf8` has been changed to cast instead of allocate.
+      * std: `starts_with` and `ends_with` methods added to vectors via the
+        `ImmutableEqVector` trait, which is in the prelude.
+      * std: Vectors can be indexed with the `get_opt` method, which returns `None`
+        if the index is out of bounds.
+      * std: Task failure no longer propagates between tasks, as the model was
+        complex, expensive, and incompatible with thread-based tasks.
+      * std: The `Any` type can be used for dynamic typing.
+      * std: `~Any` can be passed to the `fail!` macro and retrieved via
+        `task::try`.
+      * std: Methods that produce iterators generally do not have an `_iter`
+        suffix now.
+      * std: `cell::Cell` and `cell::RefCell` can be used to introduce mutability
+        roots (mutable fields, etc.). Use instead of e.g. `@mut`.
+      * std: `util::ignore` renamed to `prelude::drop`.
+      * std: Slices have `sort` and `sort_by` methods via the `MutableVector`
+        trait.
+      * std: `vec::raw` has seen a lot of cleanup and API changes.
+      * std: The standard library no longer includes any C++ code, and very
+        minimal C, eliminating the dependency on libstdc++.
+      * std: Runtime scheduling and I/O functionality has been factored out into
+        extensible interfaces and is now implemented by two different crates:
+        libnative, for native threading and I/O; and libgreen, for green threading
+        and I/O. This paves the way for using the standard library in more limited
+        embeded environments.
+      * std: The `comm` module has been rewritten to be much faster, have a
+        simpler, more consistent API, and to work for both native and green
+        threading.
+      * std: All libuv dependencies have been moved into the rustuv crate.
+      * native: New implementations of runtime scheduling on top of OS threads.
+      * native: New native implementations of TCP, UDP, file I/O, process spawning,
+        and other I/O.
+      * green: The green thread scheduler and message passing types are almost
+        entirely lock-free.
+      * extra: The `flatpipes` module had bitrotted and was removed.
+      * extra: All crypto functions have been removed and Rust now has a policy of
+        not reimplementing crypto in the standard library. In the future crypto
+        will be provided by external crates with bindings to established libraries.
+      * extra: `c_vec` has been modernized.
+      * extra: The `sort` module has been removed. Use the `sort` method on
+        mutable slices.
 
    * Tooling
-      * The `rust` and `rusti` commands have been removed, due to lack of maintenance.
+      * The `rust` and `rusti` commands have been removed, due to lack of
+        maintenance.
+      * `rustdoc` was completely rewritten.
+      * `rustdoc` can test code examples in documentation.
+      * `rustpkg` can test packages with the argument, 'test'.
+      * `rustpkg` supports arbitrary dependencies, including C libraries.
+      * `rustc`'s support for generating debug info is improved again.
+      * `rustc` has better error reporting for unbalanced delimiters.
+      * `rustc`'s JIT support was removed due to bitrot.
+      * Executables and static libraries can be built with LTO (-Z lto)
+      * `rustc` adds a `--dep-info` flag for communicating dependencies to
+        build tools.
 
 Version 0.8 (September 2013)
 --------------------------

branches/snap-stage3/doc/rust.md

@@ -3806,25 +3806,6 @@ As a convenience, the logging spec can also be set to a special pseudo-crate,
 `::help`. In this case, when the application starts, the runtime will
 simply output a list of loaded modules containing log expressions, then exit.
 
-The Rust runtime itself generates logging information. The runtime's logs are
-generated for a number of artificial modules in the `::rt` pseudo-crate,
-and can be enabled just like the logs for any standard module. The full list
-of runtime logging modules follows.
-
-* `::rt::mem` Memory management
-* `::rt::comm` Messaging and task communication
-* `::rt::task` Task management
-* `::rt::dom` Task scheduling
-* `::rt::trace` Unused
-* `::rt::cache` Type descriptor cache
-* `::rt::upcall` Compiler-generated runtime calls
-* `::rt::timer` The scheduler timer
-* `::rt::gc` Garbage collection
-* `::rt::stdlib` Functions used directly by the standard library
-* `::rt::kern` The runtime kernel
-* `::rt::backtrace` Log a backtrace on task failure
-* `::rt::callback` Unused
-
 #### Logging Expressions
 
 Rust provides several macros to log information. Here's a simple Rust program

branches/snap-stage3/src/driver/driver.rs

@@ -19,7 +19,4 @@ extern mod this = "rustdoc";
 #[cfg(rustc)]
 extern mod this = "rustc";
 
-#[cfg(rustdoc_ng)]
-extern mod this = "rustdoc_ng";
-
 fn main() { this::main() }

branches/snap-stage3/src/etc/emacs/rust-mode.el

@@ -54,7 +54,9 @@
     ;; We don't want to indent out to the open bracket if the
     ;; open bracket ends the line
     (when (not (looking-at "[[:blank:]]*\\(?://.*\\)?$"))
-      (when (looking-at "[[:space:]]") (forward-to-word 1))
+      (when (looking-at "[[:space:]]")
+	(forward-word 1)
+	(backward-word 1))
       (current-column))))
 
 (defun rust-mode-indent-line ()

branches/snap-stage3/src/libextra/ebml.rs

@@ -122,11 +122,9 @@ pub mod reader {
         fail!("vint too big");
     }
 
-    #[cfg(target_arch = "x86")]
-    #[cfg(target_arch = "x86_64")]
     pub fn vuint_at(data: &[u8], start: uint) -> Res {
         use std::ptr::offset;
-        use std::unstable::intrinsics::bswap32;
+        use std::unstable::intrinsics::from_be32;
 
         if data.len() - start < 4 {
             return vuint_at_slow(data, start);
@@ -136,7 +134,7 @@ pub mod reader {
             let (ptr, _): (*u8, uint) = transmute(data);
             let ptr = offset(ptr, start as int);
             let ptr: *i32 = transmute(ptr);
-            let val = bswap32(*ptr);
+            let val = from_be32(*ptr);
             let val: u32 = transmute(val);
             if (val & 0x80000000) != 0 {
                 Res {
@@ -162,11 +160,6 @@ pub mod reader {
         }
     }
 
-    #[cfg(not(target_arch = "x86"), not(target_arch = "x86_64"))]
-    pub fn vuint_at(data: &[u8], start: uint) -> Res {
-        vuint_at_slow(data, start)
-    }
-
     pub fn Doc<'a>(data: &'a [u8]) -> Doc<'a> {
         Doc { data: data, start: 0u, end: data.len() }
     }

branches/snap-stage3/src/libextra/time.rs

@@ -12,17 +12,16 @@
 
 use std::io::Reader;
 use std::io::mem::BufReader;
+use std::libc;
 use std::num;
 use std::str;
 
 static NSEC_PER_SEC: i32 = 1_000_000_000_i32;
 
-pub mod rustrt {
+mod rustrt {
     use super::Tm;
 
     extern {
-        pub fn rust_get_time(sec: &mut i64, nsec: &mut i32);
-        pub fn rust_precise_time_ns(ns: &mut u64);
         pub fn rust_tzset();
         pub fn rust_gmtime(sec: i64, nsec: i32, result: &mut Tm);
         pub fn rust_localtime(sec: i64, nsec: i32, result: &mut Tm);
@@ -31,6 +30,31 @@ pub mod rustrt {
     }
 }
 
+#[cfg(unix, not(target_os = "macos"))]
+mod imp {
+    use std::libc::{c_int, timespec};
+
+    // Apparently android provides this in some other library?
+    #[cfg(not(target_os = "android"))]
+    #[link(name = "rt")]
+    extern {}
+
+    extern {
+        pub fn clock_gettime(clk_id: c_int, tp: *mut timespec) -> c_int;
+    }
+
+}
+#[cfg(target_os = "macos")]
+mod imp {
+    use std::libc::{timeval, timezone, c_int, mach_timebase_info};
+
+    extern {
+        pub fn gettimeofday(tp: *mut timeval, tzp: *mut timezone) -> c_int;
+        pub fn mach_absolute_time() -> u64;
+        pub fn mach_timebase_info(info: *mut mach_timebase_info) -> c_int;
+    }
+}
+
 /// A record specifying a time value in seconds and nanoseconds.
 
 
@@ -64,11 +88,45 @@ impl Ord for Timespec {
  */
 pub fn get_time() -> Timespec {
     unsafe {
-        let mut sec = 0i64;
-        let mut nsec = 0i32;
-        rustrt::rust_get_time(&mut sec, &mut nsec);
+        let (sec, nsec) = os_get_time();
         return Timespec::new(sec, nsec);
     }
+
+    #[cfg(windows)]
+    unsafe fn os_get_time() -> (i64, i32) {
+        static NANOSECONDS_FROM_1601_TO_1970: u64 = 11644473600000000;
+
+        let mut time = libc::FILETIME {
+            dwLowDateTime: 0,
+            dwHighDateTime: 0,
+        };
+        libc::GetSystemTimeAsFileTime(&mut time);
+
+        // A FILETIME contains a 64-bit value representing the number of
+        // hectonanosecond (100-nanosecond) intervals since 1601-01-01T00:00:00Z.
+        // http://support.microsoft.com/kb/167296/en-us
+        let ns_since_1601 = ((time.dwHighDateTime as u64 << 32) |
+                             (time.dwLowDateTime  as u64 <<  0)) / 10;
+        let ns_since_1970 = ns_since_1601 - NANOSECONDS_FROM_1601_TO_1970;
+
+        ((ns_since_1970 / 1000000) as i64,
+         ((ns_since_1970 % 1000000) * 1000) as i32)
+    }
+
+    #[cfg(target_os = "macos")]
+    unsafe fn os_get_time() -> (i64, i32) {
+        use std::ptr;
+        let mut tv = libc::timeval { tv_sec: 0, tv_usec: 0 };
+        imp::gettimeofday(&mut tv, ptr::mut_null());
+        (tv.tv_sec as i64, tv.tv_usec * 1000)
+    }
+
+    #[cfg(not(target_os = "macos"), not(windows))]
+    unsafe fn os_get_time() -> (i64, i32) {
+        let mut tv = libc::timespec { tv_sec: 0, tv_nsec: 0 };
+        imp::clock_gettime(libc::CLOCK_REALTIME, &mut tv);
+        (tv.tv_sec as i64, tv.tv_nsec as i32)
+    }
 }
 
 
@@ -77,10 +135,38 @@ pub fn get_time() -> Timespec {
  * in nanoseconds since an unspecified epoch.
  */
 pub fn precise_time_ns() -> u64 {
-    unsafe {
-        let mut ns = 0u64;
-        rustrt::rust_precise_time_ns(&mut ns);
-        ns
+    return os_precise_time_ns();
+
+    #[cfg(windows)]
+    fn os_precise_time_ns() -> u64 {
+        let mut ticks_per_s = 0;
+        assert_eq!(unsafe {
+            libc::QueryPerformanceFrequency(&mut ticks_per_s)
+        }, 1);
+        let ticks_per_s = if ticks_per_s == 0 {1} else {ticks_per_s};
+        let mut ticks = 0;
+        assert_eq!(unsafe {
+            libc::QueryPerformanceCounter(&mut ticks)
+        }, 1);
+
+        return (ticks as u64 * 1000000000) / (ticks_per_s as u64);
+    }
+
+    #[cfg(target_os = "macos")]
+    fn os_precise_time_ns() -> u64 {
+        let time = unsafe { imp::mach_absolute_time() };
+        let mut info = libc::mach_timebase_info { numer: 0, denom: 0 };
+        unsafe { imp::mach_timebase_info(&mut info); }
+        return time * ((info.numer / info.denom) as u64);
+    }
+
+    #[cfg(not(windows), not(target_os = "macos"))]
+    fn os_precise_time_ns() -> u64 {
+        let mut ts = libc::timespec { tv_sec: 0, tv_nsec: 0 };
+        unsafe {
+            imp::clock_gettime(libc::CLOCK_MONOTONIC, &mut ts);
+        }
+        return (ts.tv_sec as u64) * 1000000000 + (ts.tv_nsec as u64)
     }
 }