---

yaml
---
r: 13797
b: refs/heads/try
c: fe57a7e
h: refs/heads/master
i:
  13795: f6ee3db
v: v3

Author: unknown

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 08c6cb5f708efa7484ca27d6b14b86d6ae58b692
+refs/heads/try: fe57a7e582aea2a92e12d9b34cdec678f11edd6f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/AUTHORS.txt

@@ -26,9 +26,7 @@ Jeff Balogh <[email protected]>
 Jeff Muizelaar <[email protected]>
 Jeffrey Yasskin <[email protected]>
 Jesse Ruderman <[email protected]>
-Joe Pletcher <[email protected]>
 Josh Matthews <[email protected]>
-Joshua Clark <[email protected]>
 Joshua Wise <[email protected]>
 Jyun-Yan You <[email protected]>
 Kelly Wilson <[email protected]>

branches/try/LICENSE.txt

@@ -186,6 +186,17 @@ included:
     USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
     OF SUCH DAMAGE.
 
+* The auxiliary file src/etc/pkg/modpath.iss contains a
+  library routine compiled, by Inno Setup, into the Windows
+  installer binary. This file is licensed under the LGPL,
+  but, in our legal interpretation, this does not affect the
+  aggregate "collected work" license of the Rust
+  distribution (MIT) nor any other components of it. We
+  believe that the terms governing distribution of the
+  binary Windows installer built from modpath.iss are
+  therefore LGPL, but not the terms governing distribution
+  of any of the files installed by such an installer (such
+  as the Rust compiler or runtime libraries themselves).
 
 * The libuv asynchronous I/O library. Code for this package
   is found in the src/rt/libuv directory, within this

branches/try/Makefile.in

@@ -114,7 +114,7 @@ LIBRUSTC_GLOB :=$(call CFG_LIB_GLOB,rustc)
 
 # version-string calculation
 CFG_GIT_DIR := $(CFG_SRC_DIR).git
-CFG_RELEASE = 0.2pre
+CFG_RELEASE = 0.1.1
 CFG_VERSION = $(CFG_RELEASE)
 
 ifneq ($(wildcard $(CFG_GIT)),)

branches/try/configure

@@ -289,7 +289,7 @@ probe CFG_GCC              gcc
 probe CFG_LLVM_CONFIG      llvm-config
 probe CFG_VALGRIND         valgrind
 probe CFG_PERF             perf
-probe CFG_MAKENSIS         makensis
+probe CFG_ISCC             iscc
 probe CFG_NATURALDOCS      NaturalDocs naturaldocs
 probe CFG_LLNEXTGEN        LLnextgen
 probe CFG_PANDOC           pandoc
@@ -340,8 +340,7 @@ then
     CFG_CLANG_VERSION=$("$CFG_CLANG" \
                       --version \
                       | grep version \
-                      | sed 's/.*\(version .*\)/\1/' \
-                      | cut -d ' ' -f 2)
+                      | cut -d ' ' -f 3)
 
     case $CFG_CLANG_VERSION in
         (3.0svn | 3.0 | 3.1)

branches/try/doc/rust.md

@@ -761,9 +761,7 @@ fn main() {
 ##### Export declarations
 
 ~~~~~~~~ {.ebnf .gram}
-export_decl : "export" ident [ ',' ident ] * 
-            | "export" ident "::{}"
-            | "export" ident '{' ident [ ',' ident ] * '}' ;
+export_decl : "export" ident [ ',' ident ] * ;
 ~~~~~~~~
 
 An _export declaration_ restricts the set of local names within a module that
@@ -815,40 +813,6 @@ mod foo {
 }
 ~~~~~~~~
 
-When exporting the name of an `enum` type `t`, by default, the module also
-implicitly exports all of `t`'s constructors. For example:
-
-~~~~~~~~
-mod foo {
-    export t;
-    
-    enum t {a, b, c};
-}
-~~~~~~~~
-
-Here, `foo` imports `t`, `a`, `b`, and `c`. 
-
-The second and third forms of export declaration can be used to export
-an `enum` item without exporting all of its constructors. These two
-forms can only be used to export an `enum` item. The second form
-exports the `enum` type name without exporting any of its
-constructors, achieving a simple kind of data abstraction. The third
-form exports an `enum` type name along with a subset of its
-constructors. For example:
-
-~~~~~~~~
-mod foo {
-    export abstract{};
-    export slightly_abstract{a, b};
-
-    enum abstract {x, y, z}
-    enum slightly_abstract {a, b, c, d}
-} 
-~~~~~~~~
-
-Module `foo` exports the types `abstract` and `slightly_abstract`, as well as
-constructors `a` and `b`, but doesn't export constructors `x`, `y`, `z`, `c`,
-or `d`.
 
 ### Functions
 
@@ -1058,9 +1022,7 @@ accessed through the components `x` and `y`, and laid out in memory with the
 An _enumeration item_ simultaneously declares a new nominal
 [enumerated type](#enumerated-types) as well as a set of *constructors* that
 can be used to create or pattern-match values of the corresponding enumerated
-type. Note that `enum` previously was refered to as a `tag`, however this
-definition has been deprecated. While `tag` is no longer used, the two are 
-synonymous.
+type.
 
 The constructors of an `enum` type may be recursive: that is, each constructor
 may take an argument that refers, directly or indirectly, to the enumerated
@@ -1681,13 +1643,13 @@ x.y <- c;
 A _swap expression_ consists of an *lval* followed by a bi-directional arrow
 (`<->`) and another *lval* expression.
 
-Evaluating a swap expression causes, as a side effect, the values held in the
+Evaluating a swap expression causes, as a side effect, the vales held in the
 left-hand-side and right-hand-side *lvals* to be exchanged indivisibly.
 
-Evaluating a swap expression neither changes reference counts nor deeply
-copies any unique structure pointed to by the moved
-*rval*. Instead, the swap expression represents an indivisible *exchange of
-ownership* between the right-hand-side and the left-hand-side of the
+Evaluating a move expression does not change reference counts, nor does it
+cause a deep copy of any unique structure pointed to by the moved
+*rval*. Instead, the move expression represents an indivisible *exchange of
+ownership* between the right-hand-side to the left-hand-side of the
 expression. No allocation or destruction is entailed.
 
 An example of three different swap expressions:
@@ -2009,7 +1971,7 @@ alt_pat : pat [ "to" pat ] ? [ "if" expr ] ;
 
 An `alt` expression branches on a *pattern*. The exact form of matching that
 occurs depends on the pattern. Patterns consist of some combination of
-literals, destructured enum constructors, records and tuples, variable binding
+literals, destructured tag constructors, records and tuples, variable binding
 specifications and placeholders (`_`). An `alt` expression has a *head
 expression*, which is the value to compare to the patterns. The type of the
 patterns must equal the type of the head expression.
@@ -2024,7 +1986,7 @@ An example of an `alt` expression:
 
 
 ~~~~
-enum list<X> { nil; cons(X, @list<X>); }
+tag list<X> { nil; cons(X, @list<X>); }
 
 let x: list<int> = cons(10, @cons(11, @nil));
 
@@ -3288,7 +3250,7 @@ such as vectors, strings, and the low level communication system (ports,
 channels, tasks).
 
 Support for other built-in types such as simple types, tuples, records, and
-enums is open-coded by the Rust compiler.
+tags is open-coded by the Rust compiler.
 
 
 

branches/try/doc/tutorial.md

@@ -92,9 +92,7 @@ packages:
   * curl
 
 Assuming you're on a relatively modern Linux system and have met the
-prerequisites, something along these lines should work. Building from source on
-Windows requires some extra steps: please see the
-[getting started][wiki-get-started] page on the Rust wiki.
+prerequisites, something along these lines should work:
 
 ~~~~
 ## notrust
@@ -105,9 +103,8 @@ $ ./configure
 $ make && make install
 ~~~~
 
-You may need to use `sudo make install` if you do not normally have
-permission to modify the destination directory (either `/usr/local/bin`
-or the directory specified with to `configure` with `--prefix`).
+Building from source on windows requires some extra steps, please see
+the [getting started][wiki-get-started] page on the Rust wiki.
 
 When complete, `make install` will place the following programs into
 `/usr/local/bin`:
@@ -1349,7 +1346,7 @@ destructors. Resources might go away in the future.
 Rust datatypes are not trivial to copy (the way, for example,
 JavaScript values can be copied by simply taking one or two machine
 words and plunking them somewhere else). Shared boxes require
-reference count updates, big records, enums, or unique pointers require
+reference count updates, big records, tags, or unique pointers require
 an arbitrary amount of data to be copied (plus updating the reference
 counts of shared boxes hanging off them).
 
@@ -1462,7 +1459,7 @@ alt my_rec {
 
 The fact that arguments are conceptually passed by safe reference does
 not mean all arguments are passed by pointer. Composite types like
-records and enums *are* passed by pointer, but single-word values, like
+records and tags *are* passed by pointer, but single-word values, like
 integers and pointers, are simply passed by value. Most of the time,
 the programmer does not have to worry about this, as the compiler will
 simply pick the most efficient passing style. There is one exception,

branches/try/mk/dist.mk

@@ -6,8 +6,9 @@ PKG_NAME := rust
 PKG_DIR = $(PKG_NAME)-$(CFG_RELEASE)
 PKG_TAR = $(PKG_DIR).tar.gz
 
-ifdef CFG_MAKENSIS
-PKG_NSI = $(S)src/etc/pkg/rust.nsi
+ifdef CFG_ISCC
+PKG_ISS = $(wildcard $(S)src/etc/pkg/*.iss)
+PKG_ICO = $(S)src/etc/pkg/rust-logo.ico
 PKG_EXE = $(PKG_DIR)-install.exe
 endif
 
@@ -38,18 +39,23 @@ PKG_FILES := \
 
 UNROOTED_PKG_FILES := $(patsubst $(S)%,./%,$(PKG_FILES))
 
-lic.txt: $(S)LICENSE.txt
-	@$(call E, crlf: $@)
-	@$(Q)perl -pe 's@\r\n|\n@\r\n@go' <$< >$@
+ifdef CFG_ISCC
+LICENSE.txt: $(S)LICENSE.txt
+	cp $< $@
 
-ifdef CFG_MAKENSIS
-$(PKG_EXE): $(PKG_NSI) $(PKG_FILES) all rustc-stage3 lic.txt
-	@$(call E, makensis: $@)
-	$(Q)"$(CFG_MAKENSIS)" -NOCD -V1 "-XOutFile $@" \
-                        "-XLicenseData lic.txt" $<
-	$(Q)rm -f lic.txt
+%.iss: $(S)src/etc/pkg/%.iss
+	cp $< $@
+
+%.ico: $(S)src/etc/pkg/%.ico
+	cp $< $@
+
+$(PKG_EXE): rust.iss modpath.iss LICENSE.txt rust-logo.ico \
+            $(PKG_FILES) all rustc-stage3
+	@$(call E, ISCC: $@)
+	$(Q)"$(CFG_ISCC)" $<
 endif
 
+
 $(PKG_TAR): $(PKG_FILES)
 	@$(call E, making dist dir)
 	$(Q)rm -Rf dist
@@ -68,7 +74,7 @@ $(PKG_TAR): $(PKG_FILES)
 	$(Q)tar -czf $(PKG_TAR) -C dist $(PKG_DIR)
 	$(Q)rm -Rf dist
 
-.PHONY: dist nsis-dist distcheck
+.PHONY: dist distcheck
 
 ifdef CFG_WINDOWSY
 
@@ -84,8 +90,6 @@ else
 
 dist: $(PKG_TAR)
 
-nsis-dist: $(PKG_EXE)
-
 distcheck: $(PKG_TAR)
 	$(Q)rm -Rf dist
 	$(Q)mkdir -p dist

branches/try/mk/platform.mk

@@ -188,8 +188,7 @@ ifeq ($(CFG_C_COMPILER),clang)
   CC=clang
   CXX=clang++
   CPP=cpp
-  # -Wno-c++11-compat allows us to use 'alignof' as an identifier in the runtime
-  CFG_GCCISH_CFLAGS += -Wall -Werror -Wno-c++11-compat -fno-rtti -g
+  CFG_GCCISH_CFLAGS += -Wall -Werror -fno-rtti -g
   CFG_GCCISH_LINK_FLAGS += -g
   CFG_DEPEND_C = $(CFG_GCCISH_CROSS)$(CXX) $(CFG_GCCISH_CFLAGS) -MT "$(1)" \
     -MM $(2)