---

yaml
---
r: 81908
b: refs/heads/master
c: d96dfc9
h: refs/heads/master
v: v3

Author: klutzy

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 3165ddeb408cb4caf42fb48954dce4a82e3b4200
+refs/heads/master: d96dfc9a59db75323536916e78befea69e85d5ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/.gitattributes

@@ -4,7 +4,6 @@
 *.cpp rust
 *.h rust
 *.rs rust
-src/etc/pkg/rust-logo.ico binary
 src/rt/msvc/* -whitespace
 src/rt/vg/* -whitespace
 src/rt/linenoise/* -whitespace

trunk/RELEASES.txt

@@ -1,7 +1,7 @@
-Version 0.8 (September 2013)
+Version 0.8 (October 2013)
 --------------------------
 
-   * ~2200 changes, numerous bugfixes
+   * ~2100 changes, numerous bugfixes
 
    * Language
       * The `for` loop syntax has changed to work with the `Iterator` trait.

trunk/configure

@@ -684,7 +684,7 @@ do
       isaac linenoise sync test \
       arch/i386 arch/x86_64 arch/arm arch/mips  \
       libuv libuv/src/ares libuv/src/eio libuv/src/ev \
-      jemalloc sundown/src sundown/html
+      jemalloc
     do
       make_dir $t/rt/stage$s/$i
     done

trunk/mk/rt.mk

@@ -82,16 +82,7 @@ RUNTIME_CXXS_$(1)_$(2) := \
               rt/rust_android_dummy.cpp \
               rt/rust_test_helpers.cpp
 
-RUNTIME_CS_$(1)_$(2) := rt/linenoise/linenoise.c \
-			rt/linenoise/utf8.c \
-			rt/sundown/src/autolink.c \
-			rt/sundown/src/buffer.c \
-			rt/sundown/src/stack.c \
-			rt/sundown/src/markdown.c \
-			rt/sundown/html/houdini_href_e.c \
-			rt/sundown/html/houdini_html_e.c \
-			rt/sundown/html/html_smartypants.c \
-			rt/sundown/html/html.c
+RUNTIME_CS_$(1)_$(2) := rt/linenoise/linenoise.c rt/linenoise/utf8.c
 
 RUNTIME_S_$(1)_$(2) := rt/arch/$$(HOST_$(1))/_context.S \
 			rt/arch/$$(HOST_$(1))/ccall.S \
@@ -126,8 +117,6 @@ RUNTIME_DEF_$(1)_$(2) := $$(RT_OUTPUT_DIR_$(1))/rustrt$$(CFG_DEF_SUFFIX_$(1))
 RUNTIME_INCS_$(1)_$(2) := -I $$(S)src/rt -I $$(S)src/rt/isaac -I $$(S)src/rt/uthash \
                      -I $$(S)src/rt/arch/$$(HOST_$(1)) \
                      -I $$(S)src/rt/linenoise \
-                     -I $$(S)src/rt/sundown/src \
-                     -I $$(S)src/rt/sundown/html \
                      -I $$(S)src/libuv/include
 RUNTIME_OBJS_$(1)_$(2) := $$(RUNTIME_CXXS_$(1)_$(2):rt/%.cpp=$$(RT_BUILD_DIR_$(1)_$(2))/%.o) \
                      $$(RUNTIME_CS_$(1)_$(2):rt/%.c=$$(RT_BUILD_DIR_$(1)_$(2))/%.o) \

trunk/mk/tests.mk

@@ -227,9 +227,8 @@ ALL_CS := $(wildcard $(S)src/rt/*.cpp \
                      $(S)src/rt/*/*/*.cpp \
                      $(S)src/rustllvm/*.cpp)
 ALL_CS := $(filter-out $(S)src/rt/miniz.cpp \
-		       $(wildcard $(S)src/rt/linenoise/*.c) \
-		       $(wildcard $(S)src/rt/sundown/src/*.c) \
-		       $(wildcard $(S)src/rt/sundown/html/*.c) \
+                       $(S)src/rt/linenoise/linenoise.c \
+                       $(S)src/rt/linenoise/utf8.c \
 	,$(ALL_CS))
 ALL_HS := $(wildcard $(S)src/rt/*.h \
                      $(S)src/rt/*/*.h \
@@ -242,8 +241,6 @@ ALL_HS := $(filter-out $(S)src/rt/vg/valgrind.h \
                        $(S)src/rt/msvc/inttypes.h \
                        $(S)src/rt/linenoise/linenoise.h \
                        $(S)src/rt/linenoise/utf8.h \
-		       $(wildcard $(S)src/rt/sundown/src/*.h) \
-		       $(wildcard $(S)src/rt/sundown/html/*.h) \
 	,$(ALL_HS))
 
 # Run the tidy script in multiple parts to avoid huge 'echo' commands

trunk/src/etc/pkg/rust-logo.ico

@@ -17,7 +17,7 @@
  * In this example, a large vector of floats is shared between several tasks.
  * With simple pipes, without Arc, a copy would have to be made for each task.
  *
- * ```rust
+ * ~~~ {.rust}
  * extern mod std;
  * use extra::arc;
  * let numbers=vec::from_fn(100, |ind| (ind as float)*rand::random());
@@ -34,7 +34,7 @@
  *           // Work with the local numbers
  *       }
  *   }
- * ```
+ * ~~~
  */
 
 #[allow(missing_doc)];
@@ -440,7 +440,7 @@ impl<T:Freeze + Send> RWArc<T> {
      *
      * # Example
      *
-     * ```rust
+     * ~~~ {.rust}
      * do arc.write_downgrade |mut write_token| {
      *     do write_token.write_cond |state, condvar| {
      *         ... exclusive access with mutable state ...
@@ -450,7 +450,7 @@ impl<T:Freeze + Send> RWArc<T> {
      *         ... shared access with immutable state ...
      *     }
      * }
-     * ```
+     * ~~~
      */
     pub fn write_downgrade<U>(&self, blk: &fn(v: RWWriteMode<T>) -> U) -> U {
         unsafe {

trunk/src/libextra/arc.rs

@@ -13,19 +13,19 @@ use std::str;
 
 /// Available encoding character sets
 pub enum CharacterSet {
-    /// The standard character set (uses `+` and `/`)
+    /// The standard character set (uses '+' and '/')
     Standard,
-    /// The URL safe character set (uses `-` and `_`)
+    /// The URL safe character set (uses '-' and '_')
     UrlSafe
 }
 
-/// Contains configuration parameters for `to_base64`.
+/// Contains configuration parameters for to_base64
 pub struct Config {
     /// Character set to use
     char_set: CharacterSet,
-    /// True to pad output with `=` characters
+    /// True to pad output with '=' characters
     pad: bool,
-    /// `Some(len)` to wrap lines at `len`, `None` to disable line wrapping
+    /// Some(len) to wrap lines at len, None to disable line wrapping
     line_length: Option<uint>
 }
 
@@ -62,15 +62,15 @@ impl<'self> ToBase64 for &'self [u8] {
      *
      * # Example
      *
-     * ```rust
+     * ~~~ {.rust}
      * extern mod extra;
      * use extra::base64::{ToBase64, standard};
      *
      * fn main () {
      *     let str = [52,32].to_base64(standard);
      *     printfln!("%s", str);
      * }
-     * ```
+     * ~~~
      */
     fn to_base64(&self, config: Config) -> ~str {
         let bytes = match config.char_set {
@@ -170,7 +170,7 @@ impl<'self> FromBase64 for &'self str {
      *
      * This converts a string literal to base64 and back.
      *
-     * ```rust
+     * ~~~ {.rust}
      * extern mod extra;
      * use extra::base64::{ToBase64, FromBase64, standard};
      * use std::str;
@@ -183,7 +183,7 @@ impl<'self> FromBase64 for &'self str {
      *     let result_str = str::from_utf8(bytes);
      *     printfln!("%s", result_str);
      * }
-     * ```
+     * ~~~
      */
     fn from_base64(&self) -> Result<~[u8], ~str> {
         let mut r = ~[];

trunk/src/libextra/base64.rs

@@ -116,7 +116,7 @@ struct BigBitv {
 }
 
 /**
- * A mask that has a 1 for each defined bit in the n'th element of a `BigBitv`,
+ * a mask that has a 1 for each defined bit in the nth element of a big_bitv,
  * assuming n bits.
  */
 #[inline]
@@ -284,7 +284,7 @@ impl Bitv {
      * Calculates the union of two bitvectors
      *
      * Sets `self` to the union of `self` and `v1`. Both bitvectors must be
-     * the same length. Returns `true` if `self` changed.
+     * the same length. Returns 'true' if `self` changed.
     */
     #[inline]
     pub fn union(&mut self, v1: &Bitv) -> bool { self.do_op(Union, v1) }
@@ -293,7 +293,7 @@ impl Bitv {
      * Calculates the intersection of two bitvectors
      *
      * Sets `self` to the intersection of `self` and `v1`. Both bitvectors
-     * must be the same length. Returns `true` if `self` changed.
+     * must be the same length. Returns 'true' if `self` changed.
     */
     #[inline]
     pub fn intersect(&mut self, v1: &Bitv) -> bool {
@@ -395,7 +395,7 @@ impl Bitv {
         self.do_op(Difference, v)
     }
 
-    /// Returns `true` if all bits are 1
+    /// Returns true if all bits are 1
     #[inline]
     pub fn is_true(&self) -> bool {
       match self.rep {
@@ -417,7 +417,7 @@ impl Bitv {
         self.iter().invert()
     }
 
-    /// Returns `true` if all bits are 0
+    /// Returns true if all bits are 0
     pub fn is_false(&self) -> bool {
       match self.rep {
         Small(ref b) => b.is_false(self.nbits),
@@ -433,18 +433,18 @@ impl Bitv {
     }
 
     /**
-     * Converts `self` to a vector of `uint` with the same length.
+     * Converts `self` to a vector of uint with the same length.
      *
-     * Each `uint` in the resulting vector has either value `0u` or `1u`.
+     * Each uint in the resulting vector has either value 0u or 1u.
      */
     pub fn to_vec(&self) -> ~[uint] {
         vec::from_fn(self.nbits, |x| self.init_to_vec(x))
     }
 
     /**
      * Organise the bits into bytes, such that the first bit in the
-     * `Bitv` becomes the high-order bit of the first byte. If the
-     * size of the `Bitv` is not a multiple of 8 then trailing bits
+     * bitv becomes the high-order bit of the first byte. If the
+     * size of the bitv is not a multiple of 8 then trailing bits
      * will be filled-in with false/0
      */
     pub fn to_bytes(&self) -> ~[u8] {
@@ -472,7 +472,7 @@ impl Bitv {
     }
 
     /**
-     * Transform `self` into a `[bool]` by turning each bit into a `bool`.
+     * Transform self into a [bool] by turning each bit into a bool
      */
     pub fn to_bools(&self) -> ~[bool] {
         vec::from_fn(self.nbits, |i| self[i])
@@ -498,7 +498,7 @@ impl Bitv {
 
 
     /**
-     * Compare a bitvector to a vector of `bool`.
+     * Compare a bitvector to a vector of bool.
      *
      * Both the bitvector and vector must have the same length.
      */
@@ -519,9 +519,9 @@ impl Bitv {
 }
 
 /**
- * Transform a byte-vector into a `Bitv`. Each byte becomes 8 bits,
+ * Transform a byte-vector into a bitv. Each byte becomes 8 bits,
  * with the most significant bits of each byte coming first. Each
- * bit becomes `true` if equal to 1 or `false` if equal to 0.
+ * bit becomes true if equal to 1 or false if equal to 0.
  */
 pub fn from_utf8(bytes: &[u8]) -> Bitv {
     from_fn(bytes.len() * 8, |i| {
@@ -532,15 +532,15 @@ pub fn from_utf8(bytes: &[u8]) -> Bitv {
 }
 
 /**
- * Transform a `[bool]` into a `Bitv` by converting each `bool` into a bit.
+ * Transform a [bool] into a bitv by converting each bool into a bit.
  */
 pub fn from_bools(bools: &[bool]) -> Bitv {
     from_fn(bools.len(), |i| bools[i])
 }
 
 /**
- * Create a `Bitv` of the specified length where the value at each
- * index is `f(index)`.
+ * Create a bitv of the specified length where the value at each
+ * index is f(index).
  */
 pub fn from_fn(len: uint, f: &fn(index: uint) -> bool) -> Bitv {
     let mut bitv = Bitv::new(len, false);
@@ -571,7 +571,7 @@ fn iterate_bits(base: uint, bits: uint, f: &fn(uint) -> bool) -> bool {
     return true;
 }
 
-/// An iterator for `Bitv`.
+/// An iterator for Bitv
 pub struct BitvIterator<'self> {
     priv bitv: &'self Bitv,
     priv next_idx: uint,
@@ -631,12 +631,12 @@ impl<'self> RandomAccessIterator<bool> for BitvIterator<'self> {
 ///
 /// It should also be noted that the amount of storage necessary for holding a
 /// set of objects is proportional to the maximum of the objects when viewed
-/// as a `uint`.
+/// as a uint.
 #[deriving(Clone)]
 pub struct BitvSet {
     priv size: uint,
 
-    // In theory this is a `Bitv` instead of always a `BigBitv`, but knowing that
+    // In theory this is a Bitv instead of always a BigBitv, but knowing that
     // there's an array of storage makes our lives a whole lot easier when
     // performing union/intersection/etc operations
     priv bitv: BigBitv
@@ -861,7 +861,7 @@ impl MutableSet<uint> for BitvSet {
 }
 
 impl BitvSet {
-    /// Visits each of the words that the two bit vectors (`self` and `other`)
+    /// Visits each of the words that the two bit vectors (self and other)
     /// both have in common. The three yielded arguments are (bit location,
     /// w1, w2) where the bit location is the number of bits offset so far,
     /// and w1/w2 are the words coming from the two vectors self, other.
@@ -874,13 +874,13 @@ impl BitvSet {
             .map(|((i, &w), o_store)| (i * uint::bits, w, o_store[i]))
     }
 
-    /// Visits each word in `self` or `other` that extends beyond the other. This
+    /// Visits each word in self or other that extends beyond the other. This
     /// will only iterate through one of the vectors, and it only iterates
     /// over the portion that doesn't overlap with the other one.
     ///
-    /// The yielded arguments are a `bool`, the bit offset, and a word. The `bool`
-    /// is true if the word comes from `self`, and `false` if it comes from
-    /// `other`.
+    /// The yielded arguments are a bool, the bit offset, and a word. The bool
+    /// is true if the word comes from 'self', and false if it comes from
+    /// 'other'.
     fn outlier_iter<'a>(&'a self, other: &'a BitvSet)
         -> Map<'static, ((uint, &'a uint), uint), (bool, uint, uint),
                Zip<Enumerate<vec::VecIterator<'a, uint>>, Repeat<uint>>> {

trunk/src/libextra/bitv.rs

@@ -26,7 +26,8 @@ Rust extras are part of the standard Rust distribution.
        url = "https://github.com/mozilla/rust/tree/master/src/libextra")];
 
 #[doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
-      html_favicon_url = "http://www.rust-lang.org/favicon.ico")];
+      html_favicon_url = "http://www.rust-lang.org/favicon.ico",
+      passes = "strip-hidden")];
 
 #[comment = "Rust extras"];
 #[license = "MIT/ASL2"];

trunk/src/libextra/extra.rs

@@ -25,7 +25,7 @@ ports and channels.
 
 This example sends boxed integers across tasks using serialization.
 
-```rust
+~~~ {.rust}
 let (port, chan) = serial::pipe_stream();
 
 do task::spawn || {
@@ -37,7 +37,7 @@ do task::spawn || {
 for i in range(0, 10) {
     assert @i == port.recv()
 }
- ```
+~~~
 
 # Safety Note
 

trunk/src/libextra/flatpipes.rs

@@ -14,13 +14,13 @@
  *
  * # Example
  *
- * ```rust
+ * ~~~ {.rust}
  * # fn fib(n: uint) -> uint {42};
  * # fn make_a_sandwich() {};
  * let mut delayed_fib = extra::future::spawn (|| fib(5000) );
  * make_a_sandwich();
  * printfln!("fib(5000) = %?", delayed_fib.get())
- * ```
+ * ~~~
  */
 
 #[allow(missing_doc)];