---

yaml
---
r: 96190
b: refs/heads/dist-snap
c: 543cae9
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: e12bc239b4e85d0dedc5ba6e9f7ffa0b91ade634
+refs/heads/dist-snap: 543cae9a464fda1f1652eb1b103e648472d5dd73
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/po/ja/tutorial-tasks.md.po

@@ -213,7 +213,7 @@ msgstr ""
 #. type: Plain text
 #: doc/tutorial-tasks.md:102
 msgid ""
-"The `spawn` function has a very simple type signature: `fn spawn(f: proc())`. "
+"The `spawn` function has a very simple type signature: `fn spawn(f: ~fn())`. "
 "Because it accepts only owned closures, and owned closures contain only "
 "owned data, `spawn` can safely move the entire closure and all its "
 "associated state into an entirely different task for execution. Like any "

branches/dist-snap/doc/po/ja/tutorial.md.po

@@ -3509,13 +3509,13 @@ msgstr "## 所有クロージャ"
 #. type: Plain text
 #: doc/tutorial.md:1510
 msgid ""
-"Owned closures, written `proc`, hold on to "
+"Owned closures, written `~fn` in analogy to the `~` pointer type, hold on to "
 "things that can safely be sent between processes. They copy the values they "
 "close over, much like managed closures, but they also own them: that is, no "
 "other code can access them. Owned closures are used in concurrent code, "
 "particularly for spawning [tasks][tasks]."
 msgstr ""
-"`~` `proc` で書き表される所有クロージャは安全にプロセス"
+"`~` ポインタ型と同様に `~fn` 型  で書き表される所有クロージャは安全にプロセス"
 "間で送信することができます。所有クローじゃはマネージドクロージャと全く同じよ"
 "うに閉じ込める値をコピーしますが、値を所有します。つまり、他のコードは閉じ込"
 "められた値にアクセスできなくなります。所有クロージャは並列プログラム、特に "
@@ -3666,11 +3666,11 @@ msgstr ""
 #: doc/tutorial.md:1582
 msgid ""
 "`do` is a convenient way to create tasks with the `task::spawn` function.  "
-"`spawn` has the signature `spawn(fn: proc())`. In other words, it is a "
+"`spawn` has the signature `spawn(fn: ~fn())`. In other words, it is a "
 "function that takes an owned closure that takes no arguments."
 msgstr ""
 "`task::spawn` 関数を用いてタスクを生成する場合、 `do` を用いると便利です。"
-"`spawn` は、 `spawn(fn: proc())` という方を持っています。言い換えると、"
+"`spawn` は、 `spawn(fn: ~fn())` という方を持っています。言い換えると、"
 "`spawn` は「引数をとらない所有クロージャ」を引数としてとる関数ということで"
 "す。"
 

branches/dist-snap/doc/po/tutorial-tasks.md.pot

@@ -213,7 +213,7 @@ msgstr ""
 #. type: Plain text
 #: doc/tutorial-tasks.md:102
 msgid ""
-"The `spawn` function has a very simple type signature: `fn spawn(f: proc())`. "
+"The `spawn` function has a very simple type signature: `fn spawn(f: ~fn())`. "
 "Because it accepts only owned closures, and owned closures contain only "
 "owned data, `spawn` can safely move the entire closure and all its "
 "associated state into an entirely different task for execution. Like any "

branches/dist-snap/doc/po/tutorial.md.pot

@@ -2683,7 +2683,7 @@ msgstr ""
 #. type: Plain text
 #: doc/tutorial.md:1510
 msgid ""
-"Owned closures, written `proc`, hold on to "
+"Owned closures, written `~fn` in analogy to the `~` pointer type, hold on to "
 "things that can safely be sent between processes. They copy the values they "
 "close over, much like managed closures, but they also own them: that is, no "
 "other code can access them. Owned closures are used in concurrent code, "
@@ -2808,7 +2808,7 @@ msgstr ""
 #: doc/tutorial.md:1582
 msgid ""
 "`do` is a convenient way to create tasks with the `task::spawn` function.  "
-"`spawn` has the signature `spawn(fn: proc())`. In other words, it is a "
+"`spawn` has the signature `spawn(fn: ~fn())`. In other words, it is a "
 "function that takes an owned closure that takes no arguments."
 msgstr ""
 

branches/dist-snap/doc/rust.md

@@ -1550,7 +1550,6 @@ keyword for struct fields and enum variants). When an item is declared as `pub`,
 it can be thought of as being accessible to the outside world. For example:
 
 ~~~~
-# fn main() {}
 // Declare a private struct
 struct Foo;
 

branches/dist-snap/doc/tutorial-container.md

@@ -87,7 +87,6 @@ Reaching the end of the iterator is signalled by returning `None` instead of
 `Some(item)`:
 
 ~~~
-# fn main() {}
 /// A stream of N zeroes
 struct ZeroStream {
     priv remaining: uint
@@ -302,7 +301,6 @@ the iterator can provide better information.
 The `ZeroStream` from earlier can provide an exact lower and upper bound:
 
 ~~~
-# fn main() {}
 /// A stream of N zeroes
 struct ZeroStream {
     priv remaining: uint

branches/dist-snap/doc/tutorial-macros.md

@@ -216,7 +216,7 @@ Now consider code like the following:
 
 ~~~~
 # enum t1 { good_1(t2, uint), bad_1 };
-# struct t2 { body: t3 }
+# pub struct t2 { body: t3 }
 # enum t3 { good_2(uint), bad_2};
 # fn f(x: t1) -> uint {
 match x {
@@ -262,7 +262,7 @@ macro_rules! biased_match (
 )
 
 # enum t1 { good_1(t2, uint), bad_1 };
-# struct t2 { body: t3 }
+# pub struct t2 { body: t3 }
 # enum t3 { good_2(uint), bad_2};
 # fn f(x: t1) -> uint {
 biased_match!((x)       ~ (good_1(g1, val)) else { return 0 };
@@ -364,7 +364,7 @@ macro_rules! biased_match (
 
 
 # enum t1 { good_1(t2, uint), bad_1 };
-# struct t2 { body: t3 }
+# pub struct t2 { body: t3 }
 # enum t3 { good_2(uint), bad_2};
 # fn f(x: t1) -> uint {
 biased_match!(

branches/dist-snap/doc/tutorial-tasks.md

@@ -91,7 +91,7 @@ _owned types_. The language leaves the implementation details to the standard
 library.
 
 The `spawn` function has a very simple type signature: `fn spawn(f:
-proc())`. Because it accepts only owned closures, and owned closures
+~fn())`. Because it accepts only owned closures, and owned closures
 contain only owned data, `spawn` can safely move the entire closure
 and all its associated state into an entirely different task for
 execution. Like any closure, the function passed to `spawn` may capture

branches/dist-snap/doc/tutorial.md

@@ -1409,7 +1409,7 @@ pervasively in Rust code.
 
 ## Owned closures
 
-Owned closures, written `proc`,
+Owned closures, written `~fn` in analogy to the `~` pointer type,
 hold on to things that can safely be sent between
 processes. They copy the values they close over, much like managed
 closures, but they also own them: that is, no other code can access
@@ -1484,7 +1484,7 @@ parentheses, where it looks more like a typical block of
 code.
 
 `do` is a convenient way to create tasks with the `task::spawn`
-function.  `spawn` has the signature `spawn(fn: proc())`. In other
+function.  `spawn` has the signature `spawn(fn: ~fn())`. In other
 words, it is a function that takes an owned closure that takes no
 arguments.
 
@@ -2568,7 +2568,6 @@ pub fn foo() { bar(); }
 ~~~
 // c.rs
 pub fn bar() { println("Baz!"); }
-# fn main() {}
 ~~~
 
 There also exist two short forms for importing multiple names at once:
@@ -2744,7 +2743,7 @@ Therefore, if you plan to compile your crate as a library, you should annotate i
 #[link(name = "farm", vers = "2.5")];
 
 // ...
-# fn farm() {}
+# pub fn farm() {}
 ~~~~
 
 You can also in turn require in a `extern mod` statement that certain link metadata items match some criteria.
@@ -2770,7 +2769,7 @@ or setting the crate type (library or executable) explicitly:
 
 // Turn on a warning
 #[warn(non_camel_case_types)]
-# fn farm() {}
+# pub fn farm() {}
 ~~~~
 
 If you're compiling your crate with `rustpkg`,
@@ -2791,9 +2790,7 @@ We define two crates, and use one of them as a library in the other.
 ~~~~
 // world.rs
 #[link(name = "world", vers = "0.42")];
-# extern mod extra;
 pub fn explore() -> &'static str { "world" }
-# fn main() {}
 ~~~~
 
 ~~~~ {.xfail-test}

branches/dist-snap/mk/clean.mk

@@ -12,19 +12,13 @@
 # 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))
@@ -39,6 +33,19 @@ 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)
@@ -53,27 +60,6 @@ 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/dist-snap/mk/ctags.mk

@@ -15,27 +15,7 @@
 
 .PHONY: TAGS.emacs TAGS.vi
 
-# This is using a blacklist approach, probably more durable than a whitelist.
-# We exclude: external dependencies (llvm, libuv, gyp, rt/{msvc,sundown,vg}),
-# tests (compiletest, test) and a couple of other things (rt/arch, etc)
-CTAGS_LOCATIONS=$(patsubst ${CFG_SRC_DIR}src/llvm,,\
-				$(patsubst ${CFG_SRC_DIR}src/libuv,,\
-				$(patsubst ${CFG_SRC_DIR}src/compiletest,,\
-				$(patsubst ${CFG_SRC_DIR}src/test,,\
-				$(patsubst ${CFG_SRC_DIR}src/gyp,,\
-				$(patsubst ${CFG_SRC_DIR}src/etc,,\
-				$(patsubst ${CFG_SRC_DIR}src/rt,,\
-				$(patsubst ${CFG_SRC_DIR}src/rt/arch,,\
-				$(patsubst ${CFG_SRC_DIR}src/rt/msvc,,\
-				$(patsubst ${CFG_SRC_DIR}src/rt/sundown,,\
-				$(patsubst ${CFG_SRC_DIR}src/rt/vg,,\
-				$(wildcard ${CFG_SRC_DIR}src/*) $(wildcard ${CFG_SRC_DIR}src/rt/*)\
-				)))))))))))
-CTAGS_OPTS=--options="${CFG_SRC_DIR}src/etc/ctags.rust" --languages=-javascript --recurse ${CTAGS_LOCATIONS}
-# We could use `--languages=Rust`, but there is value in producing tags for the
-# C++ parts of the code base too (at the time of writing, those are .h and .cpp
-# files in src/rt, src/rt/sync and src/rustllvm); we mainly just want to
-# exclude the external dependencies.
+CTAGS_OPTS=--options=${CFG_SRC_DIR}/src/etc/ctags.rust -R ${CFG_SRC_DIR}/src
 
 TAGS.emacs:
 	ctags -e -f $@ ${CTAGS_OPTS}

branches/dist-snap/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/dist-snap/mk/rt.mk

@@ -90,18 +90,14 @@ endif
 endif
 
 RUNTIME_CXXS_$(1)_$(2) := \
-	      rt/rust_cxx_glue.cpp
+              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
 
-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_CS_$(1)_$(2) :=
 
 RUNTIME_S_$(1)_$(2) := rt/arch/$$(HOST_$(1))/_context.S \
 			rt/arch/$$(HOST_$(1))/record_sp.S
@@ -119,7 +115,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))/rust_cxx_glue.o: rt/rust_cxx_glue.cpp $$(MKFILE_DEPS)
+$$(RT_BUILD_DIR_$(1)_$(2))/%.o: rt/%.cpp $$(MKFILE_DEPS)
 	@$$(call E, compile: $$@)
 	$$(Q)$$(call CFG_COMPILE_CXX_$(1), $$@, $$(RUNTIME_INCS_$(1)_$(2)) \
                  $$(SNAP_DEFINES) $$(RUNTIME_CXXFLAGS_$(1)_$(2))) $$<
@@ -246,13 +242,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.c
-UV_SUPPORT_OBJS_$(1) := $$(UV_SUPPORT_CS_$(1):rt/%.c=$$(UV_SUPPORT_DIR_$(1))/%.o)
+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_DIR_$(1))/%.o: rt/%.c
+$$(UV_SUPPORT_DIR_$(1))/%.o: rt/%.cpp
 	@$$(call E, compile: $$@)
 	@mkdir -p $$(@D)
-	$$(Q)$$(call CFG_COMPILE_C_$(1), $$@, \
+	$$(Q)$$(call CFG_COMPILE_CXX_$(1), $$@, \
 		-I $$(S)src/libuv/include \
                  $$(RUNTIME_CFLAGS_$(1))) $$<
 

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

@@ -5,9 +5,8 @@
 # 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" ]
+PATH=$1
+if [ -d "$PATH" ]
 then
     shift
     RUN=$1
@@ -18,10 +17,10 @@ then
 
         L_RET=1
         L_COUNT=0
-        cd $TEST_PATH
+        cd $PATH
         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
+            TEST_EXEC_ENV=22 LD_LIBRARY_PATH=$PATH $PATH/$RUN $@ 1>$PATH/$RUN.stdout 2>$PATH/$RUN.stderr
             L_RET=$?
             if [ $L_COUNT -gt 0 ]
             then
@@ -31,7 +30,7 @@ then
             L_COUNT=$((L_COUNT+1))
         done
 
-        echo $L_RET > $TEST_PATH/$RUN.exitcode
+        echo $L_RET > $PATH/$RUN.exitcode
 
     fi
 fi