---

yaml
---
r: 79431
b: refs/heads/snap-stage3
c: 3c30ecb
h: refs/heads/master
i:
  79429: a22143c
  79427: 95f0b23
  79423: ab19176
v: v3

Author: sfackler

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 124eb2119c78651cfaaa7a046a101fa2e20f83ca
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 807408b708a11c9a96b2dc4fedd611276273574f
+refs/heads/snap-stage3: 3c30ecb706dc32257d1ec6bdcb0c88eb924483dd
 refs/heads/try: ac820906c0e53eab79a98ee64f7231f57c3887b4
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/tests.mk

@@ -250,6 +250,7 @@ tidy:
 		| grep '^$(S)src/test' -v \
 		| grep '^$(S)src/libuv' -v \
 		| grep '^$(S)src/llvm' -v \
+		| grep '^$(S)src/gyp' -v \
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py
 		$(Q)find $(S)src/etc -name '*.py' \
 		| xargs -n 10 $(CFG_PYTHON) $(S)src/etc/tidy.py

branches/snap-stage3/src/compiletest/procsrv.rs

@@ -63,7 +63,7 @@ pub fn run(lib_path: &str,
 
     Result {
         status: output.status,
-        out: str::from_bytes(output.output),
-        err: str::from_bytes(output.error)
+        out: str::from_utf8(output.output),
+        err: str::from_utf8(output.error)
     }
 }

branches/snap-stage3/src/libextra/base64.rs

@@ -145,7 +145,7 @@ impl<'self> ToBase64 for &'self [u8] {
         }
 
         unsafe {
-            str::raw::from_bytes_owned(v)
+            str::raw::from_utf8_owned(v)
         }
     }
 }
@@ -162,7 +162,7 @@ impl<'self> FromBase64 for &'self str {
      * Convert any base64 encoded string (literal, `@`, `&`, or `~`)
      * to the byte values it encodes.
      *
-     * You can use the `from_bytes` function in `std::str`
+     * You can use the `from_utf8` function in `std::str`
      * to turn a `[u8]` into a string with characters corresponding to those
      * values.
      *
@@ -180,7 +180,7 @@ impl<'self> FromBase64 for &'self str {
      *     printfln!("%s", hello_str);
      *     let bytes = hello_str.from_base64();
      *     printfln!("%?", bytes);
-     *     let result_str = str::from_bytes(bytes);
+     *     let result_str = str::from_utf8(bytes);
      *     printfln!("%s", result_str);
      * }
      * ~~~

branches/snap-stage3/src/libextra/bitv.rs

@@ -523,7 +523,7 @@ impl Bitv {
  * with the most significant bits of each byte coming first. Each
  * bit becomes true if equal to 1 or false if equal to 0.
  */
-pub fn from_bytes(bytes: &[u8]) -> Bitv {
+pub fn from_utf8(bytes: &[u8]) -> Bitv {
     from_fn(bytes.len() * 8, |i| {
         let b = bytes[i / 8] as uint;
         let offset = i % 8;
@@ -1275,8 +1275,8 @@ mod tests {
     }
 
     #[test]
-    fn test_from_bytes() {
-        let bitv = from_bytes([0b10110110, 0b00000000, 0b11111111]);
+    fn test_from_utf8() {
+        let bitv = from_utf8([0b10110110, 0b00000000, 0b11111111]);
         let str = ~"10110110" + "00000000" + "11111111";
         assert_eq!(bitv.to_str(), str);
     }
@@ -1302,7 +1302,7 @@ mod tests {
     #[test]
     fn test_to_bools() {
         let bools = ~[false, false, true, false, false, true, true, false];
-        assert_eq!(from_bytes([0b00100110]).to_bools(), bools);
+        assert_eq!(from_utf8([0b00100110]).to_bools(), bools);
     }
 
     #[test]

branches/snap-stage3/src/libextra/ebml.rs

@@ -41,7 +41,7 @@ impl Doc {
     }
 
     pub fn as_str_slice<'a>(&'a self) -> &'a str {
-        str::from_bytes_slice(self.data.slice(self.start, self.end))
+        str::from_utf8_slice(self.data.slice(self.start, self.end))
     }
 
     pub fn as_str(&self) -> ~str {

branches/snap-stage3/src/libextra/hex.rs

@@ -45,7 +45,7 @@ impl<'self> ToHex for &'self [u8] {
         }
 
         unsafe {
-            str::raw::from_bytes_owned(v)
+            str::raw::from_utf8_owned(v)
         }
     }
 }
@@ -62,7 +62,7 @@ impl<'self> FromHex for &'self str {
      * Convert any hexadecimal encoded string (literal, `@`, `&`, or `~`)
      * to the byte values it encodes.
      *
-     * You can use the `from_bytes` function in `std::str`
+     * You can use the `from_utf8` function in `std::str`
      * to turn a `[u8]` into a string with characters corresponding to those
      * values.
      *
@@ -80,7 +80,7 @@ impl<'self> FromHex for &'self str {
      *     printfln!("%s", hello_str);
      *     let bytes = hello_str.from_hex().unwrap();
      *     printfln!("%?", bytes);
-     *     let result_str = str::from_bytes(bytes);
+     *     let result_str = str::from_utf8(bytes);
      *     printfln!("%s", result_str);
      * }
      * ~~~

branches/snap-stage3/src/libextra/json.rs

@@ -858,7 +858,7 @@ impl<T : iterator::Iterator<char>> Parser<T> {
 
 /// Decodes a json value from an @io::Reader
 pub fn from_reader(rdr: @io::Reader) -> Result<Json, Error> {
-    let s = str::from_bytes(rdr.read_whole_stream());
+    let s = str::from_utf8(rdr.read_whole_stream());
     let mut parser = Parser(~s.iter());
     parser.parse()
 }

branches/snap-stage3/src/libextra/terminfo/parser/compiled.rs

@@ -213,7 +213,7 @@ pub fn parse(file: @Reader, longnames: bool) -> Result<~TermInfo, ~str> {
         return Err(~"incompatible file: more string offsets than expected");
     }
 
-    let names_str = str::from_bytes(file.read_bytes(names_bytes as uint - 1)); // don't read NUL
+    let names_str = str::from_utf8(file.read_bytes(names_bytes as uint - 1)); // don't read NUL
     let term_names: ~[~str] = names_str.split_iter('|').map(|s| s.to_owned()).collect();
 
     file.read_byte(); // consume NUL

branches/snap-stage3/src/libextra/test.rs

@@ -731,13 +731,6 @@ fn run_tests(opts: &TestOpts,
     }
 }
 
-// Windows tends to dislike being overloaded with threads.
-#[cfg(windows)]
-static SCHED_OVERCOMMIT : uint = 1;
-
-#[cfg(unix)]
-static SCHED_OVERCOMMIT : uint = 4u;
-
 fn get_concurrency() -> uint {
     use std::rt;
     match os::getenv("RUST_TEST_TASKS") {
@@ -749,9 +742,7 @@ fn get_concurrency() -> uint {
             }
         }
         None => {
-            let threads = rt::util::default_sched_threads();
-            if threads == 1 { 1 }
-            else { threads * SCHED_OVERCOMMIT }
+            rt::util::default_sched_threads()
         }
     }
 }

branches/snap-stage3/src/libextra/time.rs

@@ -321,6 +321,33 @@ fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
         Some((value, pos))
     }
 
+    fn match_fractional_seconds(ss: &str, pos: uint) -> (i32, uint) {
+        let len = ss.len();
+        let mut value = 0_i32;
+        let mut multiplier = NSEC_PER_SEC / 10;
+        let mut pos = pos;
+
+        loop {
+            if pos >= len {
+                break;
+            }
+            let range = ss.char_range_at(pos);
+
+            match range.ch {
+                '0' .. '9' => {
+                    pos = range.next;
+                    // This will drop digits after the nanoseconds place
+                    let digit = range.ch as i32 - '0' as i32;
+                    value += digit * multiplier;
+                    multiplier /= 10;
+                }
+                _ => break
+            }
+        }
+
+        (value, pos)
+    }
+
     fn match_digits_in_range(ss: &str, pos: uint, digits: uint, ws: bool,
                              min: i32, max: i32) -> Option<(i32, uint)> {
         match match_digits(ss, pos, digits, ws) {
@@ -441,6 +468,11 @@ fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
             Some(item) => { let (v, pos) = item; tm.tm_mday = v; Ok(pos) }
             None => Err(~"Invalid day of the month")
           },
+          'f' => {
+            let (val, pos) = match_fractional_seconds(s, pos);
+            tm.tm_nsec = val;
+            Ok(pos)
+          }
           'F' => {
             parse_type(s, pos, 'Y', &mut *tm)
                 .chain(|pos| parse_char(s, pos, '-'))
@@ -773,6 +805,7 @@ fn do_strftime(format: &str, tm: &Tm) -> ~str {
           }
           'd' => fmt!("%02d", tm.tm_mday as int),
           'e' => fmt!("%2d", tm.tm_mday as int),
+          'f' => fmt!("%09d", tm.tm_nsec as int),
           'F' => {
             fmt!("%s-%s-%s",
                 parse_type('Y', tm),
@@ -1011,12 +1044,12 @@ mod tests {
           Err(_) => ()
         }
 
-        let format = "%a %b %e %T %Y";
+        let format = "%a %b %e %T.%f %Y";
         assert_eq!(strptime("", format), Err(~"Invalid time"));
         assert!(strptime("Fri Feb 13 15:31:30", format)
             == Err(~"Invalid time"));
 
-        match strptime("Fri Feb 13 15:31:30 2009", format) {
+        match strptime("Fri Feb 13 15:31:30.01234 2009", format) {
           Err(e) => fail!(e),
           Ok(ref tm) => {
             assert!(tm.tm_sec == 30_i32);
@@ -1030,7 +1063,7 @@ mod tests {
             assert!(tm.tm_isdst == 0_i32);
             assert!(tm.tm_gmtoff == 0_i32);
             assert!(tm.tm_zone == ~"");
-            assert!(tm.tm_nsec == 0_i32);
+            assert!(tm.tm_nsec == 12340000_i32);
           }
         }
 
@@ -1187,6 +1220,7 @@ mod tests {
         assert_eq!(local.strftime("%D"), ~"02/13/09");
         assert_eq!(local.strftime("%d"), ~"13");
         assert_eq!(local.strftime("%e"), ~"13");
+        assert_eq!(local.strftime("%f"), ~"000054321");
         assert_eq!(local.strftime("%F"), ~"2009-02-13");
         // assert!(local.strftime("%G") == "2009");
         // assert!(local.strftime("%g") == "09");

branches/snap-stage3/src/libextra/uuid.rs

@@ -210,7 +210,7 @@ impl Uuid {
     ///
     /// # Arguments
     /// * `b` An array or slice of 16 bytes
-    pub fn from_bytes(b: &[u8]) -> Option<Uuid> {
+    pub fn from_utf8(b: &[u8]) -> Option<Uuid> {
         if b.len() != 16 {
             return None
         }
@@ -307,7 +307,7 @@ impl Uuid {
             s[i*2+0] = digit[0];
             s[i*2+1] = digit[1];
         }
-        str::from_bytes(s)
+        str::from_utf8(s)
     }
 
     /// Returns a string of hexadecimal digits, separated into groups with a hypen
@@ -413,7 +413,7 @@ impl Uuid {
             ub[i] = FromStrRadix::from_str_radix(vs.slice(i*2, (i+1)*2), 16).unwrap();
         }
 
-        Ok(Uuid::from_bytes(ub).unwrap())
+        Ok(Uuid::from_utf8(ub).unwrap())
     }
 }
 
@@ -705,11 +705,11 @@ mod test {
     }
 
     #[test]
-    fn test_from_bytes() {
+    fn test_from_utf8() {
         let b = ~[ 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2,
                    0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 ];
 
-        let u = Uuid::from_bytes(b).unwrap();
+        let u = Uuid::from_utf8(b).unwrap();
         let expected = ~"a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8";
 
         assert!(u.to_simple_str() == expected);
@@ -729,7 +729,7 @@ mod test {
         let b_in: [u8, ..16] = [ 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2,
                                  0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 ];
 
-        let u = Uuid::from_bytes(b_in.clone()).unwrap();
+        let u = Uuid::from_utf8(b_in.clone()).unwrap();
 
         let b_out = u.to_bytes();
 

branches/snap-stage3/src/librustc/back/link.rs

@@ -386,7 +386,7 @@ pub mod write {
                         cc_prog, prog.status));
             sess.note(fmt!("%s arguments: %s",
                         cc_prog, cc_args.connect(" ")));
-            sess.note(str::from_bytes(prog.error + prog.output));
+            sess.note(str::from_utf8(prog.error + prog.output));
             sess.abort_if_errors();
         }
     }
@@ -943,7 +943,7 @@ pub fn link_binary(sess: Session,
                       cc_prog, prog.status));
         sess.note(fmt!("%s arguments: %s",
                        cc_prog, cc_args.connect(" ")));
-        sess.note(str::from_bytes(prog.error + prog.output));
+        sess.note(str::from_utf8(prog.error + prog.output));
         sess.abort_if_errors();
     }
 

branches/snap-stage3/src/librustc/metadata/decoder.rs

@@ -1239,7 +1239,7 @@ fn read_path(d: ebml::Doc) -> (~str, uint) {
     do reader::with_doc_data(d) |desc| {
         let pos = io::u64_from_be_bytes(desc, 0u, 4u) as uint;
         let pathbytes = desc.slice(4u, desc.len());
-        let path = str::from_bytes(pathbytes);
+        let path = str::from_utf8(pathbytes);
 
         (path, pos)
     }

branches/snap-stage3/src/librustc/metadata/tydecode.rs

@@ -97,7 +97,7 @@ pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident {
 
 fn parse_ident_(st: &mut PState, is_last: @fn(char) -> bool) ->
    ast::Ident {
-    let rslt = scan(st, is_last, str::from_bytes);
+    let rslt = scan(st, is_last, str::from_utf8);
     return st.tcx.sess.ident_of(rslt);
 }
 
@@ -477,7 +477,7 @@ fn parse_abi_set(st: &mut PState) -> AbiSet {
     let mut abis = AbiSet::empty();
     while peek(st) != ']' {
         // FIXME(#5422) str API should not force this copy
-        let abi_str = scan(st, |c| c == ',', str::from_bytes);
+        let abi_str = scan(st, |c| c == ',', str::from_utf8);
         let abi = abi::lookup(abi_str).expect(abi_str);
         abis.add(abi);
     }

branches/snap-stage3/src/librustc/rustc.rs

@@ -161,7 +161,7 @@ Available lint options:
         max_key = num::max(name.len(), max_key);
     }
     fn padded(max: uint, s: &str) -> ~str {
-        str::from_bytes(vec::from_elem(max - s.len(), ' ' as u8)) + s
+        str::from_utf8(vec::from_elem(max - s.len(), ' ' as u8)) + s
     }
     println("\nAvailable lint checks:\n");
     printfln!("    %s  %7.7s  %s",
@@ -244,7 +244,7 @@ pub fn run_compiler(args: &[~str], demitter: diagnostic::Emitter) {
       1u => {
         let ifile = matches.free[0].as_slice();
         if "-" == ifile {
-            let src = str::from_bytes(io::stdin().read_whole_stream());
+            let src = str::from_utf8(io::stdin().read_whole_stream());
             str_input(src.to_managed())
         } else {
             file_input(Path(ifile))

branches/snap-stage3/src/librustdoc/markdown_writer.rs

@@ -116,8 +116,8 @@ fn pandoc_writer(
 
         debug!("pandoc result: %i", output.status);
         if output.status != 0 {
-            error!("pandoc-out: %s", str::from_bytes(output.output));
-            error!("pandoc-err: %s", str::from_bytes(output.error));
+            error!("pandoc-out: %s", str::from_utf8(output.output));
+            error!("pandoc-err: %s", str::from_utf8(output.error));
             fail!("pandoc failed");
         }
     }

branches/snap-stage3/src/librustpkg/rustpkg.rs

@@ -153,7 +153,7 @@ impl<'self> PkgScript<'self> {
                    exe.to_str(), sysroot.to_str(), "configs");
             let output = run::process_output(exe.to_str(), [sysroot.to_str(), ~"configs"]);
             // Run the configs() function to get the configs
-            let cfgs = str::from_bytes_slice(output.output).word_iter()
+            let cfgs = str::from_utf8_slice(output.output).word_iter()
                 .map(|w| w.to_owned()).collect();
             (cfgs, output.status)
         }