std.fmt.format — with generators

doc/docgen.zig

@@ -1050,7 +1050,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                 try out.write("<pre>");
                 try tokenizeAndPrint(tokenizer, out, code.source_token);
                 try out.write("</pre>");
-                const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", .{code.name});
+                const name_plus_ext = try std.fmtgen.allocPrint(allocator, "{}.zig", .{code.name});
                 const tmp_source_file_name = try fs.path.join(
                     allocator,
                     &[_][]const u8{ tmp_dir_name, name_plus_ext },
@@ -1059,7 +1059,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
 
                 switch (code.id) {
                     Code.Id.Exe => |expected_outcome| code_block: {
-                        const name_plus_bin_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ code.name, exe_ext });
+                        const name_plus_bin_ext = try std.fmtgen.allocPrint(allocator, "{}{}", .{ code.name, exe_ext });
                         var build_args = std.ArrayList([]const u8).init(allocator);
                         defer build_args.deinit();
                         try build_args.appendSlice(&[_][]const u8{
@@ -1090,7 +1090,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                             },
                         }
                         for (code.link_objects) |link_object| {
-                            const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ link_object, obj_ext });
+                            const name_with_ext = try std.fmtgen.allocPrint(allocator, "{}{}", .{ link_object, obj_ext });
                             const full_path_object = try fs.path.join(
                                 allocator,
                                 &[_][]const u8{ tmp_dir_name, name_with_ext },
@@ -1355,15 +1355,15 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
                         });
                     },
                     Code.Id.Obj => |maybe_error_match| {
-                        const name_plus_obj_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ code.name, obj_ext });
+                        const name_plus_obj_ext = try std.fmtgen.allocPrint(allocator, "{}{}", .{ code.name, obj_ext });
                         const tmp_obj_file_name = try fs.path.join(
                             allocator,
                             &[_][]const u8{ tmp_dir_name, name_plus_obj_ext },
                         );
                         var build_args = std.ArrayList([]const u8).init(allocator);
                         defer build_args.deinit();
 
-                        const name_plus_h_ext = try std.fmt.allocPrint(allocator, "{}.h", .{code.name});
+                        const name_plus_h_ext = try std.fmtgen.allocPrint(allocator, "{}.h", .{code.name});
                         const output_h_file_name = try fs.path.join(
                             allocator,
                             &[_][]const u8{ tmp_dir_name, name_plus_h_ext },

lib/std/atomic/queue.zig

@@ -353,7 +353,7 @@ test "std.atomic.Queue dump" {
     sos.reset();
     try queue.dumpToStream(SliceOutStream.Error, &sos.stream);
 
-    var expected = try std.fmt.bufPrint(expected_buffer[0..],
+    var expected = try std.fmtgen.bufPrint(expected_buffer[0..],
         \\head: 0x{x}=1
         \\ (null)
         \\tail: 0x{x}=1
@@ -373,7 +373,7 @@ test "std.atomic.Queue dump" {
     sos.reset();
     try queue.dumpToStream(SliceOutStream.Error, &sos.stream);
 
-    expected = try std.fmt.bufPrint(expected_buffer[0..],
+    expected = try std.fmtgen.bufPrint(expected_buffer[0..],
         \\head: 0x{x}=1
         \\ 0x{x}=2
         \\  (null)

lib/std/buffer.zig

@@ -65,16 +65,8 @@ pub const Buffer = struct {
     }
 
     pub fn allocPrint(allocator: *Allocator, comptime format: []const u8, args: var) !Buffer {
-        const countSize = struct {
-            fn countSize(size: *usize, bytes: []const u8) (error{}!void) {
-                size.* += bytes.len;
-            }
-        }.countSize;
-        var size: usize = 0;
-        std.fmt.format(&size, error{}, countSize, format, args) catch |err| switch (err) {};
-        var self = try Buffer.initSize(allocator, size);
-        assert((std.fmt.bufPrint(self.list.items, format, args) catch unreachable).len == size);
-        return self;
+        const slice = try std.fmtgen.allocPrint(allocator, format, args);
+        return Buffer.fromOwnedSlice(allocator, slice);
     }
 
     pub fn deinit(self: *Buffer) void {

lib/std/fifo.zig

@@ -294,7 +294,11 @@ pub fn LinearFifo(
         pub usingnamespace if (T == u8)
             struct {
                 pub fn print(self: *Self, comptime format: []const u8, args: var) !void {
-                    return std.fmt.format(self, error{OutOfMemory}, Self.write, format, args);
+                    var generator = std.fmtgen.Generator([]const u8).init();
+                    _ = async std.fmtgen.format(&generator, format, args);
+                    while (generator.next()) |bytes| {
+                        try self.write(bytes);
+                    }
                 }
             }
         else