---

yaml
---
r: 148335
b: refs/heads/try2
c: 8f4edf9
h: refs/heads/master
i:
  148333: b110d4a
  148331: 6d38a33
  148327: a9b56e7
  148319: c42340e
v: v3

Author: dguenther

[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: 93fb12e3d0644f6a8ddfa2ac1d6b0a1d8341e287
+refs/heads/try2: 8f4edf9bf889bbb1f7bfb5bac4d0c825d2d5374d
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -806,9 +806,7 @@ path_glob : ident [ "::" path_glob ] ?
 
 A _use declaration_ creates one or more local name bindings synonymous
 with some other [path](#paths).
-Usually a `use` declaration is used to shorten the path required to refer to a
-module item. These declarations may appear at the top of [modules](#modules) and
-[blocks](#blocks).
+Usually a `use` declaration is used to shorten the path required to refer to a module item.
 
 *Note*: Unlike in many languages,
 `use` declarations in Rust do *not* declare linkage dependency with external crates.
@@ -2320,24 +2318,14 @@ let base = Point3d {x: 1, y: 2, z: 3};
 Point3d {y: 0, z: 10, .. base};
 ~~~~
 
-### Block expressions
+### Record expressions
 
 ~~~~ {.ebnf .gram}
-block_expr : '{' [ view_item ] *
-                 [ stmt ';' | item ] *
-                 [ expr ] '}'
+rec_expr : '{' ident ':' expr
+               [ ',' ident ':' expr ] *
+               [ ".." expr ] '}'
 ~~~~
 
-A _block expression_ is similar to a module in terms of the declarations that
-are possible. Each block conceptually introduces a new namespace scope. View
-items can bring new names into scopes and declared items are in scope for only
-the block itself.
-
-A block will execute each statement sequentially, and then execute the
-expression (if given). If the final expression is omitted, the type and return
-value of the block are `()`, but if it is provided, the type and return value
-of the block are that of the expression itself.
-
 ### Method-call expressions
 
 ~~~~ {.ebnf .gram}

branches/try2/src/compiletest/header.rs

@@ -90,14 +90,10 @@ pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
     fn xfail_target(config: &config) -> ~str {
         ~"xfail-" + util::get_os(config.target)
     }
-    fn xfail_stage(config: &config) -> ~str {
-        ~"xfail-" + config.stage_id.split('-').next().unwrap()
-    }
 
     let val = iter_header(testfile, |ln| {
         if parse_name_directive(ln, "xfail-test") { false }
         else if parse_name_directive(ln, xfail_target(config)) { false }
-        else if parse_name_directive(ln, xfail_stage(config)) { false }
         else if config.mode == common::mode_pretty &&
             parse_name_directive(ln, "xfail-pretty") { false }
         else { true }

branches/try2/src/etc/check-summary.py

@@ -7,22 +7,30 @@
     summaries = []
     def summarise(fname):
         summary = {}
-        fd = open(fname)
-        for line in fd:
-            status, test = line.strip().split(' ', 1)
-            if not summary.has_key(status):
-                summary[status] = []
-            summary[status].append(test)
-        summaries.append((fname, summary))
+        with open(fname) as fd:
+            for line in fd:
+                splitline = line.strip().split(' ')
+                if len(splitline) == 1:
+                    continue
+                status = splitline[0]
+                test = splitline[-1]
+                # track bench runs
+                if splitline[1] == 'ns/iter':
+                    status = 'bench'
+                if not summary.has_key(status):
+                    summary[status] = []
+                summary[status].append(test)
+            summaries.append((fname, summary))
     def count(t):
         return sum(map(lambda (f, s): len(s.get(t, [])), summaries))
     logfiles = sys.argv[1:]
     map(summarise, logfiles)
     ok = count('ok')
     failed = count('failed')
     ignored = count('ignored')
-    print "summary of %d test runs: %d passed; %d failed; %d ignored" % \
-            (len(logfiles), ok, failed, ignored)
+    measured = count('bench')
+    print "summary of %d test runs: %d passed; %d failed; %d ignored; %d measured" % \
+            (len(logfiles), ok, failed, ignored, measured)
     print ""
     if failed > 0:
         print "failed tests:"

branches/try2/src/libextra/base64.rs

@@ -154,25 +154,7 @@ impl<'a> ToBase64 for &'a [u8] {
 pub trait FromBase64 {
     /// Converts the value of `self`, interpreted as base64 encoded data, into
     /// an owned vector of bytes, returning the vector.
-    fn from_base64(&self) -> Result<~[u8], FromBase64Error>;
-}
-
-/// Errors that can occur when decoding a base64 encoded string
-pub enum FromBase64Error {
-    /// The input contained a character not part of the base64 format
-    InvalidBase64Character(char, uint),
-    /// The input had an invalid length
-    InvalidBase64Length,
-}
-
-impl ToStr for FromBase64Error {
-    fn to_str(&self) -> ~str {
-        match *self {
-            InvalidBase64Character(ch, idx) =>
-                format!("Invalid character '{}' at position {}", ch, idx),
-            InvalidBase64Length => ~"Invalid length",
-        }
-    }
+    fn from_base64(&self) -> Result<~[u8], ~str>;
 }
 
 impl<'a> FromBase64 for &'a str {
@@ -206,7 +188,7 @@ impl<'a> FromBase64 for &'a str {
      * }
      * ```
      */
-    fn from_base64(&self) -> Result<~[u8], FromBase64Error> {
+    fn from_base64(&self) -> Result<~[u8], ~str> {
         let mut r = ~[];
         let mut buf: u32 = 0;
         let mut modulus = 0;
@@ -223,7 +205,8 @@ impl<'a> FromBase64 for &'a str {
                 '/'|'_' => buf |= 0x3F,
                 '\r'|'\n' => continue,
                 '=' => break,
-                _ => return Err(InvalidBase64Character(self.char_at(idx), idx)),
+                _ => return Err(format!("Invalid character '{}' at position {}",
+                                     self.char_at(idx), idx))
             }
 
             buf <<= 6;
@@ -238,7 +221,8 @@ impl<'a> FromBase64 for &'a str {
 
         for (idx, byte) in it {
             if (byte as char) != '=' {
-                return Err(InvalidBase64Character(self.char_at(idx), idx));
+                return Err(format!("Invalid character '{}' at position {}",
+                                self.char_at(idx), idx));
             }
         }
 
@@ -251,7 +235,7 @@ impl<'a> FromBase64 for &'a str {
                 r.push((buf >> 8 ) as u8);
             }
             0 => (),
-            _ => return Err(InvalidBase64Length),
+            _ => return Err(~"Invalid Base64 length")
         }
 
         Ok(r)

branches/try2/src/libextra/comm.rs

@@ -127,9 +127,9 @@ mod test {
         // Rendezvous streams should be able to handle any number of messages being sent
         let (port, chan) = rendezvous();
         do spawn {
-            10000.times(|| { chan.send(()) })
+            1000000.times(|| { chan.send(()) })
         }
-        10000.times(|| { port.recv() })
+        1000000.times(|| { port.recv() })
     }
 
     #[test]

branches/try2/src/libextra/ebml.rs

@@ -90,7 +90,7 @@ pub mod reader {
 
     // ebml reading
 
-    pub struct Res {
+    struct Res {
         val: uint,
         next: uint
     }
@@ -130,40 +130,32 @@ pub mod reader {
             return vuint_at_slow(data, start);
         }
 
-        // Lookup table for parsing EBML Element IDs as per http://ebml.sourceforge.net/specs/
-        // The Element IDs are parsed by reading a big endian u32 positioned at data[start].
-        // Using the four most significant bits of the u32 we lookup in the table below how the
-        // element ID should be derived from it.
-        //
-        // The table stores tuples (shift, mask) where shift is the number the u32 should be right
-        // shifted with and mask is the value the right shifted value should be masked with.
-        // If for example the most significant bit is set this means it's a class A ID and the u32
-        // should be right shifted with 24 and masked with 0x7f. Therefore we store (24, 0x7f) at
-        // index 0x8 - 0xF (four bit numbers where the most significant bit is set).
-        //
-        // By storing the number of shifts and masks in a table instead of checking in order if
-        // the most significant bit is set, the second most significant bit is set etc. we can
-        // replace up to three "and+branch" with a single table lookup which gives us a measured
-        // speedup of around 2x on x86_64.
-        static SHIFT_MASK_TABLE: [(u32, u32), ..16] = [
-            (0, 0x0), (0, 0x0fffffff),
-            (8, 0x1fffff), (8, 0x1fffff),
-            (16, 0x3fff), (16, 0x3fff), (16, 0x3fff), (16, 0x3fff),
-            (24, 0x7f), (24, 0x7f), (24, 0x7f), (24, 0x7f),
-            (24, 0x7f), (24, 0x7f), (24, 0x7f), (24, 0x7f)
-        ];
-
         unsafe {
             let (ptr, _): (*u8, uint) = transmute(data);
             let ptr = offset(ptr, start as int);
             let ptr: *i32 = transmute(ptr);
-            let val = from_be32(*ptr) as u32;
-
-            let i = (val >> 28u) as uint;
-            let (shift, mask) = SHIFT_MASK_TABLE[i];
-            Res {
-                val: ((val >> shift) & mask) as uint,
-                next: start + (((32 - shift) >> 3) as uint)
+            let val = from_be32(*ptr);
+            let val: u32 = transmute(val);
+            if (val & 0x80000000) != 0 {
+                Res {
+                    val: ((val >> 24) & 0x7f) as uint,
+                    next: start + 1
+                }
+            } else if (val & 0x40000000) != 0 {
+                Res {
+                    val: ((val >> 16) & 0x3fff) as uint,
+                    next: start + 2
+                }
+            } else if (val & 0x20000000) != 0 {
+                Res {
+                    val: ((val >> 8) & 0x1fffff) as uint,
+                    next: start + 3
+                }
+            } else {
+                Res {
+                    val: (val & 0x0fffffff) as uint,
+                    next: start + 4
+                }
             }
         }
     }
@@ -946,54 +938,6 @@ mod tests {
     use std::io::mem::MemWriter;
     use std::option::{None, Option, Some};
 
-    #[test]
-    fn test_vuint_at() {
-        let data = [
-            0x80,
-            0xff,
-            0x40, 0x00,
-            0x7f, 0xff,
-            0x20, 0x00, 0x00,
-            0x3f, 0xff, 0xff,
-            0x10, 0x00, 0x00, 0x00,
-            0x1f, 0xff, 0xff, 0xff
-        ];
-
-        let mut res: reader::Res;
-
-        // Class A
-        res = reader::vuint_at(data, 0);
-        assert_eq!(res.val, 0);
-        assert_eq!(res.next, 1);
-        res = reader::vuint_at(data, res.next);
-        assert_eq!(res.val, (1 << 7) - 1);
-        assert_eq!(res.next, 2);
-
-        // Class B
-        res = reader::vuint_at(data, res.next);
-        assert_eq!(res.val, 0);
-        assert_eq!(res.next, 4);
-        res = reader::vuint_at(data, res.next);
-        assert_eq!(res.val, (1 << 14) - 1);
-        assert_eq!(res.next, 6);
-
-        // Class C
-        res = reader::vuint_at(data, res.next);
-        assert_eq!(res.val, 0);
-        assert_eq!(res.next, 9);
-        res = reader::vuint_at(data, res.next);
-        assert_eq!(res.val, (1 << 21) - 1);
-        assert_eq!(res.next, 12);
-
-        // Class D
-        res = reader::vuint_at(data, res.next);
-        assert_eq!(res.val, 0);
-        assert_eq!(res.next, 16);
-        res = reader::vuint_at(data, res.next);
-        assert_eq!(res.val, (1 << 28) - 1);
-        assert_eq!(res.next, 20);
-    }
-
     #[test]
     fn test_option_int() {
         fn test_v(v: Option<int>) {

branches/try2/src/libextra/hex.rs

@@ -53,25 +53,7 @@ impl<'a> ToHex for &'a [u8] {
 pub trait FromHex {
     /// Converts the value of `self`, interpreted as hexadecimal encoded data,
     /// into an owned vector of bytes, returning the vector.
-    fn from_hex(&self) -> Result<~[u8], FromHexError>;
-}
-
-/// Errors that can occur when decoding a hex encoded string
-pub enum FromHexError {
-    /// The input contained a character not part of the hex format
-    InvalidHexCharacter(char, uint),
-    /// The input had a invalid length
-    InvalidHexLength,
-}
-
-impl ToStr for FromHexError {
-    fn to_str(&self) -> ~str {
-        match *self {
-            InvalidHexCharacter(ch, idx) =>
-                format!("Invalid character '{}' at position {}", ch, idx),
-            InvalidHexLength => ~"Invalid input length",
-        }
-    }
+    fn from_hex(&self) -> Result<~[u8], ~str>;
 }
 
 impl<'a> FromHex for &'a str {
@@ -101,7 +83,7 @@ impl<'a> FromHex for &'a str {
      * }
      * ```
      */
-    fn from_hex(&self) -> Result<~[u8], FromHexError> {
+    fn from_hex(&self) -> Result<~[u8], ~str> {
         // This may be an overestimate if there is any whitespace
         let mut b = vec::with_capacity(self.len() / 2);
         let mut modulus = 0;
@@ -118,7 +100,8 @@ impl<'a> FromHex for &'a str {
                     buf >>= 4;
                     continue
                 }
-                _ => return Err(InvalidHexCharacter(self.char_at(idx), idx)),
+                _ => return Err(format!("Invalid character '{}' at position {}",
+                                        self.char_at(idx), idx))
             }
 
             modulus += 1;
@@ -130,7 +113,7 @@ impl<'a> FromHex for &'a str {
 
         match modulus {
             0 => Ok(b),
-            _ => Err(InvalidHexLength),
+            _ => Err(~"Invalid input length")
         }
     }
 }

branches/try2/src/libextra/test.rs

@@ -474,7 +474,7 @@ impl<T: Writer> ConsoleTestState<T> {
         match self.log_out {
             None => (),
             Some(ref mut o) => {
-                let s = format!("{} {}", match *result {
+                let s = format!("{} {}\n", match *result {
                         TrOk => ~"ok",
                         TrFailed => ~"failed",
                         TrIgnored => ~"ignored",

branches/try2/src/librustc/back/link.rs

@@ -1166,7 +1166,7 @@ fn add_local_native_libraries(args: &mut ~[~str], sess: Session) {
 fn add_upstream_rust_crates(args: &mut ~[~str], sess: Session,
                             dylib: bool, tmpdir: &Path) {
     // Converts a library file-stem into a cc -l argument
-    fn unlib(config: @session::Config, stem: &str) -> ~str {
+    fn unlib(config: @session::config, stem: &str) -> ~str {
         if stem.starts_with("lib") &&
             config.os != abi::OsWin32 {
             stem.slice(3, stem.len()).to_owned()

branches/try2/src/librustc/back/rpath.rs

@@ -39,7 +39,7 @@ pub fn get_rpath_flags(sess: session::Session, out_filename: &Path) -> ~[~str] {
 
     debug!("preparing the RPATH!");
 
-    let sysroot = sess.filesearch.sysroot;
+    let sysroot = sess.filesearch.sysroot();
     let output = out_filename;
     let libs = sess.cstore.get_used_crates(cstore::RequireDynamic);
     let libs = libs.move_iter().filter_map(|(_, l)| l.map(|p| p.clone())).collect();
@@ -55,7 +55,7 @@ pub fn get_rpath_flags(sess: session::Session, out_filename: &Path) -> ~[~str] {
 
 fn get_sysroot_absolute_rt_lib(sess: session::Session) -> Path {
     let r = filesearch::relative_target_lib_path(sess.opts.target_triple);
-    let mut p = sess.filesearch.sysroot.join(&r);
+    let mut p = sess.filesearch.sysroot().join(&r);
     p.push(os::dll_filename("rustrt"));
     p
 }