---

yaml
---
r: 144990
b: refs/heads/try2
c: a835995
h: refs/heads/master
v: v3

Author: Tim Kuehn

[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: 3c17903c36320646aedf6ba7e13f7623703b2e9d
+refs/heads/try2: a83599548895c35d3f9b87f7f2e012b09af404c0
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libextra/comm.rs

@@ -1,4 +1,4 @@
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -90,9 +90,55 @@ pub fn DuplexStream<T:Send,U:Send>()
      })
 }
 
+/// An extension of `pipes::stream` that provides synchronous message sending.
+pub struct SyncChan<T> { priv duplex_stream: DuplexStream<T, ()> }
+/// An extension of `pipes::stream` that acknowledges each message received.
+pub struct SyncPort<T> { priv duplex_stream: DuplexStream<(), T> }
+
+impl<T: Send> GenericChan<T> for SyncChan<T> {
+    fn send(&self, val: T) {
+        assert!(self.try_send(val), "SyncChan.send: receiving port closed");
+    }
+}
+
+impl<T: Send> GenericSmartChan<T> for SyncChan<T> {
+    /// Sends a message, or report if the receiver has closed the connection before receiving.
+    fn try_send(&self, val: T) -> bool {
+        self.duplex_stream.try_send(val) && self.duplex_stream.try_recv().is_some()
+    }
+}
+
+impl<T: Send> GenericPort<T> for SyncPort<T> {
+    fn recv(&self) -> T {
+        self.try_recv().expect("SyncPort.recv: sending channel closed")
+    }
+
+    fn try_recv(&self) -> Option<T> {
+        do self.duplex_stream.try_recv().map_move |val| {
+            self.duplex_stream.try_send(());
+            val
+        }
+    }
+}
+
+impl<T: Send> Peekable<T> for SyncPort<T> {
+    fn peek(&self) -> bool {
+        self.duplex_stream.peek()
+    }
+}
+
+/// Creates a stream whose channel, upon sending a message, blocks until the message is received.
+pub fn rendezvous<T: Send>() -> (SyncPort<T>, SyncChan<T>) {
+    let (chan_stream, port_stream) = DuplexStream();
+    (SyncPort { duplex_stream: port_stream }, SyncChan { duplex_stream: chan_stream })
+}
+
 #[cfg(test)]
 mod test {
-    use comm::DuplexStream;
+    use comm::{DuplexStream, rendezvous};
+    use std::rt::test::run_in_newsched_task;
+    use std::task::spawn_unlinked;
+
 
     #[test]
     pub fn DuplexStream1() {
@@ -104,4 +150,58 @@ mod test {
         assert!(left.recv() == 123);
         assert!(right.recv() == ~"abc");
     }
+
+    #[test]
+    pub fn basic_rendezvous_test() {
+        let (port, chan) = rendezvous();
+
+        do spawn {
+            chan.send("abc");
+        }
+
+        assert!(port.recv() == "abc");
+    }
+
+    #[test]
+    fn recv_a_lot() {
+        // Rendezvous streams should be able to handle any number of messages being sent
+        do run_in_newsched_task {
+            let (port, chan) = rendezvous();
+            do spawn {
+                do 1000000.times { chan.send(()) }
+            }
+            do 1000000.times { port.recv() }
+        }
+    }
+
+    #[test]
+    fn send_and_fail_and_try_recv() {
+        let (port, chan) = rendezvous();
+        do spawn_unlinked {
+            chan.duplex_stream.send(()); // Can't access this field outside this module
+            fail!()
+        }
+        port.recv()
+    }
+
+    #[test]
+    fn try_send_and_recv_then_fail_before_ack() {
+        let (port, chan) = rendezvous();
+        do spawn_unlinked {
+            port.duplex_stream.recv();
+            fail!()
+        }
+        chan.try_send(());
+    }
+
+    #[test]
+    #[should_fail]
+    fn send_and_recv_then_fail_before_ack() {
+        let (port, chan) = rendezvous();
+        do spawn_unlinked {
+            port.duplex_stream.recv();
+            fail!()
+        }
+        chan.send(());
+    }
 }

branches/try2/src/libextra/glob.rs

@@ -147,14 +147,8 @@ enum PatternToken {
     Char(char),
     AnyChar,
     AnySequence,
-    AnyWithin(~[CharSpecifier]),
-    AnyExcept(~[CharSpecifier])
-}
-
-#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, IterBytes)]
-enum CharSpecifier {
-    SingleChar(char),
-    CharRange(char, char)
+    AnyWithin(~[char]),
+    AnyExcept(~[char])
 }
 
 #[deriving(Eq)]
@@ -170,15 +164,12 @@ impl Pattern {
      * This function compiles Unix shell style patterns: `?` matches any single character,
      * `*` matches any (possibly empty) sequence of characters and `[...]` matches any character
      * inside the brackets, unless the first character is `!` in which case it matches any
-     * character except those between the `!` and the `]`. Character sequences can also specify
-     * ranges of characters, as ordered by Unicode, so e.g. `[0-9]` specifies any character
-     * between 0 and 9 inclusive.
+     * character except those between the `!` and the `]`.
      *
      * The metacharacters `?`, `*`, `[`, `]` can be matched by using brackets (e.g. `[?]`).
      * When a `]` occurs immediately following `[` or `[!` then it is interpreted as
      * being part of, rather then ending, the character set, so `]` and NOT `]` can be
-     * matched by `[]]` and `[!]]` respectively. The `-` character can be specified inside a
-     * character sequence pattern by placing it at the start or the end, e.g. `[abc-]`.
+     * matched by `[]]` and `[!]]` respectively.
      *
      * When a `[` does not have a closing `]` before the end of the string then the `[` will
      * be treated literally.
@@ -208,8 +199,7 @@ impl Pattern {
                         match chars.slice_from(i + 3).position_elem(&']') {
                             None => (),
                             Some(j) => {
-                                let cs = parse_char_specifiers(chars.slice(i + 2, i + 3 + j));
-                                tokens.push(AnyExcept(cs));
+                                tokens.push(AnyExcept(chars.slice(i + 2, i + 3 + j).to_owned()));
                                 i += j + 4;
                                 loop;
                             }
@@ -219,8 +209,7 @@ impl Pattern {
                         match chars.slice_from(i + 2).position_elem(&']') {
                             None => (),
                             Some(j) => {
-                                let cs = parse_char_specifiers(chars.slice(i + 1, i + 2 + j));
-                                tokens.push(AnyWithin(cs));
+                                tokens.push(AnyWithin(chars.slice(i + 1, i + 2 + j).to_owned()));
                                 i += j + 3;
                                 loop;
                             }
@@ -346,11 +335,15 @@ impl Pattern {
                         AnyChar => {
                             !require_literal(c)
                         }
-                        AnyWithin(ref specifiers) => {
-                            !require_literal(c) && in_char_specifiers(*specifiers, c, options)
+                        AnyWithin(ref chars) => {
+                            !require_literal(c) &&
+                            chars.iter()
+                                .rposition(|&e| chars_eq(e, c, options.case_sensitive)).is_some()
                         }
-                        AnyExcept(ref specifiers) => {
-                            !require_literal(c) && !in_char_specifiers(*specifiers, c, options)
+                        AnyExcept(ref chars) => {
+                            !require_literal(c) &&
+                            chars.iter()
+                                .rposition(|&e| chars_eq(e, c, options.case_sensitive)).is_none()
                         }
                         Char(c2) => {
                             chars_eq(c, c2, options.case_sensitive)
@@ -377,63 +370,6 @@ impl Pattern {
 
 }
 
-fn parse_char_specifiers(s: &[char]) -> ~[CharSpecifier] {
-    let mut cs = ~[];
-    let mut i = 0;
-    while i < s.len() {
-        if i + 3 <= s.len() && s[i + 1] == '-' {
-            cs.push(CharRange(s[i], s[i + 2]));
-            i += 3;
-        } else {
-            cs.push(SingleChar(s[i]));
-            i += 1;
-        }
-    }
-    cs
-}
-
-fn in_char_specifiers(specifiers: &[CharSpecifier], c: char, options: MatchOptions) -> bool {
-
-    for &specifier in specifiers.iter() {
-        match specifier {
-            SingleChar(sc) => {
-                if chars_eq(c, sc, options.case_sensitive) {
-                    return true;
-                }
-            }
-            CharRange(start, end) => {
-
-                // FIXME: work with non-ascii chars properly (issue #1347)
-                if !options.case_sensitive && c.is_ascii() && start.is_ascii() && end.is_ascii() {
-
-                    let start = start.to_ascii().to_lower();
-                    let end = end.to_ascii().to_lower();
-
-                    let start_up = start.to_upper();
-                    let end_up = end.to_upper();
-
-                    // only allow case insensitive matching when
-                    // both start and end are within a-z or A-Z
-                    if start != start_up && end != end_up {
-                        let start = start.to_char();
-                        let end = end.to_char();
-                        let c = c.to_ascii().to_lower().to_char();
-                        if c >= start && c <= end {
-                            return true;
-                        }
-                    }
-                }
-
-                if c >= start && c <= end {
-                    return true;
-                }
-            }
-        }
-    }
-
-    false
-}
-
 /// A helper function to determine if two chars are (possibly case-insensitively) equal.
 fn chars_eq(a: char, b: char, case_sensitive: bool) -> bool {
     if cfg!(windows) && path::windows::is_sep(a) && path::windows::is_sep(b) {
@@ -736,54 +672,6 @@ mod test {
         glob("/*/*/*/*").skip(10000).next();
     }
 
-    #[test]
-    fn test_range_pattern() {
-
-        let pat = Pattern::new("a[0-9]b");
-        for i in range(0, 10) {
-            assert!(pat.matches(fmt!("a%db", i)));
-        }
-        assert!(!pat.matches("a_b"));
-
-        let pat = Pattern::new("a[!0-9]b");
-        for i in range(0, 10) {
-            assert!(!pat.matches(fmt!("a%db", i)));
-        }
-        assert!(pat.matches("a_b"));
-
-        let pats = ["[a-z123]", "[1a-z23]", "[123a-z]"];
-        for &p in pats.iter() {
-            let pat = Pattern::new(p);
-            for c in "abcdefghijklmnopqrstuvwxyz".iter() {
-                assert!(pat.matches(c.to_str()));
-            }
-            for c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ".iter() {
-                let options = MatchOptions {case_sensitive: false, .. MatchOptions::new()};
-                assert!(pat.matches_with(c.to_str(), options));
-            }
-            assert!(pat.matches("1"));
-            assert!(pat.matches("2"));
-            assert!(pat.matches("3"));
-        }
-
-        let pats = ["[abc-]", "[-abc]", "[a-c-]"];
-        for &p in pats.iter() {
-            let pat = Pattern::new(p);
-            assert!(pat.matches("a"));
-            assert!(pat.matches("b"));
-            assert!(pat.matches("c"));
-            assert!(pat.matches("-"));
-            assert!(!pat.matches("d"));
-        }
-
-        let pat = Pattern::new("[2-1]");
-        assert!(!pat.matches("1"));
-        assert!(!pat.matches("2"));
-
-        assert!(Pattern::new("[-]").matches("-"));
-        assert!(!Pattern::new("[!-]").matches("-"));
-    }
-
     #[test]
     fn test_unclosed_bracket() {
         // unclosed `[` should be treated literally