---

yaml
---
r: 150853
b: refs/heads/try2
c: fbdde0e
h: refs/heads/master
i:
  150851: c257ea7
v: v3

Author: thehydroimpulse

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: ccccbd23680f317509a14ed7a4abb7f1969e78ae
+refs/heads/try2: fbdde0e7ba4edecd3411e6e7ec22324aed027a4e
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/man/rustc.1

@@ -182,7 +182,8 @@ rustdoc
 See <\fBhttps://github.com/mozilla/rust/issues\fR> for issues.
 
 .SH "AUTHOR"
-See \fBAUTHORS.txt\fR in the Rust source distribution.
+See \fBAUTHORS.txt\fR in the rust source distribution. Graydon Hoare
+<\fI[email protected]\fR> is the project leader.
 
 .SH "COPYRIGHT"
 This work is dual-licensed under Apache 2.0 and MIT terms.  See \fBCOPYRIGHT\fR

branches/try2/man/rustdoc.1

@@ -90,7 +90,8 @@ rustc
 See <\fBhttps://github.com/mozilla/rust/issues\fR> for issues.
 
 .SH "AUTHOR"
-See \fBAUTHORS.txt\fR in the Rust source distribution.
+See \fBAUTHORS.txt\fR in the rust source distribution. Graydon Hoare
+<\fI[email protected]\fR> is the project leader.
 
 .SH "COPYRIGHT"
 This work is dual-licensed under Apache 2.0 and MIT terms.  See \fBCOPYRIGHT\fR

branches/try2/mk/dist.mk

@@ -118,7 +118,7 @@ PKG_EXE = dist/$(PKG_NAME)-install.exe
 %.ico: $(S)src/etc/pkg/%.ico
 	cp $< $@
 
-$(PKG_EXE): rust.iss modpath.iss upgrade.iss LICENSE.txt rust-logo.ico \
+$(PKG_EXE): rust.iss modpath.iss LICENSE.txt rust-logo.ico \
             $(CSREQ3_T_$(CFG_BUILD)_H_$(CFG_BUILD)) \
             dist-prepare-win
 	$(CFG_PYTHON) $(S)src/etc/copy-runtime-deps.py tmp/dist/win/bin

branches/try2/mk/docs.mk

@@ -26,7 +26,7 @@
 # L10N_LANGS are the languages for which the docs have been
 # translated.
 ######################################################################
-DOCS := index intro tutorial guide-ffi guide-macros guide-lifetimes \
+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 \

branches/try2/mk/main.mk

@@ -349,44 +349,21 @@ EXTRAFLAGS_STAGE$(1) = $$(RUSTFLAGS_STAGE$(1))
 
 CFGFLAG$(1)_T_$(2)_H_$(3) = stage$(1)
 
-endef
-
-# Same macro/variables as above, but defined in a separate loop so it can use
-# all the varibles above for all archs. The RPATH_VAR setup sometimes needs to
-# reach across triples to get things in order.
-define SREQ_CMDS
-
-ifeq ($$(OSTYPE_$(3)),apple-darwin)
-  RPATH_VAR$(1)_T_$(2)_H_$(3) := \
-      DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
-else
-  RPATH_VAR$(1)_T_$(2)_H_$(3) := \
-      LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
-endif
-
 # Pass --cfg stage0 only for the build->host part of stage0;
 # if you're building a cross config, the host->* parts are
 # effectively stage1, since it uses the just-built stage0.
-#
-# This logic is similar to how the LD_LIBRARY_PATH variable must
-# change be slightly different when doing cross compilations.
-# The build doesn't copy over all target libraries into
-# a new directory, so we need to point the library path at
-# the build directory where all the target libraries came
-# from (the stage0 build host). Otherwise the relative rpaths
-# inside of the rustc binary won't get resolved correctly.
 ifeq ($(1),0)
 ifneq ($(strip $(CFG_BUILD)),$(strip $(3)))
 CFGFLAG$(1)_T_$(2)_H_$(3) = stage1
+endif
+endif
 
 ifeq ($$(OSTYPE_$(3)),apple-darwin)
   RPATH_VAR$(1)_T_$(2)_H_$(3) := \
-      DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(CURDIR)/$$(TLIB1_T_$(2)_H_$(CFG_BUILD))"
+      DYLD_LIBRARY_PATH="$$$$DYLD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
 else
   RPATH_VAR$(1)_T_$(2)_H_$(3) := \
-      LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(CURDIR)/$$(TLIB1_T_$(2)_H_$(CFG_BUILD))"
-endif
-endif
+      LD_LIBRARY_PATH="$$$$LD_LIBRARY_PATH:$$(CURDIR)/$$(HLIB$(1)_H_$(3))"
 endif
 
 STAGE$(1)_T_$(2)_H_$(3) := 						\
@@ -413,11 +390,6 @@ $(foreach build,$(CFG_HOST), \
   $(eval $(foreach stage,$(STAGES), \
    $(eval $(call SREQ,$(stage),$(target),$(build))))))))
 
-$(foreach build,$(CFG_HOST), \
- $(eval $(foreach target,$(CFG_TARGET), \
-  $(eval $(foreach stage,$(STAGES), \
-   $(eval $(call SREQ_CMDS,$(stage),$(target),$(build))))))))
-
 ######################################################################
 # rustc-H-targets
 #

branches/try2/mk/prepare.mk

@@ -20,7 +20,13 @@
 #   PREPARE_TARGETS - the target triples, space separated
 #   PREPARE_DEST_DIR - the directory to put the image
 
+
+# On windows we install from stage3, but on unix only stage2
+ifdef CFG_WINDOWSY_$(CFG_BUILD)
+PREPARE_STAGE=3
+else
 PREPARE_STAGE=2
+endif
 
 DEFAULT_PREPARE_DIR_CMD = umask 022 && mkdir -p
 DEFAULT_PREPARE_BIN_CMD = install -m755

branches/try2/src/doc/complement-lang-faq.md

@@ -27,7 +27,7 @@ Some examples that demonstrate different aspects of the language:
 
 You may also be interested in browsing [GitHub's Rust][github-rust] page.
 
-[github-rust]: https://github.com/trending?l=rust
+[github-rust]: https://github.com/languages/Rust
 
 ## Does it run on Windows?
 
@@ -141,14 +141,8 @@ export RUST_LOG=hello
 ./hello
 ```
 
-**Long answer** RUST_LOG takes a 'logging spec' that consists of a
-comma-separated list of paths, where a path consists of the crate name and
-sequence of module names, each separated by double-colons. For standalone .rs
-files the crate is implicitly named after the source file, so in the above
-example we were setting RUST_LOG to the name of the hello crate. Multiple paths
-can be combined to control the exact logging you want to see. For example, when
-debugging linking in the compiler you might set
-`RUST_LOG=rustc::metadata::creader,rustc::util::filesearch,rustc::back::rpath`
-For a full description see [the language reference][1].
+**Long answer** RUST_LOG takes a 'logging spec' that consists of a comma-separated list of paths, where a path consists of the crate name and sequence of module names, each separated by double-colons. For standalone .rs files the crate is implicitly named after the source file, so in the above example we were setting RUST_LOG to the name of the hello crate. Multiple paths can be combined to control the exact logging you want to see. For example, when debugging linking in the compiler you might set `RUST_LOG=rustc::metadata::creader,rustc::util::filesearch,rustc::back::rpath`
+
+If you aren't sure which paths you need, try setting RUST_LOG to `::help` and running your program. This will print a list of paths available for logging. For a full description see [the language reference][1].
 
 [1]:http://doc.rust-lang.org/doc/master/rust.html#logging-system

branches/try2/src/doc/guide-ffi.md

@@ -11,16 +11,14 @@ snappy includes a C interface (documented in
 The following is a minimal example of calling a foreign function which will
 compile if snappy is installed:
 
-~~~~
+~~~~ {.ignore}
 extern crate libc;
 use libc::size_t;
 
 #[link(name = "snappy")]
-# #[cfg(ignore_this)]
 extern {
     fn snappy_max_compressed_length(source_length: size_t) -> size_t;
 }
-# unsafe fn snappy_max_compressed_length(a: size_t) -> size_t { a }
 
 fn main() {
     let x = unsafe { snappy_max_compressed_length(100) };
@@ -80,11 +78,7 @@ vectors as pointers to memory. Rust's vectors are guaranteed to be a contiguous
 length is number of elements currently contained, and the capacity is the total size in elements of
 the allocated memory. The length is less than or equal to the capacity.
 
-~~~~
-# extern crate libc;
-# use libc::{c_int, size_t};
-# unsafe fn snappy_validate_compressed_buffer(_: *u8, _: size_t) -> c_int { 0 }
-# fn main() {}
+~~~~ {.ignore}
 pub fn validate_compressed_buffer(src: &[u8]) -> bool {
     unsafe {
         snappy_validate_compressed_buffer(src.as_ptr(), src.len() as size_t) == 0
@@ -104,20 +98,14 @@ required capacity to hold the compressed output. The vector can then be passed t
 `snappy_compress` function as an output parameter. An output parameter is also passed to retrieve
 the true length after compression for setting the length.
 
-~~~~
-# extern crate libc;
-# use libc::{size_t, c_int};
-# unsafe fn snappy_compress(a: *u8, b: size_t, c: *mut u8,
-#                           d: *mut size_t) -> c_int { 0 }
-# unsafe fn snappy_max_compressed_length(a: size_t) -> size_t { a }
-# fn main() {}
-pub fn compress(src: &[u8]) -> Vec<u8> {
+~~~~ {.ignore}
+pub fn compress(src: &[u8]) -> ~[u8] {
     unsafe {
         let srclen = src.len() as size_t;
         let psrc = src.as_ptr();
 
         let mut dstlen = snappy_max_compressed_length(srclen);
-        let mut dst = Vec::with_capacity(dstlen as uint);
+        let mut dst = slice::with_capacity(dstlen as uint);
         let pdst = dst.as_mut_ptr();
 
         snappy_compress(psrc, srclen, pdst, &mut dstlen);
@@ -130,26 +118,16 @@ pub fn compress(src: &[u8]) -> Vec<u8> {
 Decompression is similar, because snappy stores the uncompressed size as part of the compression
 format and `snappy_uncompressed_length` will retrieve the exact buffer size required.
 
-~~~~
-# extern crate libc;
-# use libc::{size_t, c_int};
-# unsafe fn snappy_uncompress(compressed: *u8,
-#                             compressed_length: size_t,
-#                             uncompressed: *mut u8,
-#                             uncompressed_length: *mut size_t) -> c_int { 0 }
-# unsafe fn snappy_uncompressed_length(compressed: *u8,
-#                                      compressed_length: size_t,
-#                                      result: *mut size_t) -> c_int { 0 }
-# fn main() {}
-pub fn uncompress(src: &[u8]) -> Option<Vec<u8>> {
+~~~~ {.ignore}
+pub fn uncompress(src: &[u8]) -> Option<~[u8]> {
     unsafe {
         let srclen = src.len() as size_t;
         let psrc = src.as_ptr();
 
         let mut dstlen: size_t = 0;
         snappy_uncompressed_length(psrc, srclen, &mut dstlen);
 
-        let mut dst = Vec::with_capacity(dstlen as uint);
+        let mut dst = slice::with_capacity(dstlen as uint);
         let pdst = dst.as_mut_ptr();
 
         if snappy_uncompress(psrc, srclen, pdst, &mut dstlen) == 0 {
@@ -209,19 +187,16 @@ A basic example is:
 
 Rust code:
 
-~~~~
+~~~~ {.ignore}
 extern fn callback(a:i32) {
     println!("I'm called from C with value {0}", a);
 }
 
 #[link(name = "extlib")]
-# #[cfg(ignore)]
 extern {
-   fn register_callback(cb: extern fn(i32)) -> i32;
+   fn register_callback(cb: extern "C" fn(i32)) -> i32;
    fn trigger_callback();
 }
-# unsafe fn register_callback(cb: extern fn(i32)) -> i32 { 0 }
-# unsafe fn trigger_callback() { }
 
 fn main() {
     unsafe {
@@ -265,39 +240,33 @@ referenced Rust object.
 
 Rust code:
 
-~~~~
+~~~~ {.ignore}
 
 struct RustObject {
     a: i32,
     // other members
 }
 
-extern fn callback(target: *mut RustObject, a:i32) {
+extern fn callback(target: *RustObject, a:i32) {
     println!("I'm called from C with value {0}", a);
-    unsafe {
-        // Update the value in RustObject with the value received from the callback
-        (*target).a = a;
-    }
+    (*target).a = a; // Update the value in RustObject with the value received from the callback
 }
 
 #[link(name = "extlib")]
-# #[cfg(ignore)]
 extern {
-   fn register_callback(target: *mut RustObject,
-                        cb: extern fn(*mut RustObject, i32)) -> i32;
+   fn register_callback(target: *RustObject, cb: extern "C" fn(*RustObject, i32)) -> i32;
    fn trigger_callback();
 }
-# unsafe fn register_callback(a: *mut RustObject,
-#                             b: extern fn(*mut RustObject, i32)) -> i32 { 0 }
-# unsafe fn trigger_callback() {}
 
 fn main() {
     // Create the object that will be referenced in the callback
-    let mut rust_object = ~RustObject{ a: 5 };
+    let rust_object = ~RustObject{a: 5, ...};
 
     unsafe {
-        register_callback(&mut *rust_object, callback);
-        trigger_callback();
+        // Gets a raw pointer to the object
+        let target_addr:*RustObject = ptr::to_unsafe_ptr(rust_object);
+        register_callback(target_addr, callback);
+        trigger_callback(); // Triggers the callback
     }
 }
 ~~~~
@@ -434,15 +403,13 @@ Foreign APIs often export a global variable which could do something like track
 global state. In order to access these variables, you declare them in `extern`
 blocks with the `static` keyword:
 
-~~~
+~~~{.ignore}
 extern crate libc;
 
 #[link(name = "readline")]
-# #[cfg(ignore)]
 extern {
     static rl_readline_version: libc::c_int;
 }
-# static rl_readline_version: libc::c_int = 0;
 
 fn main() {
     println!("You have readline version {} installed.",
@@ -454,23 +421,21 @@ Alternatively, you may need to alter global state provided by a foreign
 interface. To do this, statics can be declared with `mut` so rust can mutate
 them.
 
-~~~
+~~~{.ignore}
 extern crate libc;
 use std::ptr;
 
 #[link(name = "readline")]
-# #[cfg(ignore)]
 extern {
     static mut rl_prompt: *libc::c_char;
 }
-# static mut rl_prompt: *libc::c_char = 0 as *libc::c_char;
 
 fn main() {
-    "[my-awesome-shell] $".with_c_str(|buf| {
+    do "[my-awesome-shell] $".as_c_str |buf| {
         unsafe { rl_prompt = buf; }
         // get a line, process it
         unsafe { rl_prompt = ptr::null(); }
-    });
+    }
 }
 ~~~
 

branches/try2/src/doc/guide-macros.md

@@ -407,7 +407,7 @@ As an example, `loop` and `for-loop` labels (discussed in the lifetimes guide)
 will not clash. The following code will print "Hello!" only once:
 
 ~~~
-#![feature(macro_rules)]
+#[feature(macro_rules)];
 
 macro_rules! loop_x (
     ($e: expr) => (

branches/try2/src/doc/guide-pointers.md

@@ -250,7 +250,7 @@ struct.
 # Managed Pointers
 
 > **Note**: the `@` form of managed pointers is deprecated and behind a
-> feature gate (it requires a `#![feature(managed_pointers)]` attribute on
+> feature gate (it requires a `#[feature(managed_pointers)];` attribute on
 > the crate root; remember the semicolon!). There are replacements, currently 
 > there is `std::rc::Rc` and `std::gc::Gc` for shared ownership via reference
 > counting and garbage collection respectively.

branches/try2/src/doc/guide-testing.md

@@ -185,7 +185,7 @@ amount.
 For example:
 
 ~~~
-# #![allow(unused_imports)]
+# #[allow(unused_imports)];
 extern crate test;
 
 use std::slice;
@@ -247,7 +247,7 @@ recognize that some calculation has no external effects and remove
 it entirely.
 
 ~~~
-# #![allow(unused_imports)]
+# #[allow(unused_imports)];
 extern crate test;
 use test::Bencher;