---

yaml
---
r: 89958
b: refs/heads/master
c: 0036f7b
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 61e07d67924e26ec232312633e5c4ab6b954ea17
+refs/heads/master: 0036f7bbba5d14f5c019098ed0d30f06da045840
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8

trunk/configure

@@ -520,20 +520,14 @@ then
     fi
 fi
 
-BIN_SUF=
-if [ $CFG_OSTYPE = "pc-mingw32" ]
-then
-    BIN_SUF=.exe
-fi
-
 if [ ! -z "$CFG_ENABLE_LOCAL_RUST" ]
 then
-    if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} ]
+    if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc ]
     then
         err "no local rust to use"
     else
-        LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} --version`
-        step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: $LRV"
+        LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc --version`
+        step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: " $LRV
     fi
 fi
 

trunk/doc/rust.md

@@ -1131,8 +1131,9 @@ block.
 let fptr: extern "C" fn() -> ~[int] = new_vec;
 ~~~~
 
-Extern functions may be called directly from Rust code as Rust uses large,
-contiguous stack segments like C.
+Extern functions may be called from Rust code, but
+caution must be taken with respect to the size of the stack
+segment, just as when calling an extern function normally.
 
 ### Type definitions
 
@@ -3596,9 +3597,9 @@ and releases them back to its environment when they are no longer needed.
 The default implementation of the service-provider interface
 consists of the C runtime functions `malloc` and `free`.
 
-The runtime memory-management system, in turn, supplies Rust tasks with
-facilities for allocating releasing stacks, as well as allocating and freeing
-heap data.
+The runtime memory-management system, in turn, supplies Rust tasks
+with facilities for allocating, extending and releasing stacks,
+as well as allocating and freeing heap data.
 
 ### Built in types
 
@@ -3761,6 +3762,7 @@ have come and gone during the course of Rust's development:
 
 Additional specific influences can be seen from the following languages:
 
+* The stack-growth implementation of Go.
 * The structural algebraic types and compilation manager of SML.
 * The attribute and assembly systems of C#.
 * The references and deterministic destructor system of C++.

trunk/src/etc/local_stage0.sh

@@ -3,8 +3,8 @@
 TARG_DIR=$1
 PREFIX=$2
 
-LIB_DIR=lib
-LIB_PREFIX=lib
+BINDIR=bin
+LIBDIR=lib
 
 OS=`uname -s`
 case $OS in
@@ -21,8 +21,7 @@ case $OS in
     (*)
 	BIN_SUF=.exe
 	LIB_SUF=.dll
-	LIB_DIR=bin
-	LIB_PREFIX=
+	LIBDIR=bin
 	break
 	;;
 esac
@@ -32,7 +31,7 @@ if [ -z $PREFIX ]; then
     exit 1
 fi
 
-if [ ! -e ${PREFIX}/bin/rustc${BIN_SUF} ]; then
+if [ ! -e ${PREFIX}/bin/rustc ]; then
     echo "No local rust installed at ${PREFIX}"
     exit 1
 fi
@@ -42,9 +41,9 @@ if [ -z $TARG_DIR ]; then
     exit 1
 fi
 
-cp ${PREFIX}/bin/rustc${BIN_SUF} ${TARG_DIR}/stage0/bin/
-cp ${PREFIX}/${LIB_DIR}/rustc/${TARG_DIR}/${LIB_DIR}/* ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}extra*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}rust*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}std*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
-cp ${PREFIX}/${LIB_DIR}/${LIB_PREFIX}syntax*${LIB_SUF} ${TARG_DIR}/stage0/${LIB_DIR}/
+cp ${PREFIX}/bin/rustc ${TARG_DIR}/stage0/bin/
+cp ${PREFIX}/lib/rustc/${TARG_DIR}/${LIBDIR}/* ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/libextra*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/librust*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/libstd*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/
+cp ${PREFIX}/lib/libsyntax*${LIB_SUF} ${TARG_DIR}/stage0/${LIBDIR}/

trunk/src/librustdoc/html/render.rs

@@ -466,14 +466,15 @@ impl DocFolder for Cache {
         // Register any generics to their corresponding string. This is used
         // when pretty-printing types
         match item.inner {
-            clean::StructItem(ref s)   => self.generics(&s.generics),
-            clean::EnumItem(ref e)     => self.generics(&e.generics),
-            clean::FunctionItem(ref f) => self.generics(&f.generics),
-            clean::TypedefItem(ref t)  => self.generics(&t.generics),
-            clean::TraitItem(ref t)    => self.generics(&t.generics),
-            clean::ImplItem(ref i)     => self.generics(&i.generics),
-            clean::TyMethodItem(ref i) => self.generics(&i.generics),
-            clean::MethodItem(ref i)   => self.generics(&i.generics),
+            clean::StructItem(ref s)          => self.generics(&s.generics),
+            clean::EnumItem(ref e)            => self.generics(&e.generics),
+            clean::FunctionItem(ref f)        => self.generics(&f.generics),
+            clean::TypedefItem(ref t)         => self.generics(&t.generics),
+            clean::TraitItem(ref t)           => self.generics(&t.generics),
+            clean::ImplItem(ref i)            => self.generics(&i.generics),
+            clean::TyMethodItem(ref i)        => self.generics(&i.generics),
+            clean::MethodItem(ref i)          => self.generics(&i.generics),
+            clean::ForeignFunctionItem(ref f) => self.generics(&f.generics),
             _ => {}
         }
 

trunk/src/libstd/ptr.rs

@@ -155,7 +155,7 @@ pub unsafe fn replace_ptr<T>(dest: *mut T, mut src: T) -> T {
  * Reads the value from `*src` and returns it. Does not copy `*src`.
  */
 #[inline(always)]
-pub unsafe fn read_ptr<T>(src: *T) -> T {
+pub unsafe fn read_ptr<T>(src: *mut T) -> T {
     let mut tmp: T = intrinsics::uninit();
     copy_nonoverlapping_memory(&mut tmp, src, 1);
     tmp
@@ -168,7 +168,7 @@ pub unsafe fn read_ptr<T>(src: *T) -> T {
 #[inline(always)]
 pub unsafe fn read_and_zero_ptr<T>(dest: *mut T) -> T {
     // Copy the data out from `dest`:
-    let tmp = read_ptr(&*dest);
+    let tmp = read_ptr(dest);
 
     // Now zero out `dest`:
     zero_memory(dest, 1);

trunk/src/libstd/vec.rs

@@ -1527,7 +1527,7 @@ impl<T> OwnedVector<T> for ~[T] {
                 let valptr = ptr::to_mut_unsafe_ptr(&mut self[ln - 1u]);
                 unsafe {
                     raw::set_len(self, ln - 1u);
-                    Some(ptr::read_ptr(&*valptr))
+                    Some(ptr::read_ptr(valptr))
                 }
             }
         }