---

yaml
---
r: 232499
b: refs/heads/try
c: 1ddee80
h: refs/heads/master
i:
  232497: b399909
  232495: 3633441
v: v3

Author: eefriedman

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: edeb4f1c86cbf6af8ef9874d4b3af50f721ea1b8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: de67d62c6b7e76ca53b66b3796258238348b3c96
+refs/heads/try: 1ddee8070d3cb83609b1f71c29e3deda3d30fd51
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/mk/crates.mk

@@ -52,38 +52,37 @@
 TARGET_CRATES := libc std flate arena term \
                  serialize getopts collections test rand \
                  log graphviz core rbml alloc \
-                 rustc_unicode rustc_bitflags \
-		 alloc_system
+                 rustc_unicode rustc_bitflags
 RUSTC_CRATES := rustc rustc_typeck rustc_borrowck rustc_resolve rustc_driver \
                 rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
-                rustc_data_structures rustc_platform_intrinsics
+                rustc_data_structures
 HOST_CRATES := syntax $(RUSTC_CRATES) rustdoc fmt_macros
+CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc rustbook error-index-generator
 
 DEPS_core :=
 DEPS_libc := core
 DEPS_rustc_unicode := core
-DEPS_alloc := core libc alloc_system
+DEPS_alloc := core libc native:jemalloc
 DEPS_std := core libc rand alloc collections rustc_unicode \
 	native:rust_builtin native:backtrace \
-	alloc_system
+	rustc_bitflags
 DEPS_graphviz := std
-DEPS_syntax := std term serialize log fmt_macros arena libc rustc_bitflags
+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_privacy rustc_lint
 
 DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back \
-	                log syntax serialize rustc_llvm rustc_platform_intrinsics
-DEPS_rustc_typeck := rustc syntax rustc_platform_intrinsics
+	                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_privacy := rustc log syntax
 DEPS_rustc_lint := rustc log syntax
 DEPS_rustc := syntax flate arena serialize getopts rbml \
               log graphviz rustc_llvm rustc_back rustc_data_structures
-DEPS_rustc_llvm := native:rustllvm libc std rustc_bitflags
-DEPS_rustc_platform_intrinsics := rustc rustc_llvm
+DEPS_rustc_llvm := native:rustllvm libc std
 DEPS_rustc_back := std syntax rustc_llvm flate log libc
 DEPS_rustc_data_structures := std log serialize
 DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts \
@@ -103,7 +102,6 @@ DEPS_test := std getopts serialize rbml term native:rust_test_helpers
 DEPS_rand := core
 DEPS_log := std
 DEPS_fmt_macros = std
-DEPS_alloc_system := core libc
 
 TOOL_DEPS_compiletest := test getopts
 TOOL_DEPS_rustdoc := rustdoc
@@ -123,26 +121,14 @@ ONLY_RLIB_rand := 1
 ONLY_RLIB_collections := 1
 ONLY_RLIB_rustc_unicode := 1
 ONLY_RLIB_rustc_bitflags := 1
-ONLY_RLIB_alloc_system := 1
 
 # Documented-by-default crates
 DOC_CRATES := std alloc collections core libc rustc_unicode
 
-ifeq ($(CFG_DISABLE_JEMALLOC),)
-TARGET_CRATES += alloc_jemalloc
-DEPS_std += alloc_jemalloc
-DEPS_alloc_jemalloc := core libc native:jemalloc
-ONLY_RLIB_alloc_jemalloc := 1
-else
-RUSTFLAGS_rustc_back := --cfg disable_jemalloc
-endif
-
 ################################################################################
 # You should not need to edit below this line
 ################################################################################
 
-CRATES := $(TARGET_CRATES) $(HOST_CRATES)
-
 # This macro creates some simple definitions for each crate being built, just
 # some munging of all of the parameters above.
 #

branches/try/mk/rt.mk

@@ -184,6 +184,8 @@ $$(JEMALLOC_LOCAL_$(1)): $$(JEMALLOC_DEPS) $$(MKFILE_DEPS)
 		EXTRA_CFLAGS="-g1 -ffunction-sections -fdata-sections"
 	$$(Q)$$(MAKE) -C "$$(JEMALLOC_BUILD_DIR_$(1))" build_lib_static
 
+ifeq ($$(CFG_DISABLE_JEMALLOC),)
+RUSTFLAGS_alloc := --cfg jemalloc
 ifeq ($(1),$$(CFG_BUILD))
 ifneq ($$(CFG_JEMALLOC_ROOT),)
 $$(JEMALLOC_LIB_$(1)): $$(CFG_JEMALLOC_ROOT)/libjemalloc_pic.a
@@ -197,6 +199,10 @@ else
 $$(JEMALLOC_LIB_$(1)): $$(JEMALLOC_LOCAL_$(1))
 	$$(Q)cp $$< $$@
 endif
+else
+$$(JEMALLOC_LIB_$(1)): $$(MKFILE_DEPS)
+	$$(Q)touch $$@
+endif
 
 ################################################################################
 # compiler-rt

branches/try/mk/tests.mk

@@ -22,8 +22,7 @@ $(eval $(call RUST_CRATE,coretest))
 DEPS_collectionstest :=
 $(eval $(call RUST_CRATE,collectionstest))
 
-TEST_TARGET_CRATES = $(filter-out core rustc_unicode alloc_system \
-		     		  alloc_jemalloc,$(TARGET_CRATES)) \
+TEST_TARGET_CRATES = $(filter-out core rustc_unicode,$(TARGET_CRATES)) \
 			collectionstest coretest
 TEST_DOC_CRATES = $(DOC_CRATES)
 TEST_HOST_CRATES = $(filter-out rustc_typeck rustc_borrowck rustc_resolve \

branches/try/src/doc/trpl/the-stack-and-the-heap.md

@@ -549,7 +549,7 @@ reuse.
 If you’d like to dive into this topic in greater detail, [this paper][wilson]
 is a great introduction.
 
-[wilson]: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.143.4688
+[wilson]: http://www.cs.northwestern.edu/~pdinda/icsclass/doc/dsa.pdf
 
 ## Semantic impact
 

branches/try/src/etc/unicode.py

@@ -395,6 +395,46 @@ def emit_conversions_module(f, to_upper, to_lower, to_title):
         is_pub=False, t_type = t_type, pfun=pfun)
     f.write("}\n\n")
 
+def emit_grapheme_module(f, grapheme_table, grapheme_cats):
+    f.write("""pub mod grapheme {
+    use core::slice::SliceExt;
+    pub use self::GraphemeCat::*;
+    use core::result::Result::{Ok, Err};
+
+    #[allow(non_camel_case_types)]
+    #[derive(Clone, Copy)]
+    pub enum GraphemeCat {
+""")
+    for cat in grapheme_cats + ["Any"]:
+        f.write("        GC_" + cat + ",\n")
+    f.write("""    }
+
+    fn bsearch_range_value_table(c: char, r: &'static [(char, char, GraphemeCat)]) -> GraphemeCat {
+        use core::cmp::Ordering::{Equal, Less, Greater};
+        match r.binary_search_by(|&(lo, hi, _)| {
+            if lo <= c && c <= hi { Equal }
+            else if hi < c { Less }
+            else { Greater }
+        }) {
+            Ok(idx) => {
+                let (_, _, cat) = r[idx];
+                cat
+            }
+            Err(_) => GC_Any
+        }
+    }
+
+    pub fn grapheme_category(c: char) -> GraphemeCat {
+        bsearch_range_value_table(c, grapheme_cat_table)
+    }
+
+""")
+
+    emit_table(f, "grapheme_cat_table", grapheme_table, "&'static [(char, char, GraphemeCat)]",
+        pfun=lambda x: "(%s,%s,GC_%s)" % (escape_char(x[0]), escape_char(x[1]), x[2]),
+        is_pub=False)
+    f.write("}\n")
+
 def emit_charwidth_module(f, width_table):
     f.write("pub mod charwidth {\n")
     f.write("    use core::option::Option;\n")
@@ -457,6 +497,79 @@ def emit_norm_module(f, canon, compat, combine, norm_props):
     canon_comp_keys = canon_comp.keys()
     canon_comp_keys.sort()
 
+    f.write("pub mod normalization {\n")
+
+    def mkdata_fun(table):
+        def f(char):
+            data = "(%s,&[" % escape_char(char)
+            first = True
+            for d in table[char]:
+                if not first:
+                    data += ","
+                first = False
+                data += escape_char(d)
+            data += "])"
+            return data
+        return f
+
+    f.write("    // Canonical decompositions\n")
+    emit_table(f, "canonical_table", canon_keys, "&'static [(char, &'static [char])]",
+        pfun=mkdata_fun(canon))
+
+    f.write("    // Compatibility decompositions\n")
+    emit_table(f, "compatibility_table", compat_keys, "&'static [(char, &'static [char])]",
+        pfun=mkdata_fun(compat))
+
+    def comp_pfun(char):
+        data = "(%s,&[" % escape_char(char)
+        canon_comp[char].sort(lambda x, y: x[0] - y[0])
+        first = True
+        for pair in canon_comp[char]:
+            if not first:
+                data += ","
+            first = False
+            data += "(%s,%s)" % (escape_char(pair[0]), escape_char(pair[1]))
+        data += "])"
+        return data
+
+    f.write("    // Canonical compositions\n")
+    emit_table(f, "composition_table", canon_comp_keys,
+        "&'static [(char, &'static [(char, char)])]", pfun=comp_pfun)
+
+    f.write("""
+    fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
+        use core::cmp::Ordering::{Equal, Less, Greater};
+        use core::slice::SliceExt;
+        use core::result::Result::{Ok, Err};
+        match r.binary_search_by(|&(lo, hi, _)| {
+            if lo <= c && c <= hi { Equal }
+            else if hi < c { Less }
+            else { Greater }
+        }) {
+            Ok(idx) => {
+                let (_, _, result) = r[idx];
+                result
+            }
+            Err(_) => 0
+        }
+    }\n
+""")
+
+    emit_table(f, "combining_class_table", combine, "&'static [(char, char, u8)]", is_pub=False,
+            pfun=lambda x: "(%s,%s,%s)" % (escape_char(x[0]), escape_char(x[1]), x[2]))
+
+    f.write("""    #[deprecated(reason = "use the crates.io `unicode-normalization` lib instead",
+                 since = "1.0.0")]
+    #[unstable(feature = "unicode",
+               reason = "this functionality will be moved to crates.io")]
+    pub fn canonical_combining_class(c: char) -> u8 {
+        bsearch_range_value_table(c, combining_class_table)
+    }
+
+}
+
+""")
+
 def remove_from_wtable(wtable, val):
     wtable_out = []
     while wtable:
@@ -536,3 +649,53 @@ def optimize_width_table(wtable):
         # normalizations and conversions module
         emit_norm_module(rf, canon_decomp, compat_decomp, combines, norm_props)
         emit_conversions_module(rf, to_upper, to_lower, to_title)
+
+        ### character width module
+        width_table = []
+        for zwcat in ["Me", "Mn", "Cf"]:
+            width_table.extend(map(lambda (lo, hi): (lo, hi, 0, 0), gencats[zwcat]))
+        width_table.append((4448, 4607, 0, 0))
+
+        # get widths, except those that are explicitly marked zero-width above
+        ea_widths = load_east_asian_width(["W", "F", "A"], ["Me", "Mn", "Cf"])
+        # these are doublewidth
+        for dwcat in ["W", "F"]:
+            width_table.extend(map(lambda (lo, hi): (lo, hi, 2, 2), ea_widths[dwcat]))
+        width_table.extend(map(lambda (lo, hi): (lo, hi, 1, 2), ea_widths["A"]))
+
+        width_table.sort(key=lambda w: w[0])
+
+        # soft hyphen is not zero width in preformatted text; it's used to indicate
+        # a hyphen inserted to facilitate a linebreak.
+        width_table = remove_from_wtable(width_table, 173)
+
+        # optimize the width table by collapsing adjacent entities when possible
+        width_table = optimize_width_table(width_table)
+        emit_charwidth_module(rf, width_table)
+
+        ### grapheme cluster module
+        # from http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Break_Property_Values
+        grapheme_cats = load_properties("auxiliary/GraphemeBreakProperty.txt", [])
+
+        # Control
+        #  Note 1:
+        # This category also includes Cs (surrogate codepoints), but Rust's `char`s are
+        # Unicode Scalar Values only, and surrogates are thus invalid `char`s.
+        # Thus, we have to remove Cs from the Control category
+        #  Note 2:
+        # 0x0a and 0x0d (CR and LF) are not in the Control category for Graphemes.
+        # However, the Graphemes iterator treats these as a special case, so they
+        # should be included in grapheme_cats["Control"] for our implementation.
+        grapheme_cats["Control"] = group_cat(list(
+            (set(ungroup_cat(grapheme_cats["Control"]))
+             | set(ungroup_cat(grapheme_cats["CR"]))
+             | set(ungroup_cat(grapheme_cats["LF"])))
+            - set(ungroup_cat([surrogate_codepoints]))))
+        del(grapheme_cats["CR"])
+        del(grapheme_cats["LF"])
+
+        grapheme_table = []
+        for cat in grapheme_cats:
+            grapheme_table.extend([(x, y, cat) for (x, y) in grapheme_cats[cat]])
+        grapheme_table.sort(key=lambda w: w[0])
+        emit_grapheme_module(rf, grapheme_table, grapheme_cats.keys())