---

yaml
---
r: 104170
b: refs/heads/try
c: cc34dbb
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
-refs/heads/try: 2fe7bfe4d2de9942449d3656317e66bc9ec50204
+refs/heads/try: cc34dbb84090f74c84037afb269003f13aa46b78
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/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

branches/try/mk/crates.mk

@@ -57,7 +57,7 @@ TOOLS := compiletest rustdoc rustc
 
 DEPS_std := native:rustrt native:compiler-rt
 DEPS_extra := std term sync serialize getopts collections
-DEPS_green := std native:context_switch
+DEPS_green := std
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
 DEPS_syntax := std extra term serialize collections

branches/try/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                              \

branches/try/mk/rt.mk

@@ -35,7 +35,7 @@
 # that's per-target so you're allowed to conditionally add files based on the
 # target.
 ################################################################################
-NATIVE_LIBS := rustrt sundown uv_support morestack miniz context_switch
+NATIVE_LIBS := rustrt sundown uv_support morestack miniz
 
 # $(1) is the target triple
 define NATIVE_LIBRARIES
@@ -54,10 +54,9 @@ NATIVE_DEPS_rustrt_$(1) := rust_builtin.c \
 			rust_android_dummy.c \
 			rust_test_helpers.c \
 			rust_try.ll \
+			arch/$$(HOST_$(1))/_context.S \
 			arch/$$(HOST_$(1))/record_sp.S
 NATIVE_DEPS_morestack_$(1) := arch/$$(HOST_$(1))/morestack.S
-NATIVE_DEPS_context_switch_$(1) := \
-			arch/$$(HOST_$(1))/_context.S
 
 ################################################################################
 # You shouldn't find it that necessary to edit anything below this line.

branches/try/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 $$@

branches/try/src/compiletest/compiletest.rs

@@ -219,14 +219,12 @@ pub fn run_tests(config: &config) {
             mode_debug_info => {
                 println!("arm-linux-androideabi debug-info \
                          test uses tcp 5039 port. please reserve it");
+                //arm-linux-androideabi debug-info test uses remote debugger
+                //so, we test 1 task at once
+                os::setenv("RUST_TEST_TASKS","1");
             }
             _ =>{}
         }
-
-        //arm-linux-androideabi debug-info test uses remote debugger
-        //so, we test 1 task at once.
-        // also trying to isolate problems with adb_run_wrapper.sh ilooping
-        os::setenv("RUST_TEST_TASKS","1");
     }
 
     let opts = test_opts(config);

branches/try/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.

branches/try/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

branches/try/src/doc/tutorial.md

@@ -293,7 +293,7 @@ braced block gives the whole block the value of that last expression.
 
 Put another way, the semicolon in Rust *ignores the value of an expression*.
 Thus, if the branches of the `if` had looked like `{ 4; }`, the above example
-would simply assign `()` (unit or void) to `price`. But without the semicolon, each
+would simply assign `()` (nil or void) to `price`. But without the semicolon, each
 branch has a different value, and `price` gets the value of the branch that
 was taken.
 
@@ -352,7 +352,7 @@ before the opening and after the closing quote, and can contain any sequence of
 characters except their closing delimiter.  More on strings
 [later](#vectors-and-strings).
 
-The unit type, written `()`, has a single value, also written `()`.
+The nil type, written `()`, has a single value, also written `()`.
 
 ## Operators
 
@@ -852,7 +852,7 @@ fn line(a: int, b: int, x: int) -> int {
 It's better Rust style to write a return value this way instead of
 writing an explicit `return`. The utility of `return` comes in when
 returning early from a function. Functions that do not return a value
-are said to return unit, `()`, and both the return type and the return
+are said to return nil, `()`, and both the return type and the return
 value may be omitted from the definition. The following two functions
 are equivalent.
 

branches/try/src/etc/adb_run_wrapper.sh

@@ -2,6 +2,9 @@
 # usage : adb_run_wrapper [test dir - where test executables exist] [test executable]
 #
 
+# Sometimes android shell produce exitcode "1 : Text File Busy"
+# Retry after $WAIT seconds, expecting resource cleaned-up
+WAIT=10
 TEST_PATH=$1
 BIN_PATH=/system/bin
 if [ -d "$TEST_PATH" ]
@@ -13,9 +16,20 @@ then
     then
         shift
 
+        L_RET=1
+        L_COUNT=0
         cd $TEST_PATH
-        TEST_EXEC_ENV=22 LD_LIBRARY_PATH=$TEST_PATH PATH=$BIN_PATH:$TEST_PATH $TEST_PATH/$RUN $@ 1>$TEST_PATH/$RUN.stdout 2>$TEST_PATH/$RUN.stderr
-        L_RET=$?
+        while [ $L_RET -eq 1 ]
+        do
+            TEST_EXEC_ENV=22 LD_LIBRARY_PATH=$TEST_PATH PATH=$BIN_PATH:$TEST_PATH $TEST_PATH/$RUN $@ 1>$TEST_PATH/$RUN.stdout 2>$TEST_PATH/$RUN.stderr
+            L_RET=$?
+            if [ $L_COUNT -gt 0 ]
+            then
+               /system/bin/sleep $WAIT
+               /system/bin/sync
+            fi
+            L_COUNT=$((L_COUNT+1))
+        done
 
         echo $L_RET > $TEST_PATH/$RUN.exitcode
 

branches/try/src/libarena/lib.rs

@@ -33,8 +33,8 @@ use std::cast::{transmute, transmute_mut, transmute_mut_region};
 use std::cast;
 use std::cell::{Cell, RefCell};
 use std::mem;
-use std::cmp;
 use std::num;
+use std::ptr;
 use std::kinds::marker;
 use std::rc::Rc;
 use std::rt::global_heap;
@@ -144,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);
 
@@ -155,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
@@ -184,7 +184,7 @@ impl Arena {
     // Functions for the POD part of the arena
     fn alloc_pod_grow(&mut self, n_bytes: uint, align: uint) -> *u8 {
         // Allocate a new chunk.
-        let new_min_chunk_size = cmp::max(n_bytes, self.chunk_size());
+        let new_min_chunk_size = num::max(n_bytes, self.chunk_size());
         self.chunks.set(@Cons(self.pod_head.clone(), self.chunks.get()));
         self.pod_head =
             chunk(num::next_power_of_two(new_min_chunk_size + 1u), true);
@@ -224,7 +224,7 @@ impl Arena {
     fn alloc_nonpod_grow(&mut self, n_bytes: uint, align: uint)
                          -> (*u8, *u8) {
         // Allocate a new chunk.
-        let new_min_chunk_size = cmp::max(n_bytes, self.chunk_size());
+        let new_min_chunk_size = num::max(n_bytes, self.chunk_size());
         self.chunks.set(@Cons(self.head.clone(), self.chunks.get()));
         self.head =
             chunk(num::next_power_of_two(new_min_chunk_size + 1u), false);
@@ -261,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));
         }
     }