break off some of std.io into std.fmt, generalize printf

closes #250

CMakeLists.txt

@@ -210,6 +210,7 @@ install(FILES "${CMAKE_SOURCE_DIR}/std/elf.zig" DESTINATION "${ZIG_STD_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/std/empty.zig" DESTINATION "${ZIG_STD_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/std/endian.zig" DESTINATION "${ZIG_STD_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/std/errno.zig" DESTINATION "${ZIG_STD_DEST}")
+install(FILES "${CMAKE_SOURCE_DIR}/std/fmt.zig" DESTINATION "${ZIG_STD_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/std/hash_map.zig" DESTINATION "${ZIG_STD_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/std/index.zig" DESTINATION "${ZIG_STD_DEST}")
 install(FILES "${CMAKE_SOURCE_DIR}/std/io.zig" DESTINATION "${ZIG_STD_DEST}")

example/guess_number/main.zig

@@ -1,5 +1,6 @@
 const std = @import("std");
 const io = std.io;
+const fmt = std.fmt;
 const Rand = std.rand.Rand;
 const os = std.os;
 
@@ -23,7 +24,7 @@ pub fn main(args: [][]u8) -> %void {
             return err;
         };
 
-        const guess = io.parseUnsigned(u8, line_buf[0...line_len - 1], 10) %% {
+        const guess = fmt.parseUnsigned(u8, line_buf[0...line_len - 1], 10) %% {
             %%io.stdout.printf("Invalid number.\n");
             continue;
         };

std/fmt.zig

@@ -0,0 +1,334 @@
+const math = @import("math.zig");
+const debug = @import("debug.zig");
+const assert = debug.assert;
+const mem = @import("mem.zig");
+
+const max_f64_digits = 65;
+const max_int_digits = 65;
+
+const State = enum { // TODO put inside format function and make sure the name and debug info is correct
+    Start,
+    OpenBrace,
+    CloseBrace,
+    Integer,
+    IntegerWidth,
+    Character,
+};
+
+/// Renders fmt string with args, calling output with slices of bytes.
+/// Return false from output function and output will not be called again.
+/// Returns false if output ever returned false, true otherwise.
+pub fn format(context: var, output: fn(@typeOf(context), []const u8)->bool,
+    comptime fmt: []const u8, args: ...) -> bool
+{
+    comptime var start_index = 0;
+    comptime var state = State.Start;
+    comptime var next_arg = 0;
+    comptime var radix = 0;
+    comptime var uppercase = false;
+    comptime var width = 0;
+    comptime var width_start = 0;
+
+    inline for (fmt) |c, i| {
+        switch (state) {
+            State.Start => switch (c) {
+                '{' => {
+                    // TODO if you make this an if statement with && then it breaks
+                    if (start_index < i) {
+                        if (!output(context, fmt[start_index...i]))
+                            return false;
+                    }
+                    state = State.OpenBrace;
+                },
+                '}' => {
+                    if (start_index < i) {
+                        if (!output(context, fmt[start_index...i]))
+                            return false;
+                    }
+                    state = State.CloseBrace;
+                },
+                else => {},
+            },
+            State.OpenBrace => switch (c) {
+                '{' => {
+                    state = State.Start;
+                    start_index = i;
+                },
+                '}' => {
+                    if (!formatValue(args[next_arg], context, output))
+                        return false;
+                    next_arg += 1;
+                    state = State.Start;
+                    start_index = i + 1;
+                },
+                'd' => {
+                    radix = 10;
+                    uppercase = false;
+                    width = 0;
+                    state = State.Integer;
+                },
+                'x' => {
+                    radix = 16;
+                    uppercase = false;
+                    width = 0;
+                    state = State.Integer;
+                },
+                'X' => {
+                    radix = 16;
+                    uppercase = true;
+                    width = 0;
+                    state = State.Integer;
+                },
+                'c' => {
+                    state = State.Character;
+                },
+                else => @compileError("Unknown format character: " ++ []u8{c}),
+            },
+            State.CloseBrace => switch (c) {
+                '}' => {
+                    state = State.Start;
+                    start_index = i;
+                },
+                else => @compileError("Single '}' encountered in format string"),
+            },
+            State.Integer => switch (c) {
+                '}' => {
+                    if (!formatInt(args[next_arg], radix, uppercase, width, context, output))
+                        return false;
+                    next_arg += 1;
+                    state = State.Start;
+                    start_index = i + 1;
+                },
+                '0' ... '9' => {
+                    width_start = i;
+                    state = State.IntegerWidth;
+                },
+                else => @compileError("Unexpected character in format string: " ++ []u8{c}),
+            },
+            State.IntegerWidth => switch (c) {
+                '}' => {
+                    width = comptime %%parseUnsigned(usize, fmt[width_start...i], 10);
+                    if (!formatInt(args[next_arg], radix, uppercase, width, context, output))
+                        return false;
+                    next_arg += 1;
+                    state = State.Start;
+                    start_index = i + 1;
+                },
+                '0' ... '9' => {},
+                else => @compileError("Unexpected character in format string: " ++ []u8{c}),
+            },
+            State.Character => switch (c) {
+                '}' => {
+                    if (!formatAsciiChar(args[next_arg], context, output))
+                        return false;
+                    next_arg += 1;
+                    state = State.Start;
+                    start_index = i + 1;
+                },
+                else => @compileError("Unexpected character in format string: " ++ []u8{c}),
+            },
+        }
+    }
+    comptime {
+        if (args.len != next_arg) {
+            @compileError("Unused arguments");
+        }
+        if (state != State.Start) {
+            @compileError("Incomplete format string: " ++ fmt);
+        }
+    }
+    if (start_index < fmt.len) {
+        if (!output(context, fmt[start_index...]))
+            return false;
+    }
+
+    return true;
+}
+
+pub fn formatValue(value: var, context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool {
+    const T = @typeOf(value);
+    if (@isInteger(T)) {
+        return formatInt(value, 10, false, 0, context, output);
+    } else if (@isFloat(T)) {
+        @compileError("TODO implement formatFloat");
+    } else if (@canImplicitCast([]const u8, value)) {
+        const casted_value = ([]const u8)(value);
+        return output(context, casted_value);
+    } else if (T == void) {
+        return output(context, "void");
+    } else {
+        @compileError("Unable to format type '" ++ @typeName(T) ++ "'");
+    }
+}
+
+pub fn formatAsciiChar(c: u8, context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool {
+    return output(context, (&c)[0...1]);
+}
+
+pub fn formatInt(value: var, base: u8, uppercase: bool, width: usize,
+    context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool
+{
+    if (@typeOf(value).is_signed) {
+        return formatIntSigned(value, base, uppercase, width, context, output);
+    } else {
+        return formatIntUnsigned(value, base, uppercase, width, context, output);
+    }
+}
+
+fn formatIntSigned(value: var, base: u8, uppercase: bool, width: usize,
+    context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool
+{
+    const uint = @intType(false, @typeOf(value).bit_count);
+    if (value < 0) {
+        const minus_sign: u8 = '-';
+        if (!output(context, (&minus_sign)[0...1]))
+            return false;
+        const new_value = uint(-(value + 1)) + 1;
+        const new_width = if (width == 0) 0 else (width - 1);
+        return formatIntUnsigned(new_value, base, uppercase, new_width, context, output);
+    } else if (width == 0) {
+        return formatIntUnsigned(uint(value), base, uppercase, width, context, output);
+    } else {
+        const plus_sign: u8 = '+';
+        if (!output(context, (&plus_sign)[0...1]))
+            return false;
+        const new_value = uint(value);
+        const new_width = if (width == 0) 0 else (width - 1);
+        return formatIntUnsigned(new_value, base, uppercase, new_width, context, output);
+    }
+}
+
+fn formatIntUnsigned(value: var, base: u8, uppercase: bool, width: usize,
+    context: var, output: fn(@typeOf(context), []const u8)->bool) -> bool
+{
+    // max_int_digits accounts for the minus sign. when printing an unsigned
+    // number we don't need to do that.
+    var buf: [max_int_digits - 1]u8 = undefined;
+    var a = value;
+    var index: usize = buf.len;
+
+    while (true) {
+        const digit = a % base;
+        index -= 1;
+        buf[index] = digitToChar(u8(digit), uppercase);
+        a /= base;
+        if (a == 0)
+            break;
+    }
+
+    const digits_buf = buf[index...];
+    const padding = if (width > digits_buf.len) (width - digits_buf.len) else 0;
+
+    if (padding > index) {
+        const zero_byte: u8 = '0';
+        var leftover_padding = padding - index;
+        while (true) {
+            if (!output(context, (&zero_byte)[0...1]))
+                return false;
+            leftover_padding -= 1;
+            if (leftover_padding == 0)
+                break;
+        }
+        mem.set(u8, buf[0...index], '0');
+        return output(context, buf);
+    } else {
+        const padded_buf = buf[index - padding...];
+        mem.set(u8, padded_buf[0...padding], '0');
+        return output(context, padded_buf);
+    }
+}
+
+pub fn formatIntBuf(out_buf: []u8, value: var, base: u8, uppercase: bool, width: usize) -> usize {
+    var context = FormatIntBuf {
+        .out_buf = out_buf,
+        .index = 0,
+    };
+    _ = formatInt(value, base, uppercase, width, &context, formatIntCallback);
+    return context.index;
+}
+const FormatIntBuf = struct {
+    out_buf: []u8,
+    index: usize,
+};
+fn formatIntCallback(context: &FormatIntBuf, bytes: []const u8) -> bool {
+    mem.copy(u8, context.out_buf[context.index...], bytes);
+    context.index += bytes.len;
+    return true;
+}
+
+pub fn parseUnsigned(comptime T: type, buf: []const u8, radix: u8) -> %T {
+    var x: T = 0;
+
+    for (buf) |c| {
+        const digit = %return charToDigit(c, radix);
+        x = %return math.mulOverflow(T, x, radix);
+        x = %return math.addOverflow(T, x, digit);
+    }
+
+    return x;
+}
+
+error InvalidChar;
+fn charToDigit(c: u8, radix: u8) -> %u8 {
+    const value = switch (c) {
+        '0' ... '9' => c - '0',
+        'A' ... 'Z' => c - 'A' + 10,
+        'a' ... 'z' => c - 'a' + 10,
+        else => return error.InvalidChar,
+    };
+
+    if (value >= radix)
+        return error.InvalidChar;
+
+    return value;
+}
+
+fn digitToChar(digit: u8, uppercase: bool) -> u8 {
+    return switch (digit) {
+        0 ... 9 => digit + '0',
+        10 ... 35 => digit + ((if (uppercase) u8('A') else u8('a')) - 10),
+        else => @unreachable(),
+    };
+}
+
+fn testBufPrintInt() {
+    @setFnTest(this);
+
+    var buffer: [max_int_digits]u8 = undefined;
+    const buf = buffer[0...];
+    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 2, false, 0), "-101111000110000101001110"));
+    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 10, false, 0), "-12345678"));
+    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, false, 0), "-bc614e"));
+    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, true, 0), "-BC614E"));
+
+    assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(12345678), 10, true, 0), "12345678"));
+
+    assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(666), 10, false, 6), "000666"));
+    assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, 6), "001234"));
+    assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, 1), "1234"));
+
+    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(42), 10, false, 3), "+42"));
+    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-42), 10, false, 3), "-42"));
+}
+
+fn bufPrintIntToSlice(buf: []u8, value: var, base: u8, uppercase: bool, width: usize) -> []u8 {
+    return buf[0...formatIntBuf(buf, value, base, uppercase, width)];
+}
+
+fn testParseU64DigitTooBig() {
+    @setFnTest(this);
+
+    parseUnsigned(u64, "123a", 10) %% |err| {
+        if (err == error.InvalidChar) return;
+        @unreachable();
+    };
+    @unreachable();
+}
+
+fn testParseUnsignedComptime() {
+    @setFnTest(this);
+
+    comptime {
+        assert(%%parseUnsigned(usize, "2", 10) == 2);
+    }
+}

std/index.zig

@@ -1,20 +1,21 @@
-pub const rand = @import("rand.zig");
-pub const io = @import("io.zig");
-pub const os = @import("os.zig");
-pub const math = @import("math.zig");
 pub const cstr = @import("cstr.zig");
-pub const sort = @import("sort.zig");
-pub const net = @import("net.zig");
-pub const list = @import("list.zig");
-pub const hash_map = @import("hash_map.zig");
-pub const mem = @import("mem.zig");
 pub const debug = @import("debug.zig");
+pub const fmt = @import("fmt.zig");
+pub const hash_map = @import("hash_map.zig");
+pub const io = @import("io.zig");
+pub const list = @import("list.zig");
+pub const math = @import("math.zig");
+pub const mem = @import("mem.zig");
+pub const net = @import("net.zig");
+pub const os = @import("os.zig");
+pub const rand = @import("rand.zig");
+pub const sort = @import("sort.zig");
 pub const linux = switch(@compileVar("os")) {
     Os.linux => @import("linux.zig"),
-    else => null_import,
+    else => empty_import,
 };
 pub const darwin = switch(@compileVar("os")) {
     Os.darwin => @import("darwin.zig"),
-    else => null_import,
+    else => empty_import,
 };
-const null_import = @import("empty.zig");
+pub const empty_import = @import("empty.zig");

std/io.zig

@@ -11,6 +11,7 @@ const assert = debug.assert;
 const os = @import("os.zig");
 const mem = @import("mem.zig");
 const Buffer0 = @import("cstr.zig").Buffer0;
+const fmt = @import("fmt.zig");
 
 pub const stdin_fileno = 0;
 pub const stdout_fileno = 1;
@@ -61,8 +62,6 @@ error Unseekable;
 error Eof;
 
 const buffer_size = 4 * 1024;
-const max_f64_digits = 65;
-const max_int_digits = 65;
 
 pub const OpenRead     = 0b0001;
 pub const OpenWrite    = 0b0010;
@@ -81,173 +80,46 @@ pub const OutStream = struct {
     }
 
     pub fn write(self: &OutStream, bytes: []const u8) -> %void {
-        var src_bytes_left = bytes.len;
         var src_index: usize = 0;
-        const dest_space_left = self.buffer.len - self.index;
 
-        while (src_bytes_left > 0) {
-            const copy_amt = math.min(dest_space_left, src_bytes_left);
-            @memcpy(&self.buffer[self.index], &bytes[src_index], copy_amt);
+        while (src_index < bytes.len) {
+            const dest_space_left = self.buffer.len - self.index;
+            const copy_amt = math.min(dest_space_left, bytes.len - src_index);
+            mem.copy(u8, self.buffer[self.index...], bytes[src_index...src_index + copy_amt]);
             self.index += copy_amt;
+            assert(self.index <= self.buffer.len);
             if (self.index == self.buffer.len) {
                 %return self.flush();
             }
-            src_bytes_left -= copy_amt;
+            src_index += copy_amt;
         }
     }
 
-    const State = enum { // TODO put inside printf function and make sure the name and debug info is correct
-        Start,
-        OpenBrace,
-        CloseBrace,
-        Integer,
-        IntegerWidth,
-        Character,
-    };
-
     /// Calls print and then flushes the buffer.
     pub fn printf(self: &OutStream, comptime format: []const u8, args: ...) -> %void {
-        comptime var start_index = 0;
-        comptime var state = State.Start;
-        comptime var next_arg = 0;
-        comptime var radix = 0;
-        comptime var uppercase = false;
-        comptime var width = 0;
-        comptime var width_start = 0;
-
-        inline for (format) |c, i| {
-            switch (state) {
-                State.Start => switch (c) {
-                    '{' => {
-                        if (start_index < i) %return self.write(format[start_index...i]);
-                        state = State.OpenBrace;
-                    },
-                    '}' => {
-                        if (start_index < i) %return self.write(format[start_index...i]);
-                        state = State.CloseBrace;
-                    },
-                    else => {},
-                },
-                State.OpenBrace => switch (c) {
-                    '{' => {
-                        state = State.Start;
-                        start_index = i;
-                    },
-                    '}' => {
-                        %return self.printValue(args[next_arg]);
-                        next_arg += 1;
-                        state = State.Start;
-                        start_index = i + 1;
-                    },
-                    'd' => {
-                        radix = 10;
-                        uppercase = false;
-                        width = 0;
-                        state = State.Integer;
-                    },
-                    'x' => {
-                        radix = 16;
-                        uppercase = false;
-                        width = 0;
-                        state = State.Integer;
-                    },
-                    'X' => {
-                        radix = 16;
-                        uppercase = true;
-                        width = 0;
-                        state = State.Integer;
-                    },
-                    'c' => {
-                        state = State.Character;
-                    },
-                    else => @compileError("Unknown format character: " ++ []u8{c}),
-                },
-                State.CloseBrace => switch (c) {
-                    '}' => {
-                        state = State.Start;
-                        start_index = i;
-                    },
-                    else => @compileError("Single '}' encountered in format string"),
-                },
-                State.Integer => switch (c) {
-                    '}' => {
-                        %return self.printInt(args[next_arg], radix, uppercase, width);
-                        next_arg += 1;
-                        state = State.Start;
-                        start_index = i + 1;
-                    },
-                    '0' ... '9' => {
-                        width_start = i;
-                        state = State.IntegerWidth;
-                    },
-                    else => @compileError("Unexpected character in format string: " ++ []u8{c}),
-                },
-                State.IntegerWidth => switch (c) {
-                    '}' => {
-                        width = comptime %%parseUnsigned(usize, format[width_start...i], 10);
-                        %return self.printInt(args[next_arg], radix, uppercase, width);
-                        next_arg += 1;
-                        state = State.Start;
-                        start_index = i + 1;
-                    },
-                    '0' ... '9' => {},
-                    else => @compileError("Unexpected character in format string: " ++ []u8{c}),
-                },
-                State.Character => switch (c) {
-                    '}' => {
-                        %return self.printAsciiChar(args[next_arg]);
-                        next_arg += 1;
-                        state = State.Start;
-                        start_index = i + 1;
-                    },
-                    else => @compileError("Unexpected character in format string: " ++ []u8{c}),
-                },
-            }
-        }
-        comptime {
-            if (args.len != next_arg) {
-                @compileError("Unused arguments");
-            }
-            if (state != State.Start) {
-                @compileError("Incomplete format string: " ++ format);
-            }
-        }
-        if (start_index < format.len) {
-            %return self.write(format[start_index...format.len]);
-        }
+        %return self.print(format, args);
         %return self.flush();
     }
 
-    pub fn printValue(self: &OutStream, value: var) -> %void {
-        const T = @typeOf(value);
-        if (@isInteger(T)) {
-            return self.printInt(value, 10, false, 0);
-        } else if (@isFloat(T)) {
-            return self.printFloat(T, value);
-        } else if (@canImplicitCast([]const u8, value)) {
-            const casted_value = ([]const u8)(value);
-            return self.write(casted_value);
-        } else if (T == void) {
-            return self.write("void");
-        } else {
-            @compileError("Unable to print type '" ++ @typeName(T) ++ "'");
-        }
+    /// Does not flush the buffer.
+    pub fn print(self: &OutStream, comptime format: []const u8, args: ...) -> %void {
+        var context = PrintContext {
+            .self = self,
+            .result = {},
+        };
+        _ = fmt.format(&context, printOutput, format, args);
+        return context.result;
     }
-
-    pub fn printInt(self: &OutStream, x: var, base: u8, uppercase: bool, width: usize) -> %void {
-        if (self.index + max_int_digits >= self.buffer.len) {
-            %return self.flush();
-        }
-        const amt_printed = bufPrintInt(self.buffer[self.index...], x, base, uppercase, width);
-        self.index += amt_printed;
-    }
-
-    pub fn printAsciiChar(self: &OutStream, c: u8) -> %void {
-        if (self.index + 1 >= self.buffer.len) {
-            %return self.flush();
-        }
-        self.buffer[self.index] = c;
-        self.index += 1;
+    const PrintContext = struct {
+        self: &OutStream,
+        result: %void,
+    };
+    fn printOutput(context: &PrintContext, bytes: []const u8) -> bool {
+        context.self.write(bytes) %% |err| {
+            context.result = err;
+            return false;
+        };
+        return true;
     }
 
     pub fn flush(self: &OutStream) -> %void {
@@ -506,90 +378,6 @@ pub const InStream = struct {
     }
 };
 
-pub fn parseUnsigned(comptime T: type, buf: []const u8, radix: u8) -> %T {
-    var x: T = 0;
-
-    for (buf) |c| {
-        const digit = %return charToDigit(c, radix);
-        x = %return math.mulOverflow(T, x, radix);
-        x = %return math.addOverflow(T, x, digit);
-    }
-
-    return x;
-}
-
-error InvalidChar;
-fn charToDigit(c: u8, radix: u8) -> %u8 {
-    const value = switch (c) {
-        '0' ... '9' => c - '0',
-        'A' ... 'Z' => c - 'A' + 10,
-        'a' ... 'z' => c - 'a' + 10,
-        else => return error.InvalidChar,
-    };
-
-    if (value >= radix)
-        return error.InvalidChar;
-
-    return value;
-}
-
-fn digitToChar(digit: u8, uppercase: bool) -> u8 {
-    return switch (digit) {
-        0 ... 9 => digit + '0',
-        10 ... 35 => digit + ((if (uppercase) u8('A') else u8('a')) - 10),
-        else => @unreachable(),
-    };
-}
-
-/// Guaranteed to not use more than max_int_digits
-pub fn bufPrintInt(out_buf: []u8, x: var, base: u8, uppercase: bool, width: usize) -> usize {
-    if (@typeOf(x).is_signed)
-        bufPrintSigned(out_buf, x, base, uppercase, width)
-    else
-        bufPrintUnsigned(out_buf, x, base, uppercase, width)
-}
-
-fn bufPrintSigned(out_buf: []u8, x: var, base: u8, uppercase: bool, width: usize) -> usize {
-    const uint = @intType(false, @typeOf(x).bit_count);
-    if (x < 0) {
-        out_buf[0] = '-';
-        const new_value = uint(-(x + 1)) + 1;
-        const new_width = if (width == 0) 0 else (width - 1);
-        return 1 + bufPrintUnsigned(out_buf[1...], new_value, base, uppercase, new_width);
-    } else if (width == 0) {
-        return bufPrintUnsigned(out_buf, uint(x), base, uppercase, width);
-    } else {
-        out_buf[0] = '+';
-        const new_value = uint(x);
-        const new_width = if (width == 0) 0 else (width - 1);
-        return 1 + bufPrintUnsigned(out_buf[1...], new_value, base, uppercase, new_width);
-    }
-}
-
-fn bufPrintUnsigned(out_buf: []u8, x: var, base: u8, uppercase: bool, width: usize) -> usize {
-    // max_int_digits accounts for the minus sign. when printing an unsigned
-    // number we don't need to do that.
-    var buf: [max_int_digits - 1]u8 = undefined;
-    var a = x;
-    var index: usize = buf.len;
-
-    while (true) {
-        const digit = a % base;
-        index -= 1;
-        buf[index] = digitToChar(u8(digit), uppercase);
-        a /= base;
-        if (a == 0)
-            break;
-    }
-
-    const src_buf = buf[index...];
-    const padding = if (width > src_buf.len) (width - src_buf.len) else 0;
-
-    mem.set(u8, out_buf[0...padding], '0');
-    mem.copy(u8, out_buf[padding...], src_buf);
-    return src_buf.len + padding;
-}
-
 pub fn openSelfExe(stream: &InStream) -> %void {
     switch (@compileVar("os")) {
         Os.linux => {
@@ -602,45 +390,3 @@ pub fn openSelfExe(stream: &InStream) -> %void {
         else => @compileError("unsupported os"),
     }
 }
-
-fn bufPrintIntToSlice(buf: []u8, value: var, base: u8, uppercase: bool, width: usize) -> []u8 {
-    return buf[0...bufPrintInt(buf, value, base, uppercase, width)];
-}
-
-fn testParseU64DigitTooBig() {
-    @setFnTest(this);
-
-    parseUnsigned(u64, "123a", 10) %% |err| {
-        if (err == error.InvalidChar) return;
-        @unreachable();
-    };
-    @unreachable();
-}
-
-fn testParseUnsignedComptime() {
-    @setFnTest(this);
-
-    comptime {
-        assert(%%parseUnsigned(usize, "2", 10) == 2);
-    }
-}
-
-fn testBufPrintInt() {
-    @setFnTest(this);
-
-    var buffer: [max_int_digits]u8 = undefined;
-    const buf = buffer[0...];
-    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 2, false, 0), "-101111000110000101001110"));
-    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 10, false, 0), "-12345678"));
-    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, false, 0), "-bc614e"));
-    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, true, 0), "-BC614E"));
-
-    assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(12345678), 10, true, 0), "12345678"));
-
-    assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(666), 10, false, 6), "000666"));
-    assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, 6), "001234"));
-    assert(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, 1), "1234"));
-
-    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(42), 10, false, 3), "+42"));
-    assert(mem.eql(u8, bufPrintIntToSlice(buf, i32(-42), 10, false, 3), "-42"));
-}

test/cases/enum_with_members.zig

@@ -1,6 +1,6 @@
 const assert = @import("std").debug.assert;
 const mem = @import("std").mem;
-const io = @import("std").io;
+const fmt = @import("std").fmt;
 
 const ET = enum {
     SINT: i32,
@@ -8,8 +8,8 @@ const ET = enum {
 
     pub fn print(a: &const ET, buf: []u8) -> %usize {
         return switch (*a) {
-            ET.SINT => |x| { io.bufPrintInt(buf, x, 10, false, 0) },
-            ET.UINT => |x| { io.bufPrintInt(buf, x, 10, false, 0) },
+            ET.SINT => |x| { fmt.formatIntBuf(buf, x, 10, false, 0) },
+            ET.UINT => |x| { fmt.formatIntBuf(buf, x, 10, false, 0) },
         }
     }
 };