---

yaml
---
r: 124803
b: refs/heads/auto
c: ca6ffac
h: refs/heads/master
i:
  124801: 0526a0f
  124799: e25f2c0
v: v3

Author: chris-morgan

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 72625defd7a127c238da05abf22364448b7be526
+refs/heads/auto: ca6ffac4e4683705b895e368375103315ca0e1ca
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/etc/vim/syntax/rust.vim

@@ -60,6 +60,10 @@ syn region    rustBoxPlacementBalance start="(" end=")" containedin=rustBoxPlace
 syn region    rustBoxPlacementBalance start="\[" end="\]" containedin=rustBoxPlacement transparent
 " {} are handled by rustFoldBraces
 
+syn region rustMacroRepeat matchgroup=rustMacroRepeatDelimiters start="$(" end=")" contains=TOP nextgroup=rustMacroRepeatCount
+syn match rustMacroRepeatCount ".\?[*+]" contained
+syn match rustMacroVariable "$\w\+"
+
 " Reserved (but not yet used) keywords {{{2
 syn keyword   rustReservedKeyword alignof be do offsetof priv pure sizeof typeof unsized yield
 
@@ -233,6 +237,9 @@ hi def link rustBinNumber       rustNumber
 hi def link rustIdentifierPrime rustIdentifier
 hi def link rustTrait           rustType
 
+hi def link rustMacroRepeatCount   rustMacroRepeatDelimiters
+hi def link rustMacroRepeatDelimiters   Macro
+hi def link rustMacroVariable Define
 hi def link rustSigil         StorageClass
 hi def link rustEscape        Special
 hi def link rustEscapeUnicode rustEscape

branches/auto/src/librlibc/lib.rs

@@ -21,26 +21,22 @@
 //! the system libc library.
 
 #![crate_name = "rlibc"]
-#![experimental]
 #![license = "MIT/ASL2"]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/master/")]
+#![feature(intrinsics)]
 
-#![feature(intrinsics, phase)]
 #![no_std]
+#![experimental]
 
 // This library defines the builtin functions, so it would be a shame for
 // LLVM to optimize these function calls to themselves!
 #![no_builtins]
 
+#[cfg(test)] extern crate std;
 #[cfg(test)] extern crate native;
-#[cfg(test)] extern crate test;
-#[cfg(test)] extern crate debug;
-
-#[cfg(test)] #[phase(plugin, link)] extern crate std;
-#[cfg(test)] #[phase(plugin, link)] extern crate core;
 
 // Require the offset intrinsics for LLVM to properly optimize the
 // implementations below. If pointer arithmetic is done through integers the
@@ -99,107 +95,11 @@ pub unsafe extern "C" fn memcmp(s1: *const u8, s2: *const u8, n: uint) -> i32 {
         let a = *offset(s1, i as int);
         let b = *offset(s2, i as int);
         if a != b {
-            return a as i32 - b as i32
+            return (a - b) as i32
         }
         i += 1;
     }
     return 0;
 }
 
-#[cfg(test)]
-mod test {
-    use core::option::{Some, None};
-    use core::iter::Iterator;
-    use core::collections::Collection;
-    use core::str::StrSlice;
-    use core::slice::{MutableVector, ImmutableVector};
-
-    use super::{memcmp, memset, memcpy, memmove};
-
-    #[test]
-    fn memcmp_single_byte_pointers() {
-        unsafe {
-            assert_eq!(memcmp(&0xFAu8, &0xFAu8, 1), 0x00);
-            assert!(memcmp(&0xEFu8, &0xFEu8, 1) < 0x00);
-        }
-    }
-
-    #[test]
-    fn memcmp_strings() {
-        {
-            let (x, z) = ("Hello!", "Good Bye.");
-            let l = x.len();
-            unsafe {
-                assert_eq!(memcmp(x.as_ptr(), x.as_ptr(), l), 0);
-                assert!(memcmp(x.as_ptr(), z.as_ptr(), l) > 0);
-                assert!(memcmp(z.as_ptr(), x.as_ptr(), l) < 0);
-            }
-        }
-        {
-            let (x, z) = ("hey!", "hey.");
-            let l = x.len();
-            unsafe {
-                assert!(memcmp(x.as_ptr(), z.as_ptr(), l) < 0);
-            }
-        }
-    }
-
-    #[test]
-    fn memset_single_byte_pointers() {
-        let mut x: u8 = 0xFF;
-        unsafe {
-            memset(&mut x, 0xAA, 1);
-            assert_eq!(x, 0xAA);
-            memset(&mut x, 0x00, 1);
-            assert_eq!(x, 0x00);
-            x = 0x01;
-            memset(&mut x, 0x12, 0);
-            assert_eq!(x, 0x01);
-        }
-    }
-
-    #[test]
-    fn memset_array() {
-        let mut buffer = [b'X', .. 100];
-        unsafe {
-            memset(buffer.as_mut_ptr(), b'#' as i32, buffer.len());
-        }
-        for byte in buffer.iter() { assert_eq!(*byte, b'#'); }
-    }
-
-    #[test]
-    fn memcpy_and_memcmp_arrays() {
-        let (src, mut dst) = ([b'X', .. 100], [b'Y', .. 100]);
-        unsafe {
-            assert!(memcmp(src.as_ptr(), dst.as_ptr(), 100) != 0);
-            let _ = memcpy(dst.as_mut_ptr(), src.as_ptr(), 100);
-            assert_eq!(memcmp(src.as_ptr(), dst.as_ptr(), 100), 0);
-        }
-    }
-
-    #[test]
-    fn memmove_overlapping() {
-        {
-            let mut buffer = [ b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9' ];
-            unsafe {
-                memmove(&mut buffer[4], &buffer[0], 6);
-                let mut i = 0;
-                for byte in b"0123012345".iter() {
-                    assert_eq!(buffer[i], *byte);
-                    i += 1;
-                }
-            }
-        }
-        {
-            let mut buffer = [ b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9' ];
-            unsafe {
-                memmove(&mut buffer[0], &buffer[4], 6);
-                let mut i = 0;
-                for byte in b"4567896789".iter() {
-                    assert_eq!(buffer[i], *byte);
-                    i += 1;
-                }
-            }
-        }
-    }
-}
+#[test] fn work_on_windows() { } // FIXME #10872 needed for a happy windows