moving zig printing to a seprate file

Author: marcinmachura

bench/algorithm/binarytrees/1.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const print = @import("../../include/zig/print.zig");
 const builtin = @import("builtin");
 const math = std.math;
 const Allocator = std.mem.Allocator;
@@ -14,7 +15,7 @@ pub fn main() !void {
         const stretch_depth = max_depth + 1;
         const stretch_tree = Node.make(stretch_depth, global_allocator).?;
         defer stretch_tree.deinit();
-        try printFmt("stretch tree of depth {d}\t check: {d}\n", .{ stretch_depth, stretch_tree.check() });
+        try print.printFmt("stretch tree of depth {d}\t check: {d}\n", .{ stretch_depth, stretch_tree.check() });
     }
     const long_lived_tree = Node.make(max_depth, global_allocator).?;
     defer long_lived_tree.deinit();
@@ -29,10 +30,10 @@ pub fn main() !void {
             defer tree.deinit();
             sum += tree.check();
         }
-        try printFmt("{d}\t trees of depth {d}\t check: {d}\n", .{ iterations, depth, sum });
+        try print.printFmt("{d}\t trees of depth {d}\t check: {d}\n", .{ iterations, depth, sum });
     }
 
-    try printFmt("long lived tree of depth {d}\t check: {d}\n", .{ max_depth, long_lived_tree.check() });
+    try print.printFmt("long lived tree of depth {d}\t check: {d}\n", .{ max_depth, long_lived_tree.check() });
 }
 
 fn get_n() !usize {
@@ -42,12 +43,6 @@ fn get_n() !usize {
     return @as(usize, @intCast(try std.fmt.parseInt(u32, arg, 10)));
 }
 
-fn printFmt(comptime fmt: []const u8, args: anytype) !void {
-    var buf: [256]u8 = undefined;
-    const out = try std.fmt.bufPrint(&buf, fmt, args);
-    _ = try std.posix.write(std.posix.STDOUT_FILENO, out);
-}
-
 const Node = struct {
     const Self = @This();
 

bench/algorithm/coro-prime-sieve/1.zig

@@ -2,6 +2,7 @@
 // https://gist.github.com/SpexGuy/953e5780cd2d2c524cba6a79f13076e6
 
 const std = @import("std");
+const print = @import("../../include/zig/print.zig");
 
 const Channel = struct {
     value: u32,
@@ -34,7 +35,7 @@ fn filter(out_channel: *Channel, in_channel: *Channel, prime: u32) void {
 
 var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
 const global_allocator = arena.allocator();
-const stdout = std.io.getStdOut().writer();
+
 
 pub fn main() !void {
     defer arena.deinit();
@@ -52,7 +53,7 @@ pub fn main() !void {
     while (i < n) : (i += 1) {
         resume ch.frame;
         const prime = ch.value;
-        try stdout.print("{}\n", .{prime});
+        try print.printFmt("{}\n", .{prime});
         if (i >= n - 1) break;
         const ch1 = try global_allocator.create(Channel);
         const frame = try global_allocator.create(@Frame(filter));

bench/algorithm/edigits/1.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const print = @import("../../include/zig/print.zig");
 const bigint = std.math.big.int;
 const math = std.math;
 const global_allocator = std.heap.c_allocator;
@@ -43,19 +44,14 @@ pub fn main() !void {
             j += 1;
         }
         if (i + 10 <= n_usize) {
-            try printFmt("{s}\t:{d}\n", .{ sb, i + 10 });
+            try print.printFmt("{s}\t:{d}\n", .{ sb, i + 10 });
         } else {
-            try printFmt("{s}\t:{d}\n", .{ sb, n });
+            try print.printFmt("{s}\t:{d}\n", .{ sb, n });
         }
         i += 10;
     }
 }
 
-fn printFmt(comptime fmt: []const u8, args: anytype) !void {
-    var buf: [256]u8 = undefined;
-    const out = try std.fmt.bufPrint(&buf, fmt, args);
-    _ = try std.posix.write(std.posix.STDOUT_FILENO, out);
-}
 
 fn sum_terms(a: i32, b: i32) anyerror!Pair {
     if (b == a + 1) {

bench/algorithm/fannkuch-redux/1.zig

@@ -1,18 +1,14 @@
 // From https://github.com/tiehuis/zig-benchmarks-game/blob/master/src/fannkuch-redux.zig
 
 const std = @import("std");
+const print = @import("../../include/zig/print.zig");
 
 const global_allocator = std.heap.c_allocator;
 
 var buffer: [1024]u8 = undefined;
 var fixed_allocator = std.heap.FixedBufferAllocator.init(buffer[0..]);
 var allocator = fixed_allocator.allocator();
 
-fn printFmt(comptime fmt: []const u8, args: anytype) !void {
-    var buf: [256]u8 = undefined;
-    const out = try std.fmt.bufPrint(&buf, fmt, args);
-    _ = try std.posix.write(std.posix.STDOUT_FILENO, out);
-}
 
 pub fn main() !void {
     const n = try get_n();
@@ -88,7 +84,7 @@ pub fn main() !void {
         }
     }
 
-    try printFmt("{d}\nPfannkuchen({d}) = {d}\n", .{ checksum, n, max_flips_count });
+    try print.printFmt("{d}\nPfannkuchen({d}) = {d}\n", .{ checksum, n, max_flips_count });
 }
 
 fn get_n() !usize {

bench/algorithm/fannkuch-redux/2-m.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const print = @import("../../include/zig/print.zig");
 
 const max_n = 12;
 const Vec = @Vector(max_n, u8);
@@ -128,14 +129,9 @@ pub fn main() !void {
     const perms_count = factorialComptime(n);
     try runInParallel(tasks, perms_count, pfannkuchenStats, .{ n, &stats });
 
-    try printFmt("{d}\nPfannkuchen({d}) = {d}\n", .{ stats.checksum, n, stats.max_flips });
+    try print.printFmt("{d}\nPfannkuchen({d}) = {d}\n", .{ stats.checksum, n, stats.max_flips });
 }
 
-fn printFmt(comptime fmt: []const u8, args: anytype) !void {
-    var buf: [256]u8 = undefined;
-    const out = try std.fmt.bufPrint(&buf, fmt, args);
-    _ = try std.posix.write(std.posix.STDOUT_FILENO, out);
-}
 
 fn get_n() !u8 {
     var arg_it = std.process.args();

bench/algorithm/fannkuch-redux/2.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const print = @import("../../include/zig/print.zig");
 
 const Vec = @Vector(16, u8);
 
@@ -62,14 +63,9 @@ pub fn main() !void {
         for (count[1..r], 0..) |*v, i| v.* = @intCast(i + 2);
     }
 
-    try printFmt("{d}\nPfannkuchen({d}) = {d}\n", .{ checksum, n, max_flip_count });
+    try print.printFmt("{d}\nPfannkuchen({d}) = {d}\n", .{ checksum, n, max_flip_count });
 }
 
-fn printFmt(comptime fmt: []const u8, args: anytype) !void {
-    var buf: [256]u8 = undefined;
-    const out = try std.fmt.bufPrint(&buf, fmt, args);
-    _ = try std.posix.write(std.posix.STDOUT_FILENO, out);
-}
 
 fn get_n() !u8 {
     var arg_it = std.process.args();

bench/algorithm/fannkuch-redux/3-i.zig

@@ -23,6 +23,9 @@
 //
 
 const std = @import("std");
+const print = @import("../../include/zig/print.zig");
+
+
 const u8x16 = @Vector(16, u8);
 
 fn get_n() !u4 {
@@ -35,9 +38,7 @@ fn get_n() !u4 {
 pub fn main() !void {
     const n = try get_n();
     const x = fannkuchRedux(n);
-    var buf: [128]u8 = undefined;
-    const out = try std.fmt.bufPrint(&buf, "{}\nPfannkuchen({}) = {}\n", .{ x[0], n, x[1] });
-    _ = try std.posix.write(std.posix.STDOUT_FILENO, out);
+    try print.printFmt("{}\nPfannkuchen({}) = {}\n", .{ x[0], n, x[1] });
 }
 
 inline fn shuffle_epi8(x: u8x16, mask: u8x16) u8x16 {

bench/algorithm/helloworld/1.zig

@@ -1,18 +1,13 @@
 const std = @import("std");
+const print = @import("../../include/zig/print.zig");
 const global_allocator = std.heap.c_allocator;
 
-fn printFmt(comptime fmt: []const u8, args: anytype) !void {
-    var buf: [256]u8 = undefined;
-    const out = try std.fmt.bufPrint(&buf, fmt, args);
-    _ = try std.posix.write(std.posix.STDOUT_FILENO, out);
-}
-
 pub fn main() !void {
     const args = try std.process.argsAlloc(global_allocator);
     defer std.process.argsFree(global_allocator, args);
     if (args.len > 1) {
-        try printFmt("Hello world {s}!\n", .{args[1]});
+        try print.printFmt("Hello world {s}!\n", .{args[1]});
     } else {
-        try printFmt("Hello world!\n", .{});
+        try print.printFmt("Hello world!\n", .{});
     }
 }

bench/algorithm/json-serde/1.zig

@@ -1,8 +1,10 @@
 const std = @import("std");
+const print = @import("../../include/zig/print.zig");
 const json = std.json;
 
 const global_allocator = std.heap.c_allocator;
 
+
 pub fn main() !void {
     const args = try std.process.argsAlloc(global_allocator);
     defer std.process.argsFree(global_allocator, args);
@@ -48,9 +50,7 @@ fn printHash(bytes: []const u8) !void {
     const Md5 = std.crypto.hash.Md5;
     var hash: [Md5.digest_length]u8 = undefined;
     Md5.hash(bytes, &hash, .{});
-    var buf: [256]u8 = undefined;
-    const out = try std.fmt.bufPrint(&buf, "{s}\n", .{std.fmt.fmtSliceHexLower(&hash)});
-    _ = try std.posix.write(std.posix.STDOUT_FILENO, out);
+    try print.printFmt("{s}\n", .{std.fmt.fmtSliceHexLower(&hash)});
 }
 
 const GeoData = struct {

bench/algorithm/knucleotide/1-m.zig

@@ -1,12 +1,8 @@
 const std = @import("std");
+const print = @import("../../include/zig/print.zig");
 
 const gpa = std.heap.c_allocator;
 
-fn printFmt(comptime fmt: []const u8, args: anytype) !void {
-    var buf: [256]u8 = undefined;
-    const out = try std.fmt.bufPrint(&buf, fmt, args);
-    _ = try std.posix.write(std.posix.STDOUT_FILENO, out);
-}
 
 const Code = struct {
     data: u64,
@@ -134,12 +130,12 @@ fn printMap(frame: usize, maps: []const Map) !void {
     std.mem.sort(CountCode, cc_storage[0..cc_len], {}, CountCode.dsc);
 
     for (cc_storage[0..cc_len]) |c| {
-        try printFmt("{!s} {d:.3}\n", .{
+        try print.printFmt("{!s} {d:.3}\n", .{
             c.code.toString(frame),
             @as(f32, @floatFromInt(c.count)) / @as(f32, @floatFromInt(total)) * 100.0,
         });
     }
-    try printFmt("\n", .{});
+    try print.printFmt("\n", .{});
 }
 
 fn printOcc(occ: []const u8, maps: []const Map) !void {
@@ -148,7 +144,7 @@ fn printOcc(occ: []const u8, maps: []const Map) !void {
     for (maps) |m| {
         if (m.get(code)) |count| total += count;
     }
-    try printFmt("{}\t{s}\n", .{ total, occ });
+    try print.printFmt("{}\t{s}\n", .{ total, occ });
 }
 
 fn runInParallel(task_count: usize, len: usize, comptime f: anytype, args: anytype) !void {