---

yaml
---
r: 95463
b: refs/heads/dist-snap
c: cf844ab
h: refs/heads/master
i:
  95461: a07871c
  95459: 54e2f53
  95455: e2af7ec
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 532ab94c4b5e1f111cbf75d4aa20c78a88759b2e
+refs/heads/dist-snap: cf844abced94b74913985c7cffb6bd0b9a9b3445
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/Makefile.in

@@ -440,6 +440,7 @@ CSREQ$(1)_T_$(2)_H_$(3) = \
 	$$(TSREQ$(1)_T_$(2)_H_$(3)) \
 	$$(HBIN$(1)_H_$(3))/rustpkg$$(X_$(3)) \
 	$$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3)) \
+	$$(HBIN$(1)_H_$(3))/rusti$$(X_$(3)) \
 	$$(HLIB$(1)_H_$(3))/$(CFG_LIBRUSTPKG_$(3)) \
 	$$(HLIB$(1)_H_$(3))/$(CFG_LIBRUSTDOC_$(3)) \
 	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_STDLIB_$(2)) \

branches/dist-snap/src/librustc/middle/trans/_match.rs

@@ -1917,7 +1917,7 @@ fn trans_match_inner(scope_cx: @mut Block,
             Infallible
         }
     };
-    let lldiscr = discr_datum.to_ref_llval(bcx);
+    let lldiscr = discr_datum.to_zeroable_ref_llval(bcx);
     compile_submatch(bcx, matches, [lldiscr], chk);
 
     let mut arm_cxs = ~[];
@@ -1996,7 +1996,7 @@ pub fn store_local(bcx: @mut Block,
                 if bcx.sess().asm_comments() {
                     add_comment(bcx, "creating zeroable ref llval");
                 }
-                let llptr = init_datum.to_ref_llval(bcx);
+                let llptr = init_datum.to_zeroable_ref_llval(bcx);
                 return bind_irrefutable_pat(bcx, pat, llptr, BindLocal);
             }
         }

branches/dist-snap/src/librustc/middle/trans/datum.rs

@@ -473,25 +473,38 @@ impl Datum {
                     C_null(type_of::type_of(bcx.ccx(), self.ty).ptr_to())
                 } else {
                     let slot = alloc_ty(bcx, self.ty, "");
-                    // The store created here can be modified through a reference, for example:
-                    //
-                    //     // free the old allocation, and change the pointer to a new allocation
-                    //     fn foo(x: &mut ~u8) {
-                    //         *x = ~5;
-                    //     }
-                    //
-                    //     foo(&mut ~5);
                     Store(bcx, self.val, slot);
-                    // The old cleanup needs to be cancelled, in order for the destructor to observe
-                    // any changes made through the reference.
-                    self.cancel_clean(bcx);
-                    add_clean_temp_mem(bcx, slot, self.ty);
                     slot
                 }
             }
         }
     }
 
+    pub fn to_zeroable_ref_llval(&self, bcx: @mut Block) -> ValueRef {
+        /*!
+         * Returns a by-ref llvalue that can be zeroed in order to
+         * cancel cleanup. This is a kind of hokey bridge used
+         * to adapt to the match code. Please don't use it for new code.
+         */
+
+        match self.mode {
+            // All by-ref datums are zeroable, even if we *could* just
+            // cancel the cleanup.
+            ByRef(_) => self.val,
+
+            // By value datums can't be zeroed (where would you store
+            // the zero?) so we have to spill them. Add a temp cleanup
+            // for this spilled value and cancel the cleanup on this
+            // current value.
+            ByValue => {
+                let slot = self.to_ref_llval(bcx);
+                self.cancel_clean(bcx);
+                add_clean_temp_mem(bcx, slot, self.ty);
+                slot
+            }
+        }
+    }
+
     pub fn appropriate_mode(&self, ccx: &mut CrateContext) -> DatumMode {
         /*! See the `appropriate_mode()` function */
 

branches/dist-snap/src/librustdoc/html/format.rs

@@ -115,12 +115,7 @@ impl fmt::Default for clean::Path {
 fn resolved_path(w: &mut io::Writer, id: ast::NodeId, p: &clean::Path,
                  print_all: bool) {
     path(w, p, print_all,
-        |_cache, loc| {
-            match p.segments[0].name.as_slice() {
-                "super" => Some("../".repeat(loc.len() - 1)),
-                _ => Some("../".repeat(loc.len())),
-            }
-        },
+        |_cache, loc| { Some("../".repeat(loc.len())) },
         |cache| {
             match cache.paths.find(&id) {
                 None => None,

branches/dist-snap/src/librustdoc/html/render.rs

@@ -44,6 +44,7 @@ use std::rt::io::file::{FileInfo, DirectoryInfo};
 use std::rt::io::file;
 use std::rt::io;
 use std::rt::io::Reader;
+use std::os;
 use std::str;
 use std::task;
 use std::unstable::finally::Finally;
@@ -686,7 +687,15 @@ impl Context {
             Process(Context, clean::Item),
         }
         enum Progress { JobNew, JobDone }
-        static WORKERS: int = 10;
+
+        let workers = match os::getenv("RUSTDOC_WORKERS") {
+            Some(s) => {
+                match from_str::<uint>(s) {
+                    Some(n) => n, None => fail2!("{} not a number", s)
+                }
+            }
+            None => 10,
+        };
 
         let mut item = match crate.module.take() {
             Some(i) => i,
@@ -706,7 +715,7 @@ impl Context {
         // using the same channel/port. Through this, the crate is recursed on
         // in a hierarchical fashion, and parallelization is only achieved if
         // one node in the hierarchy has more than one child (very common).
-        for i in range(0, WORKERS) {
+        for i in range(0, workers) {
             let port = port.clone();
             let chan = chan.clone();
             let prog_chan = prog_chan.clone();
@@ -761,7 +770,7 @@ impl Context {
             if jobs == 0 { break }
         }
 
-        for _ in range(0, WORKERS) {
+        for _ in range(0, workers) {
             chan.send(Die);
         }
     }