basic/src/Buffer.c

#include "Buffer.h"

#include <assert.h>
#include <string.h>

#include "Constants.h"
#include "Memory.h"

void bufferInit(Buffer* b) {
    *b = (Buffer){};
}

void bufferDestroy(Buffer* b) {
    memoryFree(b->data);
    *b = (Buffer){};
}

void bufferReset(Buffer* b) {
    b->readIndex = 0;
    b->writeIndex = 0;
}

bool bufferWrite(Buffer* b, const void* p, size_t n) {
    while(b->writeIndex + n > b->maxIndex) {
        size_t newSize = b->maxIndex <= 0 ? 16 : (b->maxIndex * 5) / 4;
        u8* newData = memoryAllocate(newSize);
        if(newData == nullptr) {
            return true;
        }
        memcpy(newData, b->data, b->writeIndex);
        memoryFree(b->data);
        b->data = newData;
        b->maxIndex = newSize;
    }
    memcpy(b->data + b->writeIndex, p, n);
    b->writeIndex += n;
    return false;
}

bool bufferRead(Buffer* b, void* p, size_t n) {
    if(b->readIndex + n > b->writeIndex) {
        return true;
    }
    memcpy(p, b->data + b->readIndex, n);
    b->readIndex += n;
    return false;
}

#define BUFFER_READ_WRITE_IMPL(Type, type)       \
    bool bufferWrite##Type(Buffer* b, type t) {  \
        return bufferWrite(b, &t, sizeof(type)); \
    }                                            \
    bool bufferRead##Type(Buffer* b, type* t) {  \
        return bufferRead(b, t, sizeof(type));   \
    }

BUFFER_READ_WRITE_IMPL(I32, i32)
BUFFER_READ_WRITE_IMPL(U8, u8)

bool bufferWriteString(Buffer* b, const char* s) {
    size_t l = strlen(s) + 1;
    assert(l <= MAX_STRING_LENGTH && l <= MAX_LITERAL_LENGTH);
    static_assert(MAX_STRING_LENGTH <= 0xFF);
    static_assert(MAX_LITERAL_LENGTH <= 0xFF);
    u8 u = l & 0xFF;
    return bufferWriteU8(b, u) || bufferWrite(b, s, u);
}

const char* bufferReadString(Buffer* b) {
    u8 l = 0;
    if(bufferReadU8(b, &l) || b->readIndex + l > b->writeIndex) {
        return nullptr;
    }
    const char* s = (char*)(b->data + b->readIndex);
    b->readIndex += l;
    return s;
}