Commit 3eff77bfb52accbc16eb831753ff4917fc2b4873 | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-03-13 12:07:06-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-03-13 12:07:06-04:00
log	3eff77bfb52accbc16eb831753ff4917fc2b4873
tree	49fbf58b5b43ebaffc71eabb7aaa1eb4197044f4
parent	a9297f22671dff800821ff940395411f2adb8582
parent	4905102901e7d798860f8346faeae505a7268968
signature	Commit is signed but in an unrecognized format.

Merge branch 'fengb-format-stream'

16 files changed, 361 insertions(+), 441 deletions(-)

lib
- std
  - buffer.zig
  - builtin.zig
  - fifo.zig
  - fmt.zig
  - http
    headers.zig
  - io
    fixed_buffer_stream.zig
    out_stream.zig
  - json.zig
  - math
    big
    int.zig
  - net.zig
  - os
    uefi.zig
  - progress.zig
  - zig
    cross_target.zig
src-self-hosted

lib/std/buffer.zig+4-12

...	...	@@ -65,13 +65,9 @@ pub const Buffer = struct {
65	65	}
66	66
67	67	pub fn allocPrint(allocator: *Allocator, comptime format: []const u8, args: var) !Buffer {
68		const countSize = struct {
69		fn countSize(size: *usize, bytes: []const u8) (error{}!void) {
70		size.* += bytes.len;
71		}
72		}.countSize;
73		var size: usize = 0;
74		std.fmt.format(&size, error{}, countSize, format, args) catch \|err\| switch (err) {};
	68	const size = std.math.cast(usize, std.fmt.count(format, args)) catch \|err\| switch (err) {
	69	error.Overflow => return error.OutOfMemory,
	70	};
75	71	var self = try Buffer.initSize(allocator, size);
76	72	assert((std.fmt.bufPrint(self.list.items, format, args) catch unreachable).len == size);
77	73	return self;
...	...	@@ -154,10 +150,6 @@ pub const Buffer = struct {
154	150	mem.copy(u8, self.list.toSlice(), m);
155	151	}
156	152
157		pub fn print(self: *Buffer, comptime fmt: []const u8, args: var) !void {
158		return std.fmt.format(self, error{OutOfMemory}, Buffer.append, fmt, args);
159		}
160
161	153	pub fn outStream(self: Buffer) std.io.OutStream(Buffer, error{OutOfMemory}, appendWrite) {
162	154	return .{ .context = self };
163	155	}
...	...	@@ -216,7 +208,7 @@ test "Buffer.print" {
216	208	var buf = try Buffer.init(testing.allocator, "");
217	209	defer buf.deinit();
218	210
219		try buf.print("Hello {} the {}", .{ 2, "world" });
	211	try buf.outStream().print("Hello {} the {}", .{ 2, "world" });
220	212	testing.expect(buf.eql("Hello 2 the world"));
221	213	}
222	214

lib/std/builtin.zig+5-7

...	...	@@ -436,19 +436,17 @@ pub const Version = struct {
436	436	self: Version,
437	437	comptime fmt: []const u8,
438	438	options: std.fmt.FormatOptions,
439		context: var,
440		comptime Error: type,
441		comptime output: fn (@TypeOf(context), []const u8) Error!void,
442		) Error!void {
	439	out_stream: var,
	440	) !void {
443	441	if (fmt.len == 0) {
444	442	if (self.patch == 0) {
445	443	if (self.minor == 0) {
446		return std.fmt.format(context, Error, output, "{}", .{self.major});
	444	return std.fmt.format(out_stream, "{}", .{self.major});
447	445	} else {
448		return std.fmt.format(context, Error, output, "{}.{}", .{ self.major, self.minor });
	446	return std.fmt.format(out_stream, "{}.{}", .{ self.major, self.minor });
449	447	}
450	448	} else {
451		return std.fmt.format(context, Error, output, "{}.{}.{}", .{ self.major, self.minor, self.patch });
	449	return std.fmt.format(out_stream, "{}.{}.{}", .{ self.major, self.minor, self.patch });
452	450	}
453	451	} else {
454	452	@compileError("Unknown format string: '" ++ fmt ++ "'");

lib/std/fifo.zig+13-3

...	...	@@ -293,8 +293,18 @@ pub fn LinearFifo(
293	293
294	294	pub usingnamespace if (T == u8)
295	295	struct {
296		pub fn print(self: *Self, comptime format: []const u8, args: var) !void {
297		return std.fmt.format(self, error{OutOfMemory}, Self.write, format, args);
	296	const OutStream = std.io.OutStream(*Self, Error, appendWrite);
	297	const Error = error{OutOfMemory};
	298
	299	/// Same as `write` except it returns the number of bytes written, which is always the same
	300	/// as `bytes.len`. The purpose of this function existing is to match `std.io.OutStream` API.
	301	pub fn appendWrite(fifo: *Self, bytes: []const u8) Error!usize {
	302	try fifo.write(bytes);
	303	return bytes.len;
	304	}
	305
	306	pub fn outStream(self: *Self) OutStream {
	307	return .{ .context = self };
298	308	}
299	309	}
300	310	else
...	...	@@ -407,7 +417,7 @@ test "LinearFifo(u8, .Dynamic)" {
407	417	fifo.shrink(0);
408	418
409	419	{
410		try fifo.print("{}, {}!", .{ "Hello", "World" });
	420	try fifo.outStream().print("{}, {}!", .{ "Hello", "World" });
411	421	var result: [30]u8 = undefined;
412	422	testing.expectEqualSlices(u8, "Hello, World!", result[0..fifo.read(&result)]);
413	423	testing.expectEqual(@as(usize, 0), fifo.readableLength());

lib/std/fmt.zig+224-297

...	...	@@ -69,19 +69,17 @@ fn peekIsAlign(comptime fmt: []const u8) bool {
69	69	///
70	70	/// If a formatted user type contains a function of the type
71	71	/// ```
72		/// fn format(value: ?, comptime fmt: []const u8, options: std.fmt.FormatOptions, context: var, comptime Errors: type, comptime output: fn (@TypeOf(context), []const u8) Errors!void) Errors!void
	72	/// fn format(value: ?, comptime fmt: []const u8, options: std.fmt.FormatOptions, out_stream: var) !void
73	73	/// ```
74	74	/// with `?` being the type formatted, this function will be called instead of the default implementation.
75	75	/// This allows user types to be formatted in a logical manner instead of dumping all fields of the type.
76	76	///
77	77	/// A user type may be a `struct`, `vector`, `union` or `enum` type.
78	78	pub fn format(
79		context: var,
80		comptime Errors: type,
81		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
	79	out_stream: var,
82	80	comptime fmt: []const u8,
83	81	args: var,
84		) Errors!void {
	82	) !void {
85	83	const ArgSetType = u32;
86	84	if (@typeInfo(@TypeOf(args)) != .Struct) {
87	85	@compileError("Expected tuple or struct argument, found " ++ @typeName(@TypeOf(args)));
...	...	@@ -138,7 +136,7 @@ pub fn format(
138	136	.Start => switch (c) {
139	137	'{' => {
140	138	if (start_index < i) {
141		try output(context, fmt[start_index..i]);
	139	try out_stream.writeAll(fmt[start_index..i]);
142	140	}
143	141
144	142	start_index = i;
...	...	@@ -150,7 +148,7 @@ pub fn format(
150	148	},
151	149	'}' => {
152	150	if (start_index < i) {
153		try output(context, fmt[start_index..i]);
	151	try out_stream.writeAll(fmt[start_index..i]);
154	152	}
155	153	state = .CloseBrace;
156	154	},
...	...	@@ -185,9 +183,7 @@ pub fn format(
185	183	args[arg_to_print],
186	184	fmt[0..0],
187	185	options,
188		context,
189		Errors,
190		output,
	186	out_stream,
191	187	default_max_depth,
192	188	);
193	189
...	...	@@ -218,9 +214,7 @@ pub fn format(
218	214	args[arg_to_print],
219	215	fmt[specifier_start..i],
220	216	options,
221		context,
222		Errors,
223		output,
	217	out_stream,
224	218	default_max_depth,
225	219	);
226	220	state = .Start;
...	...	@@ -265,9 +259,7 @@ pub fn format(
265	259	args[arg_to_print],
266	260	fmt[specifier_start..specifier_end],
267	261	options,
268		context,
269		Errors,
270		output,
	262	out_stream,
271	263	default_max_depth,
272	264	);
273	265	state = .Start;
...	...	@@ -293,9 +285,7 @@ pub fn format(
293	285	args[arg_to_print],
294	286	fmt[specifier_start..specifier_end],
295	287	options,
296		context,
297		Errors,
298		output,
	288	out_stream,
299	289	default_max_depth,
300	290	);
301	291	state = .Start;
...	...	@@ -316,7 +306,7 @@ pub fn format(
316	306	}
317	307	}
318	308	if (start_index < fmt.len) {
319		try output(context, fmt[start_index..]);
	309	try out_stream.writeAll(fmt[start_index..]);
320	310	}
321	311	}
322	312
...	...	@@ -324,141 +314,131 @@ pub fn formatType(
324	314	value: var,
325	315	comptime fmt: []const u8,
326	316	options: FormatOptions,
327		context: var,
328		comptime Errors: type,
329		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
	317	out_stream: var,
330	318	max_depth: usize,
331		) Errors!void {
	319	) @TypeOf(out_stream).Error!void {
332	320	if (comptime std.mem.eql(u8, fmt, "*")) {
333		try output(context, @typeName(@TypeOf(value).Child));
334		try output(context, "@");
335		try formatInt(@ptrToInt(value), 16, false, FormatOptions{}, context, Errors, output);
	321	try out_stream.writeAll(@typeName(@TypeOf(value).Child));
	322	try out_stream.writeAll("@");
	323	try formatInt(@ptrToInt(value), 16, false, FormatOptions{}, out_stream);
336	324	return;
337	325	}
338	326
339	327	const T = @TypeOf(value);
	328	if (comptime std.meta.trait.hasFn("format")(T)) {
	329	return try value.format(fmt, options, out_stream);
	330	}
	331
340	332	switch (@typeInfo(T)) {
341	333	.ComptimeInt, .Int, .Float => {
342		return formatValue(value, fmt, options, context, Errors, output);
	334	return formatValue(value, fmt, options, out_stream);
343	335	},
344	336	.Void => {
345		return output(context, "void");
	337	return out_stream.writeAll("void");
346	338	},
347	339	.Bool => {
348		return output(context, if (value) "true" else "false");
	340	return out_stream.writeAll(if (value) "true" else "false");
349	341	},
350	342	.Optional => {
351	343	if (value) \|payload\| {
352		return formatType(payload, fmt, options, context, Errors, output, max_depth);
	344	return formatType(payload, fmt, options, out_stream, max_depth);
353	345	} else {
354		return output(context, "null");
	346	return out_stream.writeAll("null");
355	347	}
356	348	},
357	349	.ErrorUnion => {
358	350	if (value) \|payload\| {
359		return formatType(payload, fmt, options, context, Errors, output, max_depth);
	351	return formatType(payload, fmt, options, out_stream, max_depth);
360	352	} else \|err\| {
361		return formatType(err, fmt, options, context, Errors, output, max_depth);
	353	return formatType(err, fmt, options, out_stream, max_depth);
362	354	}
363	355	},
364	356	.ErrorSet => {
365		try output(context, "error.");
366		return output(context, @errorName(value));
	357	try out_stream.writeAll("error.");
	358	return out_stream.writeAll(@errorName(value));
367	359	},
368	360	.Enum => \|enumInfo\| {
369		if (comptime std.meta.trait.hasFn("format")(T)) {
370		return value.format(fmt, options, context, Errors, output);
371		}
372
373		try output(context, @typeName(T));
	361	try out_stream.writeAll(@typeName(T));
374	362	if (enumInfo.is_exhaustive) {
375		try output(context, ".");
376		try output(context, @tagName(value));
	363	try out_stream.writeAll(".");
	364	try out_stream.writeAll(@tagName(value));
377	365	} else {
378	366	// TODO: when @tagName works on exhaustive enums print known enum strings
379		try output(context, "(");
380		try formatType(@enumToInt(value), fmt, options, context, Errors, output, max_depth);
381		try output(context, ")");
	367	try out_stream.writeAll("(");
	368	try formatType(@enumToInt(value), fmt, options, out_stream, max_depth);
	369	try out_stream.writeAll(")");
382	370	}
383	371	},
384	372	.Union => {
385		if (comptime std.meta.trait.hasFn("format")(T)) {
386		return value.format(fmt, options, context, Errors, output);
387		}
388
389		try output(context, @typeName(T));
	373	try out_stream.writeAll(@typeName(T));
390	374	if (max_depth == 0) {
391		return output(context, "{ ... }");
	375	return out_stream.writeAll("{ ... }");
392	376	}
393	377	const info = @typeInfo(T).Union;
394	378	if (info.tag_type) \|UnionTagType\| {
395		try output(context, "{ .");
396		try output(context, @tagName(@as(UnionTagType, value)));
397		try output(context, " = ");
	379	try out_stream.writeAll("{ .");
	380	try out_stream.writeAll(@tagName(@as(UnionTagType, value)));
	381	try out_stream.writeAll(" = ");
398	382	inline for (info.fields) \|u_field\| {
399	383	if (@enumToInt(@as(UnionTagType, value)) == u_field.enum_field.?.value) {
400		try formatType(@field(value, u_field.name), fmt, options, context, Errors, output, max_depth - 1);
	384	try formatType(@field(value, u_field.name), fmt, options, out_stream, max_depth - 1);
401	385	}
402	386	}
403		try output(context, " }");
	387	try out_stream.writeAll(" }");
404	388	} else {
405		try format(context, Errors, output, "@{x}", .{@ptrToInt(&value)});
	389	try format(out_stream, "@{x}", .{@ptrToInt(&value)});
406	390	}
407	391	},
408	392	.Struct => \|StructT\| {
409		if (comptime std.meta.trait.hasFn("format")(T)) {
410		return value.format(fmt, options, context, Errors, output);
411		}
412
413		try output(context, @typeName(T));
	393	try out_stream.writeAll(@typeName(T));
414	394	if (max_depth == 0) {
415		return output(context, "{ ... }");
	395	return out_stream.writeAll("{ ... }");
416	396	}
417		try output(context, "{");
	397	try out_stream.writeAll("{");
418	398	inline for (StructT.fields) \|f, i\| {
419	399	if (i == 0) {
420		try output(context, " .");
	400	try out_stream.writeAll(" .");
421	401	} else {
422		try output(context, ", .");
	402	try out_stream.writeAll(", .");
423	403	}
424		try output(context, f.name);
425		try output(context, " = ");
426		try formatType(@field(value, f.name), fmt, options, context, Errors, output, max_depth - 1);
	404	try out_stream.writeAll(f.name);
	405	try out_stream.writeAll(" = ");
	406	try formatType(@field(value, f.name), fmt, options, out_stream, max_depth - 1);
427	407	}
428		try output(context, " }");
	408	try out_stream.writeAll(" }");
429	409	},
430	410	.Pointer => \|ptr_info\| switch (ptr_info.size) {
431	411	.One => switch (@typeInfo(ptr_info.child)) {
432	412	.Array => \|info\| {
433	413	if (info.child == u8) {
434		return formatText(value, fmt, options, context, Errors, output);
	414	return formatText(value, fmt, options, out_stream);
435	415	}
436		return format(context, Errors, output, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
	416	return format(out_stream, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
437	417	},
438	418	.Enum, .Union, .Struct => {
439		return formatType(value.*, fmt, options, context, Errors, output, max_depth);
	419	return formatType(value.*, fmt, options, out_stream, max_depth);
440	420	},
441		else => return format(context, Errors, output, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) }),
	421	else => return format(out_stream, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) }),
442	422	},
443	423	.Many, .C => {
444	424	if (ptr_info.sentinel) \|sentinel\| {
445		return formatType(mem.span(value), fmt, options, context, Errors, output, max_depth);
	425	return formatType(mem.span(value), fmt, options, out_stream, max_depth);
446	426	}
447	427	if (ptr_info.child == u8) {
448	428	if (fmt.len > 0 and fmt[0] == 's') {
449		return formatText(mem.span(value), fmt, options, context, Errors, output);
	429	return formatText(mem.span(value), fmt, options, out_stream);
450	430	}
451	431	}
452		return format(context, Errors, output, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
	432	return format(out_stream, "{}@{x}", .{ @typeName(T.Child), @ptrToInt(value) });
453	433	},
454	434	.Slice => {
455	435	if (fmt.len > 0 and ((fmt[0] == 'x') or (fmt[0] == 'X'))) {
456		return formatText(value, fmt, options, context, Errors, output);
	436	return formatText(value, fmt, options, out_stream);
457	437	}
458	438	if (ptr_info.child == u8) {
459		return formatText(value, fmt, options, context, Errors, output);
	439	return formatText(value, fmt, options, out_stream);
460	440	}
461		return format(context, Errors, output, "{}@{x}", .{ @typeName(ptr_info.child), @ptrToInt(value.ptr) });
	441	return format(out_stream, "{}@{x}", .{ @typeName(ptr_info.child), @ptrToInt(value.ptr) });
462	442	},
463	443	},
464	444	.Array => \|info\| {
...	...	@@ -473,27 +453,27 @@ pub fn formatType(
473	453	.sentinel = null,
474	454	},
475	455	});
476		return formatType(@as(Slice, &value), fmt, options, context, Errors, output, max_depth);
	456	return formatType(@as(Slice, &value), fmt, options, out_stream, max_depth);
477	457	},
478	458	.Vector => {
479	459	const len = @typeInfo(T).Vector.len;
480		try output(context, "{ ");
	460	try out_stream.writeAll("{ ");
481	461	var i: usize = 0;
482	462	while (i < len) : (i += 1) {
483		try formatValue(value[i], fmt, options, context, Errors, output);
	463	try formatValue(value[i], fmt, options, out_stream);
484	464	if (i < len - 1) {
485		try output(context, ", ");
	465	try out_stream.writeAll(", ");
486	466	}
487	467	}
488		try output(context, " }");
	468	try out_stream.writeAll(" }");
489	469	},
490	470	.Fn => {
491		return format(context, Errors, output, "{}@{x}", .{ @typeName(T), @ptrToInt(value) });
	471	return format(out_stream, "{}@{x}", .{ @typeName(T), @ptrToInt(value) });
492	472	},
493		.Type => return output(context, @typeName(T)),
	473	.Type => return out_stream.writeAll(@typeName(T)),
494	474	.EnumLiteral => {
495	475	const buffer = [_]u8{'.'} ++ @tagName(value);
496		return formatType(buffer, fmt, options, context, Errors, output, max_depth);
	476	return formatType(buffer, fmt, options, out_stream, max_depth);
497	477	},
498	478	else => @compileError("Unable to format type '" ++ @typeName(T) ++ "'"),
499	479	}
...	...	@@ -503,21 +483,19 @@ fn formatValue(
503	483	value: var,
504	484	comptime fmt: []const u8,
505	485	options: FormatOptions,
506		context: var,
507		comptime Errors: type,
508		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
509		) Errors!void {
	486	out_stream: var,
	487	) !void {
510	488	if (comptime std.mem.eql(u8, fmt, "B")) {
511		return formatBytes(value, options, 1000, context, Errors, output);
	489	return formatBytes(value, options, 1000, out_stream);
512	490	} else if (comptime std.mem.eql(u8, fmt, "Bi")) {
513		return formatBytes(value, options, 1024, context, Errors, output);
	491	return formatBytes(value, options, 1024, out_stream);
514	492	}
515	493
516	494	const T = @TypeOf(value);
517	495	switch (@typeInfo(T)) {
518		.Float => return formatFloatValue(value, fmt, options, context, Errors, output),
519		.Int, .ComptimeInt => return formatIntValue(value, fmt, options, context, Errors, output),
520		.Bool => return output(context, if (value) "true" else "false"),
	496	.Float => return formatFloatValue(value, fmt, options, out_stream),
	497	.Int, .ComptimeInt => return formatIntValue(value, fmt, options, out_stream),
	498	.Bool => return out_stream.writeAll(if (value) "true" else "false"),
521	499	else => comptime unreachable,
522	500	}
523	501	}
...	...	@@ -526,10 +504,8 @@ pub fn formatIntValue(
526	504	value: var,
527	505	comptime fmt: []const u8,
528	506	options: FormatOptions,
529		context: var,
530		comptime Errors: type,
531		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
532		) Errors!void {
	507	out_stream: var,
	508	) !void {
533	509	comptime var radix = 10;
534	510	comptime var uppercase = false;
535	511
...	...	@@ -544,7 +520,7 @@ pub fn formatIntValue(
544	520	uppercase = false;
545	521	} else if (comptime std.mem.eql(u8, fmt, "c")) {
546	522	if (@TypeOf(int_value).bit_count <= 8) {
547		return formatAsciiChar(@as(u8, int_value), options, context, Errors, output);
	523	return formatAsciiChar(@as(u8, int_value), options, out_stream);
548	524	} else {
549	525	@compileError("Cannot print integer that is larger than 8 bits as a ascii");
550	526	}
...	...	@@ -561,21 +537,19 @@ pub fn formatIntValue(
561	537	@compileError("Unknown format string: '" ++ fmt ++ "'");
562	538	}
563	539
564		return formatInt(int_value, radix, uppercase, options, context, Errors, output);
	540	return formatInt(int_value, radix, uppercase, options, out_stream);
565	541	}
566	542
567	543	fn formatFloatValue(
568	544	value: var,
569	545	comptime fmt: []const u8,
570	546	options: FormatOptions,
571		context: var,
572		comptime Errors: type,
573		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
574		) Errors!void {
	547	out_stream: var,
	548	) !void {
575	549	if (fmt.len == 0 or comptime std.mem.eql(u8, fmt, "e")) {
576		return formatFloatScientific(value, options, context, Errors, output);
	550	return formatFloatScientific(value, options, out_stream);
577	551	} else if (comptime std.mem.eql(u8, fmt, "d")) {
578		return formatFloatDecimal(value, options, context, Errors, output);
	552	return formatFloatDecimal(value, options, out_stream);
579	553	} else {
580	554	@compileError("Unknown format string: '" ++ fmt ++ "'");
581	555	}
...	...	@@ -585,17 +559,15 @@ pub fn formatText(
585	559	bytes: []const u8,
586	560	comptime fmt: []const u8,
587	561	options: FormatOptions,
588		context: var,
589		comptime Errors: type,
590		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
591		) Errors!void {
	562	out_stream: var,
	563	) !void {
592	564	if (fmt.len == 0) {
593		return output(context, bytes);
	565	return out_stream.writeAll(bytes);
594	566	} else if (comptime std.mem.eql(u8, fmt, "s")) {
595		return formatBuf(bytes, options, context, Errors, output);
	567	return formatBuf(bytes, options, out_stream);
596	568	} else if (comptime (std.mem.eql(u8, fmt, "x") or std.mem.eql(u8, fmt, "X"))) {
597	569	for (bytes) \|c\| {
598		try formatInt(c, 16, fmt[0] == 'X', FormatOptions{ .width = 2, .fill = '0' }, context, Errors, output);
	570	try formatInt(c, 16, fmt[0] == 'X', FormatOptions{ .width = 2, .fill = '0' }, out_stream);
599	571	}
600	572	return;
601	573	} else {
...	...	@@ -606,27 +578,23 @@ pub fn formatText(
606	578	pub fn formatAsciiChar(
607	579	c: u8,
608	580	options: FormatOptions,
609		context: var,
610		comptime Errors: type,
611		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
612		) Errors!void {
613		return output(context, @as(*const [1]u8, &c)[0..]);
	581	out_stream: var,
	582	) !void {
	583	return out_stream.writeAll(@as(*const [1]u8, &c));
614	584	}
615	585
616	586	pub fn formatBuf(
617	587	buf: []const u8,
618	588	options: FormatOptions,
619		context: var,
620		comptime Errors: type,
621		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
622		) Errors!void {
623		try output(context, buf);
	589	out_stream: var,
	590	) !void {
	591	try out_stream.writeAll(buf);
624	592
625	593	const width = options.width orelse 0;
626	594	var leftover_padding = if (width > buf.len) (width - buf.len) else return;
627		const pad_byte: u8 = options.fill;
	595	const pad_byte = [1]u8{options.fill};
628	596	while (leftover_padding > 0) : (leftover_padding -= 1) {
629		try output(context, @as(*const [1]u8, &pad_byte)[0..1]);
	597	try out_stream.writeAll(&pad_byte);
630	598	}
631	599	}
632	600
...	...	@@ -636,40 +604,38 @@ pub fn formatBuf(
636	604	pub fn formatFloatScientific(
637	605	value: var,
638	606	options: FormatOptions,
639		context: var,
640		comptime Errors: type,
641		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
642		) Errors!void {
	607	out_stream: var,
	608	) !void {
643	609	var x = @floatCast(f64, value);
644	610
645	611	// Errol doesn't handle these special cases.
646	612	if (math.signbit(x)) {
647		try output(context, "-");
	613	try out_stream.writeAll("-");
648	614	x = -x;
649	615	}
650	616
651	617	if (math.isNan(x)) {
652		return output(context, "nan");
	618	return out_stream.writeAll("nan");
653	619	}
654	620	if (math.isPositiveInf(x)) {
655		return output(context, "inf");
	621	return out_stream.writeAll("inf");
656	622	}
657	623	if (x == 0.0) {
658		try output(context, "0");
	624	try out_stream.writeAll("0");
659	625
660	626	if (options.precision) \|precision\| {
661	627	if (precision != 0) {
662		try output(context, ".");
	628	try out_stream.writeAll(".");
663	629	var i: usize = 0;
664	630	while (i < precision) : (i += 1) {
665		try output(context, "0");
	631	try out_stream.writeAll("0");
666	632	}
667	633	}
668	634	} else {
669		try output(context, ".0");
	635	try out_stream.writeAll(".0");
670	636	}
671	637
672		try output(context, "e+00");
	638	try out_stream.writeAll("e+00");
673	639	return;
674	640	}
675	641
...	...	@@ -679,50 +645,50 @@ pub fn formatFloatScientific(
679	645	if (options.precision) \|precision\| {
680	646	errol.roundToPrecision(&float_decimal, precision, errol.RoundMode.Scientific);
681	647
682		try output(context, float_decimal.digits[0..1]);
	648	try out_stream.writeAll(float_decimal.digits[0..1]);
683	649
684	650	// {e0} case prints no `.`
685	651	if (precision != 0) {
686		try output(context, ".");
	652	try out_stream.writeAll(".");
687	653
688	654	var printed: usize = 0;
689	655	if (float_decimal.digits.len > 1) {
690	656	const num_digits = math.min(float_decimal.digits.len, precision + 1);
691		try output(context, float_decimal.digits[1..num_digits]);
	657	try out_stream.writeAll(float_decimal.digits[1..num_digits]);
692	658	printed += num_digits - 1;
693	659	}
694	660
695	661	while (printed < precision) : (printed += 1) {
696		try output(context, "0");
	662	try out_stream.writeAll("0");
697	663	}
698	664	}
699	665	} else {
700		try output(context, float_decimal.digits[0..1]);
701		try output(context, ".");
	666	try out_stream.writeAll(float_decimal.digits[0..1]);
	667	try out_stream.writeAll(".");
702	668	if (float_decimal.digits.len > 1) {
703	669	const num_digits = if (@TypeOf(value) == f32) math.min(@as(usize, 9), float_decimal.digits.len) else float_decimal.digits.len;
704	670
705		try output(context, float_decimal.digits[1..num_digits]);
	671	try out_stream.writeAll(float_decimal.digits[1..num_digits]);
706	672	} else {
707		try output(context, "0");
	673	try out_stream.writeAll("0");
708	674	}
709	675	}
710	676
711		try output(context, "e");
	677	try out_stream.writeAll("e");
712	678	const exp = float_decimal.exp - 1;
713	679
714	680	if (exp >= 0) {
715		try output(context, "+");
	681	try out_stream.writeAll("+");
716	682	if (exp > -10 and exp < 10) {
717		try output(context, "0");
	683	try out_stream.writeAll("0");
718	684	}
719		try formatInt(exp, 10, false, FormatOptions{ .width = 0 }, context, Errors, output);
	685	try formatInt(exp, 10, false, FormatOptions{ .width = 0 }, out_stream);
720	686	} else {
721		try output(context, "-");
	687	try out_stream.writeAll("-");
722	688	if (exp > -10 and exp < 10) {
723		try output(context, "0");
	689	try out_stream.writeAll("0");
724	690	}
725		try formatInt(-exp, 10, false, FormatOptions{ .width = 0 }, context, Errors, output);
	691	try formatInt(-exp, 10, false, FormatOptions{ .width = 0 }, out_stream);
726	692	}
727	693	}
728	694
...	...	@@ -731,36 +697,34 @@ pub fn formatFloatScientific(
731	697	pub fn formatFloatDecimal(
732	698	value: var,
733	699	options: FormatOptions,
734		context: var,
735		comptime Errors: type,
736		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
737		) Errors!void {
	700	out_stream: var,
	701	) !void {
738	702	var x = @as(f64, value);
739	703
740	704	// Errol doesn't handle these special cases.
741	705	if (math.signbit(x)) {
742		try output(context, "-");
	706	try out_stream.writeAll("-");
743	707	x = -x;
744	708	}
745	709
746	710	if (math.isNan(x)) {
747		return output(context, "nan");
	711	return out_stream.writeAll("nan");
748	712	}
749	713	if (math.isPositiveInf(x)) {
750		return output(context, "inf");
	714	return out_stream.writeAll("inf");
751	715	}
752	716	if (x == 0.0) {
753		try output(context, "0");
	717	try out_stream.writeAll("0");
754	718
755	719	if (options.precision) \|precision\| {
756	720	if (precision != 0) {
757		try output(context, ".");
	721	try out_stream.writeAll(".");
758	722	var i: usize = 0;
759	723	while (i < precision) : (i += 1) {
760		try output(context, "0");
	724	try out_stream.writeAll("0");
761	725	}
762	726	} else {
763		try output(context, ".0");
	727	try out_stream.writeAll(".0");
764	728	}
765	729	}
766	730
...	...	@@ -782,14 +746,14 @@ pub fn formatFloatDecimal(
782	746
783	747	if (num_digits_whole > 0) {
784	748	// We may have to zero pad, for instance 1e4 requires zero padding.
785		try output(context, float_decimal.digits[0..num_digits_whole_no_pad]);
	749	try out_stream.writeAll(float_decimal.digits[0..num_digits_whole_no_pad]);
786	750
787	751	var i = num_digits_whole_no_pad;
788	752	while (i < num_digits_whole) : (i += 1) {
789		try output(context, "0");
	753	try out_stream.writeAll("0");
790	754	}
791	755	} else {
792		try output(context, "0");
	756	try out_stream.writeAll("0");
793	757	}
794	758
795	759	// {.0} special case doesn't want a trailing '.'
...	...	@@ -797,7 +761,7 @@ pub fn formatFloatDecimal(
797	761	return;
798	762	}
799	763
800		try output(context, ".");
	764	try out_stream.writeAll(".");
801	765
802	766	// Keep track of fractional count printed for case where we pre-pad then post-pad with 0's.
803	767	var printed: usize = 0;
...	...	@@ -809,7 +773,7 @@ pub fn formatFloatDecimal(
809	773
810	774	var i: usize = 0;
811	775	while (i < zeros_to_print) : (i += 1) {
812		try output(context, "0");
	776	try out_stream.writeAll("0");
813	777	printed += 1;
814	778	}
815	779
...	...	@@ -821,14 +785,14 @@ pub fn formatFloatDecimal(
821	785	// Remaining fractional portion, zero-padding if insufficient.
822	786	assert(precision >= printed);
823	787	if (num_digits_whole_no_pad + precision - printed < float_decimal.digits.len) {
824		try output(context, float_decimal.digits[num_digits_whole_no_pad .. num_digits_whole_no_pad + precision - printed]);
	788	try out_stream.writeAll(float_decimal.digits[num_digits_whole_no_pad .. num_digits_whole_no_pad + precision - printed]);
825	789	return;
826	790	} else {
827		try output(context, float_decimal.digits[num_digits_whole_no_pad..]);
	791	try out_stream.writeAll(float_decimal.digits[num_digits_whole_no_pad..]);
828	792	printed += float_decimal.digits.len - num_digits_whole_no_pad;
829	793
830	794	while (printed < precision) : (printed += 1) {
831		try output(context, "0");
	795	try out_stream.writeAll("0");
832	796	}
833	797	}
834	798	} else {
...	...	@@ -840,14 +804,14 @@ pub fn formatFloatDecimal(
840	804
841	805	if (num_digits_whole > 0) {
842	806	// We may have to zero pad, for instance 1e4 requires zero padding.
843		try output(context, float_decimal.digits[0..num_digits_whole_no_pad]);
	807	try out_stream.writeAll(float_decimal.digits[0..num_digits_whole_no_pad]);
844	808
845	809	var i = num_digits_whole_no_pad;
846	810	while (i < num_digits_whole) : (i += 1) {
847		try output(context, "0");
	811	try out_stream.writeAll("0");
848	812	}
849	813	} else {
850		try output(context, "0");
	814	try out_stream.writeAll("0");
851	815	}
852	816
853	817	// Omit `.` if no fractional portion
...	...	@@ -855,7 +819,7 @@ pub fn formatFloatDecimal(
855	819	return;
856	820	}
857	821
858		try output(context, ".");
	822	try out_stream.writeAll(".");
859	823
860	824	// Zero-fill until we reach significant digits or run out of precision.
861	825	if (float_decimal.exp < 0) {
...	...	@@ -863,11 +827,11 @@ pub fn formatFloatDecimal(
863	827
864	828	var i: usize = 0;
865	829	while (i < zero_digit_count) : (i += 1) {
866		try output(context, "0");
	830	try out_stream.writeAll("0");
867	831	}
868	832	}
869	833
870		try output(context, float_decimal.digits[num_digits_whole_no_pad..]);
	834	try out_stream.writeAll(float_decimal.digits[num_digits_whole_no_pad..]);
871	835	}
872	836	}
873	837
...	...	@@ -875,12 +839,10 @@ pub fn formatBytes(
875	839	value: var,
876	840	options: FormatOptions,
877	841	comptime radix: usize,
878		context: var,
879		comptime Errors: type,
880		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
881		) Errors!void {
	842	out_stream: var,
	843	) !void {
882	844	if (value == 0) {
883		return output(context, "0B");
	845	return out_stream.writeAll("0B");
884	846	}
885	847
886	848	const mags_si = " kMGTPEZY";
...	...	@@ -897,10 +859,10 @@ pub fn formatBytes(
897	859	else => unreachable,
898	860	};
899	861
900		try formatFloatDecimal(new_value, options, context, Errors, output);
	862	try formatFloatDecimal(new_value, options, out_stream);
901	863
902	864	if (suffix == ' ') {
903		return output(context, "B");
	865	return out_stream.writeAll("B");
904	866	}
905	867
906	868	const buf = switch (radix) {
...	...	@@ -908,7 +870,7 @@ pub fn formatBytes(
908	870	1024 => &[_]u8{ suffix, 'i', 'B' },
909	871	else => unreachable,
910	872	};
911		return output(context, buf);
	873	return out_stream.writeAll(buf);
912	874	}
913	875
914	876	pub fn formatInt(
...	...	@@ -916,10 +878,8 @@ pub fn formatInt(
916	878	base: u8,
917	879	uppercase: bool,
918	880	options: FormatOptions,
919		context: var,
920		comptime Errors: type,
921		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
922		) Errors!void {
	881	out_stream: var,
	882	) !void {
923	883	const int_value = if (@TypeOf(value) == comptime_int) blk: {
924	884	const Int = math.IntFittingRange(value, value);
925	885	break :blk @as(Int, value);
...	...	@@ -927,9 +887,9 @@ pub fn formatInt(
927	887	value;
928	888
929	889	if (@TypeOf(int_value).is_signed) {
930		return formatIntSigned(int_value, base, uppercase, options, context, Errors, output);
	890	return formatIntSigned(int_value, base, uppercase, options, out_stream);
931	891	} else {
932		return formatIntUnsigned(int_value, base, uppercase, options, context, Errors, output);
	892	return formatIntUnsigned(int_value, base, uppercase, options, out_stream);
933	893	}
934	894	}
935	895
...	...	@@ -938,10 +898,8 @@ fn formatIntSigned(
938	898	base: u8,
939	899	uppercase: bool,
940	900	options: FormatOptions,
941		context: var,
942		comptime Errors: type,
943		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
944		) Errors!void {
	901	out_stream: var,
	902	) !void {
945	903	const new_options = FormatOptions{
946	904	.width = if (options.width) \|w\| (if (w == 0) 0 else w - 1) else null,
947	905	.precision = options.precision,
...	...	@@ -950,15 +908,15 @@ fn formatIntSigned(
950	908	const bit_count = @typeInfo(@TypeOf(value)).Int.bits;
951	909	const Uint = std.meta.IntType(false, bit_count);
952	910	if (value < 0) {
953		try output(context, "-");
	911	try out_stream.writeAll("-");
954	912	const new_value = math.absCast(value);
955		return formatIntUnsigned(new_value, base, uppercase, new_options, context, Errors, output);
	913	return formatIntUnsigned(new_value, base, uppercase, new_options, out_stream);
956	914	} else if (options.width == null or options.width.? == 0) {
957		return formatIntUnsigned(@intCast(Uint, value), base, uppercase, options, context, Errors, output);
	915	return formatIntUnsigned(@intCast(Uint, value), base, uppercase, options, out_stream);
958	916	} else {
959		try output(context, "+");
	917	try out_stream.writeAll("+");
960	918	const new_value = @intCast(Uint, value);
961		return formatIntUnsigned(new_value, base, uppercase, new_options, context, Errors, output);
	919	return formatIntUnsigned(new_value, base, uppercase, new_options, out_stream);
962	920	}
963	921	}
964	922
...	...	@@ -967,10 +925,8 @@ fn formatIntUnsigned(
967	925	base: u8,
968	926	uppercase: bool,
969	927	options: FormatOptions,
970		context: var,
971		comptime Errors: type,
972		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
973		) Errors!void {
	928	out_stream: var,
	929	) !void {
974	930	assert(base >= 2);
975	931	var buf: [math.max(@TypeOf(value).bit_count, 1)]u8 = undefined;
976	932	const min_int_bits = comptime math.max(@TypeOf(value).bit_count, @TypeOf(base).bit_count);
...	...	@@ -994,34 +950,23 @@ fn formatIntUnsigned(
994	950	const zero_byte: u8 = options.fill;
995	951	var leftover_padding = padding - index;
996	952	while (true) {
997		try output(context, @as(*const [1]u8, &zero_byte)[0..]);
	953	try out_stream.writeAll(@as(*const [1]u8, &zero_byte)[0..]);
998	954	leftover_padding -= 1;
999	955	if (leftover_padding == 0) break;
1000	956	}
1001	957	mem.set(u8, buf[0..index], options.fill);
1002		return output(context, &buf);
	958	return out_stream.writeAll(&buf);
1003	959	} else {
1004	960	const padded_buf = buf[index - padding ..];
1005	961	mem.set(u8, padded_buf[0..padding], options.fill);
1006		return output(context, padded_buf);
	962	return out_stream.writeAll(padded_buf);
1007	963	}
1008	964	}
1009	965
1010	966	pub fn formatIntBuf(out_buf: []u8, value: var, base: u8, uppercase: bool, options: FormatOptions) usize {
1011		var context = FormatIntBuf{
1012		.out_buf = out_buf,
1013		.index = 0,
1014		};
1015		formatInt(value, base, uppercase, options, &context, error{}, formatIntCallback) catch unreachable;
1016		return context.index;
1017		}
1018		const FormatIntBuf = struct {
1019		out_buf: []u8,
1020		index: usize,
1021		};
1022		fn formatIntCallback(context: *FormatIntBuf, bytes: []const u8) (error{}!void) {
1023		mem.copy(u8, context.out_buf[context.index..], bytes);
1024		context.index += bytes.len;
	967	var fbs = std.io.fixedBufferStream(out_buf);
	968	formatInt(value, base, uppercase, options, fbs.outStream()) catch unreachable;
	969	return fbs.pos;
1025	970	}
1026	971
1027	972	pub fn parseInt(comptime T: type, buf: []const u8, radix: u8) !T {
...	...	@@ -1121,44 +1066,36 @@ fn digitToChar(digit: u8, uppercase: bool) u8 {
1121	1066	};
1122	1067	}
1123	1068
1124		const BufPrintContext = struct {
1125		remaining: []u8,
1126		};
1127
1128		fn bufPrintWrite(context: *BufPrintContext, bytes: []const u8) !void {
1129		if (context.remaining.len < bytes.len) {
1130		mem.copy(u8, context.remaining, bytes[0..context.remaining.len]);
1131		return error.BufferTooSmall;
1132		}
1133		mem.copy(u8, context.remaining, bytes);
1134		context.remaining = context.remaining[bytes.len..];
1135		}
1136
1137	1069	pub const BufPrintError = error{
1138	1070	/// As much as possible was written to the buffer, but it was too small to fit all the printed bytes.
1139		BufferTooSmall,
	1071	NoSpaceLeft,
1140	1072	};
1141	1073	pub fn bufPrint(buf: []u8, comptime fmt: []const u8, args: var) BufPrintError![]u8 {
1142		var context = BufPrintContext{ .remaining = buf };
1143		try format(&context, BufPrintError, bufPrintWrite, fmt, args);
1144		return buf[0 .. buf.len - context.remaining.len];
	1074	var fbs = std.io.fixedBufferStream(buf);
	1075	try format(fbs.outStream(), fmt, args);
	1076	return fbs.getWritten();
	1077	}
	1078
	1079	// Count the characters needed for format. Useful for preallocating memory
	1080	pub fn count(comptime fmt: []const u8, args: var) u64 {
	1081	var counting_stream = std.io.countingOutStream(std.io.null_out_stream);
	1082	format(counting_stream.outStream(), fmt, args) catch \|err\| switch (err) {};
	1083	return counting_stream.bytes_written;
1145	1084	}
1146	1085
1147	1086	pub const AllocPrintError = error{OutOfMemory};
1148	1087
1149	1088	pub fn allocPrint(allocator: *mem.Allocator, comptime fmt: []const u8, args: var) AllocPrintError![]u8 {
1150		var size: usize = 0;
1151		format(&size, error{}, countSize, fmt, args) catch \|err\| switch (err) {};
	1089	const size = math.cast(usize, count(fmt, args)) catch \|err\| switch (err) {
	1090	// Output too long. Can't possibly allocate enough memory to display it.
	1091	error.Overflow => return error.OutOfMemory,
	1092	};
1152	1093	const buf = try allocator.alloc(u8, size);
1153	1094	return bufPrint(buf, fmt, args) catch \|err\| switch (err) {
1154		error.BufferTooSmall => unreachable, // we just counted the size above
	1095	error.NoSpaceLeft => unreachable, // we just counted the size above
1155	1096	};
1156	1097	}
1157	1098
1158		fn countSize(size: *usize, bytes: []const u8) (error{}!void) {
1159		size.* += bytes.len;
1160		}
1161
1162	1099	pub fn allocPrint0(allocator: *mem.Allocator, comptime fmt: []const u8, args: var) AllocPrintError![:0]u8 {
1163	1100	const result = try allocPrint(allocator, fmt ++ "\x00", args);
1164	1101	return result[0 .. result.len - 1 :0];
...	...	@@ -1251,20 +1188,17 @@ test "int.padded" {
1251	1188	test "buffer" {
1252	1189	{
1253	1190	var buf1: [32]u8 = undefined;
1254		var context = BufPrintContext{ .remaining = buf1[0..] };
1255		try formatType(1234, "", FormatOptions{}, &context, error{BufferTooSmall}, bufPrintWrite, default_max_depth);
1256		var res = buf1[0 .. buf1.len - context.remaining.len];
1257		std.testing.expect(mem.eql(u8, res, "1234"));
1258
1259		context = BufPrintContext{ .remaining = buf1[0..] };
1260		try formatType('a', "c", FormatOptions{}, &context, error{BufferTooSmall}, bufPrintWrite, default_max_depth);
1261		res = buf1[0 .. buf1.len - context.remaining.len];
1262		std.testing.expect(mem.eql(u8, res, "a"));
1263
1264		context = BufPrintContext{ .remaining = buf1[0..] };
1265		try formatType(0b1100, "b", FormatOptions{}, &context, error{BufferTooSmall}, bufPrintWrite, default_max_depth);
1266		res = buf1[0 .. buf1.len - context.remaining.len];
1267		std.testing.expect(mem.eql(u8, res, "1100"));
	1191	var fbs = std.io.fixedBufferStream(&buf1);
	1192	try formatType(1234, "", FormatOptions{}, fbs.outStream(), default_max_depth);
	1193	std.testing.expect(mem.eql(u8, fbs.getWritten(), "1234"));
	1194
	1195	fbs.reset();
	1196	try formatType('a', "c", FormatOptions{}, fbs.outStream(), default_max_depth);
	1197	std.testing.expect(mem.eql(u8, fbs.getWritten(), "a"));
	1198
	1199	fbs.reset();
	1200	try formatType(0b1100, "b", FormatOptions{}, fbs.outStream(), default_max_depth);
	1201	std.testing.expect(mem.eql(u8, fbs.getWritten(), "1100"));
1268	1202	}
1269	1203	}
1270	1204
...	...	@@ -1449,14 +1383,12 @@ test "custom" {
1449	1383	self: SelfType,
1450	1384	comptime fmt: []const u8,
1451	1385	options: FormatOptions,
1452		context: var,
1453		comptime Errors: type,
1454		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
1455		) Errors!void {
	1386	out_stream: var,
	1387	) !void {
1456	1388	if (fmt.len == 0 or comptime std.mem.eql(u8, fmt, "p")) {
1457		return std.fmt.format(context, Errors, output, "({d:.3},{d:.3})", .{ self.x, self.y });
	1389	return std.fmt.format(out_stream, "({d:.3},{d:.3})", .{ self.x, self.y });
1458	1390	} else if (comptime std.mem.eql(u8, fmt, "d")) {
1459		return std.fmt.format(context, Errors, output, "{d:.3}x{d:.3}", .{ self.x, self.y });
	1391	return std.fmt.format(out_stream, "{d:.3}x{d:.3}", .{ self.x, self.y });
1460	1392	} else {
1461	1393	@compileError("Unknown format character: '" ++ fmt ++ "'");
1462	1394	}
...	...	@@ -1640,10 +1572,10 @@ test "hexToBytes" {
1640	1572	test "formatIntValue with comptime_int" {
1641	1573	const value: comptime_int = 123456789123456789;
1642	1574
1643		var buf = std.ArrayList(u8).init(std.testing.allocator);
1644		defer buf.deinit();
1645		try formatIntValue(value, "", FormatOptions{}, &buf, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice);
1646		std.testing.expect(mem.eql(u8, buf.toSliceConst(), "123456789123456789"));
	1575	var buf: [20]u8 = undefined;
	1576	var fbs = std.io.fixedBufferStream(&buf);
	1577	try formatIntValue(value, "", FormatOptions{}, fbs.outStream());
	1578	std.testing.expect(mem.eql(u8, fbs.getWritten(), "123456789123456789"));
1647	1579	}
1648	1580
1649	1581	test "formatType max_depth" {
...	...	@@ -1656,12 +1588,10 @@ test "formatType max_depth" {
1656	1588	self: SelfType,
1657	1589	comptime fmt: []const u8,
1658	1590	options: FormatOptions,
1659		context: var,
1660		comptime Errors: type,
1661		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
1662		) Errors!void {
	1591	out_stream: var,
	1592	) !void {
1663	1593	if (fmt.len == 0) {
1664		return std.fmt.format(context, Errors, output, "({d:.3},{d:.3})", .{ self.x, self.y });
	1594	return std.fmt.format(out_stream, "({d:.3},{d:.3})", .{ self.x, self.y });
1665	1595	} else {
1666	1596	@compileError("Unknown format string: '" ++ fmt ++ "'");
1667	1597	}
...	...	@@ -1695,25 +1625,22 @@ test "formatType max_depth" {
1695	1625	inst.a = &inst;
1696	1626	inst.tu.ptr = &inst.tu;
1697	1627
1698		var buf0 = std.ArrayList(u8).init(std.testing.allocator);
1699		defer buf0.deinit();
1700		try formatType(inst, "", FormatOptions{}, &buf0, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 0);
1701		std.testing.expect(mem.eql(u8, buf0.toSlice(), "S{ ... }"));
1702
1703		var buf1 = std.ArrayList(u8).init(std.testing.allocator);
1704		defer buf1.deinit();
1705		try formatType(inst, "", FormatOptions{}, &buf1, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 1);
1706		std.testing.expect(mem.eql(u8, buf1.toSlice(), "S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }"));
1707
1708		var buf2 = std.ArrayList(u8).init(std.testing.allocator);
1709		defer buf2.deinit();
1710		try formatType(inst, "", FormatOptions{}, &buf2, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 2);
1711		std.testing.expect(mem.eql(u8, buf2.toSlice(), "S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }"));
1712
1713		var buf3 = std.ArrayList(u8).init(std.testing.allocator);
1714		defer buf3.deinit();
1715		try formatType(inst, "", FormatOptions{}, &buf3, @TypeOf(std.ArrayList(u8).appendSlice).ReturnType.ErrorSet, std.ArrayList(u8).appendSlice, 3);
1716		std.testing.expect(mem.eql(u8, buf3.toSlice(), "S{ .a = S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ .ptr = TU{ ... } } }, .e = E.Two, .vec = (10.200,2.220) }"));
	1628	var buf: [1000]u8 = undefined;
	1629	var fbs = std.io.fixedBufferStream(&buf);
	1630	try formatType(inst, "", FormatOptions{}, fbs.outStream(), 0);
	1631	std.testing.expect(mem.eql(u8, fbs.getWritten(), "S{ ... }"));
	1632
	1633	fbs.reset();
	1634	try formatType(inst, "", FormatOptions{}, fbs.outStream(), 1);
	1635	std.testing.expect(mem.eql(u8, fbs.getWritten(), "S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }"));
	1636
	1637	fbs.reset();
	1638	try formatType(inst, "", FormatOptions{}, fbs.outStream(), 2);
	1639	std.testing.expect(mem.eql(u8, fbs.getWritten(), "S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }"));
	1640
	1641	fbs.reset();
	1642	try formatType(inst, "", FormatOptions{}, fbs.outStream(), 3);
	1643	std.testing.expect(mem.eql(u8, fbs.getWritten(), "S{ .a = S{ .a = S{ .a = S{ ... }, .tu = TU{ ... }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ ... } }, .e = E.Two, .vec = (10.200,2.220) }, .tu = TU{ .ptr = TU{ .ptr = TU{ ... } } }, .e = E.Two, .vec = (10.200,2.220) }"));
1717	1644	}
1718	1645
1719	1646	test "positional" {

lib/std/http/headers.zig+6-8

...	...	@@ -350,15 +350,13 @@ pub const Headers = struct {
350	350	self: Self,
351	351	comptime fmt: []const u8,
352	352	options: std.fmt.FormatOptions,
353		context: var,
354		comptime Errors: type,
355		output: fn (@TypeOf(context), []const u8) Errors!void,
356		) Errors!void {
	353	out_stream: var,
	354	) !void {
357	355	for (self.toSlice()) \|entry\| {
358		try output(context, entry.name);
359		try output(context, ": ");
360		try output(context, entry.value);
361		try output(context, "\n");
	356	try out_stream.writeAll(entry.name);
	357	try out_stream.writeAll(": ");
	358	try out_stream.writeAll(entry.value);
	359	try out_stream.writeAll("\n");
362	360	}
363	361	}
364	362	};

lib/std/io/fixed_buffer_stream.zig+1-1

...	...	@@ -103,7 +103,7 @@ pub fn FixedBufferStream(comptime Buffer: type) type {
103	103	return self.pos;
104	104	}
105	105
106		pub fn getWritten(self: Self) []const u8 {
	106	pub fn getWritten(self: Self) Buffer {
107	107	return self.buffer[0..self.pos];
108	108	}
109	109

lib/std/io/out_stream.zig+1-1

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

lib/std/json.zig+72-62

...	...	@@ -2252,45 +2252,43 @@ pub const StringifyOptions = struct {
2252	2252	pub fn stringify(
2253	2253	value: var,
2254	2254	options: StringifyOptions,
2255		context: var,
2256		comptime Errors: type,
2257		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
2258		) Errors!void {
	2255	out_stream: var,
	2256	) !void {
2259	2257	const T = @TypeOf(value);
2260	2258	switch (@typeInfo(T)) {
2261	2259	.Float, .ComptimeFloat => {
2262		return std.fmt.formatFloatScientific(value, std.fmt.FormatOptions{}, context, Errors, output);
	2260	return std.fmt.formatFloatScientific(value, std.fmt.FormatOptions{}, out_stream);
2263	2261	},
2264	2262	.Int, .ComptimeInt => {
2265		return std.fmt.formatIntValue(value, "", std.fmt.FormatOptions{}, context, Errors, output);
	2263	return std.fmt.formatIntValue(value, "", std.fmt.FormatOptions{}, out_stream);
2266	2264	},
2267	2265	.Bool => {
2268		return output(context, if (value) "true" else "false");
	2266	return out_stream.writeAll(if (value) "true" else "false");
2269	2267	},
2270	2268	.Optional => {
2271	2269	if (value) \|payload\| {
2272		return try stringify(payload, options, context, Errors, output);
	2270	return try stringify(payload, options, out_stream);
2273	2271	} else {
2274		return output(context, "null");
	2272	return out_stream.writeAll("null");
2275	2273	}
2276	2274	},
2277	2275	.Enum => {
2278	2276	if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
2279		return value.jsonStringify(options, context, Errors, output);
	2277	return value.jsonStringify(options, out_stream);
2280	2278	}
2281	2279
2282	2280	@compileError("Unable to stringify enum '" ++ @typeName(T) ++ "'");
2283	2281	},
2284	2282	.Union => {
2285	2283	if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
2286		return value.jsonStringify(options, context, Errors, output);
	2284	return value.jsonStringify(options, out_stream);
2287	2285	}
2288	2286
2289	2287	const info = @typeInfo(T).Union;
2290	2288	if (info.tag_type) \|UnionTagType\| {
2291	2289	inline for (info.fields) \|u_field\| {
2292	2290	if (@enumToInt(@as(UnionTagType, value)) == u_field.enum_field.?.value) {
2293		return try stringify(@field(value, u_field.name), options, context, Errors, output);
	2291	return try stringify(@field(value, u_field.name), options, out_stream);
2294	2292	}
2295	2293	}
2296	2294	} else {
...	...	@@ -2299,10 +2297,10 @@ pub fn stringify(
2299	2297	},
2300	2298	.Struct => \|S\| {
2301	2299	if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
2302		return value.jsonStringify(options, context, Errors, output);
	2300	return value.jsonStringify(options, out_stream);
2303	2301	}
2304	2302
2305		try output(context, "{");
	2303	try out_stream.writeAll("{");
2306	2304	comptime var field_output = false;
2307	2305	inline for (S.fields) \|Field, field_i\| {
2308	2306	// don't include void fields
...	...	@@ -2311,39 +2309,39 @@ pub fn stringify(
2311	2309	if (!field_output) {
2312	2310	field_output = true;
2313	2311	} else {
2314		try output(context, ",");
	2312	try out_stream.writeAll(",");
2315	2313	}
2316	2314
2317		try stringify(Field.name, options, context, Errors, output);
2318		try output(context, ":");
2319		try stringify(@field(value, Field.name), options, context, Errors, output);
	2315	try stringify(Field.name, options, out_stream);
	2316	try out_stream.writeAll(":");
	2317	try stringify(@field(value, Field.name), options, out_stream);
2320	2318	}
2321		try output(context, "}");
	2319	try out_stream.writeAll("}");
2322	2320	return;
2323	2321	},
2324	2322	.Pointer => \|ptr_info\| switch (ptr_info.size) {
2325	2323	.One => {
2326	2324	// TODO: avoid loops?
2327		return try stringify(value.*, options, context, Errors, output);
	2325	return try stringify(value.*, options, out_stream);
2328	2326	},
2329	2327	// TODO: .Many when there is a sentinel (waiting for https://github.com/ziglang/zig/pull/3972)
2330	2328	.Slice => {
2331	2329	if (ptr_info.child == u8 and std.unicode.utf8ValidateSlice(value)) {
2332		try output(context, "\"");
	2330	try out_stream.writeAll("\"");
2333	2331	var i: usize = 0;
2334	2332	while (i < value.len) : (i += 1) {
2335	2333	switch (value[i]) {
2336	2334	// normal ascii characters
2337		0x20...0x21, 0x23...0x2E, 0x30...0x5B, 0x5D...0x7F => try output(context, value[i .. i + 1]),
	2335	0x20...0x21, 0x23...0x2E, 0x30...0x5B, 0x5D...0x7F => try out_stream.writeAll(value[i .. i + 1]),
2338	2336	// control characters with short escapes
2339		'\\' => try output(context, "\\\\"),
2340		'\"' => try output(context, "\\\""),
2341		'/' => try output(context, "\\/"),
2342		0x8 => try output(context, "\\b"),
2343		0xC => try output(context, "\\f"),
2344		'\n' => try output(context, "\\n"),
2345		'\r' => try output(context, "\\r"),
2346		'\t' => try output(context, "\\t"),
	2337	'\\' => try out_stream.writeAll("\\\\"),
	2338	'\"' => try out_stream.writeAll("\\\""),
	2339	'/' => try out_stream.writeAll("\\/"),
	2340	0x8 => try out_stream.writeAll("\\b"),
	2341	0xC => try out_stream.writeAll("\\f"),
	2342	'\n' => try out_stream.writeAll("\\n"),
	2343	'\r' => try out_stream.writeAll("\\r"),
	2344	'\t' => try out_stream.writeAll("\\t"),
2347	2345	else => {
2348	2346	const ulen = std.unicode.utf8ByteSequenceLength(value[i]) catch unreachable;
2349	2347	const codepoint = std.unicode.utf8Decode(value[i .. i + ulen]) catch unreachable;
...	...	@@ -2351,40 +2349,40 @@ pub fn stringify(
2351	2349	// If the character is in the Basic Multilingual Plane (U+0000 through U+FFFF),
2352	2350	// then it may be represented as a six-character sequence: a reverse solidus, followed
2353	2351	// by the lowercase letter u, followed by four hexadecimal digits that encode the character's code point.
2354		try output(context, "\\u");
2355		try std.fmt.formatIntValue(codepoint, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, context, Errors, output);
	2352	try out_stream.writeAll("\\u");
	2353	try std.fmt.formatIntValue(codepoint, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream);
2356	2354	} else {
2357	2355	// To escape an extended character that is not in the Basic Multilingual Plane,
2358	2356	// the character is represented as a 12-character sequence, encoding the UTF-16 surrogate pair.
2359	2357	const high = @intCast(u16, (codepoint - 0x10000) >> 10) + 0xD800;
2360	2358	const low = @intCast(u16, codepoint & 0x3FF) + 0xDC00;
2361		try output(context, "\\u");
2362		try std.fmt.formatIntValue(high, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, context, Errors, output);
2363		try output(context, "\\u");
2364		try std.fmt.formatIntValue(low, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, context, Errors, output);
	2359	try out_stream.writeAll("\\u");
	2360	try std.fmt.formatIntValue(high, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream);
	2361	try out_stream.writeAll("\\u");
	2362	try std.fmt.formatIntValue(low, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream);
2365	2363	}
2366	2364	i += ulen - 1;
2367	2365	},
2368	2366	}
2369	2367	}
2370		try output(context, "\"");
	2368	try out_stream.writeAll("\"");
2371	2369	return;
2372	2370	}
2373	2371
2374		try output(context, "[");
	2372	try out_stream.writeAll("[");
2375	2373	for (value) \|x, i\| {
2376	2374	if (i != 0) {
2377		try output(context, ",");
	2375	try out_stream.writeAll(",");
2378	2376	}
2379		try stringify(x, options, context, Errors, output);
	2377	try stringify(x, options, out_stream);
2380	2378	}
2381		try output(context, "]");
	2379	try out_stream.writeAll("]");
2382	2380	return;
2383	2381	},
2384	2382	else => @compileError("Unable to stringify type '" ++ @typeName(T) ++ "'"),
2385	2383	},
2386	2384	.Array => \|info\| {
2387		return try stringify(value[0..], options, context, Errors, output);
	2385	return try stringify(value[0..], options, out_stream);
2388	2386	},
2389	2387	else => @compileError("Unable to stringify type '" ++ @typeName(T) ++ "'"),
2390	2388	}
...	...	@@ -2392,10 +2390,26 @@ pub fn stringify(
2392	2390	}
2393	2391
2394	2392	fn teststringify(expected: []const u8, value: var) !void {
2395		const TestStringifyContext = struct {
	2393	const ValidationOutStream = struct {
	2394	const Self = @This();
	2395	pub const OutStream = std.io.OutStream(*Self, Error, write);
	2396	pub const Error = error{
	2397	TooMuchData,
	2398	DifferentData,
	2399	};
	2400
2396	2401	expected_remaining: []const u8,
2397		fn testStringifyWrite(context: *@This(), bytes: []const u8) !void {
2398		if (context.expected_remaining.len < bytes.len) {
	2402
	2403	fn init(exp: []const u8) Self {
	2404	return .{ .expected_remaining = exp };
	2405	}
	2406
	2407	pub fn outStream(self: *Self) OutStream {
	2408	return .{ .context = self };
	2409	}
	2410
	2411	fn write(self: *Self, bytes: []const u8) Error!usize {
	2412	if (self.expected_remaining.len < bytes.len) {
2399	2413	std.debug.warn(
2400	2414	\\====== expected this output: =========
2401	2415	\\{}
...	...	@@ -2403,12 +2417,12 @@ fn teststringify(expected: []const u8, value: var) !void {
2403	2417	\\{}
2404	2418	\\======================================
2405	2419	, .{
2406		context.expected_remaining,
	2420	self.expected_remaining,
2407	2421	bytes,
2408	2422	});
2409	2423	return error.TooMuchData;
2410	2424	}
2411		if (!mem.eql(u8, context.expected_remaining[0..bytes.len], bytes)) {
	2425	if (!mem.eql(u8, self.expected_remaining[0..bytes.len], bytes)) {
2412	2426	std.debug.warn(
2413	2427	\\====== expected this output: =========
2414	2428	\\{}
...	...	@@ -2416,21 +2430,19 @@ fn teststringify(expected: []const u8, value: var) !void {
2416	2430	\\{}
2417	2431	\\======================================
2418	2432	, .{
2419		context.expected_remaining[0..bytes.len],
	2433	self.expected_remaining[0..bytes.len],
2420	2434	bytes,
2421	2435	});
2422	2436	return error.DifferentData;
2423	2437	}
2424		context.expected_remaining = context.expected_remaining[bytes.len..];
	2438	self.expected_remaining = self.expected_remaining[bytes.len..];
	2439	return bytes.len;
2425	2440	}
2426	2441	};
2427		var buf: [100]u8 = undefined;
2428		var context = TestStringifyContext{ .expected_remaining = expected };
2429		try stringify(value, StringifyOptions{}, &context, error{
2430		TooMuchData,
2431		DifferentData,
2432		}, TestStringifyContext.testStringifyWrite);
2433		if (context.expected_remaining.len > 0) return error.NotEnoughData;
	2442
	2443	var vos = ValidationOutStream.init(expected);
	2444	try stringify(value, StringifyOptions{}, vos.outStream());
	2445	if (vos.expected_remaining.len > 0) return error.NotEnoughData;
2434	2446	}
2435	2447
2436	2448	test "stringify basic types" {
...	...	@@ -2498,13 +2510,11 @@ test "stringify struct with custom stringifier" {
2498	2510	pub fn jsonStringify(
2499	2511	value: Self,
2500	2512	options: StringifyOptions,
2501		context: var,
2502		comptime Errors: type,
2503		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
	2513	out_stream: var,
2504	2514	) !void {
2505		try output(context, "[\"something special\",");
2506		try stringify(42, options, context, Errors, output);
2507		try output(context, "]");
	2515	try out_stream.writeAll("[\"something special\",");
	2516	try stringify(42, options, out_stream);
	2517	try out_stream.writeAll("]");
2508	2518	}
2509	2519	}{ .foo = 42 });
2510	2520	}

lib/std/math/big/int.zig+2-4

...	...	@@ -519,16 +519,14 @@ pub const Int = struct {
519	519	self: Int,
520	520	comptime fmt: []const u8,
521	521	options: std.fmt.FormatOptions,
522		context: var,
523		comptime FmtError: type,
524		output: fn (@TypeOf(context), []const u8) FmtError!void,
	522	out_stream: var,
525	523	) FmtError!void {
526	524	self.assertWritable();
527	525	// TODO look at fmt and support other bases
528	526	// TODO support read-only fixed integers
529	527	const str = self.toString(self.allocator.?, 10) catch @panic("TODO make this non allocating");
530	528	defer self.allocator.?.free(str);
531		return output(context, str);
	529	return out_stream.print(str);
532	530	}
533	531
534	532	/// Returns -1, 0, 1 if \|a\| < \|b\|, \|a\| == \|b\| or \|a\| > \|b\| respectively.

lib/std/net.zig+9-11

...	...	@@ -269,15 +269,13 @@ pub const Address = extern union {
269	269	self: Address,
270	270	comptime fmt: []const u8,
271	271	options: std.fmt.FormatOptions,
272		context: var,
273		comptime Errors: type,
274		comptime output: fn (@TypeOf(context), []const u8) Errors!void,
	272	out_stream: var,
275	273	) !void {
276	274	switch (self.any.family) {
277	275	os.AF_INET => {
278	276	const port = mem.bigToNative(u16, self.in.port);
279	277	const bytes = @ptrCast(*const [4]u8, &self.in.addr);
280		try std.fmt.format(context, Errors, output, "{}.{}.{}.{}:{}", .{
	278	try std.fmt.format(out_stream, "{}.{}.{}.{}:{}", .{
281	279	bytes[0],
282	280	bytes[1],
283	281	bytes[2],
...	...	@@ -288,7 +286,7 @@ pub const Address = extern union {
288	286	os.AF_INET6 => {
289	287	const port = mem.bigToNative(u16, self.in6.port);
290	288	if (mem.eql(u8, self.in6.addr[0..12], &[_]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff })) {
291		try std.fmt.format(context, Errors, output, "[::ffff:{}.{}.{}.{}]:{}", .{
	289	try std.fmt.format(out_stream, "[::ffff:{}.{}.{}.{}]:{}", .{
292	290	self.in6.addr[12],
293	291	self.in6.addr[13],
294	292	self.in6.addr[14],
...	...	@@ -308,30 +306,30 @@ pub const Address = extern union {
308	306	break :blk buf;
309	307	},
310	308	};
311		try output(context, "[");
	309	try out_stream.writeAll("[");
312	310	var i: usize = 0;
313	311	var abbrv = false;
314	312	while (i < native_endian_parts.len) : (i += 1) {
315	313	if (native_endian_parts[i] == 0) {
316	314	if (!abbrv) {
317		try output(context, if (i == 0) "::" else ":");
	315	try out_stream.writeAll(if (i == 0) "::" else ":");
318	316	abbrv = true;
319	317	}
320	318	continue;
321	319	}
322		try std.fmt.format(context, Errors, output, "{x}", .{native_endian_parts[i]});
	320	try std.fmt.format(out_stream, "{x}", .{native_endian_parts[i]});
323	321	if (i != native_endian_parts.len - 1) {
324		try output(context, ":");
	322	try out_stream.writeAll(":");
325	323	}
326	324	}
327		try std.fmt.format(context, Errors, output, "]:{}", .{port});
	325	try std.fmt.format(out_stream, "]:{}", .{port});
328	326	},
329	327	os.AF_UNIX => {
330	328	if (!has_unix_sockets) {
331	329	unreachable;
332	330	}
333	331
334		try std.fmt.format(context, Errors, output, "{}", .{&self.un.path});
	332	try std.fmt.format(out_stream, "{}", .{&self.un.path});
335	333	},
336	334	else => unreachable,
337	335	}

lib/std/os/uefi.zig+3-7

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

lib/std/progress.zig+1-1

...	...	@@ -190,7 +190,7 @@ pub const Progress = struct {
190	190	end.* += amt;
191	191	self.columns_written += amt;
192	192	} else \|err\| switch (err) {
193		error.BufferTooSmall => {
	193	error.NoSpaceLeft => {
194	194	self.columns_written += self.output_buffer.len - end.*;
195	195	end.* = self.output_buffer.len;
196	196	},

lib/std/zig/cross_target.zig+6-6

...	...	@@ -504,22 +504,22 @@ pub const CrossTarget = struct {
504	504	if (self.os_version_min != null or self.os_version_max != null) {
505	505	switch (self.getOsVersionMin()) {
506	506	.none => {},
507		.semver => \|v\| try result.print(".{}", .{v}),
508		.windows => \|v\| try result.print(".{}", .{@tagName(v)}),
	507	.semver => \|v\| try result.outStream().print(".{}", .{v}),
	508	.windows => \|v\| try result.outStream().print(".{}", .{@tagName(v)}),
509	509	}
510	510	}
511	511	if (self.os_version_max) \|max\| {
512	512	switch (max) {
513	513	.none => {},
514		.semver => \|v\| try result.print("...{}", .{v}),
515		.windows => \|v\| try result.print("...{}", .{@tagName(v)}),
	514	.semver => \|v\| try result.outStream().print("...{}", .{v}),
	515	.windows => \|v\| try result.outStream().print("...{}", .{@tagName(v)}),
516	516	}
517	517	}
518	518
519	519	if (self.glibc_version) \|v\| {
520		try result.print("-{}.{}", .{ @tagName(self.getAbi()), v });
	520	try result.outStream().print("-{}.{}", .{ @tagName(self.getAbi()), v });
521	521	} else if (self.abi) \|abi\| {
522		try result.print("-{}", .{@tagName(abi)});
	522	try result.outStream().print("-{}", .{@tagName(abi)});
523	523	}
524	524
525	525	return result.toOwnedSlice();

src-self-hosted/dep_tokenizer.zig+10-12

...	...	@@ -306,12 +306,12 @@ pub const Tokenizer = struct {
306	306
307	307	fn errorPosition(self: *Tokenizer, position: usize, bytes: []const u8, comptime fmt: []const u8, args: var) Error {
308	308	var buffer = try std.Buffer.initSize(&self.arena.allocator, 0);
309		std.fmt.format(&buffer, anyerror, std.Buffer.append, fmt, args) catch {};
	309	try buffer.outStream().print(fmt, args);
310	310	try buffer.append(" '");
311	311	var out = makeOutput(std.Buffer.append, &buffer);
312	312	try printCharValues(&out, bytes);
313	313	try buffer.append("'");
314		std.fmt.format(&buffer, anyerror, std.Buffer.append, " at position {}", .{position - (bytes.len - 1)}) catch {};
	314	try buffer.outStream().print(" at position {}", .{position - (bytes.len - 1)});
315	315	self.error_text = buffer.toSlice();
316	316	return Error.InvalidInput;
317	317	}
...	...	@@ -319,10 +319,9 @@ pub const Tokenizer = struct {
319	319	fn errorIllegalChar(self: *Tokenizer, position: usize, char: u8, comptime fmt: []const u8, args: var) Error {
320	320	var buffer = try std.Buffer.initSize(&self.arena.allocator, 0);
321	321	try buffer.append("illegal char ");
322		var out = makeOutput(std.Buffer.append, &buffer);
323		try printUnderstandableChar(&out, char);
324		std.fmt.format(&buffer, anyerror, std.Buffer.append, " at position {}", .{position}) catch {};
325		if (fmt.len != 0) std.fmt.format(&buffer, anyerror, std.Buffer.append, ": " ++ fmt, args) catch {};
	322	try printUnderstandableChar(&buffer, char);
	323	try buffer.outStream().print(" at position {}", .{position});
	324	if (fmt.len != 0) try buffer.outStream().print(": " ++ fmt, args);
326	325	self.error_text = buffer.toSlice();
327	326	return Error.InvalidInput;
328	327	}
...	...	@@ -996,14 +995,13 @@ fn printCharValues(out: var, bytes: []const u8) !void {
996	995	}
997	996	}
998	997
999		fn printUnderstandableChar(out: var, char: u8) !void {
	998	fn printUnderstandableChar(buffer: *std.Buffer, char: u8) !void {
1000	999	if (!std.ascii.isPrint(char) or char == ' ') {
1001		const output = @typeInfo(@TypeOf(out)).Pointer.child.output;
1002		std.fmt.format(out.context, anyerror, output, "\\x{X:2}", .{char}) catch {};
	1000	try buffer.outStream().print("\\x{X:2}", .{char});
1003	1001	} else {
1004		try out.write("'");
1005		try out.write(&[_]u8{printable_char_tab[char]});
1006		try out.write("'");
	1002	try buffer.append("'");
	1003	try buffer.appendByte(printable_char_tab[char]);
	1004	try buffer.append("'");
1007	1005	}
1008	1006	}
1009	1007

src-self-hosted/stage2.zig+3-3

...	...	@@ -1019,7 +1019,7 @@ const Stage2Target = extern struct {
1019	1019	.macosx,
1020	1020	.netbsd,
1021	1021	.openbsd,
1022		=> try os_builtin_str_buffer.print(
	1022	=> try os_builtin_str_buffer.outStream().print(
1023	1023	\\ .semver = .{{
1024	1024	\\ .min = .{{
1025	1025	\\ .major = {},
...	...	@@ -1043,7 +1043,7 @@ const Stage2Target = extern struct {
1043	1043	target.os.version_range.semver.max.patch,
1044	1044	}),
1045	1045
1046		.linux => try os_builtin_str_buffer.print(
	1046	.linux => try os_builtin_str_buffer.outStream().print(
1047	1047	\\ .linux = .{{
1048	1048	\\ .range = .{{
1049	1049	\\ .min = .{{
...	...	@@ -1078,7 +1078,7 @@ const Stage2Target = extern struct {
1078	1078	target.os.version_range.linux.glibc.patch,
1079	1079	}),
1080	1080
1081		.windows => try os_builtin_str_buffer.print(
	1081	.windows => try os_builtin_str_buffer.outStream().print(
1082	1082	\\ .windows = .{{
1083	1083	\\ .min = .{},
1084	1084	\\ .max = .{},

src-self-hosted/translate_c.zig+1-6

...	...	@@ -4752,15 +4752,10 @@ fn appendToken(c: *Context, token_id: Token.Id, bytes: []const u8) !ast.TokenInd
4752	4752	}
4753	4753
4754	4754	fn appendTokenFmt(c: *Context, token_id: Token.Id, comptime format: []const u8, args: var) !ast.TokenIndex {
4755		const S = struct {
4756		fn callback(context: *Context, bytes: []const u8) error{OutOfMemory}!void {
4757		return context.source_buffer.append(bytes);
4758		}
4759		};
4760	4755	const start_index = c.source_buffer.len();
4761	4756	errdefer c.source_buffer.shrink(start_index);
4762	4757
4763		try std.fmt.format(c, error{OutOfMemory}, S.callback, format, args);
	4758	try c.source_buffer.outStream().print(format, args);
4764	4759	const end_index = c.source_buffer.len();
4765	4760	const token_index = c.tree.tokens.len;
4766	4761	const new_token = try c.tree.tokens.addOne();