Remove the guts of fmt, but keep its interface.

Works around avr-rust/rust-legacy-fork#37

Author: gergoerdi

src/fmt/mod.rs

@@ -250,9 +250,7 @@ pub struct Formatter<'a> {
     width: Option<usize>,
     precision: Option<usize>,
 
-    buf: &'a mut (Write+'a),
-    curarg: slice::Iter<'a, ArgumentV1<'a>>,
-    args: &'a [ArgumentV1<'a>],
+    phantom: PhantomData<&'a ()>,
 }
 
 // NB. Argument is essentially an optimized partially applied formatting function,
@@ -440,7 +438,7 @@ impl<'a> Debug for Arguments<'a> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> Display for Arguments<'a> {
     fn fmt(&self, fmt: &mut Formatter) -> Result {
-        write(fmt.buf, *self)
+        Ok(())
     }
 }
 
@@ -1013,42 +1011,6 @@ pub trait UpperExp {
 /// [`write!`]: ../../std/macro.write.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn write(output: &mut Write, args: Arguments) -> Result {
-    let mut formatter = Formatter {
-        flags: 0,
-        width: None,
-        precision: None,
-        buf: output,
-        align: rt::v1::Alignment::Unknown,
-        fill: ' ',
-        args: args.args,
-        curarg: args.args.iter(),
-    };
-
-    let mut pieces = args.pieces.iter();
-
-    match args.fmt {
-        None => {
-            // We can use default formatting parameters for all arguments.
-            for (arg, piece) in args.args.iter().zip(pieces.by_ref()) {
-                formatter.buf.write_str(*piece)?;
-                (arg.formatter)(arg.value, &mut formatter)?;
-            }
-        }
-        Some(fmt) => {
-            // Every spec has a corresponding argument that is preceded by
-            // a string piece.
-            for (arg, piece) in fmt.iter().zip(pieces.by_ref()) {
-                formatter.buf.write_str(*piece)?;
-                formatter.run(arg)?;
-            }
-        }
-    }
-
-    // There can be only one trailing string piece left.
-    if let Some(piece) = pieces.next() {
-        formatter.buf.write_str(*piece)?;
-    }
-
     Ok(())
 }
 
@@ -1057,55 +1019,22 @@ impl<'a> Formatter<'a> {
         where 'b: 'c, F: FnOnce(&'b mut (Write+'b)) -> &'c mut (Write+'c)
     {
         Formatter {
-            // We want to change this
-            buf: wrap(self.buf),
-
             // And preserve these
             flags: self.flags,
             fill: self.fill,
             align: self.align,
             width: self.width,
             precision: self.precision,
 
-            // These only exist in the struct for the `run` method,
-            // which won’t be used together with this method.
-            curarg: self.curarg.clone(),
-            args: self.args,
+            phantom: self.phantom,
         }
     }
 
     // First up is the collection of functions used to execute a format string
     // at runtime. This consumes all of the compile-time statics generated by
     // the format! syntax extension.
     fn run(&mut self, arg: &rt::v1::Argument) -> Result {
-        // Fill in the format parameters into the formatter
-        self.fill = arg.format.fill;
-        self.align = arg.format.align;
-        self.flags = arg.format.flags;
-        self.width = self.getcount(&arg.format.width);
-        self.precision = self.getcount(&arg.format.precision);
-
-        // Extract the correct argument
-        let value = match arg.position {
-            rt::v1::Position::Next => { *self.curarg.next().unwrap() }
-            rt::v1::Position::At(i) => self.args[i],
-        };
-
-        // Then actually do some printing
-        (value.formatter)(value.value, self)
-    }
-
-    fn getcount(&mut self, cnt: &rt::v1::Count) -> Option<usize> {
-        match *cnt {
-            rt::v1::Count::Is(n) => Some(n),
-            rt::v1::Count::Implied => None,
-            rt::v1::Count::Param(i) => {
-                self.args[i].as_usize()
-            }
-            rt::v1::Count::NextParam => {
-                self.curarg.next().and_then(|arg| arg.as_usize())
-            }
-        }
+        Ok(())
     }
 
     // Helper methods used for padding and processing formatting arguments that
@@ -1130,58 +1059,7 @@ impl<'a> Formatter<'a> {
                         prefix: &str,
                         buf: &str)
                         -> Result {
-        let mut width = buf.len();
-
-        let mut sign = None;
-        if !is_nonnegative {
-            sign = Some('-'); width += 1;
-        } else if self.sign_plus() {
-            sign = Some('+'); width += 1;
-        }
-
-        let mut prefixed = false;
-        if self.alternate() {
-            prefixed = true; width += prefix.chars().count();
-        }
-
-        // Writes the sign if it exists, and then the prefix if it was requested
-        let write_prefix = |f: &mut Formatter| {
-            if let Some(c) = sign {
-                f.buf.write_str(c.encode_utf8(&mut [0; 4]))?;
-            }
-            if prefixed { f.buf.write_str(prefix) }
-            else { Ok(()) }
-        };
-
-        // The `width` field is more of a `min-width` parameter at this point.
-        match self.width {
-            // If there's no minimum length requirements then we can just
-            // write the bytes.
-            None => {
-                write_prefix(self)?; self.buf.write_str(buf)
-            }
-            // Check if we're over the minimum width, if so then we can also
-            // just write the bytes.
-            Some(min) if width >= min => {
-                write_prefix(self)?; self.buf.write_str(buf)
-            }
-            // The sign and prefix goes before the padding if the fill character
-            // is zero
-            Some(min) if self.sign_aware_zero_pad() => {
-                self.fill = '0';
-                self.align = rt::v1::Alignment::Right;
-                write_prefix(self)?;
-                self.with_padding(min - width, rt::v1::Alignment::Right, |f| {
-                    f.buf.write_str(buf)
-                })
-            }
-            // Otherwise, the sign and prefix goes after the padding
-            Some(min) => {
-                self.with_padding(min - width, rt::v1::Alignment::Right, |f| {
-                    write_prefix(f)?; f.buf.write_str(buf)
-                })
-            }
-        }
+        Ok(())
     }
 
     /// This function takes a string slice and emits it to the internal buffer
@@ -1197,47 +1075,7 @@ impl<'a> Formatter<'a> {
     /// Notably this function ignores the `flag` parameters.
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn pad(&mut self, s: &str) -> Result {
-        // Make sure there's a fast path up front
-        if self.width.is_none() && self.precision.is_none() {
-            return self.buf.write_str(s);
-        }
-        // The `precision` field can be interpreted as a `max-width` for the
-        // string being formatted.
-        let s = if let Some(max) = self.precision {
-            // If our string is longer that the precision, then we must have
-            // truncation. However other flags like `fill`, `width` and `align`
-            // must act as always.
-            if let Some((i, _)) = s.char_indices().skip(max).next() {
-                // LLVM here can't prove that `..i` won't panic `&s[..i]`, but
-                // we know that it can't panic. Use `get` + `unwrap_or` to avoid
-                // `unsafe` and otherwise don't emit any panic-related code
-                // here.
-                s.get(..i).unwrap_or(&s)
-            } else {
-                &s
-            }
-        } else {
-            &s
-        };
-        // The `width` field is more of a `min-width` parameter at this point.
-        match self.width {
-            // If we're under the maximum length, and there's no minimum length
-            // requirements, then we can just emit the string
-            None => self.buf.write_str(s),
-            // If we're under the maximum width, check if we're over the minimum
-            // width, if so it's as easy as just emitting the string.
-            Some(width) if s.chars().count() >= width => {
-                self.buf.write_str(s)
-            }
-            // If we're under both the maximum and the minimum width, then fill
-            // up the minimum width with the specified string + some alignment.
-            Some(width) => {
-                let align = rt::v1::Alignment::Left;
-                self.with_padding(width - s.chars().count(), align, |me| {
-                    me.buf.write_str(s)
-                })
-            }
-        }
+        Ok(())
     }
 
     /// Runs a callback, emitting the correct padding either before or
@@ -1246,45 +1084,20 @@ impl<'a> Formatter<'a> {
                        f: F) -> Result
         where F: FnOnce(&mut Formatter) -> Result,
     {
-        let align = match self.align {
-            rt::v1::Alignment::Unknown => default,
-            _ => self.align
-        };
-
-        let (pre_pad, post_pad) = match align {
-            rt::v1::Alignment::Left => (0, padding),
-            rt::v1::Alignment::Right |
-            rt::v1::Alignment::Unknown => (padding, 0),
-            rt::v1::Alignment::Center => (padding / 2, (padding + 1) / 2),
-        };
-
-        let mut fill = [0; 4];
-        let fill = self.fill.encode_utf8(&mut fill);
-
-        for _ in 0..pre_pad {
-            self.buf.write_str(fill)?;
-        }
-
-        f(self)?;
-
-        for _ in 0..post_pad {
-            self.buf.write_str(fill)?;
-        }
-
         Ok(())
     }
 
     /// Writes some data to the underlying buffer contained within this
     /// formatter.
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn write_str(&mut self, data: &str) -> Result {
-        self.buf.write_str(data)
+        Ok(())
     }
 
     /// Writes some formatted information into this instance
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn write_fmt(&mut self, fmt: Arguments) -> Result {
-        write(self.buf, fmt)
+        Ok(())
     }
 
     /// Flags for formatting
@@ -1658,15 +1471,15 @@ impl<'a> Formatter<'a> {
 #[stable(since = "1.2.0", feature = "formatter_write")]
 impl<'a> Write for Formatter<'a> {
     fn write_str(&mut self, s: &str) -> Result {
-        self.buf.write_str(s)
+        Ok(())
     }
 
     fn write_char(&mut self, c: char) -> Result {
-        self.buf.write_char(c)
+        Ok(())
     }
 
     fn write_fmt(&mut self, args: Arguments) -> Result {
-        write(self.buf, args)
+        Ok(())
     }
 }
 
@@ -1767,39 +1580,14 @@ impl Debug for char {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Display for char {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        if f.width.is_none() && f.precision.is_none() {
-            f.write_char(*self)
-        } else {
-            f.pad(self.encode_utf8(&mut [0; 4]))
-        }
+        Ok(())
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized> Pointer for *const T {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        let old_width = f.width;
-        let old_flags = f.flags;
-
-        // The alternate flag is already treated by LowerHex as being special-
-        // it denotes whether to prefix with 0x. We use it to work out whether
-        // or not to zero extend, and then unconditionally set it to get the
-        // prefix.
-        if f.alternate() {
-            f.flags |= 1 << (FlagV1::SignAwareZeroPad as u32);
-
-            if let None = f.width {
-                f.width = Some(((mem::size_of::<usize>() * 8) / 4) + 2);
-            }
-        }
-        f.flags |= 1 << (FlagV1::Alternate as u32);
-
-        let ret = LowerHex::fmt(&(*self as *const () as usize), f);
-
-        f.width = old_width;
-        f.flags = old_flags;
-
-        ret
+        Ok(())
     }
 }