pointer.c

#include <kiba/format/defaults/pointer.h>
 
#include <kiba/core/memory.h>
#include <kiba/core/string.h>
 
b8 format_read_address(format_buffer *buf, format_options options, uptr *value) {
    usize left_pad_length = 0;
    while (format_buffer_match_char(buf, FORMAT_PADDING_CHAR)) {
        ++left_pad_length;
    }
    if (!(format_buffer_match_char(buf, '0') && format_buffer_match_char(buf, 'x'))) {
        return false;
    }
    char c;
    if (!(format_buffer_peak_char(buf, &c) && character_is_hexadecimal(c))) {
        return false;
    }
    format_buffer_advance(buf);
    usize digits = 3;  // account for leading 0x
    uptr res = (uptr) c - '0';
    if (res > 9) {
        res -= 'a' - '0' - 10;
    }
    while (format_buffer_peak_char(buf, &c) && character_is_hexadecimal(c)) {
        format_buffer_advance(buf);
        uptr digit = (uptr) c - '0';
        if (digit > 9) {
            digit -= 'a' - '0' - 10;
        }
        res = res * 16 + digit;
        ++digits;
    }
    *value = res;
    usize left_pad, right_pad;
    format_calculate_padding(options, digits, &left_pad, &right_pad);
    usize i = 0;
    for (; i < right_pad && format_buffer_match_char(buf, FORMAT_PADDING_CHAR); ++i)
        ;
    return left_pad_length == left_pad && i == right_pad;
}
 
b8 format_write_address(format_buffer *buf, format_options options, uptr value) {
    const char *symbols = "0123456789abcdef";
    char        buffer[18];
    const usize size = sizeof(buffer) / sizeof(buffer[0]);
    memory_set(buffer, (u8) '0', size * sizeof(char));  // kind of relies on 1 char == 1 byte
    usize digits = 0;
    for (; value != 0; value /= 16, ++digits) {
        uptr digit                = value % 16;
        buffer[size - digits - 1] = symbols[digit];
    }
    usize min_digits = 1;
    if (options.precision > 0 && options.precision <= 16) {
        min_digits = options.precision;
    }
    digits                      = KB_MAX(digits, min_digits);
    buffer[size - digits++ - 1] = 'x';
    usize left_pad, right_pad;
    format_calculate_padding(options, ++digits, &left_pad, &right_pad);  // account for leading 0
    return format_buffer_add_char_n(buf, FORMAT_PADDING_CHAR, left_pad)
        && format_buffer_add_chars(buf, buffer + size - digits, digits)
        && format_buffer_add_char_n(buf, FORMAT_PADDING_CHAR, right_pad);
}
 
FORMAT_FUNCTION(format_read_uptr) {
    uptr *arg = VA_ARG(*args, uptr *);
    return format_read_address(buf, options, arg);
}
 
FORMAT_FUNCTION(format_write_uptr) {
    uptr arg = VA_ARG(*args, uptr);
    return format_write_address(buf, options, arg);
}
 
FORMAT_FUNCTION(format_read_pointer) {
    void **arg = VA_ARG(*args, void **);
    return format_read_address(buf, options, (uptr *) arg);
}
 
FORMAT_FUNCTION(format_write_pointer) {
    void *arg = VA_ARG(*args, void *);
    return format_write_address(buf, options, (uptr) arg);
}