Hexdump

const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var file = try std.fs.cwd().openFile("hexdump.zig", .{});
    defer file.close();

    var buf_reader = std.io.bufferedReader(file.reader());
    var in_stream = buf_reader.reader();
    
    var buf: [16]u8 = undefined;
    var cnt: u64 = 16;
    while (cnt == 16) {
        cnt = try in_stream.readAtLeast(&buf, 16);
        if (cnt == 0) {
            std.debug.print("Empty File", .{});
            break;
        }

        for (0..cnt) |i| {
            const byte: [1]u8 = .{ buf[i] };
            const hexbyte = std.fmt.fmtSliceHexUpper(&byte);
            std.debug.print("{s} ", .{hexbyte});
        }
        std.debug.print("\n", .{});
    }

}

const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var file = try std.fs.cwd().openFile("hexdump.zig", .{});
    defer file.close();

    var buf_reader = std.io.bufferedReader(file.reader());
    var in_stream = buf_reader.reader();
    
    var buf: [16]u8 = undefined;
    var cnt: u64 = 16;
    while (cnt == 16) {
        cnt = try in_stream.readAtLeast(&buf, 16);
        if (cnt == 0) {
            std.debug.print("Empty File", .{});
            break;
        }

        for (0..cnt) |i| {
            const byte: [1]u8 = .{ buf[i] };
            const hexbyte = std.fmt.fmtSliceHexUpper(&byte);
            std.debug.print("{s} ", .{hexbyte});
        }
        std.debug.print("\n", .{});
    }

}

const std = @import("std");
var std_writer = std.io.bufferedWriter(std.io.getStdOut().writer());
var stdout = std_writer.writer();


pub fn main() !void {
    var file = try std.fs.cwd().openFile("random.bin", .{});
    defer file.close();

    var buf_reader = std.io.bufferedReader(file.reader());
    var in_stream = buf_reader.reader();

    var buf: [16]u8 = undefined;
    var cnt: u64 = 16;
    while (cnt == 16) {
        cnt = try in_stream.readAtLeast(&buf, 16);
        if (cnt == 0) {
            _ = try stdout.write("Empty File");
            break;
        }

        for (0..cnt) |i| {
            const byte: [1]u8 = .{ buf[i] };
            _ = try std.fmt.fmtSliceHexUpper(&byte).format("${s} ", .{}, stdout);
        }
        _ = try stdout.write("\n");
    }

}

const std = @import("std");
var std_writer = std.io.bufferedWriter(std.io.getStdOut().writer());
var stdout = std_writer.writer();


pub fn main() !void {
    var file = try std.fs.cwd().openFile("random.bin", .{});
    defer file.close();

    var buf_reader = std.io.bufferedReader(file.reader());
    var in_stream = buf_reader.reader();

    var buf: [16]u8 = undefined;
    var cnt: u64 = 16;
    while (cnt == 16) {
        cnt = try in_stream.readAtLeast(&buf, 16);
        if (cnt == 0) {
            _ = try stdout.write("Empty File");
            break;
        }

        for (0..cnt) |i| {
            const byte: [1]u8 = .{ buf[i] };
            _ = try std.fmt.fmtSliceHexUpper(&byte).format("${s} ", .{}, stdout);
        }
        _ = try stdout.write("\n");
    }

}

const std = @import("std");
var std_writer = std.io.bufferedWriter(std.io.getStdOut().writer());
var stdout = std_writer.writer();

pub fn main() !void {
    var file = try std.fs.cwd().openFile("test.zig", .{});
    defer file.close();

    var buf_reader = std.io.bufferedReader(file.reader());
    var in_stream = buf_reader.reader();

    var buf: [16]u8 = undefined;
    var cnt: u64 = 16;
    while (cnt == 16) {
        cnt = try in_stream.readAtLeast(&buf, 16);
        if (cnt == 0) {
            try stdout.writeAll("Empty File");
            break;
        }

        for (0..cnt) |i| {
            const byte: [1]u8 = .{buf[i]};
            _ = try std.fmt.fmtSliceHexUpper(&byte).format("${s} ", .{}, stdout);
        }
        try stdout.writeByte('\n');
    }
    
    try std_writer.flush();
}

const std = @import("std");
var std_writer = std.io.bufferedWriter(std.io.getStdOut().writer());
var stdout = std_writer.writer();

pub fn main() !void {
    var file = try std.fs.cwd().openFile("test.zig", .{});
    defer file.close();

    var buf_reader = std.io.bufferedReader(file.reader());
    var in_stream = buf_reader.reader();

    var buf: [16]u8 = undefined;
    var cnt: u64 = 16;
    while (cnt == 16) {
        cnt = try in_stream.readAtLeast(&buf, 16);
        if (cnt == 0) {
            try stdout.writeAll("Empty File");
            break;
        }

        for (0..cnt) |i| {
            const byte: [1]u8 = .{buf[i]};
            _ = try std.fmt.fmtSliceHexUpper(&byte).format("${s} ", .{}, stdout);
        }
        try stdout.writeByte('\n');
    }
    
    try std_writer.flush();
}

-d --one-byte-decimal
-o --one-byte-octal
-c --one-byte-char
-h --one-byte-hex

-D --two-byte-decimal
-O --two-byte-octal
-C --two-byte-char
-H --two-byte-hex

-d --one-byte-decimal
-o --one-byte-octal
-c --one-byte-char
-h --one-byte-hex

-D --two-byte-decimal
-O --two-byte-octal
-C --two-byte-char
-H --two-byte-hex

--color=true
--color=false
--color=auto (default)

--color=true
--color=false
--color=auto (default)

Hexdump v2.0.0 ~ The alternative cross-platform hexdump utility

Usage:
  hexdump [options...] <file>

Options:
  -a, --ascii             Show ASCII represntation in column on the side
  -s, --skip <offset>     Skip reading the first <offset> bytes
  -n, --length <length>   Only read <length> bytes
  -h, --help              Display this message
  -v, --version           Display the current version
      --color=[bool]      Enable or disable color output. Default: true
      --squeeze           Show identical lines as *

 Formatting Specifiers:
      --one-byte-char     Display as ASCII character, escape code string
                            (’\n’, ‘\t’, etc.), or as DEC
      --one-byte-decimal
      --one-byte-octal
      --two-byte-decimal
      --two-byte-octal
      --two-byte-hex


Arguments:
  <length> and <offset> arguments can be followed by xxx suffixes.
    Lowercase suffixes (k, m, g, ...) indicate a base of 1000, while
    uppercase suffixes (K, M, G, ...) represent a base of 1024.

Hexdump v2.0.0 ~ The alternative cross-platform hexdump utility

Usage:
  hexdump [options...] <file>

Options:
  -a, --ascii             Show ASCII represntation in column on the side
  -s, --skip <offset>     Skip reading the first <offset> bytes
  -n, --length <length>   Only read <length> bytes
  -h, --help              Display this message
  -v, --version           Display the current version
      --color=[bool]      Enable or disable color output. Default: true
      --squeeze           Show identical lines as *

 Formatting Specifiers:
      --one-byte-char     Display as ASCII character, escape code string
                            (’\n’, ‘\t’, etc.), or as DEC
      --one-byte-decimal
      --one-byte-octal
      --two-byte-decimal
      --two-byte-octal
      --two-byte-hex


Arguments:
  <length> and <offset> arguments can be followed by xxx suffixes.
    Lowercase suffixes (k, m, g, ...) indicate a base of 1000, while
    uppercase suffixes (K, M, G, ...) represent a base of 1024.

std.io.getStdOut().isTty()

std.io.getStdOut().isTty()

    if ((!isTty
        or !stdout_handle.supportsAnsiEscapeCodes()
        or disable_color
        ) and !force_color) {
        writeAnsi = false;
    }

    if ((!isTty
        or !stdout_handle.supportsAnsiEscapeCodes()
        or disable_color
        ) and !force_color) {
        writeAnsi = false;
    }

  bin/new ran
    1.01 ± 0.04 times faster than bin/old

  bin/new ran
    1.01 ± 0.04 times faster than bin/old