---

yaml
---
r: 105399
b: refs/heads/master
c: 8b6592e
h: refs/heads/master
i:
  105397: 763b6fa
  105395: 4641d26
  105391: 8810cf8
v: v3

Author: sinistersnare

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 9e89ffc60e4a72dd0e6e9b1930111235b18e595e
+refs/heads/master: 8b6592ef1a29360716e49545cff42d7103366b02
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b8601a3d8b91ad3b653d143307611f2f5c75617e
 refs/heads/try: db814977d07bd798feb24f6b74c00800ef458a13

trunk/mk/clean.mk

@@ -78,7 +78,6 @@ define CLEAN_HOST_STAGE_N
 clean$(1)_H_$(2):							    \
 	    $$(foreach crate,$$(CRATES),clean$(1)_H_$(2)-lib-$$(crate))	    \
 	    $$(foreach tool,$$(TOOLS),clean$(1)_H_$(2)-tool-$$(tool))
-	$$(Q)rm -fr $(2)/rt/libbacktrace
 
 clean$(1)_H_$(2)-tool-%:
 	$$(Q)rm -f $$(HBIN$(1)_H_$(2))/$$*$$(X_$(2))

trunk/mk/crates.mk

@@ -37,7 +37,7 @@
 #
 #   DEPS_<crate>
 #	These lists are the dependencies of the <crate> that is to be built.
-#	Rust dependencies are listed bare (i.e. std, green) and native
+#	Rust dependencies are listed bare (i.e. std, extra, green) and native
 #	dependencies have a "native:" prefix (i.e. native:sundown). All deps
 #	will be built before the crate itself is built.
 #
@@ -49,26 +49,26 @@
 # automatically generated for all stage/host/target combinations.
 ################################################################################
 
-TARGET_CRATES := std green rustuv native flate arena glob term semver \
-                 uuid serialize sync getopts collections num test time rand \
-		 workcache url log
+TARGET_CRATES := std extra green rustuv native flate arena glob term semver \
+                 uuid serialize sync getopts collections num test time rand
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
 DEPS_std := native:rustrt native:compiler-rt native:backtrace
+DEPS_extra := std term sync serialize getopts collections time rand
 DEPS_green := std rand native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
-DEPS_syntax := std term serialize collections log
+DEPS_syntax := std term serialize collections
 DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \
-              collections time log
+              collections time extra
 DEPS_rustdoc := rustc native:sundown serialize sync getopts collections \
                 test time
-DEPS_flate := std native:miniz
+DEPS_flate := std extra native:miniz
 DEPS_arena := std collections
 DEPS_glob := std
-DEPS_serialize := std collections log
+DEPS_serialize := std collections
 DEPS_term := std collections
 DEPS_semver := std
 DEPS_uuid := std serialize rand
@@ -78,12 +78,9 @@ DEPS_collections := std rand
 DEPS_fourcc := syntax std
 DEPS_hexfloat := syntax std
 DEPS_num := std rand
-DEPS_test := std collections getopts serialize term time
+DEPS_test := std extra collections getopts serialize term
 DEPS_time := std serialize
 DEPS_rand := std
-DEPS_url := std collections
-DEPS_workcache := std serialize collections log
-DEPS_log := std sync
 
 TOOL_DEPS_compiletest := test green rustuv getopts
 TOOL_DEPS_rustdoc := rustdoc native

trunk/mk/docs.mk

@@ -29,8 +29,7 @@
 DOCS := index tutorial guide-ffi guide-macros guide-lifetimes \
 	guide-tasks guide-container guide-pointers guide-testing \
 	guide-runtime complement-bugreport complement-cheatsheet \
-	complement-lang-faq complement-project-faq rust rustdoc \
-	guide-unsafe
+	complement-lang-faq complement-project-faq rust rustdoc
 
 PDF_DOCS := tutorial rust
 

trunk/src/compiletest/compiletest.rs

@@ -9,16 +9,12 @@
 // except according to those terms.
 
 #[crate_type = "bin"];
-#[feature(phase)];
 
 #[allow(non_camel_case_types)];
 #[deny(warnings)];
-#[allow(deprecated_owned_vector)];
 
 extern crate test;
 extern crate getopts;
-#[phase(link, syntax)]
-extern crate log;
 
 use std::os;
 use std::io;

trunk/src/doc/guide-ffi.md

@@ -170,6 +170,85 @@ Foreign libraries often hand off ownership of resources to the calling code.
 When this occurs, we must use Rust's destructors to provide safety and guarantee
 the release of these resources (especially in the case of failure).
 
+As an example, we give a reimplementation of owned boxes by wrapping `malloc`
+and `free`:
+
+~~~~
+use std::cast;
+use std::libc::{c_void, size_t, malloc, free};
+use std::mem;
+use std::ptr;
+
+// Define a wrapper around the handle returned by the foreign code.
+// Unique<T> has the same semantics as ~T
+pub struct Unique<T> {
+    // It contains a single raw, mutable pointer to the object in question.
+    priv ptr: *mut T
+}
+
+// Implement methods for creating and using the values in the box.
+// NB: For simplicity and correctness, we require that T has kind Send
+// (owned boxes relax this restriction, and can contain managed (GC) boxes).
+// This is because, as implemented, the garbage collector would not know
+// about any shared boxes stored in the malloc'd region of memory.
+impl<T: Send> Unique<T> {
+    pub fn new(value: T) -> Unique<T> {
+        unsafe {
+            let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T;
+            assert!(!ptr.is_null());
+            // `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it
+            // move_val_init moves a value into this memory without
+            // attempting to drop the original value.
+            mem::move_val_init(&mut *ptr, value);
+            Unique{ptr: ptr}
+        }
+    }
+
+    // the 'r lifetime results in the same semantics as `&*x` with ~T
+    pub fn borrow<'r>(&'r self) -> &'r T {
+        unsafe { cast::copy_lifetime(self, &*self.ptr) }
+    }
+
+    // the 'r lifetime results in the same semantics as `&mut *x` with ~T
+    pub fn borrow_mut<'r>(&'r mut self) -> &'r mut T {
+        unsafe { cast::copy_mut_lifetime(self, &mut *self.ptr) }
+    }
+}
+
+// The key ingredient for safety, we associate a destructor with
+// Unique<T>, making the struct manage the raw pointer: when the
+// struct goes out of scope, it will automatically free the raw pointer.
+// NB: This is an unsafe destructor, because rustc will not normally
+// allow destructors to be associated with parametrized types, due to
+// bad interaction with managed boxes. (With the Send restriction,
+// we don't have this problem.)
+#[unsafe_destructor]
+impl<T: Send> Drop for Unique<T> {
+    fn drop(&mut self) {
+        unsafe {
+            let x = mem::uninit(); // dummy value to swap in
+            // We need to move the object out of the box, so that
+            // the destructor is called (at the end of this scope.)
+            ptr::replace(self.ptr, x);
+            free(self.ptr as *mut c_void)
+        }
+    }
+}
+
+// A comparison between the built-in ~ and this reimplementation
+fn main() {
+    {
+        let mut x = ~5;
+        *x = 10;
+    } // `x` is freed here
+
+    {
+        let mut y = Unique::new(5);
+        *y.borrow_mut() = 10;
+    } // `y` is freed here
+}
+~~~~
+
 # Callbacks from C code to Rust functions
 
 Some external libraries require the usage of callbacks to report back their

trunk/src/doc/guide-tasks.md

@@ -351,6 +351,8 @@ fn pnorm(nums: &~[f64], p: uint) -> f64 {
 
 fn main() {
     let numbers = vec::from_fn(1000000, |_| rand::random::<f64>());
+    println!("Inf-norm = {}",  *numbers.iter().max().unwrap());
+
     let numbers_arc = Arc::new(numbers);
 
     for num in range(1u, 10) {