---

yaml
---
r: 62961
b: refs/heads/snap-stage3
c: dee7c5a
h: refs/heads/master
i:
  62959: ecad624
v: v3

Author: brendanzab

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 5b09dca90be0b60ebc29998dc75cdc497d061796
+refs/heads/snap-stage3: dee7c5af6991b02c86e6a84b57551fd5cc71caaf
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/rustpkg.md

@@ -30,12 +30,6 @@ or the equivalent on Windows.
 
 Each workspace may contain one or more packages.
 
-When building code that contains one or more directives of the form `extern mod P`,
-rustpkg automatically searches for packages named `P` in the `RUST_PATH` (as described above).
-It builds those dependencies if necessary.
-Thus, when using rustpkg,
-there is no need for `-L` flags to tell the linker where to find libraries for external crates.
-
 # Package structure
 
 A valid workspace must contain each of the following subdirectories:
@@ -72,10 +66,6 @@ A package can be stored in a workspace on the local file system,
 or on a remote Web server, in which case the package ID resembles a URL.
 For example, `github.com/mozilla/rust` is a package ID
 that would refer to the git repository browsable at `http://github.com/mozilla/rust`.
-A package ID can also specify a version, like:
-`github.com/mozilla/rust#0.3`.
-In this case, `rustpkg` will check that the repository `github.com/mozilla/rust` has a tag named `0.3`,
-and report an error otherwise.
 
 ## Source files
 
@@ -86,15 +76,6 @@ rustpkg searches for four different fixed filenames in order to determine the cr
 * `test.rs`: Assumed to contain tests declared with the `#[test]` attribute.
 * `bench.rs`: Assumed to contain benchmarks declared with the `#[bench]` attribute.
 
-## Versions
-
-`rustpkg` packages do not need to declare their versions with an attribute inside one of the source files,
-because `rustpkg` infers it from the version control system.
-When building a package that is in a `git` repository,
-`rustpkg` assumes that the most recent tag specifies the current version.
-When building a package that is not under version control,
-or that has no tags, `rustpkg` assumes the intended version is 0.1.
-
 # Custom build scripts
 
 A file called `pkg.rs` at the root level in a workspace is called a *package script*.

branches/snap-stage3/mk/tests.mk

@@ -122,8 +122,18 @@ CFG_ADB_TEST_DIR=/data/tmp
 $(info check: android device test dir $(CFG_ADB_TEST_DIR) ready \
  $(shell adb remount 1>/dev/null) \
  $(shell adb shell mkdir $(CFG_ADB_TEST_DIR) 1>/dev/null) \
+ $(shell adb shell rm $(CFG_ADB_TEST_DIR)/*.so 1>/dev/null) \
+ $(shell adb shell rm $(CFG_ADB_TEST_DIR)/*-arm-linux-androideabi 1>/dev/null) \
+ $(shell adb shell rm $(CFG_ADB_TEST_DIR)/*-arm-linux-androideabi.* 1>/dev/null) \
+ $(shell adb push $(S)src/etc/adb_run_wrapper.sh $(CFG_ADB_TEST_DIR) 1>/dev/null) \
  $(shell adb push $(CFG_ANDROID_CROSS_PATH)/arm-linux-androideabi/lib/armv7-a/libgnustl_shared.so \
                   $(CFG_ADB_TEST_DIR) 1>/dev/null) \
+ $(shell adb push $(TLIB2_T_arm-linux-androideabi_H_$(CFG_BUILD_TRIPLE))/$(CFG_RUNTIME_arm-linux-androideabi) \
+                  $(CFG_ADB_TEST_DIR)) \
+ $(shell adb push $(TLIB2_T_arm-linux-androideabi_H_$(CFG_BUILD_TRIPLE))/$(STDLIB_GLOB_arm-linux-androideabi) \
+                  $(CFG_ADB_TEST_DIR)) \
+ $(shell adb push $(TLIB2_T_arm-linux-androideabi_H_$(CFG_BUILD_TRIPLE))/$(EXTRALIB_GLOB_arm-linux-androideabi) \
+                  $(CFG_ADB_TEST_DIR)) \
  )
 else
 CFG_ADB_TEST_DIR=

branches/snap-stage3/src/compiletest/runtest.rs

@@ -753,53 +753,62 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
             copy_result.out, copy_result.err));
     }
 
-    // execute program
     logv(config, fmt!("executing (%s) %s", config.target, cmdline));
 
-    // adb shell dose not forward stdout and stderr of internal result
-    // to stdout and stderr separately but to stdout only
-    let mut newargs_out = ~[];
-    let mut newargs_err = ~[];
-    newargs_out.push(~"shell");
-    newargs_err.push(~"shell");
+    let mut runargs = ~[];
 
-    let mut newcmd_out = ~"";
-    let mut newcmd_err = ~"";
+    // run test via adb_run_wrapper
+    runargs.push(~"shell");
+    runargs.push(fmt!("%s/adb_run_wrapper.sh", config.adb_test_dir));
+    runargs.push(fmt!("%s", config.adb_test_dir));
+    runargs.push(fmt!("%s", prog_short));
 
-    newcmd_out.push_str(fmt!("LD_LIBRARY_PATH=%s %s/%s",
-        config.adb_test_dir, config.adb_test_dir, prog_short));
+    for args.args.each |tv| {
+        runargs.push(tv.to_owned());
+    }
 
-    newcmd_err.push_str(fmt!("LD_LIBRARY_PATH=%s %s/%s",
-        config.adb_test_dir, config.adb_test_dir, prog_short));
+    procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""));
 
-    for args.args.each |tv| {
-        newcmd_out.push_str(" ");
-        newcmd_err.push_str(" ");
-        newcmd_out.push_str(*tv);
-        newcmd_err.push_str(*tv);
+    // get exitcode of result
+    runargs = ~[];
+    runargs.push(~"shell");
+    runargs.push(~"cat");
+    runargs.push(fmt!("%s/%s.exitcode", config.adb_test_dir, prog_short));
+
+    let procsrv::Result{ out: exitcode_out, err: _, status: _ } =
+        procsrv::run("", config.adb_path, runargs, ~[(~"",~"")],
+                     Some(~""));
+
+    let mut exitcode : int = 0;
+    for str::each_char(exitcode_out) |c| {
+        if !c.is_digit() { break; }
+        exitcode = exitcode * 10 + match c {
+            '0' .. '9' => c as int - ('0' as int),
+            _ => 101,
+        }
     }
 
-    newcmd_out.push_str(" 2>/dev/null");
-    newcmd_err.push_str(" 1>/dev/null");
+    // get stdout of result
+    runargs = ~[];
+    runargs.push(~"shell");
+    runargs.push(~"cat");
+    runargs.push(fmt!("%s/%s.stdout", config.adb_test_dir, prog_short));
 
-    newargs_out.push(newcmd_out);
-    newargs_err.push(newcmd_err);
+    let procsrv::Result{ out: stdout_out, err: _, status: _ } =
+        procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""));
 
-    let procsrv::Result{ out: out_out, err: _out_err, status: out_status } =
-            procsrv::run("", config.adb_path, newargs_out, ~[(~"",~"")],
-                         Some(~""));
-    let procsrv::Result{ out: err_out, err: _err_err, status: _err_status } =
-            procsrv::run("", config.adb_path, newargs_err, ~[(~"",~"")],
-                         Some(~""));
+    // get stderr of result
+    runargs = ~[];
+    runargs.push(~"shell");
+    runargs.push(~"cat");
+    runargs.push(fmt!("%s/%s.stderr", config.adb_test_dir, prog_short));
 
-    dump_output(config, testfile, out_out, err_out);
+    let procsrv::Result{ out: stderr_out, err: _, status: _ } =
+        procsrv::run("", config.adb_path, runargs, ~[(~"",~"")], Some(~""));
 
-    match err_out {
-        ~"" => ProcRes {status: out_status, stdout: out_out,
-            stderr: err_out, cmdline: cmdline },
-        _   => ProcRes {status: 101, stdout: out_out,
-            stderr: err_out, cmdline: cmdline }
-    }
+    dump_output(config, testfile, stdout_out, stderr_out);
+
+    ProcRes {status: exitcode, stdout: stdout_out, stderr: stderr_out, cmdline: cmdline }
 }
 
 fn _dummy_exec_compiled_test(config: &config, props: &TestProps,

branches/snap-stage3/src/etc/adb_run_wrapper.sh

@@ -0,0 +1,35 @@
+#
+# 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
+PATH=$1
+if [ -d "$PATH" ]
+then
+    shift
+    RUN=$1
+
+    if [ ! -z "$RUN" ]
+    then
+        shift
+
+        L_RET=1
+        L_COUNT=0
+        while [ $L_RET -eq 1 ]
+        do
+            LD_LIBRARY_PATH=$PATH $PATH/$RUN $@ 1>$PATH/$RUN.stdout 2>$PATH/$RUN.stderr
+            L_RET=$? 
+            if [ $L_COUNT -gt 0 ]
+            then
+               /system/bin/sleep $WAIT
+               /system/bin/sync
+            fi
+            L_COUNT=`expr $L_COUNT+1`
+        done
+        
+        echo $L_RET > $PATH/$RUN.exitcode
+
+    fi
+fi

branches/snap-stage3/src/libextra/arc.rs

@@ -48,6 +48,7 @@ use core::cast;
 use core::unstable::sync::UnsafeAtomicRcBox;
 use core::ptr;
 use core::task;
+use core::borrow;
 
 /// As sync::condvar, a mechanism for unlock-and-descheduling and signaling.
 pub struct Condvar<'self> {
@@ -425,7 +426,7 @@ impl<T:Const + Owned> RWARC<T> {
             // of this cast is removing the mutability.)
             let new_data = cast::transmute_immut(data);
             // Downgrade ensured the token belonged to us. Just a sanity check.
-            assert!(ptr::ref_eq(&(*state).data, new_data));
+            assert!(borrow::ref_eq(&(*state).data, new_data));
             // Produce new token
             RWReadMode {
                 data: new_data,

branches/snap-stage3/src/libextra/sync.rs

@@ -17,6 +17,7 @@
 
 use core::prelude::*;
 
+use core::borrow;
 use core::comm;
 use core::ptr;
 use core::task;
@@ -589,7 +590,7 @@ impl RWlock {
     /// To be called inside of the write_downgrade block.
     pub fn downgrade<'a>(&self, token: RWlockWriteMode<'a>)
                          -> RWlockReadMode<'a> {
-        if !ptr::ref_eq(self, token.lock) {
+        if !borrow::ref_eq(self, token.lock) {
             fail!("Can't downgrade() with a different rwlock's write_mode!");
         }
         unsafe {

branches/snap-stage3/src/libstd/borrow.rs

@@ -0,0 +1,60 @@
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Borrowed pointer utilities
+
+#[cfg(not(test))]
+use prelude::*;
+
+/// Cast a region pointer - &T - to a uint.
+#[inline(always)]
+pub fn to_uint<T>(thing: &T) -> uint {
+    thing as *T as uint
+}
+
+/// Determine if two borrowed pointers point to the same thing.
+#[inline(always)]
+pub fn ref_eq<'a, 'b, T>(thing: &'a T, other: &'b T) -> bool {
+    to_uint(thing) == to_uint(other)
+}
+
+// Equality for region pointers
+#[cfg(not(test))]
+impl<'self, T: Eq> Eq for &'self T {
+    #[inline(always)]
+    fn eq(&self, other: & &'self T) -> bool {
+        *(*self) == *(*other)
+    }
+    #[inline(always)]
+    fn ne(&self, other: & &'self T) -> bool {
+        *(*self) != *(*other)
+    }
+}
+
+// Comparison for region pointers
+#[cfg(not(test))]
+impl<'self, T: Ord> Ord for &'self T {
+    #[inline(always)]
+    fn lt(&self, other: & &'self T) -> bool {
+        *(*self) < *(*other)
+    }
+    #[inline(always)]
+    fn le(&self, other: & &'self T) -> bool {
+        *(*self) <= *(*other)
+    }
+    #[inline(always)]
+    fn ge(&self, other: & &'self T) -> bool {
+        *(*self) >= *(*other)
+    }
+    #[inline(always)]
+    fn gt(&self, other: & &'self T) -> bool {
+        *(*self) > *(*other)
+    }
+}

branches/snap-stage3/src/libstd/core.rc

@@ -125,6 +125,7 @@ pub mod ascii;
 pub mod ptr;
 pub mod owned;
 pub mod managed;
+pub mod borrow;
 
 
 /* Core language traits */

branches/snap-stage3/src/libstd/prelude.rs

@@ -45,7 +45,7 @@ pub use path::PosixPath;
 pub use path::WindowsPath;
 pub use ptr::Ptr;
 pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr};
-pub use str::{StrSlice, OwnedStr, StrUtil};
+pub use str::{StrVector, StrSlice, OwnedStr, StrUtil};
 pub use from_str::{FromStr};
 pub use to_bytes::IterBytes;
 pub use to_str::{ToStr, ToStrConsume};
@@ -56,7 +56,7 @@ pub use tuple::{CloneableTuple10, CloneableTuple11, CloneableTuple12};
 pub use tuple::{ImmutableTuple2, ImmutableTuple3, ImmutableTuple4, ImmutableTuple5};
 pub use tuple::{ImmutableTuple6, ImmutableTuple7, ImmutableTuple8, ImmutableTuple9};
 pub use tuple::{ImmutableTuple10, ImmutableTuple11, ImmutableTuple12};
-pub use vec::{CopyableVector, ImmutableVector};
+pub use vec::{VectorVector, CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector, MutableVector};
 pub use io::{Reader, ReaderUtil, Writer, WriterUtil};

branches/snap-stage3/src/libstd/ptr.rs

@@ -255,18 +255,6 @@ pub fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T {
     thing as *mut T
 }
 
-/// Cast a region pointer - &T - to a uint.
-#[inline(always)]
-pub fn to_uint<T>(thing: &T) -> uint {
-    thing as *T as uint
-}
-
-/// Determine if two borrowed pointers point to the same thing.
-#[inline(always)]
-pub fn ref_eq<'a,'b,T>(thing: &'a T, other: &'b T) -> bool {
-    to_uint(thing) == to_uint(other)
-}
-
 /**
   Given a **T (pointer to an array of pointers),
   iterate through each *T, up to the provided `len`,
@@ -411,40 +399,6 @@ impl<T> Ord for *const T {
     }
 }
 
-// Equality for region pointers
-#[cfg(not(test))]
-impl<'self,T:Eq> Eq for &'self T {
-    #[inline(always)]
-    fn eq(&self, other: & &'self T) -> bool {
-        *(*self) == *(*other)
-    }
-    #[inline(always)]
-    fn ne(&self, other: & &'self T) -> bool {
-        *(*self) != *(*other)
-    }
-}
-
-// Comparison for region pointers
-#[cfg(not(test))]
-impl<'self,T:Ord> Ord for &'self T {
-    #[inline(always)]
-    fn lt(&self, other: & &'self T) -> bool {
-        *(*self) < *(*other)
-    }
-    #[inline(always)]
-    fn le(&self, other: & &'self T) -> bool {
-        *(*self) <= *(*other)
-    }
-    #[inline(always)]
-    fn ge(&self, other: & &'self T) -> bool {
-        *(*self) >= *(*other)
-    }
-    #[inline(always)]
-    fn gt(&self, other: & &'self T) -> bool {
-        *(*self) > *(*other)
-    }
-}
-
 #[cfg(test)]
 pub mod ptr_tests {
     use super::*;