util:dump-hex

Author: iceboy233

util/BUILD

@@ -1,5 +1,28 @@
 package(default_visibility = ["//visibility:public"])
 
+cc_library(
+    name = "dump-hex",
+    srcs = ["dump-hex.cc"],
+    hdrs = ["dump-hex.h"],
+    deps = [
+        "//base:types",
+        "//io:file",
+        "//io:file-utils",
+        "@com_google_absl//absl/container:fixed_array",
+    ],
+)
+
+cc_test(
+    name = "dump-hex_test",
+    srcs = ["dump-hex_test.cc"],
+    deps = [
+        ":dump-hex",
+        "//base:types",
+        "//io:memory-file",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
 cc_library(
     name = "fibonacci-sequence",
     hdrs = ["fibonacci-sequence.h"],

util/dump-hex.cc

@@ -0,0 +1,78 @@
+#include "util/dump-hex.h"
+
+#include <cstddef>
+
+#include "absl/container/fixed_array.h"
+#include "io/file-utils.h"
+
+namespace util {
+namespace {
+
+inline char to_hex(int value) {
+    return value < 10 ? '0' + value : 'a' + value - 10;
+}
+
+inline char to_char(int value) {
+    return value >= 32 && value <= 127 ? value : '.';
+}
+
+void put_uint8_hex(uint8_t value, char output[2]) {
+    output[0] = to_hex(value >> 4);
+    output[1] = to_hex(value & 0xf);
+}
+
+void put_uint32_hex(uint32_t value, char output[8]) {
+    for (int i = 0; i < 8; ++i) {
+        output[i] = to_hex(value >> 28);
+        value <<= 4;
+    }
+}
+
+}  // namespace
+
+std::error_code dump_hex(
+    ConstBufferSpan input,
+    io::File &output,
+    const DumpHexOptions &options) {
+    const size_t width = options.width;
+    const size_t char_start = (width * 5 + 23) / 2;
+    absl::FixedArray<char, 80> line_buffer(char_start + width + 1, ' ');
+    line_buffer[8] = ':';
+    uint32_t offset = options.offset;
+    while (input.size() >= width) {
+        put_uint32_hex(offset, &line_buffer[0]);
+        for (size_t i = 0; i < width; ++i) {
+            put_uint8_hex(input[i], &line_buffer[i * 5 / 2 + 10]);
+            line_buffer[char_start + i] = to_char(input[i]);
+        }
+        line_buffer[char_start + width] = '\n';
+        std::error_code ec = io::write(
+            output, {line_buffer.data(), line_buffer.size()});
+        if (ec) {
+            return ec;
+        }
+        input.remove_prefix(width);
+        offset += width;
+    }
+    if (!input.empty()) {
+        put_uint32_hex(offset, &line_buffer[0]);
+        size_t i;
+        for (i = 0; i < input.size(); ++i) {
+            put_uint8_hex(input[i], &line_buffer[i * 5 / 2 + 10]);
+            line_buffer[char_start + i] = to_char(input[i]);
+        }
+        for (; i < width; ++i) {
+            line_buffer[i * 5 / 2 + 10] = ' ';
+            line_buffer[i * 5 / 2 + 11] = ' ';
+        }
+        line_buffer[char_start + input.size()] = '\n';
+        std::error_code ec = io::write(
+            output, {line_buffer.data(), char_start + input.size() + 1});
+        if (ec) {
+            return ec;
+        }
+    }
+    return {};
+}
+
+}  // namespace util

util/dump-hex.h

@@ -0,0 +1,24 @@
+#ifndef _UTIL_DUMP_HEX_H
+#define _UTIL_DUMP_HEX_H
+
+#include <cstdint>
+#include <system_error>
+
+#include "base/types.h"
+#include "io/file.h"
+
+namespace util {
+
+struct DumpHexOptions {
+    int width = 16;
+    uint32_t offset = 0;
+};
+
+std::error_code dump_hex(
+    ConstBufferSpan input,
+    io::File &output,
+    const DumpHexOptions &options);
+
+}  // namespace util
+
+#endif  // _UTIL_DUMP_HEX_H

util/dump-hex_test.cc

@@ -0,0 +1,25 @@
+#include "util/dump-hex.h"
+
+#include <string_view>
+#include <system_error>
+#include <gtest/gtest.h>
+
+#include "base/types.h"
+#include "io/memory-file.h"
+
+namespace util {
+namespace {
+
+TEST(DumpHexTest, basic) {
+    io::MemoryFile file;
+    DumpHexOptions options;
+    options.width = 7;
+    options.offset = 12;
+    EXPECT_EQ(dump_hex("hello world\n", file, options), std::error_code());
+    EXPECT_EQ(std::string_view(ConstBufferSpan(file.content())),
+              "0000000c: 6865 6c6c 6f20 77  hello w\n"
+              "00000013: 6f72 6c64 0a       orld.\n");
+}
+
+}  // namespace
+}  // namespace util