---

yaml
---
r: 94091
b: refs/heads/try
c: 7304326
h: refs/heads/master
i:
  94089: e0da402
  94087: 5f64e10
v: v3

Author: ongardie

[refs]

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

branches/try/Makefile.in

@@ -130,15 +130,6 @@ ifndef DEBUG_BORROWS
   RUSTFLAGS_STAGE2 += -Z no-debug-borrows
 endif
 
-# The executables crated during this compilation process have no need to include
-# static copies of libstd and libextra. We also generate dynamic versions of all
-# libraries, so in the interest of space, prefer dynamic linking throughout the
-# compilation process.
-RUSTFLAGS_STAGE0 += -Z prefer-dynamic
-RUSTFLAGS_STAGE1 += -Z prefer-dynamic
-RUSTFLAGS_STAGE2 += -Z prefer-dynamic
-RUSTFLAGS_STAGE3 += -Z prefer-dynamic
-
 # platform-specific auto-configuration
 include $(CFG_SRC_DIR)mk/platform.mk
 
@@ -223,7 +214,7 @@ GENERATED :=
 
 define DEF_LIBS
 
-CFG_RUNTIME_$(1) :=$(call CFG_STATIC_LIB_NAME_$(1),rustrt)
+CFG_RUNTIME_$(1) :=$(call CFG_LIB_NAME_$(1),rustrt)
 CFG_RUSTLLVM_$(1) :=$(call CFG_LIB_NAME_$(1),rustllvm)
 CFG_STDLIB_$(1) :=$(call CFG_LIB_NAME_$(1),std)
 CFG_EXTRALIB_$(1) :=$(call CFG_LIB_NAME_$(1),extra)
@@ -248,10 +239,6 @@ LIBRUSTPKG_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),rustpkg)
 LIBRUSTDOC_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),rustdoc)
 LIBRUSTUV_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),rustuv)
 
-EXTRALIB_RGLOB_$(1) :=$(call CFG_RLIB_GLOB,extra)
-STDLIB_RGLOB_$(1) :=$(call CFG_RLIB_GLOB,std)
-LIBRUSTUV_RGLOB_$(1) :=$(call CFG_RLIB_GLOB,rustuv)
-
 endef
 
 # $(1) is the path for directory to match against
@@ -405,25 +392,42 @@ TBIN$(1)_T_$(2)_H_$(3) = $$(TROOT$(1)_T_$(2)_H_$(3))/bin
 TLIB$(1)_T_$(2)_H_$(3) = $$(TROOT$(1)_T_$(2)_H_$(3))/$$(CFG_LIBDIR)
 
 # The name of the standard and extra libraries used by rustc
-HSTDLIB_DEFAULT$(1)_H_$(3) = \
-  $$(HLIB$(1)_H_$(3))/$(CFG_STDLIB_$(3))
-TSTDLIB_DEFAULT$(1)_T_$(2)_H_$(3) = \
-  $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_STDLIB_$(2))
-
-HEXTRALIB_DEFAULT$(1)_H_$(3) = \
-  $$(HLIB$(1)_H_$(3))/$(CFG_EXTRALIB_$(3))
-TEXTRALIB_DEFAULT$(1)_T_$(2)_H_$(3) = \
-  $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_EXTRALIB_$(2))
-
-HLIBRUSTC_DEFAULT$(1)_H_$(3) = \
-  $$(HLIB$(1)_H_$(3))/$(CFG_LIBRUSTC_$(3))
-TLIBRUSTC_DEFAULT$(1)_T_$(2)_H_$(3) = \
-  $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTC_$(2))
-
-HLIBRUSTUV_DEFAULT$(1)_H_$(3) = \
-  $$(HLIB$(1)_H_$(3))/$(CFG_LIBRUSTUV_$(3))
-TLIBRUSTUV_DEFAULT$(1)_T_$(2)_H_$(3) = \
-  $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTUV_$(2))
+ifdef CFG_DISABLE_SHAREDSTD
+  HSTDLIB_DEFAULT$(1)_H_$(3) = \
+    $$(HLIB$(1)_H_$(3))/libstd.rlib
+  TSTDLIB_DEFAULT$(1)_T_$(2)_H_$(3) = \
+    $$(TLIB$(1)_T_$(2)_H_$(3))/libstd.rlib
+
+  HEXTRALIB_DEFAULT$(1)_H_$(3) = \
+    $$(HLIB$(1)_H_$(3))/libextra.rlib
+  TEXTRALIB_DEFAULT$(1)_T_$(2)_H_$(3) = \
+    $$(TLIB$(1)_T_$(2)_H_$(3))/libextra.rlib
+
+  HLIBRUSTC_DEFAULT$(1)_H_$(3) = \
+    $$(HLIB$(1)_H_$(3))/librustc.rlib
+  TLIBRUSTC_DEFAULT$(1)_T_$(2)_H_$(3) = \
+    $$(TLIB$(1)_T_$(2)_H_$(3))/librustc.rlib
+else
+  HSTDLIB_DEFAULT$(1)_H_$(3) = \
+    $$(HLIB$(1)_H_$(3))/$(CFG_STDLIB_$(3))
+  TSTDLIB_DEFAULT$(1)_T_$(2)_H_$(3) = \
+    $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_STDLIB_$(2))
+
+  HEXTRALIB_DEFAULT$(1)_H_$(3) = \
+    $$(HLIB$(1)_H_$(3))/$(CFG_EXTRALIB_$(3))
+  TEXTRALIB_DEFAULT$(1)_T_$(2)_H_$(3) = \
+    $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_EXTRALIB_$(2))
+
+  HLIBRUSTC_DEFAULT$(1)_H_$(3) = \
+    $$(HLIB$(1)_H_$(3))/$(CFG_LIBRUSTC_$(3))
+  TLIBRUSTC_DEFAULT$(1)_T_$(2)_H_$(3) = \
+    $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTC_$(2))
+
+  HLIBRUSTUV_DEFAULT$(1)_H_$(3) = \
+    $$(HLIB$(1)_H_$(3))/$(CFG_LIBRUSTUV_$(3))
+  TLIBRUSTUV_DEFAULT$(1)_T_$(2)_H_$(3) = \
+    $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTUV_$(2))
+endif
 
 # Preqrequisites for using the stageN compiler
 HSREQ$(1)_H_$(3) = \

branches/try/configure

@@ -364,6 +364,7 @@ fi
 BOOL_OPTIONS=""
 VAL_OPTIONS=""
 
+opt sharedstd 1 "build libstd as a shared library"
 opt valgrind 0 "run tests with valgrind (memcheck by default)"
 opt helgrind 0 "run tests with helgrind instead of memcheck"
 opt docs     1 "build documentation"
@@ -397,7 +398,7 @@ valopt sysconfdir "/etc" "install system configuration files"
 valopt datadir "${CFG_PREFIX}/share" "install data"
 valopt infodir "${CFG_PREFIX}/share/info" "install additional info"
 valopt mandir "${CFG_PREFIX}/share/man" "install man pages in PATH"
-valopt libdir "${CFG_PREFIX}/lib" "install libraries"
+valopt libdir "${CFG_PREFIX}/lib" "install libraries" 
 
 # Validate Options
 step_msg "validating $CFG_SELF args"
@@ -519,20 +520,14 @@ then
     fi
 fi
 
-BIN_SUF=
-if [ $CFG_OSTYPE = "pc-mingw32" ]
-then
-    BIN_SUF=.exe
-fi
-
 if [ ! -z "$CFG_ENABLE_LOCAL_RUST" ]
 then
-    if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} ]
+    if [ ! -f ${CFG_LOCAL_RUST_ROOT}/bin/rustc ]
     then
         err "no local rust to use"
     else
-        LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc${BIN_SUF} --version`
-        step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: $LRV"
+        LRV=`${CFG_LOCAL_RUST_ROOT}/bin/rustc --version`
+        step_msg "using rustc at: ${CFG_LOCAL_RUST_ROOT} with version: " $LRV
     fi
 fi
 
@@ -607,7 +602,7 @@ CFG_PREFIX=${CFG_PREFIX%/}
 CFG_MANDIR=${CFG_MANDIR%/}
 CFG_HOST="$(echo $CFG_HOST | tr ',' ' ')"
 CFG_TARGET="$(echo $CFG_TARGET | tr ',' ' ')"
-CFG_SUPPORTED_TARGET="$(grep ^CC_*=* ${CFG_SRC_DIR}mk/platform.mk | sed -e 's/^CC_//' -e 's/\([^=]*\).*/\1/' | xargs)"
+CFG_SUPPORTED_TARGET="$(grep ^CC_*=* $CFG_SRC_DIR/mk/platform.mk | sed -e 's/^CC_//' -e 's/\([^=]*\).*/\1/' | xargs)"
 
 # copy host-triples to target-triples so that hosts are a subset of targets
 V_TEMP=""
@@ -877,13 +872,6 @@ do
         # Try to have LLVM pull in as few dependencies as possible (#9397)
         LLVM_OPTS="$LLVM_OPTS --disable-zlib --disable-libffi"
 
-        # pthreads works badly on mingw-w64 systems: #8996
-        case "$CFG_BUILD" in
-            (*w64-mingw32)
-            LLVM_OPTS="$LLVM_OPTS --disable-pthreads"
-            ;;
-        esac
-
         case "$CFG_C_COMPILER" in
             ("ccache clang")
             LLVM_CXX_32="ccache clang++ -m32 -Qunused-arguments"
@@ -893,11 +881,11 @@ do
             LLVM_CC_64="ccache clang -Qunused-arguments"
             ;;
             ("clang")
-            LLVM_CXX_32="clang++ -m32 -Qunused-arguments"
-            LLVM_CC_32="clang -m32 -Qunused-arguments"
+            LLVM_CXX_32="clang++ -m32"
+            LLVM_CC_32="clang -m32"
 
-            LLVM_CXX_64="clang++ -Qunused-arguments"
-            LLVM_CC_64="clang -Qunused-arguments"
+            LLVM_CXX_64="clang++"
+            LLVM_CC_64="clang"
             ;;
             ("ccache gcc")
             LLVM_CXX_32="ccache g++ -m32"

branches/try/doc/po/ja/rust.md.po

@@ -1817,10 +1817,10 @@ msgstr ""
 #, no-wrap
 msgid ""
 "~~~~ {.xfail-test}\n"
-"fn iter<T>(seq: &[T], f: |T|) {\n"
+"fn iter<T>(seq: &[T], f: &fn(T)) {\n"
 "    for elt in seq.iter() { f(elt); }\n"
 "}\n"
-"fn map<T, U>(seq: &[T], f: |T| -> U) -> ~[U] {\n"
+"fn map<T, U>(seq: &[T], f: &fn(T) -> U) -> ~[U] {\n"
 "    let mut acc = ~[];\n"
 "    for elt in seq.iter() { acc.push(f(elt)); }\n"
 "    acc\n"
@@ -2404,7 +2404,7 @@ msgid ""
 "trait Seq<T> {\n"
 "   fn len(&self) -> uint;\n"
 "   fn elt_at(&self, n: uint) -> T;\n"
-"   fn iter(&self, |T|);\n"
+"   fn iter(&self, &fn(T));\n"
 "}\n"
 "~~~~\n"
 msgstr ""
@@ -4243,7 +4243,7 @@ msgid ""
 "[function definitions](#functions) do not.  The exact type of capture "
 "depends on the [function type](#function-types) inferred for the lambda "
 "expression.  In the simplest and least-expensive form (analogous to a "
-"```|| { }``` expression), the lambda expression captures its environment "
+"```&fn() { }``` expression), the lambda expression captures its environment "
 "by reference, effectively borrowing pointers to all outer variables "
 "mentioned inside the function.  Alternately, the compiler may infer that a "
 "lambda expression should copy or move values (depending on their type.)  "
@@ -4262,7 +4262,7 @@ msgstr ""
 #, no-wrap
 msgid ""
 "~~~~\n"
-"fn ten_times(f: |int|) {\n"
+"fn ten_times(f: &fn(int)) {\n"
 "    let mut i = 0;\n"
 "    while i < 10 {\n"
 "        f(i);\n"
@@ -4455,7 +4455,7 @@ msgstr ""
 
 #. type: Plain text
 #: doc/rust.md:2339
-msgid "~~~~ # fn f(f: |int|) { } # fn g(i: int) { }"
+msgid "~~~~ # fn f(f: &fn(int)) { } # fn g(i: int) { }"
 msgstr ""
 
 #. type: Plain text
@@ -4481,7 +4481,7 @@ msgstr ""
 
 #. type: Plain text
 #: doc/rust.md:2352
-msgid "~~~~ # fn k(x:int, f: |int|) { } # fn l(i: int) { }"
+msgid "~~~~ # fn k(x:int, f: &fn(int)) { } # fn l(i: int) { }"
 msgstr ""
 
 #. type: Plain text
@@ -5383,7 +5383,7 @@ msgstr ""
 #. type: Plain text
 #: doc/rust.md:2849
 msgid ""
-"type Binop<'self> = 'self |int,int| -> int; let bo: Binop = add; x = "
+"type Binop<'self> = &'self fn(int,int) -> int; let bo: Binop = add; x = "
 "bo(5,7); ~~~~~~~~"
 msgstr ""
 
@@ -5483,7 +5483,7 @@ msgstr ""
 #, no-wrap
 msgid ""
 "~~~~~~~\n"
-"fn map<A: Clone, B: Clone>(f: |A| -> B, xs: &[A]) -> ~[B] {\n"
+"fn map<A: Clone, B: Clone>(f: &fn(A) -> B, xs: &[A]) -> ~[B] {\n"
 "    if xs.len() == 0 {\n"
 "       return ~[];\n"
 "    }\n"

branches/try/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/try/doc/po/ja/tutorial.md.po

@@ -3340,10 +3340,10 @@ msgstr ""
 
 #. type: Plain text
 #: doc/tutorial.md:1434
-msgid "~~~~ fn call_closure_with_ten(b: |int|) { b(10); }"
+msgid "~~~~ fn call_closure_with_ten(b: &fn(int)) { b(10); }"
 msgstr ""
 "~~~~\n"
-"fn call_closure_with_ten(b: |int|) { b(10); }"
+"fn call_closure_with_ten(b: &fn(int)) { b(10); }"
 
 #. type: Plain text
 #: doc/tutorial.md:1437
@@ -3400,11 +3400,11 @@ msgstr ""
 #: doc/tutorial.md:1459
 msgid ""
 "There are several forms of closure, each with its own role. The most common, "
-"called a _stack closure_, has type `||` and can directly access local "
+"called a _stack closure_, has type `&fn` and can directly access local "
 "variables in the enclosing scope."
 msgstr ""
 "クロージャにはいくつかの形態があり、それぞれに独自の役割があります。最も一般"
-"的なのはスタッククロージャと呼ばれるもので、 `||` という型を持ち、外側のロー"
+"的なのはスタッククロージャと呼ばれるもので、 `&fn` という型を持ち、外側のロー"
 "カル変数に直接アクセスすることができます。"
 
 #. type: Plain text
@@ -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` 型  で書き表される所有クロージャは安全にプロセス"
 "間で送信することができます。所有クローじゃはマネージドクロージャと全く同じよ"
 "うに閉じ込める値をコピーしますが、値を所有します。つまり、他のコードは閉じ込"
 "められた値にアクセスできなくなります。所有クロージャは並列プログラム、特に "
@@ -3531,27 +3531,27 @@ msgstr "## クロージャの互換性"
 msgid ""
 "Rust closures have a convenient subtyping property: you can pass any kind of "
 "closure (as long as the arguments and return types match) to functions that "
-"expect a `||`. Thus, when writing a higher-order function that only calls "
+"expect a `&fn()`. Thus, when writing a higher-order function that only calls "
 "its function argument, and does nothing else with it, you should almost "
-"always declare the type of that argument as `||`. That way, callers may "
+"always declare the type of that argument as `&fn()`. That way, callers may "
 "pass any kind of closure."
 msgstr ""
 "Rust のクロージャは型の派生 (subtyping) という便利な性質を持っています。この"
-"性質により、`||` 型を期待する関数には (引数と戻り値の型が一致する限り) 任"
+"性質により、`&fn()` 型を期待する関数には (引数と戻り値の型が一致する限り) 任"
 "意の種類のクロージャを渡すことができます。したがって、引数で渡された関数につ"
 "いては呼び出すだけで他に何もしない高階関数を書くときには、ほぼすべてのケース"
-"で引数の型を `||` と宣言するべきです。そうすることで、呼び出し元は任意の種類"
+"で引数の型を `&fn` と宣言するべきです。そうすることで、呼び出し元は任意の種類"
 "のクロージャを渡すことができるよになります。"
 
 #. type: Plain text
 #: doc/tutorial.md:1527
 msgid ""
-"~~~~ fn call_twice(f: ||) { f(); f(); } let closure = || { \"I'm a "
+"~~~~ fn call_twice(f: &fn()) { f(); f(); } let closure = || { \"I'm a "
 "closure, and it doesn't matter what type I am\"; }; fn function() { \"I'm a "
 "normal function\"; } call_twice(closure); call_twice(function); ~~~~"
 msgstr ""
 "~~~~\n"
-"fn call_twice(f: ||) { f(); f(); }\n"
+"fn call_twice(f: &fn()) { f(); f(); }\n"
 "let closure = || { \"I'm a closure, and it doesn't matter what type I am"
 "\"; };\n"
 "fn function() { \"I'm a normal function\"; }\n"
@@ -3598,7 +3598,7 @@ msgstr ""
 #, no-wrap
 msgid ""
 "~~~~\n"
-"fn each(v: &[int], op: |v: &int|) {\n"
+"fn each(v: &[int], op: &fn(v: &int)) {\n"
 "   let mut n = 0;\n"
 "   while n < v.len() {\n"
 "       op(&v[n]);\n"
@@ -3622,7 +3622,7 @@ msgstr ""
 #, no-wrap
 msgid ""
 "~~~~\n"
-"# fn each(v: &[int], op: |v: &int|) { }\n"
+"# fn each(v: &[int], op: &fn(v: &int)) { }\n"
 "# fn do_some_work(i: &int) { }\n"
 "each([1, 2, 3], |n| {\n"
 "    do_some_work(n);\n"
@@ -3644,7 +3644,7 @@ msgstr ""
 #, no-wrap
 msgid ""
 "~~~~\n"
-"# fn each(v: &[int], op: |v: &int|) { }\n"
+"# fn each(v: &[int], op: &fn(v: &int)) { }\n"
 "# fn do_some_work(i: &int) { }\n"
 "do each([1, 2, 3]) |n| {\n"
 "    do_some_work(n);\n"
@@ -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` は「引数をとらない所有クロージャ」を引数としてとる関数ということで"
 "す。"
 
@@ -4011,7 +4011,7 @@ msgstr ""
 #, no-wrap
 msgid ""
 "~~~~\n"
-"fn map<T, U>(vector: &[T], function: |v: &T| -> U) -> ~[U] {\n"
+"fn map<T, U>(vector: &[T], function: &fn(v: &T) -> U) -> ~[U] {\n"
 "    let mut accumulator = ~[];\n"
 "    for element in vector.iter() {\n"
 "        accumulator.push(function(element));\n"