---

yaml
---
r: 79785
b: refs/heads/try
c: 594531a
h: refs/heads/master
i:
  79783: ac35704
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: ba9fa89bfb4aae53db93e9ecac31807af96356fc
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 54ae2800ffb30513f89ce13d27ac3c8d095d98ac
-refs/heads/try: 75afcffc2ffdbac1d0a837d8407ae5720dce9631
+refs/heads/try: 594531a1c8d6cf850481848790fc25314ad367ec
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/configure

@@ -823,7 +823,7 @@ do
         index2="${CFG_SRC_DIR}src/llvm/.git/index"
         for index in ${index1} ${index2}
         do
-            config_status="${LLVM_BUILD_DIR}/config.status"
+            config_status="${CFG_BUILD_DIR}llvm/$t/config.status"
             if test -e ${index} -a \
                     -e ${config_status} -a \
                     ${config_status} -nt ${index}

branches/try/mk/rt.mk

@@ -176,9 +176,9 @@ LIBUV_NO_LOAD = run-benchmarks.target.mk run-tests.target.mk \
 
 export PYTHONPATH := $(PYTHONPATH):$$(S)src/gyp/pylib
 
-$$(LIBUV_MAKEFILE_$(1)_$(2)):
+$$(LIBUV_MAKEFILE_$(1)_$(2)): $$(LIBUV_DEPS)
 	(cd $(S)src/libuv/ && \
-	 $$(CFG_PYTHON) ./gyp_uv -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) -D ninja \
+	 ./gyp_uv -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) -D ninja \
 	   -Goutput_dir=$$(@D) --generator-output $$(@D))
 
 # XXX: Shouldn't need platform-specific conditions here

branches/try/src/libextra/crypto/sha2.rs

@@ -14,8 +14,28 @@ use cryptoutil::{write_u64_be, write_u32_be, read_u64v_be, read_u32v_be, add_byt
     add_bytes_to_bits_tuple, FixedBuffer, FixedBuffer128, FixedBuffer64, StandardPadding};
 use digest::Digest;
 
-// A structure that represents that state of a digest computation for the SHA-2 512 family
-// of digest functions
+
+// Sha-512 and Sha-256 use basically the same calculations which are implemented by these macros.
+// Inlining the calculations seems to result in better generated code.
+macro_rules! schedule_round( ($t:expr) => (
+        W[$t] = sigma1(W[$t - 2]) + W[$t - 7] + sigma0(W[$t - 15]) + W[$t - 16];
+    )
+)
+
+macro_rules! sha2_round(
+    ($A:ident, $B:ident, $C:ident, $D:ident,
+     $E:ident, $F:ident, $G:ident, $H:ident, $K:ident, $t:expr) => (
+        {
+            $H += sum1($E) + ch($E, $F, $G) + $K[$t] + W[$t];
+            $D += $H;
+            $H += sum0($A) + maj($A, $B, $C);
+        }
+    )
+)
+
+
+// A structure that represents that state of a digest computation for the SHA-2 512 family of digest
+// functions
 struct Engine512State {
     H0: u64,
     H1: u64,
@@ -88,25 +108,6 @@ impl Engine512State {
 
         let mut W = [0u64, ..80];
 
-        // Sha-512 and Sha-256 use basically the same calculations which are implemented by
-        // these macros. Inlining the calculations seems to result in better generated code.
-        macro_rules! schedule_round( ($t:expr) => (
-                W[$t] = sigma1(W[$t - 2]) + W[$t - 7] + sigma0(W[$t - 15]) + W[$t - 16];
-                )
-        )
-
-        macro_rules! sha2_round(
-            ($A:ident, $B:ident, $C:ident, $D:ident,
-             $E:ident, $F:ident, $G:ident, $H:ident, $K:ident, $t:expr) => (
-                {
-                    $H += sum1($E) + ch($E, $F, $G) + $K[$t] + W[$t];
-                    $D += $H;
-                    $H += sum0($A) + maj($A, $B, $C);
-                }
-             )
-        )
-
-
         read_u64v_be(W.mut_slice(0, 16), data);
 
         // Putting the message schedule inside the same loop as the round calculations allows for
@@ -504,25 +505,6 @@ impl Engine256State {
 
         let mut W = [0u32, ..64];
 
-        // Sha-512 and Sha-256 use basically the same calculations which are implemented
-        // by these macros. Inlining the calculations seems to result in better generated code.
-        macro_rules! schedule_round( ($t:expr) => (
-                W[$t] = sigma1(W[$t - 2]) + W[$t - 7] + sigma0(W[$t - 15]) + W[$t - 16];
-                )
-        )
-
-        macro_rules! sha2_round(
-            ($A:ident, $B:ident, $C:ident, $D:ident,
-             $E:ident, $F:ident, $G:ident, $H:ident, $K:ident, $t:expr) => (
-                {
-                    $H += sum1($E) + ch($E, $F, $G) + $K[$t] + W[$t];
-                    $D += $H;
-                    $H += sum0($A) + maj($A, $B, $C);
-                }
-             )
-        )
-
-
         read_u32v_be(W.mut_slice(0, 16), data);
 
         // Putting the message schedule inside the same loop as the round calculations allows for

branches/try/src/libextra/glob.rs

@@ -304,11 +304,11 @@ impl Pattern {
              && is_sep(prev_char.unwrap_or_default('/')))
         };
 
-        for (ti, token) in self.tokens.slice_from(i).iter().enumerate() {
-            match *token {
+        for ti in range(i, self.tokens.len()) {
+            match self.tokens[ti] {
                 AnySequence => {
                     loop {
-                        match self.matches_from(prev_char, file, i + ti + 1, options) {
+                        match self.matches_from(prev_char, file, ti + 1, options) {
                             SubPatternDoesntMatch => (), // keep trying
                             m => return m,
                         }
@@ -331,7 +331,7 @@ impl Pattern {
                     }
 
                     let (c, next) = file.slice_shift_char();
-                    let matches = match *token {
+                    let matches = match self.tokens[ti] {
                         AnyChar => {
                             !require_literal(c)
                         }

branches/try/src/libextra/time.rs

@@ -321,33 +321,6 @@ 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) {
@@ -468,11 +441,6 @@ 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, '-'))
@@ -805,7 +773,6 @@ 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),
@@ -1044,12 +1011,12 @@ mod tests {
           Err(_) => ()
         }
 
-        let format = "%a %b %e %T.%f %Y";
+        let format = "%a %b %e %T %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.01234 2009", format) {
+        match strptime("Fri Feb 13 15:31:30 2009", format) {
           Err(e) => fail!(e),
           Ok(ref tm) => {
             assert!(tm.tm_sec == 30_i32);
@@ -1063,7 +1030,7 @@ mod tests {
             assert!(tm.tm_isdst == 0_i32);
             assert!(tm.tm_gmtoff == 0_i32);
             assert!(tm.tm_zone == ~"");
-            assert!(tm.tm_nsec == 12340000_i32);
+            assert!(tm.tm_nsec == 0_i32);
           }
         }
 
@@ -1220,7 +1187,6 @@ 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/try/src/librustc/middle/borrowck/mod.rs

@@ -788,7 +788,7 @@ impl BorrowckCtxt {
                 match fname {
                     mc::NamedField(ref fname) => {
                         out.push_char('.');
-                        out.push_str(token::interner_get(*fname));
+                        out.push_str(token::ident_to_str(fname));
                     }
                     mc::PositionalField(idx) => {
                         out.push_char('#'); // invent a notation here

branches/try/src/librustc/middle/entry.rs

@@ -81,7 +81,7 @@ pub fn find_entry_point(session: Session, crate: &Crate, ast_map: ast_map::map)
 fn find_item(item: @item, ctxt: @mut EntryContext, visitor: &mut EntryVisitor) {
     match item.node {
         item_fn(*) => {
-            if item.ident.name == special_idents::main.name {
+            if item.ident == special_idents::main {
                 match ctxt.ast_map.find(&item.id) {
                     Some(&ast_map::node_item(_, path)) => {
                         if path.len() == 0 {

branches/try/src/librustc/middle/mem_categorization.rs

@@ -56,7 +56,6 @@ use syntax::ast::{MutImmutable, MutMutable};
 use syntax::ast;
 use syntax::codemap::Span;
 use syntax::print::pprust;
-use syntax::parse::token;
 
 #[deriving(Eq)]
 pub enum categorization {
@@ -100,7 +99,7 @@ pub enum InteriorKind {
 
 #[deriving(Eq, IterBytes)]
 pub enum FieldName {
-    NamedField(ast::Name),
+    NamedField(ast::Ident),
     PositionalField(uint)
 }
 
@@ -620,7 +619,7 @@ impl mem_categorization_ctxt {
         @cmt_ {
             id: node.id(),
             span: node.span(),
-            cat: cat_interior(base_cmt, InteriorField(NamedField(f_name.name))),
+            cat: cat_interior(base_cmt, InteriorField(NamedField(f_name))),
             mutbl: base_cmt.mutbl.inherit(),
             ty: f_ty
         }
@@ -1225,9 +1224,9 @@ pub fn ptr_sigil(ptr: PointerKind) -> ~str {
 }
 
 impl Repr for InteriorKind {
-    fn repr(&self, _tcx: ty::ctxt) -> ~str {
+    fn repr(&self, tcx: ty::ctxt) -> ~str {
         match *self {
-            InteriorField(NamedField(fld)) => token::interner_get(fld).to_owned(),
+            InteriorField(NamedField(fld)) => tcx.sess.str_of(fld).to_owned(),
             InteriorField(PositionalField(i)) => fmt!("#%?", i),
             InteriorElement(_) => ~"[]",
         }

branches/try/src/librustc/middle/moves.rs

@@ -429,7 +429,7 @@ impl VisitContext {
                     // specified and (2) have a type that
                     // moves-by-default:
                     let consume_with = with_fields.iter().any(|tf| {
-                        !fields.iter().any(|f| f.ident.name == tf.ident.name) &&
+                        !fields.iter().any(|f| f.ident == tf.ident) &&
                             ty::type_moves_by_default(self.tcx, tf.mt.ty)
                     });
 

branches/try/src/librustc/middle/privacy.rs

@@ -206,7 +206,7 @@ impl PrivacyVisitor {
     fn check_field(&mut self, span: Span, id: ast::DefId, ident: ast::Ident) {
         let fields = ty::lookup_struct_fields(self.tcx, id);
         for field in fields.iter() {
-            if field.ident.name != ident.name { loop; }
+            if field.ident != ident { loop; }
             if field.vis == private {
                 self.tcx.sess.span_err(span, fmt!("field `%s` is private",
                                              token::ident_to_str(&ident)));