---

yaml
---
r: 165678
b: refs/heads/auto
c: 15d5454
h: refs/heads/master
v: v3

Author: th0114nd

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 576467b4927d55dc47c28d9b8732db165522e2e2
+refs/heads/auto: 15d54549d7311893eacd43d7d6cb527ac2acf944
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/crates.mk

@@ -51,10 +51,9 @@
 
 TARGET_CRATES := libc std flate arena term \
                  serialize getopts collections test time rand \
-                 log regex graphviz core rbml alloc \
+                 log regex graphviz core rbml alloc rustrt \
                  unicode
-RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_resolve rustc_driver \
-                rustc_trans rustc_back rustc_llvm
+RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_driver rustc_trans rustc_back rustc_llvm 
 HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc regex_macros fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -63,17 +62,17 @@ DEPS_core :=
 DEPS_libc := core
 DEPS_unicode := core
 DEPS_alloc := core libc native:jemalloc
-DEPS_std := core libc rand alloc collections unicode \
-	native:rust_builtin native:backtrace native:rustrt_native
+DEPS_rustrt := alloc core libc collections native:rustrt_native
+DEPS_std := core libc rand alloc collections rustrt unicode \
+	native:rust_builtin native:backtrace
 DEPS_graphviz := std
 DEPS_syntax := std term serialize log fmt_macros arena libc
 DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \
-                     rustc_typeck rustc_resolve log syntax serialize rustc_llvm rustc_trans
+                     rustc_typeck log syntax serialize rustc_llvm rustc_trans
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back \
 	                log syntax serialize rustc_llvm
 DEPS_rustc_typeck := rustc syntax
 DEPS_rustc_borrowck := rustc log graphviz syntax
-DEPS_rustc_resolve := rustc log syntax
 DEPS_rustc := syntax flate arena serialize getopts rbml \
               time log graphviz rustc_llvm rustc_back
 DEPS_rustc_llvm := native:rustllvm libc std
@@ -120,11 +119,9 @@ DOC_CRATES := $(filter-out rustc, \
               $(filter-out rustc_trans, \
               $(filter-out rustc_typeck, \
               $(filter-out rustc_borrowck, \
-              $(filter-out rustc_resolve, \
               $(filter-out rustc_driver, \
-              $(filter-out syntax, $(CRATES))))))))
-COMPILER_DOC_CRATES := rustc rustc_trans rustc_borrowck rustc_resolve \
-                       rustc_typeck rustc_driver syntax
+              $(filter-out syntax, $(CRATES)))))))
+COMPILER_DOC_CRATES := rustc rustc_trans rustc_borrowck rustc_typeck rustc_driver syntax
 
 # This macro creates some simple definitions for each crate being built, just
 # some munging of all of the parameters above.

branches/auto/mk/dist.mk

@@ -229,7 +229,7 @@ dist-install-dir-$(1): prepare-base-dir-$(1) docs compiler-docs
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)LICENSE-APACHE $$(PREPARE_DEST_DIR)
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)LICENSE-MIT $$(PREPARE_DEST_DIR)
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)README.md $$(PREPARE_DEST_DIR)
-	$$(Q)[ ! -d doc ] || cp -r doc $$(PREPARE_DEST_DIR)
+	$$(Q)cp -r doc $$(PREPARE_DEST_DIR)
 
 dist/$$(PKG_NAME)-$(1).tar.gz: dist-install-dir-$(1)
 	@$(call E, build: $$@)
@@ -312,17 +312,9 @@ MAYBE_DIST_TAR_SRC=dist-tar-src
 MAYBE_DISTCHECK_TAR_SRC=distcheck-tar-src
 endif
 
-ifneq ($(CFG_DISABLE_DOCS),)
-MAYBE_DIST_DOCS=
-MAYBE_DISTCHECK_DOCS=
-else
-MAYBE_DIST_DOCS=dist-docs
-MAYBE_DISTCHECK_DOCS=distcheck-docs
-endif
-
-dist: $(MAYBE_DIST_TAR_SRC) dist-osx dist-tar-bins $(MAYBE_DIST_DOCS)
+dist: $(MAYBE_DIST_TAR_SRC) dist-osx dist-tar-bins dist-docs
 
-distcheck: $(MAYBE_DISTCHECK_TAR_SRC) distcheck-osx distcheck-tar-bins $(MAYBE_DISTCHECK_DOCS)
+distcheck: $(MAYBE_DISTCHECK_TAR_SRC) distcheck-osx distcheck-tar-bins distcheck-docs
 	$(Q)rm -Rf tmp/distcheck
 	@echo
 	@echo -----------------------------------------------

branches/auto/mk/docs.mk

@@ -216,6 +216,36 @@ endef
 $(foreach docname,$(DOCS),$(eval $(call DEF_DOC,$(docname))))
 
 
+# Localized documentation
+
+# FIXME: I (huonw) haven't actually been able to test properly, since
+# e.g. (by default) I'm doing an out-of-tree build (#12763), but even
+# adjusting for that, the files are too old(?) and are rejected by
+# po4a.
+#
+# As such, I've attempted to get it working as much as possible (and
+# switching from pandoc to rustdoc), but preserving the old behaviour
+# (e.g. only running on the guide)
+.PHONY: l10n-mds
+l10n-mds: $(D)/po4a.conf \
+		$(foreach lang,$(L10N_LANG),$(D)/po/$(lang)/*.md.po)
+	$(warning WARNING: localized documentation is experimental)
+	po4a --copyright-holder="The Rust Project Developers" \
+		--package-name="Rust" \
+		--package-version="$(CFG_RELEASE)" \
+		-M UTF-8 -L UTF-8 \
+		$(D)/po4a.conf
+
+define DEF_L10N_DOC
+DOC_L10N_TARGETS += doc/l10n/$(1)/$(2).html
+doc/l10n/$(1)/$(2).html: l10n-mds $$(HTML_DEPS) $$(RUSTDOC_DEPS_$(2))
+	@$$(call E, rustdoc: $$@)
+	$$(RUSTDOC) $$(RUSTDOC_HTML_OPTS) $$(RUSTDOC_FLAGS_$(1)) doc/l10n/$(1)/$(2).md
+endef
+
+$(foreach lang,$(L10N_LANGS),$(eval $(call DEF_L10N_DOC,$(lang),guide)))
+
+
 ######################################################################
 # Rustdoc (libstd/extra)
 ######################################################################
@@ -264,3 +294,7 @@ endif
 
 docs: $(DOC_TARGETS)
 compiler-docs: $(COMPILER_DOC_TARGETS)
+
+docs-l10n: $(DOC_L10N_TARGETS)
+
+.PHONY: docs-l10n

branches/auto/mk/tests.mk

@@ -21,8 +21,7 @@ $(eval $(call RUST_CRATE,coretest))
 
 TEST_TARGET_CRATES = $(filter-out core unicode,$(TARGET_CRATES)) coretest
 TEST_DOC_CRATES = $(DOC_CRATES)
-TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_resolve rustc_trans,\
-                     $(HOST_CRATES))
+TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_trans,$(HOST_CRATES))
 TEST_CRATES = $(TEST_TARGET_CRATES) $(TEST_HOST_CRATES)
 
 ######################################################################
@@ -300,7 +299,7 @@ tidy:
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
 		$(Q)echo $(ALL_HS) \
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
-		$(Q)find $(S)src -type f -perm /a+x \
+		$(Q)find $(S)src -type f -perm +a+x \
 		    -not -name '*.rs' -and -not -name '*.py' \
 		    -and -not -name '*.sh' \
 		| grep '^$(S)src/jemalloc' -v \

branches/auto/src/compiletest/runtest.rs

@@ -32,7 +32,7 @@ use std::io;
 use std::os;
 use std::str;
 use std::string::String;
-use std::thread::Thread;
+use std::task;
 use std::time::Duration;
 use test::MetricMap;
 
@@ -445,9 +445,9 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
             loop {
                 //waiting 1 second for gdbserver start
                 timer::sleep(Duration::milliseconds(1000));
-                let result = Thread::spawn(move || {
+                let result = task::try(move || {
                     tcp::TcpStream::connect("127.0.0.1:5039").unwrap();
-                }).join();
+                });
                 if result.is_err() {
                     continue;
                 }
@@ -1609,7 +1609,7 @@ fn _arm_exec_compiled_test(config: &Config,
                 stderr_out.as_slice());
 
     ProcRes {
-        status: process::ProcessExit::ExitStatus(exitcode),
+        status: process::ExitStatus(exitcode),
         stdout: stdout_out,
         stderr: stderr_out,
         cmdline: cmdline
@@ -1666,7 +1666,7 @@ fn compile_test_and_save_bitcode(config: &Config, props: &TestProps,
     // FIXME (#9639): This needs to handle non-utf8 paths
     let mut link_args = vec!("-L".to_string(),
                              aux_dir.as_str().unwrap().to_string());
-    let llvm_args = vec!("--emit=llvm-bc,obj".to_string(),
+    let llvm_args = vec!("--emit=bc,obj".to_string(),
                          "--crate-type=lib".to_string());
     link_args.extend(llvm_args.into_iter());
     let args = make_compile_args(config,

branches/auto/src/doc/README.md

@@ -6,6 +6,12 @@
 document converter, is required to generate docs as HTML from Rust's
 source code.
 
+[po4a](http://po4a.alioth.debian.org/) is required for generating translated
+docs from the master (English) docs.
+
+[GNU gettext](http://www.gnu.org/software/gettext/) is required for managing
+the translation data.
+
 ## Building
 
 To generate all the docs, just run `make docs` from the root of the repository.
@@ -38,3 +44,43 @@ The syntax for pandoc flavored markdown can be found at:
 A nice quick reference (for non-pandoc markdown) is at:
 
 - http://kramdown.gettalong.org/quickref.html
+
+## Notes for translators
+
+Notice: The procedure described below is a work in progress. We are working on
+translation system but the procedure contains some manual operations for now.
+
+To start the translation for a new language, see `po4a.conf` at first.
+
+To generate `.pot` and `.po` files, do something like:
+
+~~~~
+po4a --copyright-holder="The Rust Project Developers" \
+    --package-name="Rust" \
+    --package-version="0.13.0" \
+    -M UTF-8 -L UTF-8 \
+    src/doc/po4a.conf
+~~~~
+
+(the version number must be changed if it is not `0.13.0` now.)
+
+Now you can translate documents with `.po` files, commonly used with gettext. If
+you are not familiar with gettext-based translation, please read the online
+manual linked from http://www.gnu.org/software/gettext/ . We use UTF-8 as the
+file encoding of `.po` files.
+
+When you want to make a commit, do the command below before staging your
+change:
+
+~~~~
+for f in src/doc/po/**/*.po; do
+    msgattrib --translated $f -o $f.strip
+    if [ -e $f.strip ]; then
+       mv $f.strip $f
+    else
+       rm $f
+    fi
+done
+~~~~
+
+This removes untranslated entries from `.po` files to save disk space.

branches/auto/src/doc/guide-tasks.md

@@ -1,7 +1,5 @@
 % The Rust Tasks and Communication Guide
 
-**NOTE** This guide is badly out of date an needs to be rewritten.
-
 # Introduction
 
 Rust provides safe concurrent abstractions through a number of core library
@@ -24,7 +22,7 @@ from shared mutable state.
 At its simplest, creating a task is a matter of calling the `spawn` function
 with a closure argument. `spawn` executes the closure in the new task.
 
-```{rust,ignore}
+```{rust}
 # use std::task::spawn;
 
 // Print something profound in a different task using a named function
@@ -51,7 +49,7 @@ closure is limited to capturing `Send`-able data from its environment
 ensures that `spawn` can safely move the entire closure and all its
 associated state into an entirely different task for execution.
 
-```{rust,ignore}
+```{rust}
 # use std::task::spawn;
 # fn generate_task_number() -> int { 0 }
 // Generate some state locally
@@ -77,7 +75,7 @@ The simplest way to create a channel is to use the `channel` function to create
 of a channel, and a **receiver** is the receiving endpoint. Consider the following
 example of calculating two results concurrently:
 
-```{rust,ignore}
+```{rust}
 # use std::task::spawn;
 
 let (tx, rx): (Sender<int>, Receiver<int>) = channel();
@@ -98,15 +96,15 @@ stream for sending and receiving integers (the left-hand side of the `let`,
 `(tx, rx)`, is an example of a destructuring let: the pattern separates a tuple
 into its component parts).
 
-```{rust,ignore}
+```{rust}
 let (tx, rx): (Sender<int>, Receiver<int>) = channel();
 ```
 
 The child task will use the sender to send data to the parent task, which will
 wait to receive the data on the receiver. The next statement spawns the child
 task.
 
-```{rust,ignore}
+```{rust}
 # use std::task::spawn;
 # fn some_expensive_computation() -> int { 42 }
 # let (tx, rx) = channel();
@@ -125,7 +123,7 @@ computation, then sends the result over the captured channel.
 Finally, the parent continues with some other expensive computation, then waits
 for the child's result to arrive on the receiver:
 
-```{rust,ignore}
+```{rust}
 # fn some_other_expensive_computation() {}
 # let (tx, rx) = channel::<int>();
 # tx.send(0);
@@ -156,7 +154,7 @@ spawn(move || {
 
 Instead we can clone the `tx`, which allows for multiple senders.
 
-```{rust,ignore}
+```{rust}
 let (tx, rx) = channel();
 
 for init_val in range(0u, 3) {
@@ -181,7 +179,7 @@ Note that the above cloning example is somewhat contrived since you could also
 simply use three `Sender` pairs, but it serves to illustrate the point. For
 reference, written with multiple streams, it might look like the example below.
 
-```{rust,ignore}
+```{rust}
 # use std::task::spawn;
 
 // Create a vector of ports, one for each child task
@@ -205,7 +203,7 @@ getting the result later.
 
 The basic example below illustrates this.
 
-```{rust,ignore}
+```{rust}
 use std::sync::Future;
 
 # fn main() {
@@ -232,7 +230,7 @@ called.
 Here is another example showing how futures allow you to background
 computations. The workload will be distributed on the available cores.
 
-```{rust,ignore}
+```{rust}
 # use std::num::Float;
 # use std::sync::Future;
 fn partial_sum(start: uint) -> f64 {
@@ -270,7 +268,7 @@ Here is a small example showing how to use Arcs. We wish to run concurrently
 several computations on a single large vector of floats. Each task needs the
 full vector to perform its duty.
 
-```{rust,ignore}
+```{rust}
 use std::num::Float;
 use std::rand;
 use std::sync::Arc;
@@ -297,7 +295,7 @@ The function `pnorm` performs a simple computation on the vector (it computes
 the sum of its items at the power given as argument and takes the inverse power
 of this value). The Arc on the vector is created by the line:
 
-```{rust,ignore}
+```{rust}
 # use std::rand;
 # use std::sync::Arc;
 # fn main() {
@@ -311,7 +309,7 @@ the wrapper and not its contents. Within the task's procedure, the captured
 Arc reference can be used as a shared reference to the underlying vector as
 if it were local.
 
-```{rust,ignore}
+```{rust}
 # use std::rand;
 # use std::sync::Arc;
 # fn pnorm(nums: &[f64], p: uint) -> f64 { 4.0 }
@@ -348,17 +346,17 @@ and `()`, callers can pattern-match on a result to check whether it's an `Ok`
 result with an `int` field (representing a successful result) or an `Err` result
 (representing termination with an error).
 
-```{rust,ignore}
-# use std::thread::Thread;
+```{rust}
+# use std::task;
 # fn some_condition() -> bool { false }
 # fn calculate_result() -> int { 0 }
-let result: Result<int, Box<std::any::Any + Send>> = Thread::spawn(move || {
+let result: Result<int, Box<std::any::Any + Send>> = task::try(move || {
     if some_condition() {
         calculate_result()
     } else {
         panic!("oops!");
     }
-}).join();
+});
 assert!(result.is_err());
 ```