---

yaml
---
r: 95457
b: refs/heads/dist-snap
c: 0adb41d
h: refs/heads/master
i:
  95455: e2af7ec
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: d4a32386f3b61a4997de54ed00c0a80fd07ecc75
+refs/heads/dist-snap: 0adb41d0eb44ef74e897c22d9f1fcd8f97ef3458
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/back/rpath.rs

@@ -189,9 +189,12 @@ mod test {
         let mut d = Path::new(env!("CFG_PREFIX"));
         d.push("lib/rustc/triple/lib");
         debug2!("test_prefix_path: {} vs. {}",
-               res,
+               res.to_str(),
                d.display());
-        assert!(res.as_bytes().ends_with(d.as_vec()));
+        assert!(ends_with(res.as_bytes(), d.as_vec()));
+        fn ends_with(v: &[u8], needle: &[u8]) -> bool {
+            v.len() >= needle.len() && v.slice_from(v.len()-needle.len()) == needle
+        }
     }
 
     #[test]

branches/dist-snap/src/librustpkg/tests.rs

@@ -217,6 +217,10 @@ fn is_read_only(p: &Path) -> bool {
     }
 }
 
+fn ends_with(v: &[u8], needle: &[u8]) -> bool {
+    v.len() >= needle.len() && v.slice_from(v.len() - needle.len()) == needle
+}
+
 fn test_sysroot() -> Path {
     // Totally gross hack but it's just for test cases.
     // Infer the sysroot from the exe name and pray that it's right.
@@ -743,7 +747,7 @@ fn test_package_version() {
                                              &ws) {
         Some(p) => {
             let suffix = format!("0.4{}", os::consts::DLL_SUFFIX);
-            p.as_vec().ends_with(suffix.as_bytes())
+            ends_with(p.as_vec(), suffix.as_bytes())
         }
         None    => false
     });
@@ -781,7 +785,7 @@ fn test_package_request_version() {
         Some(p) => {
             debug2!("installed: {}", p.display());
             let suffix = format!("0.3{}", os::consts::DLL_SUFFIX);
-            p.as_vec().ends_with(suffix.as_bytes())
+            ends_with(p.as_vec(), suffix.as_bytes())
         }
         None    => false
     });

branches/dist-snap/src/libstd/fmt/mod.rs

@@ -673,24 +673,6 @@ impl<'self> Formatter<'self> {
         }
     }
 
-    #[cfg(stage0)]
-    fn getcount(&mut self, cnt: &parse::Count) -> Option<uint> {
-        match *cnt {
-            parse::CountIs(n) => { Some(n) }
-            parse::CountImplied => { None }
-            parse::CountIsParam(i) => {
-                let v = self.args[i].value;
-                unsafe { Some(*(v as *util::Void as *uint)) }
-            }
-            parse::CountIsNextParam => {
-                let v = self.curarg.next().unwrap().value;
-                unsafe { Some(*(v as *util::Void as *uint)) }
-            }
-            parse::CountIsName(*) => unreachable!()
-        }
-    }
-
-    #[cfg(not(stage0))]
     fn getcount(&mut self, cnt: &rt::Count) -> Option<uint> {
         match *cnt {
             rt::CountIs(n) => { Some(n) }

branches/dist-snap/src/libstd/fmt/parse.rs

@@ -48,27 +48,6 @@ pub struct Argument<'self> {
 
 /// Specification for the formatting of an argument in the format string.
 #[deriving(Eq)]
-#[cfg(stage0)]
-pub struct FormatSpec<'self> {
-    /// Optionally specified character to fill alignment with
-    fill: Option<char>,
-    /// Optionally specified alignment
-    align: Alignment,
-    /// Packed version of various flags provided
-    flags: uint,
-    /// The integer precision to use
-    precision: Count,
-    /// The string width requested for the resulting format
-    width: Count,
-    /// The descriptor string representing the name of the format desired for
-    /// this argument, this can be empty or any number of characters, although
-    /// it is required to be one word.
-    ty: &'self str
-}
-
-/// Specification for the formatting of an argument in the format string.
-#[deriving(Eq)]
-#[cfg(not(stage0))]
 pub struct FormatSpec<'self> {
     /// Optionally specified character to fill alignment with
     fill: Option<char>,
@@ -113,18 +92,6 @@ pub enum Flag {
 /// can reference either an argument or a literal integer.
 #[deriving(Eq)]
 #[allow(missing_doc)]
-#[cfg(stage0)]
-pub enum Count {
-    CountIs(uint),
-    CountIsParam(uint),
-    CountIsName(&'static str), // not actually used, see stage1
-    CountIsNextParam,
-    CountImplied,
-}
-
-#[deriving(Eq)]
-#[allow(missing_doc)]
-#[cfg(not(stage0))]
 pub enum Count<'self> {
     CountIs(uint),
     CountIsName(&'self str),
@@ -594,20 +561,6 @@ impl<'self> Parser<'self> {
     /// Parses a Count parameter at the current position. This does not check
     /// for 'CountIsNextParam' because that is only used in precision, not
     /// width.
-    #[cfg(stage0)]
-    fn count(&mut self) -> Count {
-        match self.integer() {
-            Some(i) => {
-                if self.consume('$') {
-                    CountIsParam(i)
-                } else {
-                    CountIs(i)
-                }
-            }
-            None => { CountImplied }
-        }
-    }
-    #[cfg(not(stage0))]
     fn count(&mut self) -> Count<'self> {
         match self.integer() {
             Some(i) => {

branches/dist-snap/src/libstd/fmt/rt.rs

@@ -34,16 +34,6 @@ pub struct Argument<'self> {
     method: Option<&'self Method<'self>>
 }
 
-#[cfg(stage0)]
-pub struct FormatSpec {
-    fill: char,
-    align: parse::Alignment,
-    flags: uint,
-    precision: parse::Count,
-    width: parse::Count,
-}
-
-#[cfg(not(stage0))]
 pub struct FormatSpec {
     fill: char,
     align: parse::Alignment,
@@ -52,7 +42,6 @@ pub struct FormatSpec {
     width: Count,
 }
 
-#[cfg(not(stage0))]
 pub enum Count {
     CountIs(uint), CountIsParam(uint), CountIsNextParam, CountImplied,
 }

branches/dist-snap/src/libstd/repr.rs

@@ -367,16 +367,6 @@ impl<'self> TyVisitor for ReprVisitor<'self> {
         }
     }
 
-    #[cfg(stage0)]
-    fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
-        do self.get::<raw::Slice<()>> |this, s| {
-            this.writer.write(['&' as u8]);
-            this.write_mut_qualifier(mtbl);
-            this.write_vec_range(s.data, s.len, inner);
-        }
-    }
-
-    #[cfg(not(stage0))]
     fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
         do self.get::<raw::Slice<()>> |this, s| {
             this.writer.write(['&' as u8]);

branches/dist-snap/src/libstd/str.rs

@@ -827,6 +827,17 @@ pub fn eq(a: &~str, b: &~str) -> bool {
     eq_slice(*a, *b)
 }
 
+/*
+Section: Searching
+*/
+
+// Utility used by various searching functions
+fn match_at<'a,'b>(haystack: &'a str, needle: &'b str, at: uint) -> bool {
+    let mut i = at;
+    for c in needle.byte_iter() { if haystack[i] != c { return false; } i += 1u; }
+    return true;
+}
+
 /*
 Section: Misc
 */
@@ -2007,16 +2018,18 @@ impl<'self> StrSlice<'self> for &'self str {
         }
     }
 
-    #[inline]
     fn starts_with<'a>(&self, needle: &'a str) -> bool {
-        let n = needle.len();
-        self.len() >= n && needle == self.slice_to(n)
+        let (self_len, needle_len) = (self.len(), needle.len());
+        if needle_len == 0u { true }
+        else if needle_len > self_len { false }
+        else { match_at(*self, needle, 0u) }
     }
 
-    #[inline]
     fn ends_with(&self, needle: &str) -> bool {
-        let (m, n) = (self.len(), needle.len());
-        m >= n && needle == self.slice_from(m - n)
+        let (self_len, needle_len) = (self.len(), needle.len());
+        if needle_len == 0u { true }
+        else if needle_len > self_len { false }
+        else { match_at(*self, needle, self_len - needle_len) }
     }
 
     fn escape_default(&self) -> ~str {

branches/dist-snap/src/libstd/unstable/intrinsics.rs

@@ -172,7 +172,6 @@ pub trait TyVisitor {
 
 extern "rust-intrinsic" {
     /// Abort the execution of the process.
-    #[cfg(not(stage0))]
     pub fn abort() -> !;
 
     /// Atomic compare and exchange, sequentially consistent.