integer.c

#include <kiba/format/defaults/integer.h>
 
#include <kiba/core/memory.h>
#include <kiba/core/string.h>
 
b8 format_read_unsigned_decimal(format_buffer *buf, format_options options, u64 *value) {
    usize left_pad_length = 0;
    while (format_buffer_match_char(buf, FORMAT_PADDING_CHAR)) {
        ++left_pad_length;
    }
    char c;
    if (!(format_buffer_peak_char(buf, &c) && character_is_decimal(c))) {
        return false;
    }
    format_buffer_advance(buf);
    u64 res = (u64) c - '0';
    usize digits = 1;
    while (format_buffer_peak_char(buf, &c) && character_is_decimal(c)) {
        format_buffer_advance(buf);
        u64 digit = (u64) c - '0';
        res       = res * 10 + 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_unsigned_decimal(format_buffer *buf, format_options options, u64 value) {
    char        buffer[20];
    const usize size = sizeof(buffer) / sizeof(buffer[0]);
    buffer[19]   = '0';  // used in case the value is just 0
    usize digits = 0;
    for (; value != 0LU; value /= 10LU, ++digits) {
        u64 digit                 = value % 10LU;
        buffer[size - digits - 1] = (char) digit + '0';
    }
    digits = KB_MAX(digits, 1);  // account for value of 0
    usize left_pad, right_pad;
    format_calculate_padding(options, digits, &left_pad, &right_pad);
    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);
}
 
b8 format_read_signed_decimal(format_buffer *buf, format_options options, i64 *value) {
    usize left_pad_length = 0;
    while (format_buffer_match_char(buf, FORMAT_PADDING_CHAR)) {
        ++left_pad_length;
    }
    char c;
    if (!format_buffer_peak_char(buf, &c)) {
        return false;
    }
    i64 factor = 1;
    usize digits = 1;
    if (c == '-') {
        factor = -1;
        ++digits;
        if (!(format_buffer_advance(buf) && format_buffer_peak_char(buf, &c))) {
            return false;
        }
    }
    if (!character_is_decimal(c)) {
        return false;
    }
    format_buffer_advance(buf);
    i64 res = (i64) c - '0';
    while (format_buffer_peak_char(buf, &c) && character_is_decimal(c)) {
        format_buffer_advance(buf);
        i64 digit = (i64) c - '0';
        res       = res * 10 + digit;
        ++digits;
    }
    res *= factor;
    *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_signed_decimal(format_buffer *buf, format_options options, i64 value) {
    char        buffer[20];
    const usize size = sizeof(buffer) / sizeof(buffer[0]);
    buffer[19]     = '0';  // used in case the value is just 0
    usize digits   = 0;
    b8    negative = value < 0L;
    if (negative) {
        value *= -1L;
    }
    for (; value != 0L; value /= 10L, ++digits) {
        i64 digit                 = value % 10L;
        buffer[size - digits - 1] = (char) digit + '0';
    }
    if (negative) {
        buffer[size - digits++ - 1] = '-';
    }
    digits = KB_MAX(digits, 1);  // account for value of 0
    usize left_pad, right_pad;
    format_calculate_padding(options, digits, &left_pad, &right_pad);
    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_u64) {
    u64 *arg = VA_ARG(*args, u64 *);
    return format_read_unsigned_decimal(buf, options, arg);
}
 
FORMAT_FUNCTION(format_write_u64) {
    u64 arg = VA_ARG(*args, u64);
    return format_write_unsigned_decimal(buf, options, arg);
}
 
FORMAT_FUNCTION(format_read_i64) {
    i64 *arg = VA_ARG(*args, i64 *);
    return format_read_signed_decimal(buf, options, arg);
}
 
FORMAT_FUNCTION(format_write_i64) {
    i64 arg = VA_ARG(*args, i64);
    return format_write_signed_decimal(buf, options, arg);
}
 
FORMAT_FUNCTION(format_read_u32) {
    u32 *arg = VA_ARG(*args, u32 *);
    u64  tmp;
    if (!format_read_unsigned_decimal(buf, options, &tmp)) {
        return false;
    }
    *arg = (u32) tmp;
    return true;
}
 
FORMAT_FUNCTION(format_write_u32) {
    u32 arg = VA_ARG(*args, u32);
    return format_write_unsigned_decimal(buf, options, arg);
}
 
FORMAT_FUNCTION(format_read_i32) {
    i32 *arg = VA_ARG(*args, i32 *);
    i64  tmp;
    if (!format_read_signed_decimal(buf, options, &tmp)) {
        return false;
    }
    *arg = (i32) tmp;
    return true;
}
 
FORMAT_FUNCTION(format_write_i32) {
    i32 arg = VA_ARG(*args, i32);
    return format_write_signed_decimal(buf, options, arg);
}
 
FORMAT_FUNCTION(format_read_u16) {
    u16 *arg = VA_ARG(*args, u16 *);
    u64  tmp;
    if (!format_read_unsigned_decimal(buf, options, &tmp)) {
        return false;
    }
    *arg = (u16) tmp;
    return true;
}
 
FORMAT_FUNCTION(format_write_u16) { return format_write_u32(buf, options, args); }
 
FORMAT_FUNCTION(format_read_i16) {
    i16 *arg = VA_ARG(*args, i16 *);
    i64  tmp;
    if (!format_read_signed_decimal(buf, options, &tmp)) {
        return false;
    }
    *arg = (i16) tmp;
    return true;
}
 
FORMAT_FUNCTION(format_write_i16) { return format_write_i32(buf, options, args); }
 
FORMAT_FUNCTION(format_read_u8) {
    u8 *arg = VA_ARG(*args, u8 *);
    u64 tmp;
    if (!format_read_unsigned_decimal(buf, options, &tmp)) {
        return false;
    }
    *arg = (u8) tmp;
    return true;
}
 
FORMAT_FUNCTION(format_write_u8) { return format_write_u32(buf, options, args); }
 
FORMAT_FUNCTION(format_read_i8) {
    i8 *arg = VA_ARG(*args, i8 *);
    i64 tmp;
    if (!format_read_signed_decimal(buf, options, &tmp)) {
        return false;
    }
    *arg = (i8) tmp;
    return true;
}
 
FORMAT_FUNCTION(format_write_i8) { return format_write_i32(buf, options, args); }
 
FORMAT_FUNCTION(format_read_usize) {
    usize *arg = VA_ARG(*args, usize *);
    u64    tmp;
    if (!format_read_unsigned_decimal(buf, options, &tmp)) {
        return false;
    }
    *arg = (usize) tmp;
    return true;
}
 
FORMAT_FUNCTION(format_write_usize) {
    usize arg = VA_ARG(*args, usize);
    return format_write_unsigned_decimal(buf, options, arg);
}