---

yaml
---
r: 118575
b: refs/heads/try
c: 7613c9d
h: refs/heads/master
i:
  118573: 63fdbb3
  118571: 02c2ab0
  118567: 3097e2a
  118559: 64f3426
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: b1646cbfd908dc948b251e362669af421100647a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d6736a1440d42f6af967a8a20ab8d73522112b72
-refs/heads/try: cc30abbcad282634fb99089eb9297e7cc4f26729
+refs/heads/try: 7613c9dd59aa771bf02a00c77af0ba4266392373
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/etc/licenseck.py

@@ -42,7 +42,6 @@
     "libsync/spsc_queue.rs", # BSD
     "libsync/mpmc_bounded_queue.rs", # BSD
     "libsync/mpsc_intrusive.rs", # BSD
-    "test/bench/shootout-binarytrees.rs", # BSD
     "test/bench/shootout-fannkuch-redux.rs", # BSD
     "test/bench/shootout-meteor.rs", # BSD
     "test/bench/shootout-pidigits.rs", # BSD

branches/try/src/liballoc/heap.rs

@@ -9,7 +9,8 @@
 // except according to those terms.
 
 // FIXME: #13994: port to the sized deallocation API when available
-// FIXME: #13996: mark the `allocate` and `reallocate` return value as `noalias` and `nonnull`
+// FIXME: #13996: mark the `allocate` and `reallocate` return value as `noalias`
+//                and `nonnull`
 
 use core::intrinsics::{abort, cttz32};
 use core::option::{None, Option};
@@ -23,7 +24,8 @@ use libc::{c_char, c_int, c_void, size_t};
 extern {
     fn je_mallocx(size: size_t, flags: c_int) -> *mut c_void;
     fn je_rallocx(ptr: *mut c_void, size: size_t, flags: c_int) -> *mut c_void;
-    fn je_xallocx(ptr: *mut c_void, size: size_t, extra: size_t, flags: c_int) -> size_t;
+    fn je_xallocx(ptr: *mut c_void, size: size_t, extra: size_t,
+                  flags: c_int) -> size_t;
     fn je_dallocx(ptr: *mut c_void, flags: c_int);
     fn je_nallocx(size: size_t, flags: c_int) -> size_t;
     fn je_malloc_stats_print(write_cb: Option<extern "C" fn(cbopaque: *mut c_void, *c_char)>,
@@ -42,8 +44,9 @@ fn mallocx_align(a: uint) -> c_int { unsafe { cttz32(a as u32) as c_int } }
 
 /// Return a pointer to `size` bytes of memory.
 ///
-/// Behavior is undefined if the requested size is 0 or the alignment is not a power of 2. The
-/// alignment must be no larger than the largest supported page size on the platform.
+/// Behavior is undefined if the requested size is 0 or the alignment is not a
+/// power of 2. The alignment must be no larger than the largest supported page
+/// size on the platform.
 #[inline]
 pub unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
     let ptr = je_mallocx(size as size_t, mallocx_align(align)) as *mut u8;
@@ -53,62 +56,73 @@ pub unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
     ptr
 }
 
-/// Extend or shrink the allocation referenced by `ptr` to `size` bytes of memory.
+/// Extend or shrink the allocation referenced by `ptr` to `size` bytes of
+/// memory.
 ///
-/// Behavior is undefined if the requested size is 0 or the alignment is not a power of 2. The
-/// alignment must be no larger than the largest supported page size on the platform.
+/// Behavior is undefined if the requested size is 0 or the alignment is not a
+/// power of 2. The alignment must be no larger than the largest supported page
+/// size on the platform.
 ///
-/// The `old_size` and `align` parameters are the parameters that were used to create the
-/// allocation referenced by `ptr`. The `old_size` parameter may also be the value returned by
-/// `usable_size` for the requested size.
+/// The `old_size` and `align` parameters are the parameters that were used to
+/// create the allocation referenced by `ptr`. The `old_size` parameter may also
+/// be the value returned by `usable_size` for the requested size.
 #[inline]
 #[allow(unused_variable)] // for the parameter names in the documentation
-pub unsafe fn reallocate(ptr: *mut u8, size: uint, align: uint, old_size: uint) -> *mut u8 {
-    let ptr = je_rallocx(ptr as *mut c_void, size as size_t, mallocx_align(align)) as *mut u8;
+pub unsafe fn reallocate(ptr: *mut u8, size: uint, align: uint,
+                         old_size: uint) -> *mut u8 {
+    let ptr = je_rallocx(ptr as *mut c_void, size as size_t,
+                         mallocx_align(align)) as *mut u8;
     if ptr.is_null() {
         abort()
     }
     ptr
 }
 
-/// Extend or shrink the allocation referenced by `ptr` to `size` bytes of memory in-place.
+/// Extend or shrink the allocation referenced by `ptr` to `size` bytes of
+/// memory in-place.
 ///
-/// Return true if successful, otherwise false if the allocation was not altered.
+/// Return true if successful, otherwise false if the allocation was not
+/// altered.
 ///
-/// Behavior is undefined if the requested size is 0 or the alignment is not a power of 2. The
-/// alignment must be no larger than the largest supported page size on the platform.
+/// Behavior is undefined if the requested size is 0 or the alignment is not a
+/// power of 2. The alignment must be no larger than the largest supported page
+/// size on the platform.
 ///
 /// The `old_size` and `align` parameters are the parameters that were used to
 /// create the allocation referenced by `ptr`. The `old_size` parameter may be
 /// any value in range_inclusive(requested_size, usable_size).
 #[inline]
 #[allow(unused_variable)] // for the parameter names in the documentation
-pub unsafe fn reallocate_inplace(ptr: *mut u8, size: uint, align: uint, old_size: uint) -> bool {
-    je_xallocx(ptr as *mut c_void, size as size_t, 0, mallocx_align(align)) == size as size_t
+pub unsafe fn reallocate_inplace(ptr: *mut u8, size: uint, align: uint,
+                                 old_size: uint) -> bool {
+    je_xallocx(ptr as *mut c_void, size as size_t, 0,
+               mallocx_align(align)) == size as size_t
 }
 
 /// Deallocate the memory referenced by `ptr`.
 ///
 /// The `ptr` parameter must not be null.
 ///
-/// The `size` and `align` parameters are the parameters that were used to create the
-/// allocation referenced by `ptr`. The `size` parameter may also be the value returned by
-/// `usable_size` for the requested size.
+/// The `size` and `align` parameters are the parameters that were used to
+/// create the allocation referenced by `ptr`. The `size` parameter may also be
+/// the value returned by `usable_size` for the requested size.
 #[inline]
 #[allow(unused_variable)] // for the parameter names in the documentation
 pub unsafe fn deallocate(ptr: *mut u8, size: uint, align: uint) {
     je_dallocx(ptr as *mut c_void, mallocx_align(align))
 }
 
-/// Return the usable size of an allocation created with the specified the `size` and `align`.
+/// Return the usable size of an allocation created with the specified the
+/// `size` and `align`.
 #[inline]
 pub fn usable_size(size: uint, align: uint) -> uint {
     unsafe { je_nallocx(size as size_t, mallocx_align(align)) as uint }
 }
 
 /// Print implementation-defined allocator statistics.
 ///
-/// These statistics may be inconsistent if other threads use the allocator during the call.
+/// These statistics may be inconsistent if other threads use the allocator
+/// during the call.
 #[unstable]
 pub fn stats_print() {
     unsafe {
@@ -145,7 +159,8 @@ unsafe fn exchange_free(ptr: *mut u8, size: uint, align: uint) {
 #[lang="closure_exchange_malloc"]
 #[inline]
 #[allow(deprecated)]
-unsafe fn closure_exchange_malloc(drop_glue: fn(*mut u8), size: uint, align: uint) -> *mut u8 {
+unsafe fn closure_exchange_malloc(drop_glue: fn(*mut u8), size: uint,
+                                  align: uint) -> *mut u8 {
     let total_size = util::get_box_size(size, align);
     let p = allocate(total_size, 8);
 

branches/try/src/test/bench/shootout-binarytrees.rs

@@ -1,42 +1,12 @@
-// The Computer Language Benchmarks Game
-// http://benchmarksgame.alioth.debian.org/
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
 //
-// contributed by the Rust Project Developers
-
-// Copyright (c) 2012-2014 The Rust Project Developers
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-// - Redistributions of source code must retain the above copyright
-//   notice, this list of conditions and the following disclaimer.
-//
-// - Redistributions in binary form must reproduce the above copyright
-//   notice, this list of conditions and the following disclaimer in
-//   the documentation and/or other materials provided with the
-//   distribution.
-//
-// - Neither the name of "The Computer Language Benchmarks Game" nor
-//   the name of "The Computer Language Shootout Benchmarks" nor the
-//   names of its contributors may be used to endorse or promote
-//   products derived from this software without specific prior
-//   written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
 
 extern crate arena;