---

yaml
---
r: 92923
b: refs/heads/auto
c: f42a36c
h: refs/heads/master
i:
  92921: 8b78ef5
  92919: 78d799f
v: v3

Author: fhahn

[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: c29b1be5edcb56f221b0a54653f62147069b41a4
+refs/heads/auto: f42a36cded2ac71e36b2572c54da0fc623af2eca
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/RELEASES.txt

@@ -1,156 +1,10 @@
-Version 0.9 (January 2014)
+Version 0.9 (XXX 2013)
 --------------------------
 
-   * ~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.
+   * ~XXX changes, numerous bugfixes
 
    * Tooling
-      * 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.
+      * The `rust` and `rusti` commands have been removed, due to lack of maintenance.
 
 Version 0.8 (September 2013)
 --------------------------

branches/auto/configure

@@ -591,7 +591,7 @@ then
     LLVM_VERSION=$($LLVM_CONFIG --version)
 
     case $LLVM_VERSION in
-        (3.[2-4]svn|3.[2-4])
+        (3.3|3.3svn|3.2|3.2svn)
             msg "found ok version of LLVM: $LLVM_VERSION"
             ;;
         (*)

branches/auto/doc/rust.md

@@ -3806,6 +3806,25 @@ 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/auto/src/libextra/ebml.rs

@@ -122,9 +122,11 @@ 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::from_be32;
+        use std::unstable::intrinsics::bswap32;
 
         if data.len() - start < 4 {
             return vuint_at_slow(data, start);
@@ -134,7 +136,7 @@ pub mod reader {
             let (ptr, _): (*u8, uint) = transmute(data);
             let ptr = offset(ptr, start as int);
             let ptr: *i32 = transmute(ptr);
-            let val = from_be32(*ptr);
+            let val = bswap32(*ptr);
             let val: u32 = transmute(val);
             if (val & 0x80000000) != 0 {
                 Res {
@@ -160,6 +162,11 @@ 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() }
     }