Register new snapshots

3 files changed, 0 insertions, 76 deletions

diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs
index 4032515f985..383130cda37 100644
--- a/src/libstd/fmt/mod.rs
+++ b/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) }
diff --git a/src/libstd/fmt/parse.rs b/src/libstd/fmt/parse.rs
index 11b869c930e..8903d817c3f 100644
--- a/src/libstd/fmt/parse.rs
+++ b/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) => {
diff --git a/src/libstd/fmt/rt.rs b/src/libstd/fmt/rt.rs
index 063d712dfa9..b20af1a35b8 100644
--- a/src/libstd/fmt/rt.rs
+++ b/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,
 }