---

yaml
---
r: 90599
b: refs/heads/master
c: efd6194
h: refs/heads/master
i:
  90597: 982e0e0
  90595: 3634960
  90591: c0bc89a
v: v3

Author: Palmer Cox

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 35fc0c8fe4210517508d624695e81c47bda00602
+refs/heads/master: efd619467df28b48b97250b2857b18a032b5dab6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
 refs/heads/try: b160761e35efcd1207112b3b782c06633cf441a8

trunk/src/etc/ctags.rust

@@ -3,9 +3,10 @@
 --regex-Rust=/^[ \t]*(pub[ \t]+)?fn[ \t]+([a-zA-Z0-9_]+)/\2/f,functions,function definitions/
 --regex-Rust=/^[ \t]*(pub[ \t]+)?type[ \t]+([a-zA-Z0-9_]+)/\2/T,types,type definitions/
 --regex-Rust=/^[ \t]*(pub[ \t]+)?enum[ \t]+([a-zA-Z0-9_]+)/\2/g,enum,enumeration names/
+--regex-Rust=/^[ \t]*(pub[ \t]+)?enum[ \t]+([a-zA-Z0-9_]+)/\2/g,enum,enumeration names/
 --regex-Rust=/^[ \t]*(pub[ \t]+)?struct[ \t]+([a-zA-Z0-9_]+)/\2/s,structure names/
 --regex-Rust=/^[ \t]*(pub[ \t]+)?mod[ \t]+([a-zA-Z0-9_]+)/\2/m,modules,module names/
 --regex-Rust=/^[ \t]*(pub[ \t]+)?static[ \t]+([a-zA-Z0-9_]+)/\2/c,consts,static constants/
 --regex-Rust=/^[ \t]*(pub[ \t]+)?trait[ \t]+([a-zA-Z0-9_]+)/\2/t,traits,traits/
 --regex-Rust=/^[ \t]*(pub[ \t]+)?impl([ \t\n]+<.*>)?[ \t]+([a-zA-Z0-9_]+)/\3/i,impls,trait implementations/
---regex-Rust=/^[ \t]*macro_rules![ \t]+([a-zA-Z0-9_]+)/\1/d,macros,macro definitions/
+--regex-Rust=/^[ \t]*macro_rules![ \t]+([a-zA-Z0-9_]+)/\2/d,macros,macro definitions/

trunk/src/libextra/term.rs

@@ -15,11 +15,11 @@
 
 use std::io::{Decorator, Writer};
 
-use std::os;
-use terminfo::*;
-use terminfo::searcher::open;
-use terminfo::parser::compiled::{parse, msys_terminfo};
-use terminfo::parm::{expand, Number, Variables};
+#[cfg(not(target_os = "win32"))] use std::os;
+#[cfg(not(target_os = "win32"))] use terminfo::*;
+#[cfg(not(target_os = "win32"))] use terminfo::searcher::open;
+#[cfg(not(target_os = "win32"))] use terminfo::parser::compiled::parse;
+#[cfg(not(target_os = "win32"))] use terminfo::parm::{expand, Number, Variables};
 
 // FIXME (#2807): Windows support.
 
@@ -74,6 +74,7 @@ pub mod attr {
     }
 }
 
+#[cfg(not(target_os = "win32"))]
 fn cap_for_attr(attr: attr::Attr) -> &'static str {
     match attr {
         attr::Bold               => "bold",
@@ -92,24 +93,29 @@ fn cap_for_attr(attr: attr::Attr) -> &'static str {
     }
 }
 
+#[cfg(not(target_os = "win32"))]
 pub struct Terminal<T> {
     priv num_colors: u16,
     priv out: T,
     priv ti: ~TermInfo
 }
 
+#[cfg(target_os = "win32")]
+pub struct Terminal<T> {
+    priv num_colors: u16,
+    priv out: T,
+}
+
+#[cfg(not(target_os = "win32"))]
 impl<T: Writer> Terminal<T> {
     pub fn new(out: T) -> Result<Terminal<T>, ~str> {
-        let term = match os::getenv("TERM") {
-            Some(t) => t,
-            None => return Err(~"TERM environment variable undefined")
-        };
+        let term = os::getenv("TERM");
+        if term.is_none() {
+            return Err(~"TERM environment variable undefined");
+        }
 
-        let entry = open(term);
+        let entry = open(term.unwrap());
         if entry.is_err() {
-            if "cygwin" == term { // msys terminal
-                return Ok(Terminal {out: out, ti: msys_terminfo(), num_colors: 8});
-            }
             return Err(entry.unwrap_err());
         }
 
@@ -235,6 +241,32 @@ impl<T: Writer> Terminal<T> {
     }
 }
 
+#[cfg(target_os = "win32")]
+impl<T: Writer> Terminal<T> {
+    pub fn new(out: T) -> Result<Terminal<T>, ~str> {
+        return Ok(Terminal {out: out, num_colors: 0});
+    }
+
+    pub fn fg(&mut self, _color: color::Color) -> bool {
+        false
+    }
+
+    pub fn bg(&mut self, _color: color::Color) -> bool {
+        false
+    }
+
+    pub fn attr(&mut self, _attr: attr::Attr) -> bool {
+        false
+    }
+
+    pub fn supports_attr(&self, _attr: attr::Attr) -> bool {
+        false
+    }
+
+    pub fn reset(&self) {
+    }
+}
+
 impl<T: Writer> Decorator<T> for Terminal<T> {
     fn inner(self) -> T {
         self.out

trunk/src/libextra/terminfo/parser/compiled.rs

@@ -316,21 +316,6 @@ pub fn parse(file: &mut io::Reader,
     Ok(~TermInfo {names: term_names, bools: bools_map, numbers: numbers_map, strings: string_map })
 }
 
-/// Create a dummy TermInfo struct for msys terminals
-pub fn msys_terminfo() -> ~TermInfo {
-    let mut strings = HashMap::new();
-    strings.insert(~"sgr0", bytes!("\x1b[0m").to_owned());
-    strings.insert(~"bold", bytes!("\x1b[1m;").to_owned());
-    strings.insert(~"setaf", bytes!("\x1b[3%p1%dm").to_owned());
-    strings.insert(~"setab", bytes!("\x1b[4%p1%dm").to_owned());
-    ~TermInfo {
-        names: ~[~"cygwin"], // msys is a fork of an older cygwin version
-        bools: HashMap::new(),
-        numbers: HashMap::new(),
-        strings: strings
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;

trunk/src/libstd/vec.rs

@@ -2127,8 +2127,7 @@ impl<'a,T> MutableVector<'a, T> for &'a mut [T] {
     #[inline]
     fn mut_chunks(self, chunk_size: uint) -> MutChunkIter<'a, T> {
         assert!(chunk_size > 0);
-        let len = self.len();
-        MutChunkIter { v: self, chunk_size: chunk_size, remaining: len }
+        MutChunkIter { v: self, chunk_size: chunk_size }
     }
 
     fn mut_shift_ref(&mut self) -> &'a mut T {
@@ -2568,31 +2567,29 @@ impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutSplitIterator<'a, T> {
 /// the remainder.
 pub struct MutChunkIter<'a, T> {
     priv v: &'a mut [T],
-    priv chunk_size: uint,
-    priv remaining: uint
+    priv chunk_size: uint
 }
 
 impl<'a, T> Iterator<&'a mut [T]> for MutChunkIter<'a, T> {
     #[inline]
     fn next(&mut self) -> Option<&'a mut [T]> {
-        if self.remaining == 0 {
+        if self.v.len() == 0 {
             None
         } else {
-            let sz = cmp::min(self.remaining, self.chunk_size);
+            let sz = cmp::min(self.v.len(), self.chunk_size);
             let tmp = util::replace(&mut self.v, &mut []);
             let (head, tail) = tmp.mut_split_at(sz);
             self.v = tail;
-            self.remaining -= sz;
             Some(head)
         }
     }
 
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) {
-        if self.remaining == 0 {
+        if self.v.len() == 0 {
             (0, Some(0))
         } else {
-            let (n, rem) = self.remaining.div_rem(&self.chunk_size);
+            let (n, rem) = self.v.len().div_rem(&self.chunk_size);
             let n = if rem > 0 { n + 1 } else { n };
             (n, Some(n))
         }
@@ -2602,15 +2599,15 @@ impl<'a, T> Iterator<&'a mut [T]> for MutChunkIter<'a, T> {
 impl<'a, T> DoubleEndedIterator<&'a mut [T]> for MutChunkIter<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut [T]> {
-        if self.remaining == 0 {
+        if self.v.len() == 0 {
             None
         } else {
-            let remainder = self.remaining % self.chunk_size;
+            let remainder = self.v.len() % self.chunk_size;
             let sz = if remainder != 0 { remainder } else { self.chunk_size };
             let tmp = util::replace(&mut self.v, &mut []);
-            let (head, tail) = tmp.mut_split_at(self.remaining - sz);
+            let tmp_len = tmp.len();
+            let (head, tail) = tmp.mut_split_at(tmp_len - sz);
             self.v = head;
-            self.remaining -= sz;
             Some(tail)
         }
     }