---

yaml
---
r: 101790
b: refs/heads/master
c: 968633b
h: refs/heads/master
v: v3

Author: flaper87

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 94d453e459107ed1c5d76f693686b29d31cdc58c
+refs/heads/master: 968633b60ad7f2fd0c5663e92b06f2c9d21964a8
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/Makefile.in

@@ -125,7 +125,10 @@ ifdef TRACE
   CFG_RUSTC_FLAGS += -Z trace
 endif
 ifdef CFG_DISABLE_RPATH
-CFG_RUSTC_FLAGS += -C no-rpath
+# NOTE: make this CFG_RUSTC_FLAGS after stage0 snapshot
+RUSTFLAGS_STAGE1 += -C no-rpath
+RUSTFLAGS_STAGE2 += -C no-rpath
+RUSTFLAGS_STAGE3 += -C no-rpath
 endif
 
 # The executables crated during this compilation process have no need to include
@@ -137,7 +140,8 @@ endif
 # snapshot will be generated with a statically linked rustc so we only have to
 # worry about the distribution of one file (with its native dynamic
 # dependencies)
-RUSTFLAGS_STAGE0 += -C prefer-dynamic
+#
+# NOTE: after a snapshot (stage0), put this on stage0 as well
 RUSTFLAGS_STAGE1 += -C prefer-dynamic
 
 # platform-specific auto-configuration

trunk/mk/dist.mk

@@ -12,7 +12,7 @@ PKG_ICO = $(S)src/etc/pkg/rust-logo.ico
 PKG_EXE = $(PKG_DIR)-install.exe
 endif
 
-PKG_GITMODULES := $(S)src/libuv $(S)src/llvm $(S)src/gyp $(S)src/compiler-rt
+PKG_GITMODULES := $(S)src/libuv $(S)src/llvm $(S)src/gyp
 
 PKG_FILES := \
     $(S)COPYRIGHT                              \

trunk/mk/tests.mk

@@ -333,22 +333,21 @@ $(foreach host,$(CFG_HOST), \
 
 define TEST_RUNNER
 
-# If NO_REBUILD is set then break the dependencies on everything but
-# the source files so we can test crates without rebuilding any of the
-# parent crates.
+# If NO_REBUILD is set then break the dependencies on extra so we can
+# test crates without rebuilding std and extra first
 ifeq ($(NO_REBUILD),)
-TESTDEP_$(1)_$(2)_$(3)_$(4) = $$(SREQ$(1)_T_$(2)_H_$(3)) \
+STDTESTDEP_$(1)_$(2)_$(3)_$(4) = $$(SREQ$(1)_T_$(2)_H_$(3)) \
 			    $$(foreach crate,$$(TARGET_CRATES),\
-				$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate)) \
-				$$(CRATE_FULLDEPS_$(1)_T_$(2)_H_$(3)_$(4))
+				$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate))
 else
-TESTDEP_$(1)_$(2)_$(3)_$(4) = $$(RSINPUTS_$(4))
+STDTESTDEP_$(1)_$(2)_$(3)_$(4) =
 endif
 
 $(3)/stage$(1)/test/$(4)test-$(2)$$(X_$(2)): CFG_COMPILER = $(2)
 $(3)/stage$(1)/test/$(4)test-$(2)$$(X_$(2)):				\
-		$$(CRATEFILE_$(4)) \
-		$$(TESTDEP_$(1)_$(2)_$(3)_$(4))
+		$$(CRATEFILE_$(4))					\
+		$$(CRATE_FULLDEPS_$(1)_T_$(2)_H_$(3)_$(4))		\
+		$$(STDTESTDEP_$(1)_$(2)_$(3)_$(4))
 	@$$(call E, oxidize: $$@)
 	$$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< --test	\
 		-L "$$(RT_OUTPUT_DIR_$(2))"		\
@@ -685,22 +684,13 @@ $(foreach host,$(CFG_HOST), \
 
 define DEF_CRATE_DOC_TEST
 
-# If NO_REBUILD is set then break the dependencies on everything but
-# the source files so we can test crate documentation without
-# rebuilding any of the parent crates.
-ifeq ($(NO_REBUILD),)
-DOCTESTDEP_$(1)_$(2)_$(3)_$(4) = \
-	$$(TEST_SREQ$(1)_T_$(2)_H_$(3))				\
-	$$(CRATE_FULLDEPS_$(1)_T_$(2)_H_$(3)_$(4))		\
-	$$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3))
-else
-DOCTESTDEP_$(1)_$(2)_$(3)_$(4) = $$(RSINPUTS_$(4))
-endif
-
 check-stage$(1)-T-$(2)-H-$(3)-doc-$(4)-exec: $$(call TEST_OK_FILE,$(1),$(2),$(3),doc-$(4))
 
 ifeq ($(2),$$(CFG_BUILD))
-$$(call TEST_OK_FILE,$(1),$(2),$(3),doc-$(4)): $$(DOCTESTDEP_$(1)_$(2)_$(3)_$(4))
+$$(call TEST_OK_FILE,$(1),$(2),$(3),doc-$(4)):				\
+	        $$(TEST_SREQ$(1)_T_$(2)_H_$(3))				\
+		$$(CRATE_FULLDEPS_$(1)_T_$(2)_H_$(3)_$(4))		\
+		$$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3))
 	@$$(call E, run doc-$(4) [$(2)])
 	$$(Q)$$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3)) --test \
 	    $$(CRATEFILE_$(4)) --test-args "$$(TESTARGS)" && touch $$@

trunk/src/doc/guide-ffi.md

@@ -195,7 +195,7 @@ 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());
+            assert!(!ptr::is_null(ptr));
             // `*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.

trunk/src/doc/rust.md

@@ -1725,95 +1725,31 @@ mod bar {
 pub type int8_t = i8;
 ~~~~
 
-> **Note:** In future versions of Rust, user-provided extensions to the compiler
-> will be able to interpret attributes.  When this facility is provided, the
-> compiler will distinguish between language-reserved and user-available
-> attributes.
+> **Note:** In future versions of Rust, user-provided extensions to the compiler will be able to interpret attributes.
+> When this facility is provided, the compiler will distinguish between language-reserved and user-available attributes.
 
-At present, only the Rust compiler interprets attributes, so all attribute names
-are effectively reserved. Some significant attributes include:
+At present, only the Rust compiler interprets attributes, so all attribute
+names are effectively reserved. Some significant attributes include:
 
 * The `doc` attribute, for documenting code in-place.
-* The `cfg` attribute, for conditional-compilation by build-configuration (see
-  [Conditional compilation](#conditional-compilation)).
+* The `cfg` attribute, for conditional-compilation by build-configuration.
 * The `crate_id` attribute, for describing the package ID of a crate.
 * The `lang` attribute, for custom definitions of traits and functions that are
   known to the Rust compiler (see [Language items](#language-items)).
 * The `link` attribute, for describing linkage metadata for a extern blocks.
 * The `test` attribute, for marking functions as unit tests.
 * The `allow`, `warn`, `forbid`, and `deny` attributes, for
   controlling lint checks (see [Lint check attributes](#lint-check-attributes)).
-* The `deriving` attribute, for automatically generating implementations of
-  certain traits.
+* The `deriving` attribute, for automatically generating
+  implementations of certain traits.
 * The `inline` attribute, for expanding functions at caller location (see
   [Inline attributes](#inline-attributes)).
-* The `static_assert` attribute, for asserting that a static bool is true at
-  compiletime.
-* The `thread_local` attribute, for defining a `static mut` as a thread-local.
-  Note that this is only a low-level building block, and is not local to a
-  *task*, nor does it provide safety.
+* The `static_assert` attribute, for asserting that a static bool is true at compiletime
+* The `thread_local` attribute, for defining a `static mut` as a thread-local. Note that this is
+  only a low-level building block, and is not local to a *task*, nor does it provide safety.
 
 Other attributes may be added or removed during development of the language.
 
-### Conditional compilation
-
-Sometimes one wants to have different compiler outputs from the same code,
-depending on build target, such as targeted operating system, or to enable
-release builds.
-
-There are two kinds of configuration options, one that is either defined or not
-(`#[cfg(foo)]`), and the other that contains a string that can be checked
-against (`#[cfg(bar = "baz")]` (currently only compiler-defined configuration
-options can have the latter form).
-
-~~~~
-// The function is only included in the build when compiling for OSX
-#[cfg(target_os = "macos")]
-fn macos_only() {
-  // ...
-}
-
-// This function is only included when either foo or bar is defined
-#[cfg(foo)]
-#[cfg(bar)]
-fn needs_foo_or_bar() {
-  // ...
-}
-
-// This function is only included when compiling for a unixish OS with a 32-bit
-// architecture
-#[cfg(unix, target_word_size = "32")]
-fn on_32bit_unix() {
-  // ...
-}
-~~~~
-
-This illustrates some conditional compilation can be achieved using the
-`#[cfg(...)]` attribute. Note that `#[cfg(foo, bar)]` is a condition that needs
-both `foo` and `bar` to be defined while `#[cfg(foo)] #[cfg(bar)]` only needs
-one of `foo` and `bar` to be defined (this resembles in the disjunctive normal
-form). Additionally, one can reverse a condition by enclosing it in a
-`not(...)`, like e. g. `#[cfg(not(target_os = "win32"))]`.
-
-To pass a configuration option which triggers a `#[cfg(identifier)]` one can use
-`rustc --cfg identifier`. In addition to that, the following configurations are
-pre-defined by the compiler:
-
- * `target_arch = "..."`. Target CPU architecture, such as `"x86"`, `"x86_64"`
-   `"mips"`, or `"arm"`.
- * `target_endian = "..."`. Endianness of the target CPU, either `"little"` or
-   `"big"`.
- * `target_family = "..."`. Operating system family of the target, e. g.
-   `"unix"` or `"windows"`. The value of this configuration option is defined as
-   a configuration itself, like `unix` or `windows`.
- * `target_os = "..."`. Operating system of the target, examples include
-   `"win32"`, `"macos"`, `"linux"`, `"android"` or `"freebsd"`.
- * `target_word_size = "..."`. Target word size in bits. This is set to `"32"`
-   for 32-bit CPU targets, and likewise set to `"64"` for 64-bit CPU targets.
- * `test`. Only set in test builds (`rustc --test`).
- * `unix`. See `target_family`.
- * `windows`. See `target_family`.
-
 ### Lint check attributes
 
 A lint check names a potentially undesirable coding pattern, such as

trunk/src/libarena/lib.rs

@@ -34,6 +34,7 @@ use std::cast;
 use std::cell::{Cell, RefCell};
 use std::mem;
 use std::num;
+use std::ptr;
 use std::kinds::marker;
 use std::rc::Rc;
 use std::rt::global_heap;
@@ -143,7 +144,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
     let fill = chunk.fill.get();
 
     while idx < fill {
-        let tydesc_data: *uint = transmute(buf.offset(idx as int));
+        let tydesc_data: *uint = transmute(ptr::offset(buf, idx as int));
         let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data);
         let (size, align) = ((*tydesc).size, (*tydesc).align);
 
@@ -154,7 +155,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
         //debug!("freeing object: idx = {}, size = {}, align = {}, done = {}",
         //       start, size, align, is_done);
         if is_done {
-            ((*tydesc).drop_glue)(buf.offset(start as int) as *i8);
+            ((*tydesc).drop_glue)(ptr::offset(buf, start as int) as *i8);
         }
 
         // Find where the next tydesc lives
@@ -260,7 +261,7 @@ impl Arena {
             //       start, n_bytes, align, head.fill);
 
             let buf = self.head.as_ptr();
-            return (buf.offset(tydesc_start as int), buf.offset(start as int));
+            return (ptr::offset(buf, tydesc_start as int), ptr::offset(buf, start as int));
         }
     }
 

trunk/src/libserialize/base64.rs renamed to trunk/src/libextra/base64.rs

@@ -63,8 +63,8 @@ impl<'a> ToBase64 for &'a [u8] {
      * # Example
      *
      * ```rust
-     * extern mod serialize;
-     * use serialize::base64::{ToBase64, STANDARD};
+     * extern mod extra;
+     * use extra::base64::{ToBase64, STANDARD};
      *
      * fn main () {
      *     let str = [52,32].to_base64(STANDARD);
@@ -189,8 +189,8 @@ impl<'a> FromBase64 for &'a str {
      * This converts a string literal to base64 and back.
      *
      * ```rust
-     * extern mod serialize;
-     * use serialize::base64::{ToBase64, FromBase64, STANDARD};
+     * extern mod extra;
+     * use extra::base64::{ToBase64, FromBase64, STANDARD};
      * use std::str;
      *
      * fn main () {
@@ -261,8 +261,8 @@ impl<'a> FromBase64 for &'a str {
 
 #[cfg(test)]
 mod test {
-    use extra::test::BenchHarness;
-    use base64::{Config, FromBase64, ToBase64, STANDARD, URL_SAFE};
+    use test::BenchHarness;
+    use base64::*;
 
     #[test]
     fn test_to_base64_basic() {

trunk/src/libextra/c_vec.rs

@@ -119,7 +119,7 @@ impl <T> CVec<T> {
     pub fn get<'a>(&'a self, ofs: uint) -> &'a T {
         assert!(ofs < self.len);
         unsafe {
-            &*self.base.offset(ofs as int)
+            &*ptr::mut_offset(self.base, ofs as int)
         }
     }
 
@@ -131,7 +131,7 @@ impl <T> CVec<T> {
     pub fn get_mut<'a>(&'a mut self, ofs: uint) -> &'a mut T {
         assert!(ofs < self.len);
         unsafe {
-            &mut *self.base.offset(ofs as int)
+            &mut *ptr::mut_offset(self.base, ofs as int)
         }
     }
 

trunk/src/libserialize/hex.rs renamed to trunk/src/libextra/hex.rs

@@ -28,8 +28,7 @@ impl<'a> ToHex for &'a [u8] {
      * # Example
      *
      * ```rust
-     * extern mod serialize;
-     * use serialize::hex::ToHex;
+     * use extra::hex::ToHex;
      *
      * fn main () {
      *     let str = [52,32].to_hex();
@@ -89,8 +88,7 @@ impl<'a> FromHex for &'a str {
      * This converts a string literal to hexadecimal and back.
      *
      * ```rust
-     * extern mod serialize;
-     * use serialize::hex::{FromHex, ToHex};
+     * use extra::hex::{FromHex, ToHex};
      * use std::str;
      *
      * fn main () {
@@ -139,8 +137,8 @@ impl<'a> FromHex for &'a str {
 
 #[cfg(test)]
 mod tests {
-    use extra::test::BenchHarness;
-    use hex::{FromHex, ToHex};
+    use test::BenchHarness;
+    use hex::*;
 
     #[test]
     pub fn test_to_hex() {

trunk/src/libextra/lib.rs

@@ -35,10 +35,20 @@ Rust extras are part of the standard Rust distribution.
 #[deny(missing_doc)];
 
 extern mod sync;
+#[cfg(not(stage0))]
 extern mod serialize;
 
 extern mod collections;
 
+#[cfg(stage0)]
+pub mod serialize {
+    #[allow(missing_doc)];
+    // Temp re-export until after a snapshot
+    extern mod serialize = "serialize";
+    pub use self::serialize::{Encoder, Decoder, Encodable, Decodable,
+                                   EncoderHelpers, DecoderHelpers};
+}
+
 // Utility modules
 
 pub mod c_vec;
@@ -49,9 +59,11 @@ pub mod url;
 pub mod json;
 pub mod tempfile;
 pub mod time;
+pub mod base64;
 pub mod workcache;
 pub mod enum_set;
 pub mod stats;
+pub mod hex;
 
 #[cfg(unicode)]
 mod unicode;

trunk/src/libnum/bigint.rs

@@ -784,12 +784,11 @@ impl BigUint {
         if n_bits == 0 || self.data.is_empty() { return (*self).clone(); }
 
         let mut borrow = 0;
-        let mut shifted_rev = vec::with_capacity(self.data.len());
+        let mut shifted = ~[];
         for elem in self.data.rev_iter() {
-            shifted_rev.push((*elem >> n_bits) | borrow);
+            shifted = ~[(*elem >> n_bits) | borrow] + shifted;
             borrow = *elem << (BigDigit::bits - n_bits);
         }
-        let shifted = { shifted_rev.reverse(); shifted_rev };
         return BigUint::new(shifted);
     }
 
@@ -2638,15 +2637,4 @@ mod bench {
             fib.to_str();
         });
     }
-
-    #[bench]
-    fn shr(bh: &mut BenchHarness) {
-        let n = { let one : BigUint = One::one(); one << 1000 };
-        bh.iter(|| {
-            let mut m = n.clone();
-            for _ in range(0, 10) {
-                m = m >> 1;
-            }
-        })
-    }
 }