---

yaml
---
r: 163230
b: refs/heads/snap-stage3
c: 4a46f5e
h: refs/heads/master
v: v3

Author: tbu-

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 9146a919b616e39e528e4d7100d16eef52f1f852
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 2d90b91b5d2d18cd433a9e6f1944b685f8b4bb04
+refs/heads/snap-stage3: 4a46f5ebde5ab6a9a219f8b99eafefb61de2286a
 refs/heads/try: 20cbbffeefc1f35e2ea63afce7b42fbd79611d42
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/mk/dist.mk

@@ -48,6 +48,7 @@ PKG_FILES := \
     $(S)configure $(S)Makefile.in              \
     $(S)man                                    \
     $(addprefix $(S)src/,                      \
+      README.md                                \
       compiletest                              \
       doc                                      \
       driver                                   \

branches/snap-stage3/src/etc/unicode.py

@@ -283,7 +283,11 @@ def load_east_asian_width(want_widths, except_cats):
     return widths
 
 def escape_char(c):
-    return "'\\u{%x}'" % c
+    if c <= 0x7f:
+        return "'\\x%2.2x'" % c
+    if c <= 0xffff:
+        return "'\\u%4.4x'" % c
+    return "'\\U%8.8x'" % c
 
 def emit_bsearch_range_table(f):
     f.write("""
@@ -373,8 +377,8 @@ def emit_conversions_module(f, lowerupper, upperlower):
             else if key < c { Less }
             else { Greater }
         }) {
-            slice::BinarySearchResult::Found(i) => Some(i),
-            slice::BinarySearchResult::NotFound(_) => None,
+            slice::Found(i) => Some(i),
+            slice::NotFound(_) => None,
         }
     }
 
@@ -388,7 +392,6 @@ def emit_conversions_module(f, lowerupper, upperlower):
 def emit_grapheme_module(f, grapheme_table, grapheme_cats):
     f.write("""pub mod grapheme {
     use core::slice::SlicePrelude;
-    use core::kinds::Copy;
     pub use self::GraphemeCat::*;
     use core::slice;
 
@@ -400,20 +403,18 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats):
         f.write("        GC_" + cat + ",\n")
     f.write("""    }
 
-    impl Copy for GraphemeCat {}
-
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, GraphemeCat)]) -> GraphemeCat {
         use core::cmp::Ordering::{Equal, Less, Greater};
         match r.binary_search(|&(lo, hi, _)| {
             if lo <= c && c <= hi { Equal }
             else if hi < c { Less }
             else { Greater }
         }) {
-            slice::BinarySearchResult::Found(idx) => {
+            slice::Found(idx) => {
                 let (_, _, cat) = r[idx];
                 cat
             }
-            slice::BinarySearchResult::NotFound(_) => GC_Any
+            slice::NotFound(_) => GC_Any
         }
     }
 
@@ -442,11 +443,11 @@ def emit_charwidth_module(f, width_table):
             else if hi < c { Less }
             else { Greater }
         }) {
-            slice::BinarySearchResult::Found(idx) => {
+            slice::Found(idx) => {
                 let (_, _, r_ncjk, r_cjk) = r[idx];
                 if is_cjk { r_cjk } else { r_ncjk }
             }
-            slice::BinarySearchResult::NotFound(_) => 1
+            slice::NotFound(_) => 1
         }
     }
 """)
@@ -539,11 +540,11 @@ def comp_pfun(char):
             else if hi < c { Less }
             else { Greater }
         }) {
-            slice::BinarySearchResult::Found(idx) => {
+            slice::Found(idx) => {
                 let (_, _, result) = r[idx];
                 result
             }
-            slice::BinarySearchResult::NotFound(_) => 0
+            slice::NotFound(_) => 0
         }
     }\n
 """)
@@ -612,7 +613,7 @@ def optimize_width_table(wtable):
             unicode_version = re.search(pattern, readme.read()).groups()
         rf.write("""
 /// The version of [Unicode](http://www.unicode.org/)
-/// that the `UnicodeChar` and `UnicodeStrPrelude` traits are based on.
+/// that the `UnicodeChar` and `UnicodeStrSlice` traits are based on.
 pub const UNICODE_VERSION: (uint, uint, uint) = (%s, %s, %s);
 """ % unicode_version)
         (canon_decomp, compat_decomp, gencats, combines,

branches/snap-stage3/src/libcollections/binary_heap.rs

@@ -15,7 +15,7 @@
 //! complexity. A priority queue can also be converted to a sorted vector in-place, allowing it to
 //! be used for an `O(n log n)` in-place heapsort.
 //!
-//! # Examples
+//! # Example
 //!
 //! This is a larger example which implements [Dijkstra's algorithm][dijkstra]
 //! to solve the [shortest path problem][sssp] on a [directed graph][dir_graph].
@@ -180,7 +180,7 @@ impl<T: Ord> Default for BinaryHeap<T> {
 impl<T: Ord> BinaryHeap<T> {
     /// Creates an empty `BinaryHeap` as a max-heap.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -194,7 +194,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// so that the `BinaryHeap` does not have to be reallocated
     /// until it contains at least that many values.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -208,7 +208,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// Creates a `BinaryHeap` from a vector. This is sometimes called
     /// `heapifying` the vector.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -227,7 +227,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// An iterator visiting all values in underlying vector, in
     /// arbitrary order.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -247,7 +247,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// the binary heap in arbitrary order.  The binary heap cannot be used
     /// after calling this.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -266,7 +266,7 @@ impl<T: Ord> BinaryHeap<T> {
 
     /// Returns the greatest item in a queue, or `None` if it is empty.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -286,7 +286,7 @@ impl<T: Ord> BinaryHeap<T> {
 
     /// Returns the number of elements the queue can hold without reallocating.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -308,7 +308,7 @@ impl<T: Ord> BinaryHeap<T> {
     ///
     /// Panics if the new capacity overflows `uint`.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -327,7 +327,7 @@ impl<T: Ord> BinaryHeap<T> {
     ///
     /// Panics if the new capacity overflows `uint`.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -350,7 +350,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// Removes the greatest item from a queue and returns it, or `None` if it
     /// is empty.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -377,7 +377,7 @@ impl<T: Ord> BinaryHeap<T> {
 
     /// Pushes an item onto the queue.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -400,7 +400,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// Pushes an item onto a queue then pops the greatest item off the queue in
     /// an optimized fashion.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -426,7 +426,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// an optimized fashion. The push is done regardless of whether the queue
     /// was empty.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -452,7 +452,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// Consumes the `BinaryHeap` and returns the underlying vector
     /// in arbitrary order.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -470,7 +470,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// Consumes the `BinaryHeap` and returns a vector in sorted
     /// (ascending) order.
     ///
-    /// # Examples
+    /// # Example
     ///
     /// ```
     /// use std::collections::BinaryHeap;