utility.c

Go to the documentation of this file.

 
#if defined(INFIX_DEBUG_ENABLED) && INFIX_DEBUG_ENABLED
 
/*
 * This section conditionally includes and defines the `note()` macro.
 * If the double_tap test harness is fully implemented (`DBLTAP_IMPLEMENTATION` is defined),
 * we use its `note()` macro for integrated test logging. Otherwise, we define a simple
 * `printf`-based fallback. This allows debug builds to function even outside the
 * test suite.
 */
#if defined(DBLTAP_ENABLE) && defined(DBLTAP_IMPLEMENTATION)
#include "common/double_tap.h"
#else
// Otherwise, define a simple printf-based fallback for note().
#include <stdio.h>
#ifndef note
#define note(...)                 \
    do {                          \
        printf("# " __VA_ARGS__); \
        printf("\n");             \
    } while (0)
#endif
#endif
#include "common/utility.h"
#include <inttypes.h>
 
void infix_dump_hex(const void * data, size_t size, const char * title) {
    const uint8_t * byte = (const uint8_t *)data;
    char line_buf[256];
    char * buf_ptr;
    size_t remaining_len;
    int written;
 
    // Print header with title and size.
    note("%s (size: %llu bytes)", title, (unsigned long long)size);
 
    for (size_t i = 0; i < size; i += 16) {
        buf_ptr = line_buf;
        remaining_len = sizeof(line_buf);
 
        // Print the current offset within the data block.
        written = snprintf(buf_ptr, remaining_len, "0x%04llx: ", (unsigned long long)i);
        // The `goto` is used here as a simple error-handling mechanism. If `snprintf`
        // fails or indicates the buffer is full, we jump to the `print_line` label
        // to output whatever portion of the line has been formatted so far.
        if (written < 0 || (size_t)written >= remaining_len)
            goto print_line;
        buf_ptr += written;
        remaining_len -= written;
 
        // Print 16 bytes in hexadecimal representation.
        for (size_t j = 0; j < 16; ++j) {
            if (i + j < size)
                written = snprintf(buf_ptr, remaining_len, "%02x ", byte[i + j]);
            else
                written = snprintf(buf_ptr, remaining_len, "   ");  // Pad if at the end.
            if (written < 0 || (size_t)written >= remaining_len)
                goto print_line;
            buf_ptr += written;
            remaining_len -= written;
 
            if (j == 7) {  // Add extra space in the middle for readability.
                written = snprintf(buf_ptr, remaining_len, " ");
                if (written < 0 || (size_t)written >= remaining_len)
                    goto print_line;
                buf_ptr += written;
                remaining_len -= written;
            }
        }
 
        written = snprintf(buf_ptr, remaining_len, "| ");
        if (written < 0 || (size_t)written >= remaining_len)
            goto print_line;
        buf_ptr += written;
        remaining_len -= written;
 
        // Print the ASCII representation of the 16 bytes.
        for (size_t j = 0; j < 16; ++j) {
            if (i + j < size) {
                // Use a '.' for non-printable characters.
                if (byte[i + j] >= 32 && byte[i + j] <= 126)
                    written = snprintf(buf_ptr, remaining_len, "%c", byte[i + j]);
                else
                    written = snprintf(buf_ptr, remaining_len, ".");
                if (written < 0 || (size_t)written >= remaining_len)
                    goto print_line;
                buf_ptr += written;
                remaining_len -= written;
            }
        }
 
print_line:
        // Output the fully formatted (or partially formatted, if truncated) line.
        // `snprintf` guarantees null-termination if the buffer size is > 0.
        note("  %s", line_buf);
    }
    note("End of %s", title);
}
 
#endif  // INFIX_DEBUG_ENABLED