---

yaml
---
r: 144188
b: refs/heads/try2
c: 83f4bee
h: refs/heads/master
v: v3

Author: Florob

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: e66478193b1ad0582cdabb5ca769a85b26ea000c
+refs/heads/try2: 83f4bee44f077c8f45eb2bd314aee7f2af8ee0dc
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -788,7 +788,7 @@ extern mod complicated_mod = "some-file/in/the-rust/path";
 ##### Use declarations
 
 ~~~~~~~~ {.ebnf .gram}
-use_decl : "pub" ? "use" ident [ '=' path
+use_decl : "pub"? "use" ident [ '=' path
                           | "::" path_glob ] ;
 
 path_glob : ident [ "::" path_glob ] ?
@@ -1920,7 +1920,7 @@ it is automatically dereferenced to make the field access possible.
 ### Vector expressions
 
 ~~~~~~~~{.ebnf .gram}
-vec_expr : '[' "mut" ? vec_elems? ']'
+vec_expr : '[' "mut"? vec_elems? ']'
 
 vec_elems : [expr [',' expr]*] | [expr ',' ".." expr]
 ~~~~~~~~

branches/try2/src/etc/extract_grammar.py

@@ -93,11 +93,7 @@
 
 "//": "linecomment",
 "/*": "openblockcomment",
-"*/": "closeblockcomment",
-"macro_rules": "macro_rules",
-"=>" : "eg",
-".." : "dotdot",
-","  : "comma"
+"*/": "closeblockcomment"
 }
 
 lines = []

branches/try2/src/etc/unicode.py

@@ -178,50 +178,118 @@ def emit_property_module_old(f, mod, tbl):
         f.write("    }\n\n")
     f.write("}\n")
 
+def format_table_content(f, content, indent):
+    line = " "*indent
+    first = True
+    for chunk in content.split(","):
+        if len(line) + len(chunk) < 98:
+            if first:
+                line += chunk
+            else:
+                line += ", " + chunk
+            first = False
+        else:
+            f.write(line + ",\n")
+            line = " "*indent + chunk
+    f.write(line)
+
 def emit_decomp_module(f, canon, compat):
     canon_keys = canon.keys()
     canon_keys.sort()
 
     compat_keys = compat.keys()
     compat_keys.sort()
-    f.write("mod decompose {\n\n");
-    f.write("    export canonical, compatibility;\n\n")
-    f.write("    fn canonical(c: char, i: block(char)) "
-            + "{ d(c, i, false); }\n\n")
-    f.write("    fn compatibility(c: char, i: block(char)) "
+    f.write("pub mod decompose {\n");
+    f.write("    use option::Option;\n");
+    f.write("    use option::{Some, None};\n");
+    f.write("    use vec::ImmutableVector;\n");
+    f.write("""
+    fn bsearch_table(c: char, r: &'static [(char, &'static [char])]) -> Option<&'static [char]> {
+        use cmp::{Equal, Less, Greater};
+        match r.bsearch(|&(val, _)| {
+            if c == val { Equal }
+            else if val < c { Less }
+            else { Greater }
+        }) {
+            Some(idx) => {
+                let (_, result) = r[idx];
+                Some(result)
+            }
+            None => None
+        }
+    }\n\n
+""")
+    f.write("    // Canonical decompositions\n")
+    f.write("    static canonical_table : &'static [(char, &'static [char])] = &[\n")
+    data = ""
+    first = True
+    for char in canon_keys:
+        if not first:
+            data += ","
+        first = False
+        data += "(%s,&[" % escape_char(char)
+        first2 = True
+        for d in canon[char]:
+            if not first2:
+                data += ","
+            first2 = False
+            data += escape_char(d)
+        data += "])"
+    format_table_content(f, data, 8)
+    f.write("\n    ];\n\n")
+    f.write("    // Compatibility decompositions\n")
+    f.write("    static compatibility_table : &'static [(char, &'static [char])] = &[\n")
+    data = ""
+    first = True
+    for char in compat_keys:
+        if not first:
+            data += ","
+        first = False
+        data += "(%s,&[" % escape_char(char)
+        first2 = True
+        for d in compat[char]:
+            if not first2:
+                data += ","
+            first2 = False
+            data += escape_char(d)
+        data += "])"
+    format_table_content(f, data, 8)
+    f.write("\n    ];\n\n")
+    f.write("    pub fn canonical(c: char, i: &fn(char)) "
+        + "{ d(c, i, false); }\n\n")
+    f.write("    pub fn compatibility(c: char, i: &fn(char)) "
             +"{ d(c, i, true); }\n\n")
-    f.write("    fn d(c: char, i: block(char), k: bool) {\n")
+    f.write("    fn d(c: char, i: &fn(char), k: bool) {\n")
+    f.write("        use iterator::Iterator;\n");
 
-    f.write("        if c <= '\\x7f' { i(c); ret; }\n")
+    f.write("        if c <= '\\x7f' { i(c); return; }\n")
 
     # First check the canonical decompositions
-    f.write("        // Canonical decomposition\n")
-    f.write("        alt c {\n")
-    for char in canon_keys:
-        f.write("          %s {\n" % escape_char(char))
-        for d in canon[char]:
-            f.write("            d(%s, i, k);\n"
-                    % escape_char(d))
-        f.write("          }\n")
-
-    f.write("          _ { }\n")
-    f.write("        }\n\n")
+    f.write("""
+        match bsearch_table(c, canonical_table) {
+            Some(canon) => {
+                for x in canon.iter() {
+                    d(*x, |b| i(b), k);
+                }
+                return;
+            }
+            None => ()
+        }\n\n""")
 
     # Bottom out if we're not doing compat.
-    f.write("        if !k { i(c); ret; }\n\n ")
+    f.write("        if !k { i(c); return; }\n")
 
     # Then check the compatibility decompositions
-    f.write("        // Compatibility decomposition\n")
-    f.write("        alt c {\n")
-    for char in compat_keys:
-        f.write("          %s {\n" % escape_char(char))
-        for d in compat[char]:
-            f.write("            d(%s, i, k);\n"
-                    % escape_char(d))
-        f.write("          }\n")
-
-    f.write("          _ { }\n")
-    f.write("        }\n\n")
+    f.write("""
+        match bsearch_table(c, compatibility_table) {
+            Some(compat) => {
+                for x in compat.iter() {
+                    d(*x, |b| i(b), k);
+                }
+                return;
+            }
+            None => ()
+        }\n\n""")
 
     # Finally bottom out.
     f.write("        i(c);\n")
@@ -256,7 +324,7 @@ def emit_decomp_module(f, canon, compat):
 
 emit_property_module(rf, "general_category", gencats)
 
-#emit_decomp_module(rf, canon_decomp, compat_decomp)
+emit_decomp_module(rf, canon_decomp, compat_decomp)
 
 derived = load_derived_core_properties("DerivedCoreProperties.txt")
 emit_property_module(rf, "derived_property", derived)

branches/try2/src/libstd/char.rs

@@ -13,7 +13,7 @@
 use option::{None, Option, Some};
 use int;
 use str::StrSlice;
-use unicode::{derived_property, general_category};
+use unicode::{derived_property, general_category, decompose};
 
 #[cfg(test)] use str::OwnedStr;
 
@@ -202,6 +202,51 @@ pub fn from_digit(num: uint, radix: uint) -> Option<char> {
     }
 }
 
+// Constants from Unicode 6.2.0 Section 3.12 Conjoining Jamo Behavior
+static S_BASE: uint = 0xAC00;
+static L_BASE: uint = 0x1100;
+static V_BASE: uint = 0x1161;
+static T_BASE: uint = 0x11A7;
+static L_COUNT: uint = 19;
+static V_COUNT: uint = 21;
+static T_COUNT: uint = 28;
+static N_COUNT: uint = (V_COUNT * T_COUNT);
+static S_COUNT: uint = (L_COUNT * N_COUNT);
+
+// Decompose a precomposed Hangul syllable
+fn decompose_hangul(s: char, f: &fn(char)) {
+    let si = s as uint - S_BASE;
+
+    let li = si / N_COUNT;
+    f((L_BASE + li) as char);
+
+    let vi = (si % N_COUNT) / T_COUNT;
+    f((V_BASE + vi) as char);
+
+    let ti = si % T_COUNT;
+    if ti > 0 {
+        f((T_BASE + ti) as char);
+    }
+}
+
+/// Returns the canonical decompostion of a character
+pub fn decompose_canonical(c: char, f: &fn(char)) {
+    if (c as uint) < S_BASE || (c as uint) >= (S_BASE + S_COUNT) {
+        decompose::canonical(c, f);
+    } else {
+        decompose_hangul(c, f);
+    }
+}
+
+/// Returns the compatibility decompostion of a character
+pub fn decompose_compatible(c: char, f: &fn(char)) {
+    if (c as uint) < S_BASE || (c as uint) >= (S_BASE + S_COUNT) {
+        decompose::compatibility(c, f);
+    } else {
+        decompose_hangul(c, f);
+    }
+}
+
 ///
 /// Return the hexadecimal unicode escape of a char.
 ///

branches/try2/src/libstd/iterator.rs

@@ -18,7 +18,7 @@ implementing the `Iterator` trait.
 */
 
 use cmp;
-use num::{Zero, One, Integer, CheckedAdd, Saturating};
+use num::{Zero, One, Integer, Saturating};
 use option::{Option, Some, None};
 use ops::{Add, Mul, Sub};
 use cmp::Ord;
@@ -838,7 +838,7 @@ impl<A, T: Iterator<A>, U: Iterator<A>> Iterator<A> for Chain<T, U> {
         let lower = a_lower.saturating_add(b_lower);
 
         let upper = match (a_upper, b_upper) {
-            (Some(x), Some(y)) => x.checked_add(&y),
+            (Some(x), Some(y)) => Some(x.saturating_add(y)),
             _ => None
         };
 
@@ -1115,34 +1115,22 @@ impl<A, T: Iterator<A>> Iterator<A> for Peekable<A, T> {
         if self.peeked.is_some() { self.peeked.take() }
         else { self.iter.next() }
     }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let (lo, hi) = self.iter.size_hint();
-        if self.peeked.is_some() {
-            let lo = lo.saturating_add(1);
-            let hi = match hi {
-                Some(x) => x.checked_add(&1),
-                None => None
-            };
-            (lo, hi)
-        } else {
-            (lo, hi)
-        }
-    }
 }
 
 impl<'self, A, T: Iterator<A>> Peekable<A, T> {
     /// Return a reference to the next element of the iterator with out advancing it,
     /// or None if the iterator is exhausted.
     #[inline]
     pub fn peek(&'self mut self) -> Option<&'self A> {
-        if self.peeked.is_none() {
-            self.peeked = self.iter.next();
-        }
         match self.peeked {
             Some(ref value) => Some(value),
-            None => None,
+            None => {
+                self.peeked = self.iter.next();
+                match self.peeked {
+                    Some(ref value) => Some(value),
+                    None => None,
+                }
+            },
         }
     }
 }
@@ -1388,7 +1376,7 @@ impl<'self, A, T: Iterator<A>, B, U: Iterator<B>> Iterator<B> for
         let (blo, bhi) = self.backiter.map_default((0, Some(0)), |it| it.size_hint());
         let lo = flo.saturating_add(blo);
         match (self.iter.size_hint(), fhi, bhi) {
-            ((0, Some(0)), Some(a), Some(b)) => (lo, a.checked_add(&b)),
+            ((0, Some(0)), Some(a), Some(b)) => (lo, Some(a.saturating_add(b))),
             _ => (lo, None)
         }
     }
@@ -1494,12 +1482,6 @@ impl<'self, A, St> Iterator<A> for Unfoldr<'self, A, St> {
     fn next(&mut self) -> Option<A> {
         (self.f)(&mut self.state)
     }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        // no possible known bounds at this point
-        (0, None)
-    }
 }
 
 /// An infinite iterator starting at `start` and advancing by `step` with each
@@ -1543,9 +1525,6 @@ impl<A: Add<A, A> + Ord + Clone> Iterator<A> for Range<A> {
             None
         }
     }
-
-    // FIXME: #8606 Implement size_hint() on Range
-    // Blocked on #8605 Need numeric trait for converting to `Option<uint>`
 }
 
 impl<A: Sub<A, A> + Integer + Ord + Clone> DoubleEndedIterator<A> for Range<A> {