buffer.c

#include <kiba/format/buffer.h>
 
#include <kiba/core/memory.h>
 
b8 format_buffer_create_static(format_buffer *buf, format_buffer_mode mode, char *buffer, usize length) {
    KB_ASSERT(buffer != KB_NULL, "provided pointer to buffer must be valid");
    buf->data   = buffer;
    buf->length = length;
    buf->head   = 0;
    buf->alloc  = KB_NULL;
    buf->mode   = mode;
    return true;
}
 
b8 format_buffer_create_dynamic(format_buffer *buf, usize initial_length, allocator *alloc) {
    KB_ASSERT(alloc != KB_NULL, "must receive valid allocator pointer");
    char *data = allocator_allocate(alloc, sizeof(char) * initial_length);
    if (data == KB_NULL) {
        KB_ERROR("can not allocate initial memory for the format buf");
        return false;
    }
    if (!format_buffer_create_static(buf, FORMAT_BUFFER_WRITE, data, initial_length)) {
        return false;
    }
    buf->alloc = alloc;
    return true;
}
 
void format_buffer_destroy(format_buffer *buf) {
    if (buf->alloc != KB_NULL) {
        allocator_free(buf->alloc, buf->data);
    }
    memory_zero(buf, sizeof(format_buffer));
}
 
static b8 format_buffer_resize(format_buffer *buf, usize min_new_size) {
    KB_ASSERT_DEBUG(buf->mode == FORMAT_BUFFER_WRITE, "only writing format_buffer may call resize");
    if (buf->alloc == KB_NULL) {
        KB_WARN("static format_buffer will not be resized");
        return false;
    }
    const usize new_length = (min_new_size / buf->length + 1) * buf->length;
    char       *new_data   = allocator_reallocate(buf->alloc, buf->data, sizeof(char) * new_length);
    if (new_data == KB_NULL) {
        KB_WARN("could not resize dynamic format_buffer");
        return false;
    }
    buf->data   = new_data;
    buf->length = new_length;
    return true;
}
 
b8 format_buffer_advance(format_buffer *buf) { return buf->head++ < buf->length; }
 
void format_buffer_reset(format_buffer *buf) { buf->head = 0; }
 
b8 format_buffer_add_char(format_buffer *buf, char c) {
    KB_ASSERT_DEBUG(buf->mode == FORMAT_BUFFER_WRITE, "only writing format_buffer may add content to the buffer");
    if (buf->head == buf->length && !format_buffer_resize(buf, buf->length + 1)) {
        return false;
    }
    buf->data[buf->head++] = c;
    return true;
}
 
b8 format_buffer_add_char_n(format_buffer *buf, char c, usize n) {
    KB_ASSERT_DEBUG(buf->mode == FORMAT_BUFFER_WRITE, "only writing format_buffer may add content to the buffer");
    usize remaining_length = buf->length - buf->head;
    if (remaining_length < n && !format_buffer_resize(buf, buf->length + n - remaining_length)) {
        return false;
    }
    memory_set(buf->data + buf->head, (u8) c, n);
    buf->head += n;
    return true;
}
 
b8 format_buffer_add_chars(format_buffer *buf, const char *chars, usize length) {
    KB_ASSERT_DEBUG(buf->mode == FORMAT_BUFFER_WRITE, "only writing format_buffer may add content to the buffer");
    usize remaining_length = buf->length - buf->head;
    if (remaining_length < length && !format_buffer_resize(buf, buf->length + length - remaining_length)) {
        return false;
    }
    memory_copy(buf->data + buf->head, chars, sizeof(char) * length);
    buf->head += length;
    return true;
}
 
b8 format_buffer_add_string_view(format_buffer *buf, string_view view) {
    if (!view.is_valid) {
        return false;
    }
    return format_buffer_add_chars(buf, string_view_data(view), view.length);
}
 
// TODO rethink how to export buffer data (e.g. proccessed, all, remaining?)
string_view string_view_from_format_buffer(const format_buffer *buf) {
    // TODO allow creation of string from char ptr with length
    return string_view_from_string((string){
        .data   = buf->data,
        .length = buf->head,
        .alloc  = KB_NULL,
    });
}
 
b8 format_buffer_peak_char(const format_buffer *buf, char *c) {
    KB_ASSERT_DEBUG(buf->mode == FORMAT_BUFFER_READ, "only reading format_buffer may read content from the buffer");
    if (buf->head < buf->length) {
        *c = buf->data[buf->head];
        return true;
    }
    return false;
}
 
b8 format_buffer_read_char(format_buffer *buf, char *c) {
    return format_buffer_peak_char(buf, c) && format_buffer_advance(buf);
}
 
b8 format_buffer_match_char(format_buffer *buf, char c) {
    char actual;
    return format_buffer_peak_char(buf, &actual) && c == actual && format_buffer_advance(buf);
}
 
b8 format_buffer_match_chars(format_buffer *buf, const char *c, usize length) {
    for (usize i = 0; i < length; ++i) {
        if (!format_buffer_match_char(buf, c[i])) {
            buf->head -= i;  // reset the head to avoid indeterministic position of head
            return false;
        }
    }
    return true;
}
 
b8 format_buffer_match_string_view(format_buffer *buf, string_view view) {
    if (!view.is_valid) {
        return false;
    }
    return format_buffer_match_chars(buf, string_view_data(view), view.length);
}