---

yaml
---
r: 93758
b: refs/heads/try
c: f4c22f7
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: f977bedafd657b52fb618cc788cc31f35336270d
+refs/heads/try: f4c22f75d46e94985d2fe45c896bde65e991b13d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/mk/clean.mk

@@ -12,13 +12,19 @@
 # Cleanup
 ######################################################################
 
-CLEAN_STAGE_RULES =								\
- $(foreach stage, $(STAGES),					\
-  $(foreach host, $(CFG_HOST),		\
+CLEAN_STAGE_RULES :=							\
+ $(foreach stage, $(STAGES),						\
+  $(foreach host, $(CFG_HOST),						\
    clean$(stage)_H_$(host)						\
-   $(foreach target, $(CFG_TARGET),		\
+   $(foreach target, $(CFG_TARGET),					\
     clean$(stage)_T_$(target)_H_$(host))))
 
+CLEAN_STAGE_RULES := $(CLEAN_STAGE_RULES)				\
+    $(foreach host, $(CFG_HOST), clean-generic-H-$(host))
+
+CLEAN_STAGE_RULES := $(CLEAN_STAGE_RULES)				\
+    $(foreach host, $(CFG_TARGET), clean-generic-T-$(host))
+
 CLEAN_LLVM_RULES = 								\
  $(foreach target, $(CFG_HOST),		\
   clean-llvm$(target))
@@ -33,19 +39,6 @@ clean: clean-misc $(CLEAN_STAGE_RULES)
 
 clean-misc:
 	@$(call E, cleaning)
-	$(Q)find $(CFG_BUILD)/rustllvm \
-	         $(CFG_BUILD)/rt \
-		 $(CFG_BUILD)/test \
-         -name '*.[odasS]' -o \
-         -name '*.so' -o      \
-         -name '*.dylib' -o   \
-         -name '*.dll' -o     \
-         -name '*.def' -o     \
-         -name '*.bc'         \
-         | xargs rm -f
-	$(Q)find $(CFG_BUILD)\
-         -name '*.dSYM'       \
-         | xargs rm -Rf
 	$(Q)rm -f $(RUNTIME_OBJS) $(RUNTIME_DEF)
 	$(Q)rm -f $(RUSTLLVM_LIB_OBJS) $(RUSTLLVM_OBJS_OBJS) $(RUSTLLVM_DEF)
 	$(Q)rm -Rf $(DOCS)
@@ -60,6 +53,27 @@ clean-misc:
 	$(Q)rm -Rf $(foreach sub, index styles files search javascript, \
                  $(wildcard doc/*/$(sub)))
 
+define CLEAN_GENERIC
+
+clean-generic-$(2)-$(1):
+	$(Q)find $(1)/rustllvm \
+	         $(1)/rt \
+		 $(1)/test \
+         -name '*.[odasS]' -o \
+         -name '*.so' -o      \
+         -name '*.dylib' -o   \
+         -name '*.dll' -o     \
+         -name '*.def' -o     \
+         -name '*.bc'         \
+         | xargs rm -f
+	$(Q)find $(1)\
+         -name '*.dSYM'       \
+         | xargs rm -Rf
+endef
+
+$(foreach host, $(CFG_HOST), $(eval $(call CLEAN_GENERIC,$(host),H)))
+$(foreach targ, $(CFG_TARGET), $(eval $(call CLEAN_GENERIC,$(targ),T)))
+
 define CLEAN_HOST_STAGE_N
 
 clean$(1)_H_$(2):

branches/try/mk/platform.mk

@@ -206,7 +206,7 @@ CFG_LIB_GLOB_arm-apple-darwin = lib$(1)-*.dylib
 CFG_LIB_DSYM_GLOB_arm-apple-darwin = lib$(1)-*.dylib.dSYM
 CFG_GCCISH_CFLAGS_arm-apple-darwin := -Wall -Werror -g -fPIC $(CFG_IOS_FLAGS)
 CFG_GCCISH_CXXFLAGS_arm-apple-darwin := -fno-rtti $(CFG_IOS_FLAGS)
-CFG_GCCISH_LINK_FLAGS_arm-apple-darwin := -dynamiclib -lpthread -framework CoreServices -Wl,-no_compact_unwind 
+CFG_GCCISH_LINK_FLAGS_arm-apple-darwin := -dynamiclib -lpthread -framework CoreServices -Wl,-no_compact_unwind
 CFG_GCCISH_DEF_FLAG_arm-apple-darwin := -Wl,-exported_symbols_list,
 CFG_GCCISH_PRE_LIB_FLAGS_arm-apple-darwin :=
 CFG_GCCISH_POST_LIB_FLAGS_arm-apple-darwin :=
@@ -506,7 +506,7 @@ define CFG_MAKE_TOOLCHAIN
         -c -o $$(1) $$(2)
   CFG_LINK_C_$(1) = $$(CC_$(1)) \
         $$(CFG_GCCISH_LINK_FLAGS) -o $$(1)          \
-        $$(CFG_GCCISH_LINK_FLAGS_$(1)))             \
+        $$(CFG_GCCISH_LINK_FLAGS_$(1))              \
         $$(CFG_GCCISH_DEF_FLAG_$(1))$$(3) $$(2)     \
         $$(call CFG_INSTALL_NAME_$(1),$$(4))
   CFG_COMPILE_CXX_$(1) = $$(CXX_$(1)) \

branches/try/mk/rt.mk

@@ -90,14 +90,18 @@ endif
 endif
 
 RUNTIME_CXXS_$(1)_$(2) := \
-              rt/sync/lock_and_signal.cpp \
-              rt/rust_builtin.cpp \
-              rt/rust_upcall.cpp \
-              rt/miniz.cpp \
-              rt/rust_android_dummy.cpp \
-              rt/rust_test_helpers.cpp
+	      rt/rust_cxx_glue.cpp
 
-RUNTIME_CS_$(1)_$(2) :=
+RUNTIME_CS_$(1)_$(2) := \
+              rt/rust_builtin.c \
+              rt/rust_upcall.c \
+              rt/miniz.c \
+              rt/rust_android_dummy.c \
+              rt/rust_test_helpers.c
+
+# stage0 remove this after the next snapshot
+%.cpp:
+	@touch tmp/foo.o
 
 RUNTIME_S_$(1)_$(2) := rt/arch/$$(HOST_$(1))/_context.S \
 			rt/arch/$$(HOST_$(1))/record_sp.S
@@ -115,7 +119,7 @@ ALL_OBJ_FILES += $$(RUNTIME_OBJS_$(1)_$(2))
 MORESTACK_OBJS_$(1)_$(2) := $$(RT_BUILD_DIR_$(1)_$(2))/arch/$$(HOST_$(1))/morestack.o
 ALL_OBJ_FILES += $$(MORESTACK_OBJS_$(1)_$(2))
 
-$$(RT_BUILD_DIR_$(1)_$(2))/%.o: rt/%.cpp $$(MKFILE_DEPS)
+$$(RT_BUILD_DIR_$(1)_$(2))/rust_cxx_glue.o: rt/rust_cxx_glue.cpp $$(MKFILE_DEPS)
 	@$$(call E, compile: $$@)
 	$$(Q)$$(call CFG_COMPILE_CXX_$(1), $$@, $$(RUNTIME_INCS_$(1)_$(2)) \
                  $$(SNAP_DEFINES) $$(RUNTIME_CXXFLAGS_$(1)_$(2))) $$<
@@ -242,13 +246,13 @@ endif
 UV_SUPPORT_NAME_$(1) := $$(call CFG_STATIC_LIB_NAME_$(1),uv_support)
 UV_SUPPORT_DIR_$(1) := $$(RT_OUTPUT_DIR_$(1))/uv_support
 UV_SUPPORT_LIB_$(1) := $$(UV_SUPPORT_DIR_$(1))/$$(UV_SUPPORT_NAME_$(1))
-UV_SUPPORT_CS_$(1) := rt/rust_uv.cpp
-UV_SUPPORT_OBJS_$(1) := $$(UV_SUPPORT_CS_$(1):rt/%.cpp=$$(UV_SUPPORT_DIR_$(1))/%.o)
+UV_SUPPORT_CS_$(1) := rt/rust_uv.c
+UV_SUPPORT_OBJS_$(1) := $$(UV_SUPPORT_CS_$(1):rt/%.c=$$(UV_SUPPORT_DIR_$(1))/%.o)
 
-$$(UV_SUPPORT_DIR_$(1))/%.o: rt/%.cpp
+$$(UV_SUPPORT_DIR_$(1))/%.o: rt/%.c
 	@$$(call E, compile: $$@)
 	@mkdir -p $$(@D)
-	$$(Q)$$(call CFG_COMPILE_CXX_$(1), $$@, \
+	$$(Q)$$(call CFG_COMPILE_C_$(1), $$@, \
 		-I $$(S)src/libuv/include \
                  $$(RUNTIME_CFLAGS_$(1))) $$<
 

branches/try/src/etc/adb_run_wrapper.sh

@@ -5,8 +5,9 @@
 # Sometimes android shell produce exitcode "1 : Text File Busy"
 # Retry after $WAIT seconds, expecting resource cleaned-up
 WAIT=10
-PATH=$1
-if [ -d "$PATH" ]
+TEST_PATH=$1
+BIN_PATH=/system/bin
+if [ -d "$TEST_PATH" ]
 then
     shift
     RUN=$1
@@ -17,10 +18,10 @@ then
 
         L_RET=1
         L_COUNT=0
-        cd $PATH
+        cd $TEST_PATH
         while [ $L_RET -eq 1 ]
         do
-            TEST_EXEC_ENV=22 LD_LIBRARY_PATH=$PATH $PATH/$RUN $@ 1>$PATH/$RUN.stdout 2>$PATH/$RUN.stderr
+            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
@@ -30,7 +31,7 @@ then
             L_COUNT=$((L_COUNT+1))
         done
 
-        echo $L_RET > $PATH/$RUN.exitcode
+        echo $L_RET > $TEST_PATH/$RUN.exitcode
 
     fi
 fi

branches/try/src/libextra/time.rs

@@ -21,8 +21,8 @@ pub mod rustrt {
     use super::Tm;
 
     extern {
-        pub fn get_time(sec: &mut i64, nsec: &mut i32);
-        pub fn precise_time_ns(ns: &mut u64);
+        pub fn rust_get_time(sec: &mut i64, nsec: &mut i32);
+        pub fn rust_precise_time_ns(ns: &mut u64);
         pub fn rust_tzset();
         pub fn rust_gmtime(sec: i64, nsec: i32, result: &mut Tm);
         pub fn rust_localtime(sec: i64, nsec: i32, result: &mut Tm);
@@ -66,7 +66,7 @@ pub fn get_time() -> Timespec {
     unsafe {
         let mut sec = 0i64;
         let mut nsec = 0i32;
-        rustrt::get_time(&mut sec, &mut nsec);
+        rustrt::rust_get_time(&mut sec, &mut nsec);
         return Timespec::new(sec, nsec);
     }
 }
@@ -79,7 +79,7 @@ pub fn get_time() -> Timespec {
 pub fn precise_time_ns() -> u64 {
     unsafe {
         let mut ns = 0u64;
-        rustrt::precise_time_ns(&mut ns);
+        rustrt::rust_precise_time_ns(&mut ns);
         ns
     }
 }

branches/try/src/libextra/workcache.rs

@@ -477,6 +477,7 @@ impl<'self, T:Send +
 
 
 #[test]
+#[cfg(not(target_os="android"))] // FIXME(#10455)
 fn test() {
     use std::{os, run};
     use std::io::fs;

branches/try/src/libstd/os.rs

@@ -138,21 +138,19 @@ Accessing environment variables is not generally threadsafe.
 Serialize access through a global lock.
 */
 fn with_env_lock<T>(f: &fn() -> T) -> T {
+    use unstable::mutex::{Mutex, MUTEX_INIT};
     use unstable::finally::Finally;
 
+    static mut lock: Mutex = MUTEX_INIT;
+
     unsafe {
         return do (|| {
-            rust_take_env_lock();
+            lock.lock();
             f()
         }).finally {
-            rust_drop_env_lock();
+            lock.unlock();
         };
     }
-
-    extern {
-        fn rust_take_env_lock();
-        fn rust_drop_env_lock();
-    }
 }
 
 /// Returns a vector of (variable, value) pairs for all the environment

branches/try/src/libstd/rt/args.rs

@@ -21,46 +21,60 @@
 //! FIXME #7756: This has a lot of C glue for lack of globals.
 
 use option::Option;
+#[cfg(test)] use option::{Some, None};
+#[cfg(test)] use realstd;
+#[cfg(test)] use realargs = realstd::rt::args;
 
 /// One-time global initialization.
-pub unsafe fn init(argc: int, argv: **u8) {
-    imp::init(argc, argv)
-}
+#[cfg(not(test))]
+pub unsafe fn init(argc: int, argv: **u8) { imp::init(argc, argv) }
+#[cfg(test)]
+pub unsafe fn init(argc: int, argv: **u8) { realargs::init(argc, argv) }
 
 /// One-time global cleanup.
-pub fn cleanup() {
-    imp::cleanup()
-}
+#[cfg(not(test))] pub fn cleanup() { imp::cleanup() }
+#[cfg(test)]      pub fn cleanup() { realargs::cleanup() }
 
 /// Take the global arguments from global storage.
-pub fn take() -> Option<~[~str]> {
-    imp::take()
+#[cfg(not(test))] pub fn take() -> Option<~[~str]> { imp::take() }
+#[cfg(test)]      pub fn take() -> Option<~[~str]> {
+    match realargs::take() {
+        realstd::option::Some(a) => Some(a),
+        realstd::option::None => None,
+    }
 }
 
 /// Give the global arguments to global storage.
 ///
 /// It is an error if the arguments already exist.
-pub fn put(args: ~[~str]) {
-    imp::put(args)
-}
+#[cfg(not(test))] pub fn put(args: ~[~str]) { imp::put(args) }
+#[cfg(test)]      pub fn put(args: ~[~str]) { realargs::put(args) }
 
 /// Make a clone of the global arguments.
-pub fn clone() -> Option<~[~str]> {
-    imp::clone()
+#[cfg(not(test))] pub fn clone() -> Option<~[~str]> { imp::clone() }
+#[cfg(test)]      pub fn clone() -> Option<~[~str]> {
+    match realargs::clone() {
+        realstd::option::Some(a) => Some(a),
+        realstd::option::None => None,
+    }
 }
 
 #[cfg(target_os = "linux")]
 #[cfg(target_os = "android")]
 #[cfg(target_os = "freebsd")]
 mod imp {
+    use cast;
     use libc;
     use option::{Option, Some, None};
     use iter::Iterator;
     use str;
     use unstable::finally::Finally;
+    use unstable::mutex::{Mutex, MUTEX_INIT};
     use util;
     use vec;
 
+    static mut global_args_ptr: uint = 0;
+
     pub unsafe fn init(argc: int, argv: **u8) {
         let args = load_argc_and_argv(argc, argv);
         put(args);
@@ -94,20 +108,22 @@ mod imp {
     }
 
     fn with_lock<T>(f: &fn() -> T) -> T {
+        static mut lock: Mutex = MUTEX_INIT;
+
         do (|| {
             unsafe {
-                rust_take_global_args_lock();
+                lock.lock();
                 f()
             }
         }).finally {
             unsafe {
-                rust_drop_global_args_lock();
+                lock.unlock();
             }
         }
     }
 
     fn get_global_ptr() -> *mut Option<~~[~str]> {
-        unsafe { rust_get_global_args_ptr() }
+        unsafe { cast::transmute(&global_args_ptr) }
     }
 
     // Copied from `os`.
@@ -117,12 +133,6 @@ mod imp {
         }
     }
 
-    extern {
-        fn rust_take_global_args_lock();
-        fn rust_drop_global_args_lock();
-        fn rust_get_global_args_ptr() -> *mut Option<~~[~str]>;
-    }
-
     #[cfg(test)]
     mod tests {
         use option::{Some, None};

branches/try/src/libstd/rt/basic.rs

@@ -241,11 +241,11 @@ impl Drop for BasicPausible {
 
 fn time() -> Time {
     extern {
-        fn get_time(sec: &mut i64, nsec: &mut i32);
+        fn rust_get_time(sec: &mut i64, nsec: &mut i32);
     }
     let mut sec = 0;
     let mut nsec = 0;
-    unsafe { get_time(&mut sec, &mut nsec) }
+    unsafe { rust_get_time(&mut sec, &mut nsec) }
 
     Time { sec: sec as u64, nsec: nsec as u64 }
 }