Ekdohibs/zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Integrated outstreams with new formatter

Browse Source
This commit is contained in:
Benjamin Feng 2020-02-29 15:35:18 -06:00
parent 7364e965f4
commit c11d1055b8
6 changed files with 27 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
lib/std/http/headers.zig
View File

@ -349,16 +349,14 @@ pub const Headers = struct {
pub fn format( pub fn format(
self: Self, self: Self,
comptime fmt: []const u8, comptime fmt: []const u8,
options: std.fmt.FormatOptions, options: std.fmtstream.FormatOptions,
context: var, out_stream: var,
comptime Errors: type, ) !void {
output: fn (@TypeOf(context), []const u8) Errors!void,
) Errors!void {
for (self.toSlice()) |entry| { for (self.toSlice()) |entry| {
try output(context, entry.name); try out_stream.writeAll(entry.name);
try output(context, ": "); try out_stream.writeAll(": ");
try output(context, entry.value); try out_stream.writeAll(entry.value);
try output(context, "\n"); try out_stream.writeAll("\n");
} }
} }
}; };
@ -593,5 +591,5 @@ test "Headers.format" {
\\foo: bar \\foo: bar
\\cookie: somevalue \\cookie: somevalue
\\ \\
, try std.fmt.bufPrint(buf[0..], "{}", .{h})); , try std.fmtstream.bufPrint(buf[0..], "{}", .{h}));
} }

2
lib/std/io/out_stream.zig
View File

@ -25,7 +25,7 @@ pub fn OutStream(
} }
pub fn print(self: Self, comptime format: []const u8, args: var) Error!void { pub fn print(self: Self, comptime format: []const u8, args: var) Error!void {
return std.fmt.format(self, Error, writeAll, format, args); return std.fmtstream.format(self, format, args);
} }
pub fn writeByte(self: Self, byte: u8) Error!void { pub fn writeByte(self: Self, byte: u8) Error!void {

8
lib/std/math/big/int.zig
View File

@ -518,17 +518,15 @@ pub const Int = struct {
pub fn format( pub fn format(
self: Int, self: Int,
comptime fmt: []const u8, comptime fmt: []const u8,
options: std.fmt.FormatOptions, options: std.fmtstream.FormatOptions,
context: var, out_stream: var,
comptime FmtError: type,
output: fn (@TypeOf(context), []const u8) FmtError!void,
) FmtError!void { ) FmtError!void {
self.assertWritable(); self.assertWritable();
// TODO look at fmt and support other bases // TODO look at fmt and support other bases
// TODO support read-only fixed integers // TODO support read-only fixed integers
const str = self.toString(self.allocator.?, 10) catch @panic("TODO make this non allocating"); const str = self.toString(self.allocator.?, 10) catch @panic("TODO make this non allocating");
defer self.allocator.?.free(str); defer self.allocator.?.free(str);
return output(context, str); return out_stream.print(str);
} }
/// Returns -1, 0, 1 if |a| < |b|, |a| == |b| or |a| > |b| respectively. /// Returns -1, 0, 1 if |a| < |b|, |a| == |b| or |a| > |b| respectively.

22
lib/std/net.zig
View File

@ -268,16 +268,14 @@ pub const Address = extern union {
pub fn format( pub fn format(
self: Address, self: Address,
comptime fmt: []const u8, comptime fmt: []const u8,
options: std.fmt.FormatOptions, options: std.fmtstream.FormatOptions,
context: var, out_stream: var,
comptime Errors: type,
comptime output: fn (@TypeOf(context), []const u8) Errors!void,
) !void { ) !void {
switch (self.any.family) { switch (self.any.family) {
os.AF_INET => { os.AF_INET => {
const port = mem.bigToNative(u16, self.in.port); const port = mem.bigToNative(u16, self.in.port);
const bytes = @ptrCast(*const [4]u8, &self.in.addr); const bytes = @ptrCast(*const [4]u8, &self.in.addr);
try std.fmt.format(context, Errors, output, "{}.{}.{}.{}:{}", .{ try std.fmtstream.format(out_stream, "{}.{}.{}.{}:{}", .{
bytes[0], bytes[0],
bytes[1], bytes[1],
bytes[2], bytes[2],
@ -288,7 +286,7 @@ pub const Address = extern union {
os.AF_INET6 => { os.AF_INET6 => {
const port = mem.bigToNative(u16, self.in6.port); const port = mem.bigToNative(u16, self.in6.port);
if (mem.eql(u8, self.in6.addr[0..12], &[_]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff })) { if (mem.eql(u8, self.in6.addr[0..12], &[_]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff })) {
try std.fmt.format(context, Errors, output, "[::ffff:{}.{}.{}.{}]:{}", .{ try std.fmtstream.format(out_stream, "[::ffff:{}.{}.{}.{}]:{}", .{
self.in6.addr[12], self.in6.addr[12],
self.in6.addr[13], self.in6.addr[13],
self.in6.addr[14], self.in6.addr[14],
@ -308,30 +306,30 @@ pub const Address = extern union {
break :blk buf; break :blk buf;
}, },
}; };
try output(context, "["); try out_stream.writeAll("[");
var i: usize = 0; var i: usize = 0;
var abbrv = false; var abbrv = false;
while (i < native_endian_parts.len) : (i += 1) { while (i < native_endian_parts.len) : (i += 1) {
if (native_endian_parts[i] == 0) { if (native_endian_parts[i] == 0) {
if (!abbrv) { if (!abbrv) {
try output(context, if (i == 0) "::" else ":"); try out_stream.writeAll(if (i == 0) "::" else ":");
abbrv = true; abbrv = true;
} }
continue; continue;
} }
try std.fmt.format(context, Errors, output, "{x}", .{native_endian_parts[i]}); try std.fmtstream.format(out_stream, "{x}", .{native_endian_parts[i]});
if (i != native_endian_parts.len - 1) { if (i != native_endian_parts.len - 1) {
try output(context, ":"); try out_stream.writeAll(":");
} }
} }
try std.fmt.format(context, Errors, output, "]:{}", .{port}); try std.fmtstream.format(out_stream, "]:{}", .{port});
}, },
os.AF_UNIX => { os.AF_UNIX => {
if (!has_unix_sockets) { if (!has_unix_sockets) {
unreachable; unreachable;
} }
try std.fmt.format(context, Errors, output, "{}", .{&self.un.path}); try std.fmtstream.format(out_stream, "{}", .{&self.un.path});
}, },
else => unreachable, else => unreachable,
} }

4
lib/std/net/test.zig
View File

@ -29,7 +29,7 @@ test "parse and render IPv6 addresses" {
}; };
for (ips) |ip, i| { for (ips) |ip, i| {
var addr = net.Address.parseIp6(ip, 0) catch unreachable; var addr = net.Address.parseIp6(ip, 0) catch unreachable;
var newIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable; var newIp = std.fmtstream.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable;
std.testing.expect(std.mem.eql(u8, printed[i], newIp[1 .. newIp.len - 3])); std.testing.expect(std.mem.eql(u8, printed[i], newIp[1 .. newIp.len - 3]));
} }
@ -51,7 +51,7 @@ test "parse and render IPv4 addresses" {
"127.0.0.1", "127.0.0.1",
}) |ip| { }) |ip| {
var addr = net.Address.parseIp4(ip, 0) catch unreachable; var addr = net.Address.parseIp4(ip, 0) catch unreachable;
var newIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable; var newIp = std.fmtstream.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable;
std.testing.expect(std.mem.eql(u8, ip, newIp[0 .. newIp.len - 2])); std.testing.expect(std.mem.eql(u8, ip, newIp[0 .. newIp.len - 2]));
} }

10
lib/std/os/uefi.zig
View File

@ -5,8 +5,6 @@ pub const protocols = @import("uefi/protocols.zig");
pub const status = @import("uefi/status.zig"); pub const status = @import("uefi/status.zig");
pub const tables = @import("uefi/tables.zig"); pub const tables = @import("uefi/tables.zig");
const fmt = @import("std").fmt;
/// The EFI image's handle that is passed to its entry point. /// The EFI image's handle that is passed to its entry point.
pub var handle: Handle = undefined; pub var handle: Handle = undefined;
@ -29,13 +27,11 @@ pub const Guid = extern struct {
pub fn format( pub fn format(
self: @This(), self: @This(),
comptime f: []const u8, comptime f: []const u8,
options: fmt.FormatOptions, options: std.fmtstream.FormatOptions,
context: var, out_stream: var,
comptime Errors: type,
output: fn (@TypeOf(context), []const u8) Errors!void,
) Errors!void { ) Errors!void {
if (f.len == 0) { if (f.len == 0) {
return fmt.format(context, Errors, output, "{x:0>8}-{x:0>4}-{x:0>4}-{x:0>2}{x:0>2}-{x:0>12}", .{ return std.fmtstream.format(out_stream, "{x:0>8}-{x:0>4}-{x:0>4}-{x:0>2}{x:0>2}-{x:0>12}", .{
self.time_low, self.time_low,
self.time_mid, self.time_mid,
self.time_high_and_version, self.time_high_and_version,