Convert printf internals to iterator

include.sh

@@ -1,5 +1,7 @@
 #!/usr/bin/env bash
 
+SUPRESS_ALL_THE_ERRORS=yes
+
 set -e
 
 include="$(realpath "$1")"
@@ -7,6 +9,10 @@ include="$(realpath "$1")"
 cargo build --release --manifest-path cbindgen/Cargo.toml
 cbindgen="$(realpath target/release/cbindgen)"
 
+if [ "$SUPRESS_ALL_THE_ERRORS" = "yes" ]; then
+    echo -e "\e[91mNote: Warnings by cbindgen are suppressed in include.sh.\e[0m"
+fi
+
 jobs=()
 for config in src/header/*/cbindgen.toml
 do
@@ -15,10 +21,16 @@ do
     if [ "${name:0:1}" != "_" ]
     then
         header="$include/${name/_//}.h"
-        pushd "$dir"
-        "$cbindgen" -c cbindgen.toml -o "$header" mod.rs &
+        pushd "$dir" > /dev/null
+        echo "$dir"
+        cbindgen_cmd='"$cbindgen" -c cbindgen.toml -o "$header" mod.rs'
+        if [ "$SUPRESS_ALL_THE_ERRORS" = "yes" ]; then
+            eval "$cbindgen_cmd" 2>&1 | (grep "^ERROR" -A 3 || true) &
+        else
+            eval "$cbindgen_cmd" &
+        fi
         jobs+=($!)
-        popd
+        popd > /dev/null
     fi
 done
 

src/header/stdio/printf.rs

@@ -20,8 +20,37 @@ enum IntKind {
     PtrDiff,
     Size,
 }
+enum FmtKind {
+    Percent,
 
-enum ArgType {
+    Signed,
+    Unsigned,
+
+    Scientific,
+    Decimal,
+    AnyNotation,
+
+    String,
+    Char,
+    Pointer,
+    GetWritten
+}
+#[derive(Clone, Copy, Debug)]
+enum Number {
+    Static(usize),
+    Index(usize),
+    Next
+}
+impl Number {
+    unsafe fn resolve(&self, ap: &mut BufferedVaList) -> usize {
+        match *self {
+            Number::Static(num) => num,
+            Number::Index(i) => ap.index(ArgKind::Int, i).int as usize,
+            Number::Next => ap.next(ArgKind::Int).int as usize,
+        }
+    }
+}
+enum ArgKind {
     Byte,
     Short,
     Int,
@@ -69,58 +98,58 @@ impl<'a> BufferedVaList<'a> {
         }
     }
 
-    unsafe fn get_arg(&mut self, ty: ArgType) -> VaArg {
+    unsafe fn get_arg(&mut self, ty: ArgKind) -> VaArg {
         match ty {
-            ArgType::Byte => VaArg {
+            ArgKind::Byte => VaArg {
                 byte: self.list.arg::<c_char>(),
             },
-            ArgType::Short => VaArg {
+            ArgKind::Short => VaArg {
                 short: self.list.arg::<c_short>(),
             },
-            ArgType::Int => VaArg {
+            ArgKind::Int => VaArg {
                 int: self.list.arg::<c_int>(),
             },
-            ArgType::Long => VaArg {
+            ArgKind::Long => VaArg {
                 long: self.list.arg::<c_long>(),
             },
-            ArgType::LongLong => VaArg {
+            ArgKind::LongLong => VaArg {
                 longlong: self.list.arg::<c_longlong>(),
             },
-            ArgType::PtrDiff => VaArg {
+            ArgKind::PtrDiff => VaArg {
                 ptrdiff: self.list.arg::<ptrdiff_t>(),
             },
-            ArgType::Size => VaArg {
+            ArgKind::Size => VaArg {
                 size: self.list.arg::<ssize_t>(),
             },
-            ArgType::IntMax => VaArg {
+            ArgKind::IntMax => VaArg {
                 intmax: self.list.arg::<intmax_t>(),
             },
-            ArgType::Double => VaArg {
+            ArgKind::Double => VaArg {
                 double: self.list.arg::<c_double>(),
             },
-            ArgType::CharPtr => VaArg {
+            ArgKind::CharPtr => VaArg {
                 char_ptr: self.list.arg::<*const c_char>(),
             },
-            ArgType::VoidPtr => VaArg {
+            ArgKind::VoidPtr => VaArg {
                 void_ptr: self.list.arg::<*const c_void>(),
             },
-            ArgType::IntPtr => VaArg {
+            ArgKind::IntPtr => VaArg {
                 int_ptr: self.list.arg::<*mut c_int>(),
             },
-            ArgType::ArgDefault => VaArg {
+            ArgKind::ArgDefault => VaArg {
                 arg_default: self.list.arg::<usize>(),
             },
         }
     }
 
-    unsafe fn get(&mut self, ty: ArgType, i: Option<usize>) -> VaArg {
+    unsafe fn get(&mut self, ty: ArgKind, i: Option<usize>) -> VaArg {
         match i {
             None => self.next(ty),
             Some(i) => self.index(ty, i),
         }
     }
 
-    unsafe fn next(&mut self, ty: ArgType) -> VaArg {
+    unsafe fn next(&mut self, ty: ArgKind) -> VaArg {
         if self.i >= self.buf.len() {
             let arg = self.get_arg(ty);
             self.buf.push(arg);
@@ -130,7 +159,7 @@ impl<'a> BufferedVaList<'a> {
         arg
     }
 
-    unsafe fn index(&mut self, ty: ArgType, i: usize) -> VaArg {
+    unsafe fn index(&mut self, ty: ArgKind, i: usize) -> VaArg {
         if self.i >= self.buf.len() {
             while self.buf.len() < (i - 1) {
                 // Getting a usize here most definitely isn't sane, however,
@@ -142,7 +171,7 @@ impl<'a> BufferedVaList<'a> {
                 // This chooses the width 10. How does it know the type of 0 and "hello"?
                 // It clearly can't.
 
-                let arg = self.get_arg(ArgType::ArgDefault);
+                let arg = self.get_arg(ArgKind::ArgDefault);
                 self.buf.push(arg);
             }
             let arg = self.get_arg(ty);
@@ -155,7 +184,7 @@ impl<'a> BufferedVaList<'a> {
 unsafe fn pop_int_raw(format: &mut *const u8) -> Option<usize> {
     let mut int = None;
     while let Some(digit) = (**format as char).to_digit(10) {
-        *format = format.offset(1);
+        *format = format.add(1);
         if int.is_none() {
             int = Some(0);
         }
@@ -164,23 +193,27 @@ unsafe fn pop_int_raw(format: &mut *const u8) -> Option<usize> {
     }
     int
 }
-
-unsafe fn pop_int(format: &mut *const u8, ap: &mut BufferedVaList) -> Option<usize> {
-    if **format == b'*' {
-        *format = format.offset(1);
-
-        // Peek ahead for a positional argument:
-        let mut format2 = *format;
-        if let Some(i) = pop_int_raw(&mut format2) {
-            if *format2 == b'$' {
-                *format = format2.offset(1);
-                return Some(ap.index(ArgType::ArgDefault, i).arg_default);
-            }
+unsafe fn pop_index(format: &mut *const u8) -> Option<usize> {
+    // Peek ahead for a positional argument:
+    let mut format2 = *format;
+    if let Some(i) = pop_int_raw(&mut format2) {
+        if *format2 == b'$' {
+            *format = format2.add(1);
+            return Some(i);
         }
-
-        Some(ap.next(ArgType::ArgDefault).arg_default)
+    }
+    None
+}
+unsafe fn pop_int(format: &mut *const u8) -> Option<Number> {
+    if **format == b'*' {
+        *format = format.add(1);
+        Some(
+            pop_index(format)
+                .map(Number::Index)
+                .unwrap_or(Number::Next)
+        )
     } else {
-        pop_int_raw(format)
+        pop_int_raw(format).map(Number::Static)
     }
 }
 
@@ -193,7 +226,7 @@ where
         b'u' => i.to_string(),
         b'x' => format!("{:x}", i),
         b'X' => format!("{:X}", i),
-        _ => panic!("fmt_int should never be called with the fmt {}", fmt),
+        _ => panic!("fmt_int should never be called with the fmt {:?}", fmt as char),
     }
 }
 
@@ -305,26 +338,57 @@ fn fmt_float_normal<W: Write>(
     Ok(string.len())
 }
 
-unsafe fn inner_printf<W: Write>(w: W, format: *const c_char, ap: va_list) -> io::Result<c_int> {
-    let w = &mut platform::CountingWriter::new(w);
-    let mut ap = BufferedVaList::new(ap);
-    let mut format = format as *const u8;
-
-    while *format != 0 {
-        if *format != b'%' {
-            w.write_all(&[*format])?;
-        } else {
-            format = format.offset(1);
-
-            // Peek ahead to maybe specify argument to fetch from
-            let mut index = None;
-            let mut format2 = format;
-            if let Some(i) = pop_int_raw(&mut format2) {
-                if *format2 == b'$' {
-                    format = format2.offset(1);
-                    index = Some(i);
-                }
+#[derive(Clone, Copy)]
+struct PrintfIter {
+    format: *const u8
+}
+struct PrintfArg {
+    index: Option<usize>,
+    alternate: bool,
+    zero: bool,
+    left: bool,
+    sign_reserve: bool,
+    sign_always: bool,
+    min_width: Number,
+    precision: Option<Number>,
+    pad_space: Number,
+    pad_zero: Number,
+    intkind: IntKind,
+    fmt: u8,
+    fmtkind: FmtKind
+}
+enum PrintfFmt {
+    Plain(&'static [u8]),
+    Arg(PrintfArg)
+}
+impl Iterator for PrintfIter {
+    type Item = Result<PrintfFmt, ()>;
+    fn next(&mut self) -> Option<Self::Item> {
+        unsafe {
+            // Send PrintfFmt::Plain until the next %
+            let mut len = 0;
+            while *self.format.add(len) != 0 && *self.format.add(len) != b'%' {
+                len += 1;
+            }
+            if len > 0 {
+                let slice = slice::from_raw_parts(self.format as *const u8, len);
+                self.format = self.format.add(len);
+                return Some(Ok(PrintfFmt::Plain(slice)));
             }
+            self.format = self.format.add(len);
+            if *self.format == 0 {
+                return None;
+            }
+
+            // *self.format is guaranteed to be '%' at this point
+            self.format = self.format.add(1);
+
+            let mut peekahead = self.format;
+            let index = pop_index(&mut peekahead)
+                .map(|i| {
+                    self.format = peekahead;
+                    i
+                });
 
             // Flags:
             let mut alternate = false;
@@ -334,7 +398,7 @@ unsafe fn inner_printf<W: Write>(w: W, format: *const c_char, ap: va_list) -> io
             let mut sign_always = false;
 
             loop {
-                match *format {
+                match *self.format {
                     b'#' => alternate = true,
                     b'0' => zero = true,
                     b'-' => left = true,
@@ -342,30 +406,30 @@ unsafe fn inner_printf<W: Write>(w: W, format: *const c_char, ap: va_list) -> io
                     b'+' => sign_always = true,
                     _ => break,
                 }
-                format = format.offset(1);
+                self.format = self.format.add(1);
             }
 
             // Width and precision:
-            let min_width = pop_int(&mut format, &mut ap).unwrap_or(0);
-            let precision = if *format == b'.' {
-                format = format.offset(1);
-                match pop_int(&mut format, &mut ap) {
+            let min_width = pop_int(&mut self.format).unwrap_or(Number::Static(0));
+            let precision = if *self.format == b'.' {
+                self.format = self.format.add(1);
+                match pop_int(&mut self.format) {
                     int @ Some(_) => int,
-                    None => return Ok(-1),
+                    None => return Some(Err(())),
                 }
             } else {
                 None
             };
 
-            let pad_space = if zero { 0 } else { min_width };
-            let pad_zero = if zero { min_width } else { 0 };
+            let pad_space = if zero { Number::Static(0) } else { min_width };
+            let pad_zero = if zero { min_width } else { Number::Static(0) };
 
             // Integer size:
-            let mut kind = IntKind::Int;
+            let mut intkind = IntKind::Int;
             loop {
-                kind = match *format {
+                intkind = match *self.format {
                     b'h' => {
-                        if kind == IntKind::Short || kind == IntKind::Byte {
+                        if intkind == IntKind::Short || intkind == IntKind::Byte {
                             IntKind::Byte
                         } else {
                             IntKind::Short
@@ -373,7 +437,7 @@ unsafe fn inner_printf<W: Write>(w: W, format: *const c_char, ap: va_list) -> io
                     }
                     b'j' => IntKind::IntMax,
                     b'l' => {
-                        if kind == IntKind::Long || kind == IntKind::LongLong {
+                        if intkind == IntKind::Long || intkind == IntKind::LongLong {
                             IntKind::LongLong
                         } else {
                             IntKind::Long
@@ -385,213 +449,270 @@ unsafe fn inner_printf<W: Write>(w: W, format: *const c_char, ap: va_list) -> io
                     _ => break,
                 };
 
-                format = format.offset(1);
+                self.format = self.format.add(1);
             }
+            let fmt = *self.format;
+            let fmtkind = match fmt {
+                b'%' => FmtKind::Percent,
+                b'd' | b'i' => FmtKind::Signed,
+                b'o' | b'u' | b'x' | b'X' => FmtKind::Unsigned,
+                b'e' | b'E' => FmtKind::Scientific,
+                b'f' | b'F' => FmtKind::Decimal,
+                b'g' | b'G' => FmtKind::AnyNotation,
+                b's' => FmtKind::String,
+                b'c' => FmtKind::Char,
+                b'p' => FmtKind::Pointer,
+                b'n' => FmtKind::GetWritten,
+                _ => return Some(Err(())),
+            };
+            self.format = self.format.add(1);
+
+            Some(Ok(PrintfFmt::Arg(PrintfArg {
+                index,
+                alternate,
+                zero,
+                left,
+                sign_reserve,
+                sign_always,
+                min_width,
+                precision,
+                pad_space,
+                pad_zero,
+                intkind,
+                fmt,
+                fmtkind
+            })))
+        }
+    }
+}
 
-            // Finally, type:
-            match *format {
-                b'%' => w.write_all(&[b'%'])?,
-                b'd' | b'i' => {
-                    let string = match kind {
-                        // Per the C standard using va_arg with a type with a size
-                        // less than that of an int for integers and double for floats
-                        // is invalid. As a result any arguments smaller than an int or
-                        // double passed to a function will be promoted to the smallest
-                        // possible size. The va_list::arg function will handle this
-                        // automagically.
-                        IntKind::Byte => ap.get(ArgType::Byte, index).byte.to_string(),
-                        IntKind::Short => ap.get(ArgType::Short, index).short.to_string(),
-                        // Types that will not be promoted
-                        IntKind::Int => ap.get(ArgType::Int, index).int.to_string(),
-                        IntKind::Long => ap.get(ArgType::Long, index).long.to_string(),
-                        IntKind::LongLong => ap.get(ArgType::LongLong, index).longlong.to_string(),
-                        IntKind::PtrDiff => ap.get(ArgType::PtrDiff, index).ptrdiff.to_string(),
-                        IntKind::Size => ap.get(ArgType::Size, index).size.to_string(),
-                        IntKind::IntMax => ap.get(ArgType::IntMax, index).intmax.to_string(),
-                    };
-                    let positive = !string.starts_with('-');
-                    let zero = precision == Some(0) && string == "0";
+unsafe fn inner_printf<W: Write>(w: W, format: *const c_char, ap: va_list) -> io::Result<c_int> {
+    let w = &mut platform::CountingWriter::new(w);
+    let mut ap = BufferedVaList::new(ap);
 
-                    let mut len = string.len();
-                    let mut final_len = string.len().max(precision.unwrap_or(0));
-                    if positive && (sign_reserve || sign_always) {
-                        final_len += 1;
-                    }
-                    if zero {
-                        len = 0;
-                        final_len = 0;
-                    }
+    let iterator = PrintfIter {
+        format: format as *const u8
+    };
 
-                    pad(w, !left, b' ', final_len..pad_space)?;
+    for section in iterator {
+        let arg = match section {
+            Ok(PrintfFmt::Plain(text)) => {
+                w.write_all(text)?;
+                continue;
+            },
+            Ok(PrintfFmt::Arg(arg)) => arg,
+            Err(()) => return Ok(-1)
+        };
+        let index = arg.index;
+        let alternate = arg.alternate;
+        let zero = arg.zero;
+        let left = arg.left;
+        let sign_reserve = arg.sign_reserve;
+        let sign_always = arg.sign_always;
+        let min_width = arg.min_width.resolve(&mut ap);
+        let precision = arg.precision.map(|n| n.resolve(&mut ap));
+        let pad_space = arg.pad_space.resolve(&mut ap);
+        let pad_zero = arg.pad_zero.resolve(&mut ap);
+        let intkind = arg.intkind;
+        let fmt = arg.fmt;
+        let fmtkind = arg.fmtkind;
+
+        // Finally, type:
+        match fmtkind {
+            FmtKind::Percent => w.write_all(&[b'%'])?,
+            FmtKind::Signed => {
+                let string = match intkind {
+                    // Per the C standard using va_arg with a type with a size
+                    // less than that of an int for integers and double for floats
+                    // is invalid. As a result any arguments smaller than an int or
+                    // double passed to a function will be promoted to the smallest
+                    // possible size. The va_list::arg function will handle this
+                    // automagically.
+                    IntKind::Byte => ap.get(ArgKind::Byte, index).byte.to_string(),
+                    IntKind::Short => ap.get(ArgKind::Short, index).short.to_string(),
+                    // Types that will not be promoted
+                    IntKind::Int => ap.get(ArgKind::Int, index).int.to_string(),
+                    IntKind::Long => ap.get(ArgKind::Long, index).long.to_string(),
+                    IntKind::LongLong => ap.get(ArgKind::LongLong, index).longlong.to_string(),
+                    IntKind::PtrDiff => ap.get(ArgKind::PtrDiff, index).ptrdiff.to_string(),
+                    IntKind::Size => ap.get(ArgKind::Size, index).size.to_string(),
+                    IntKind::IntMax => ap.get(ArgKind::IntMax, index).intmax.to_string(),
+                };
+                let positive = !string.starts_with('-');
+                let zero = precision == Some(0) && string == "0";
 
-                    let bytes = if positive {
-                        if sign_reserve {
-                            w.write_all(&[b' '])?;
-                        } else if sign_always {
-                            w.write_all(&[b'+'])?;
-                        }
-                        string.as_bytes()
-                    } else {
-                        w.write_all(&[b'-'])?;
-                        &string.as_bytes()[1..]
-                    };
-                    pad(w, true, b'0', len..precision.unwrap_or(pad_zero))?;
+                let mut len = string.len();
+                let mut final_len = string.len().max(precision.unwrap_or(0));
+                if positive && (sign_reserve || sign_always) {
+                    final_len += 1;
+                }
+                if zero {
+                    len = 0;
+                    final_len = 0;
+                }
+
+                pad(w, !left, b' ', final_len..pad_space)?;
 
-                    if !zero {
-                        w.write_all(bytes)?;
+                let bytes = if positive {
+                    if sign_reserve {
+                        w.write_all(&[b' '])?;
+                    } else if sign_always {
+                        w.write_all(&[b'+'])?;
                     }
+                    string.as_bytes()
+                } else {
+                    w.write_all(&[b'-'])?;
+                    &string.as_bytes()[1..]
+                };
+                pad(w, true, b'0', len..precision.unwrap_or(pad_zero))?;
 
-                    pad(w, left, b' ', final_len..pad_space)?;
+                if !zero {
+                    w.write_all(bytes)?;
                 }
-                b'o' | b'u' | b'x' | b'X' => {
-                    let fmt = *format;
-                    let string = match kind {
-                        // va_list will promote the following two to a c_int
-                        IntKind::Byte => fmt_int(fmt, ap.get(ArgType::Byte, index).byte),
-                        IntKind::Short => fmt_int(fmt, ap.get(ArgType::Short, index).short),
-                        IntKind::Int => fmt_int(fmt, ap.get(ArgType::Int, index).int),
-                        IntKind::Long => fmt_int(fmt, ap.get(ArgType::Long, index).long),
-                        IntKind::LongLong => {
-                            fmt_int(fmt, ap.get(ArgType::LongLong, index).longlong)
-                        }
-                        IntKind::PtrDiff => fmt_int(fmt, ap.get(ArgType::PtrDiff, index).ptrdiff),
-                        IntKind::Size => fmt_int(fmt, ap.get(ArgType::Size, index).size),
-                        IntKind::IntMax => fmt_int(fmt, ap.get(ArgType::IntMax, index).intmax),
-                    };
-                    let zero = precision == Some(0) && string == "0";
-
-                    // If this int is padded out to be larger than it is, don't
-                    // add an extra zero if octal.
-                    let no_precision = precision.map(|pad| pad < string.len()).unwrap_or(true);
-
-                    let mut len = string.len();
-                    let mut final_len = string.len().max(precision.unwrap_or(0))
-                        + if alternate && string != "0" {
-                            match fmt {
-                                b'o' if no_precision => 1,
-                                b'x' | b'X' => 2,
-                                _ => 0,
-                            }
-                        } else {
-                            0
-                        };
 
-                    if zero {
-                        len = 0;
-                        final_len = 0;
+                pad(w, left, b' ', final_len..pad_space)?;
+            },
+            FmtKind::Unsigned => {
+                let string = match intkind {
+                    // va_list will promote the following two to a c_int
+                    IntKind::Byte => fmt_int(fmt, ap.get(ArgKind::Byte, index).byte),
+                    IntKind::Short => fmt_int(fmt, ap.get(ArgKind::Short, index).short),
+                    IntKind::Int => fmt_int(fmt, ap.get(ArgKind::Int, index).int),
+                    IntKind::Long => fmt_int(fmt, ap.get(ArgKind::Long, index).long),
+                    IntKind::LongLong => {
+                        fmt_int(fmt, ap.get(ArgKind::LongLong, index).longlong)
                     }
+                    IntKind::PtrDiff => fmt_int(fmt, ap.get(ArgKind::PtrDiff, index).ptrdiff),
+                    IntKind::Size => fmt_int(fmt, ap.get(ArgKind::Size, index).size),
+                    IntKind::IntMax => fmt_int(fmt, ap.get(ArgKind::IntMax, index).intmax),
+                };
+                let zero = precision == Some(0) && string == "0";
 
-                    pad(w, !left, b' ', final_len..pad_space)?;
+                // If this int is padded out to be larger than it is, don't
+                // add an extra zero if octal.
+                let no_precision = precision.map(|pad| pad < string.len()).unwrap_or(true);
 
-                    if alternate && string != "0" {
+                let mut len = string.len();
+                let mut final_len = string.len().max(precision.unwrap_or(0))
+                    + if alternate && string != "0" {
                         match fmt {
-                            b'o' if no_precision => w.write_all(&[b'0'])?,
-                            b'x' => w.write_all(&[b'0', b'x'])?,
-                            b'X' => w.write_all(&[b'0', b'X'])?,
-                            _ => (),
+                            b'o' if no_precision => 1,
+                            b'x' | b'X' => 2,
+                            _ => 0,
                         }
-                    }
-                    pad(w, true, b'0', len..precision.unwrap_or(pad_zero))?;
-
-                    if !zero {
-                        w.write_all(string.as_bytes())?;
-                    }
+                    } else {
+                        0
+                    };
 
-                    pad(w, left, b' ', final_len..pad_space)?;
+                if zero {
+                    len = 0;
+                    final_len = 0;
                 }
-                b'e' | b'E' => {
-                    let exp_fmt = *format;
-                    let mut float = ap.get(ArgType::Double, index).double;
-                    let precision = precision.unwrap_or(6);
-
-                    fmt_float_exp(
-                        w, exp_fmt, None, false, precision, float, left, pad_space, pad_zero,
-                    )?;
-                }
-                b'f' | b'F' => {
-                    let mut float = ap.get(ArgType::Double, index).double;
-                    let precision = precision.unwrap_or(6);
 
-                    fmt_float_normal(w, false, precision, float, left, pad_space, pad_zero)?;
-                }
-                b'g' | b'G' => {
-                    let exp_fmt = b'E' | (*format & 32);
-                    let mut float = ap.get(ArgType::Double, index).double;
-                    let precision = precision.unwrap_or(6);
-
-                    if !fmt_float_exp(
-                        w,
-                        exp_fmt,
-                        Some((-4, precision as isize)),
-                        true,
-                        precision,
-                        float,
-                        left,
-                        pad_space,
-                        pad_zero,
-                    )? {
-                        fmt_float_normal(w, true, precision, float, left, pad_space, pad_zero)?;
+                pad(w, !left, b' ', final_len..pad_space)?;
+
+                if alternate && string != "0" {
+                    match fmt {
+                        b'o' if no_precision => w.write_all(&[b'0'])?,
+                        b'x' => w.write_all(&[b'0', b'x'])?,
+                        b'X' => w.write_all(&[b'0', b'X'])?,
+                        _ => (),
                     }
                 }
-                b's' => {
-                    // if kind == IntKind::Long || kind == IntKind::LongLong, handle *const wchar_t
+                pad(w, true, b'0', len..precision.unwrap_or(pad_zero))?;
 
-                    let ptr = ap.get(ArgType::CharPtr, index).char_ptr;
+                if !zero {
+                    w.write_all(string.as_bytes())?;
+                }
 
-                    if ptr.is_null() {
-                        w.write_all(b"(null)")?;
-                    } else {
-                        let mut len = 0;
-                        while *ptr.offset(len) != 0 {
-                            len += 1;
-                        }
+                pad(w, left, b' ', final_len..pad_space)?;
+            },
+            FmtKind::Scientific => {
+                let mut float = ap.get(ArgKind::Double, index).double;
+                let precision = precision.unwrap_or(6);
 
-                        let len = (len as usize).min(precision.unwrap_or(::core::usize::MAX));
+                fmt_float_exp(w, fmt, None, false, precision, float, left, pad_space, pad_zero)?;
+            },
+            FmtKind::Decimal => {
+                let mut float = ap.get(ArgKind::Double, index).double;
+                let precision = precision.unwrap_or(6);
 
-                        pad(w, !left, b' ', len..pad_space)?;
-                        w.write_all(slice::from_raw_parts(ptr as *const u8, len))?;
-                        pad(w, left, b' ', len..pad_space)?;
-                    }
+                fmt_float_normal(w, false, precision, float, left, pad_space, pad_zero)?;
+            },
+            FmtKind::AnyNotation => {
+                let exp_fmt = b'E' | (fmt & 32);
+                let mut float = ap.get(ArgKind::Double, index).double;
+                let precision = precision.unwrap_or(6);
+
+                if !fmt_float_exp(
+                    w,
+                    exp_fmt,
+                    Some((-4, precision as isize)),
+                    true,
+                    precision,
+                    float,
+                    left,
+                    pad_space,
+                    pad_zero,
+                )? {
+                    fmt_float_normal(w, true, precision, float, left, pad_space, pad_zero)?;
                 }
-                b'c' => {
-                    // if kind == IntKind::Long || kind == IntKind::LongLong, handle wint_t
-
-                    let c = ap.get(ArgType::Byte, index).byte;
+            },
+            FmtKind::String => {
+                // if intkind == IntKind::Long || intkind == IntKind::LongLong, handle *const wchar_t
+
+                let ptr = ap.get(ArgKind::CharPtr, index).char_ptr;
+
+                if ptr.is_null() {
+                    w.write_all(b"(null)")?;
+                } else {
+                    let max = precision.unwrap_or(::core::usize::MAX);
+                    let mut len = 0;
+                    while *ptr.add(len) != 0 && len < max {
+                        len += 1;
+                    }
 
-                    pad(w, !left, b' ', 1..pad_space)?;
-                    w.write_all(&[c as u8])?;
-                    pad(w, left, b' ', 1..pad_space)?;
+                    pad(w, !left, b' ', len..pad_space)?;
+                    w.write_all(slice::from_raw_parts(ptr as *const u8, len))?;
+                    pad(w, left, b' ', len..pad_space)?;
                 }
-                b'p' => {
-                    let ptr = ap.get(ArgType::VoidPtr, index).int_ptr;
+            },
+            FmtKind::Char => {
+                // if intkind == IntKind::Long || intkind == IntKind::LongLong, handle wint_t
 
-                    let mut len = 1;
-                    if ptr.is_null() {
-                        len = "(nil)".len();
-                    } else {
-                        let mut ptr = ptr as usize;
-                        while ptr >= 10 {
-                            ptr /= 10;
-                            len += 1;
-                        }
-                    }
+                let c = ap.get(ArgKind::Byte, index).byte;
 
-                    pad(w, !left, b' ', len..pad_space)?;
-                    if ptr.is_null() {
-                        write!(w, "(nil)")?;
-                    } else {
-                        write!(w, "0x{:x}", ptr as usize)?;
+                pad(w, !left, b' ', 1..pad_space)?;
+                w.write_all(&[c as u8])?;
+                pad(w, left, b' ', 1..pad_space)?;
+            },
+            FmtKind::Pointer => {
+                let ptr = ap.get(ArgKind::VoidPtr, index).int_ptr;
+
+                let mut len = 1;
+                if ptr.is_null() {
+                    len = "(nil)".len();
+                } else {
+                    let mut ptr = ptr as usize;
+                    while ptr >= 10 {
+                        ptr /= 10;
+                        len += 1;
                     }
-                    pad(w, left, b' ', len..pad_space)?;
                 }
-                b'n' => {
-                    let ptr = ap.get(ArgType::IntPtr, index).int_ptr;
-                    *ptr = w.written as c_int;
+
+                pad(w, !left, b' ', len..pad_space)?;
+                if ptr.is_null() {
+                    write!(w, "(nil)")?;
+                } else {
+                    write!(w, "0x{:x}", ptr as usize)?;
                 }
-                _ => return Ok(-1),
+                pad(w, left, b' ', len..pad_space)?;
+            },
+            FmtKind::GetWritten => {
+                let ptr = ap.get(ArgKind::IntPtr, index).int_ptr;
+                *ptr = w.written as c_int;
             }
         }
-        format = format.offset(1);
     }
     Ok(w.written as c_int)
 }

src/platform/redox/mod.rs

@@ -151,8 +151,6 @@ impl Pal for Sys {
         mut argv: *const *mut c_char,
         mut envp: *const *mut c_char,
     ) -> c_int {
-        use alloc::vec::Vec;
-
         let mut file = match File::open(path, fcntl::O_RDONLY | fcntl::O_CLOEXEC) {
             Ok(file) => file,
             Err(_) => return -1,