309 lines
5.5 KiB
C
309 lines
5.5 KiB
C
|
#include "hoedown/buffer.h"
|
||
|
|
||
|
#include <stdio.h>
|
||
|
#include <stdlib.h>
|
||
|
#include <string.h>
|
||
|
#include <assert.h>
|
||
|
|
||
|
void *
|
||
|
hoedown_malloc(size_t size)
|
||
|
{
|
||
|
void *ret = malloc(size);
|
||
|
|
||
|
if (!ret) {
|
||
|
fprintf(stderr, "Allocation failed.\n");
|
||
|
abort();
|
||
|
}
|
||
|
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
void *
|
||
|
hoedown_calloc(size_t nmemb, size_t size)
|
||
|
{
|
||
|
void *ret = calloc(nmemb, size);
|
||
|
|
||
|
if (!ret) {
|
||
|
fprintf(stderr, "Allocation failed.\n");
|
||
|
abort();
|
||
|
}
|
||
|
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
void *
|
||
|
hoedown_realloc(void *ptr, size_t size)
|
||
|
{
|
||
|
void *ret = realloc(ptr, size);
|
||
|
|
||
|
if (!ret) {
|
||
|
fprintf(stderr, "Allocation failed.\n");
|
||
|
abort();
|
||
|
}
|
||
|
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_init(
|
||
|
hoedown_buffer *buf,
|
||
|
size_t unit,
|
||
|
hoedown_realloc_callback data_realloc,
|
||
|
hoedown_free_callback data_free,
|
||
|
hoedown_free_callback buffer_free)
|
||
|
{
|
||
|
assert(buf);
|
||
|
|
||
|
buf->data = NULL;
|
||
|
buf->size = buf->asize = 0;
|
||
|
buf->unit = unit;
|
||
|
buf->data_realloc = data_realloc;
|
||
|
buf->data_free = data_free;
|
||
|
buf->buffer_free = buffer_free;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_uninit(hoedown_buffer *buf)
|
||
|
{
|
||
|
assert(buf && buf->unit);
|
||
|
buf->data_free(buf->data);
|
||
|
}
|
||
|
|
||
|
hoedown_buffer *
|
||
|
hoedown_buffer_new(size_t unit)
|
||
|
{
|
||
|
hoedown_buffer *ret = hoedown_malloc(sizeof (hoedown_buffer));
|
||
|
hoedown_buffer_init(ret, unit, hoedown_realloc, free, free);
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_free(hoedown_buffer *buf)
|
||
|
{
|
||
|
if (!buf) return;
|
||
|
assert(buf && buf->unit);
|
||
|
|
||
|
buf->data_free(buf->data);
|
||
|
|
||
|
if (buf->buffer_free)
|
||
|
buf->buffer_free(buf);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_reset(hoedown_buffer *buf)
|
||
|
{
|
||
|
assert(buf && buf->unit);
|
||
|
|
||
|
buf->data_free(buf->data);
|
||
|
buf->data = NULL;
|
||
|
buf->size = buf->asize = 0;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_grow(hoedown_buffer *buf, size_t neosz)
|
||
|
{
|
||
|
size_t neoasz;
|
||
|
assert(buf && buf->unit);
|
||
|
|
||
|
if (buf->asize >= neosz)
|
||
|
return;
|
||
|
|
||
|
neoasz = buf->asize + buf->unit;
|
||
|
while (neoasz < neosz)
|
||
|
neoasz += buf->unit;
|
||
|
|
||
|
buf->data = buf->data_realloc(buf->data, neoasz);
|
||
|
buf->asize = neoasz;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_put(hoedown_buffer *buf, const uint8_t *data, size_t size)
|
||
|
{
|
||
|
assert(buf && buf->unit);
|
||
|
|
||
|
if (buf->size + size > buf->asize)
|
||
|
hoedown_buffer_grow(buf, buf->size + size);
|
||
|
|
||
|
memcpy(buf->data + buf->size, data, size);
|
||
|
buf->size += size;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_puts(hoedown_buffer *buf, const char *str)
|
||
|
{
|
||
|
hoedown_buffer_put(buf, (const uint8_t *)str, strlen(str));
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_putc(hoedown_buffer *buf, uint8_t c)
|
||
|
{
|
||
|
assert(buf && buf->unit);
|
||
|
|
||
|
if (buf->size >= buf->asize)
|
||
|
hoedown_buffer_grow(buf, buf->size + 1);
|
||
|
|
||
|
buf->data[buf->size] = c;
|
||
|
buf->size += 1;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
hoedown_buffer_putf(hoedown_buffer *buf, FILE *file)
|
||
|
{
|
||
|
assert(buf && buf->unit);
|
||
|
|
||
|
while (!(feof(file) || ferror(file))) {
|
||
|
hoedown_buffer_grow(buf, buf->size + buf->unit);
|
||
|
buf->size += fread(buf->data + buf->size, 1, buf->unit, file);
|
||
|
}
|
||
|
|
||
|
return ferror(file);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_set(hoedown_buffer *buf, const uint8_t *data, size_t size)
|
||
|
{
|
||
|
assert(buf && buf->unit);
|
||
|
|
||
|
if (size > buf->asize)
|
||
|
hoedown_buffer_grow(buf, size);
|
||
|
|
||
|
memcpy(buf->data, data, size);
|
||
|
buf->size = size;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_sets(hoedown_buffer *buf, const char *str)
|
||
|
{
|
||
|
hoedown_buffer_set(buf, (const uint8_t *)str, strlen(str));
|
||
|
}
|
||
|
|
||
|
int
|
||
|
hoedown_buffer_eq(const hoedown_buffer *buf, const uint8_t *data, size_t size)
|
||
|
{
|
||
|
if (buf->size != size) return 0;
|
||
|
return memcmp(buf->data, data, size) == 0;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
hoedown_buffer_eqs(const hoedown_buffer *buf, const char *str)
|
||
|
{
|
||
|
return hoedown_buffer_eq(buf, (const uint8_t *)str, strlen(str));
|
||
|
}
|
||
|
|
||
|
int
|
||
|
hoedown_buffer_prefix(const hoedown_buffer *buf, const char *prefix)
|
||
|
{
|
||
|
size_t i;
|
||
|
|
||
|
for (i = 0; i < buf->size; ++i) {
|
||
|
if (prefix[i] == 0)
|
||
|
return 0;
|
||
|
|
||
|
if (buf->data[i] != prefix[i])
|
||
|
return buf->data[i] - prefix[i];
|
||
|
}
|
||
|
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_slurp(hoedown_buffer *buf, size_t size)
|
||
|
{
|
||
|
assert(buf && buf->unit);
|
||
|
|
||
|
if (size >= buf->size) {
|
||
|
buf->size = 0;
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
buf->size -= size;
|
||
|
memmove(buf->data, buf->data + size, buf->size);
|
||
|
}
|
||
|
|
||
|
const char *
|
||
|
hoedown_buffer_cstr(hoedown_buffer *buf)
|
||
|
{
|
||
|
assert(buf && buf->unit);
|
||
|
|
||
|
if (buf->size < buf->asize && buf->data[buf->size] == 0)
|
||
|
return (char *)buf->data;
|
||
|
|
||
|
hoedown_buffer_grow(buf, buf->size + 1);
|
||
|
buf->data[buf->size] = 0;
|
||
|
|
||
|
return (char *)buf->data;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
hoedown_buffer_printf(hoedown_buffer *buf, const char *fmt, ...)
|
||
|
{
|
||
|
va_list ap;
|
||
|
int n;
|
||
|
|
||
|
assert(buf && buf->unit);
|
||
|
|
||
|
if (buf->size >= buf->asize)
|
||
|
hoedown_buffer_grow(buf, buf->size + 1);
|
||
|
|
||
|
va_start(ap, fmt);
|
||
|
n = vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
|
||
|
va_end(ap);
|
||
|
|
||
|
if (n < 0) {
|
||
|
#ifndef _MSC_VER
|
||
|
return;
|
||
|
#else
|
||
|
va_start(ap, fmt);
|
||
|
n = _vscprintf(fmt, ap);
|
||
|
va_end(ap);
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
if ((size_t)n >= buf->asize - buf->size) {
|
||
|
hoedown_buffer_grow(buf, buf->size + n + 1);
|
||
|
|
||
|
va_start(ap, fmt);
|
||
|
n = vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
|
||
|
va_end(ap);
|
||
|
}
|
||
|
|
||
|
if (n < 0)
|
||
|
return;
|
||
|
|
||
|
buf->size += n;
|
||
|
}
|
||
|
|
||
|
void hoedown_buffer_put_utf8(hoedown_buffer *buf, unsigned int c) {
|
||
|
unsigned char unichar[4];
|
||
|
|
||
|
assert(buf && buf->unit);
|
||
|
|
||
|
if (c < 0x80) {
|
||
|
hoedown_buffer_putc(buf, c);
|
||
|
}
|
||
|
else if (c < 0x800) {
|
||
|
unichar[0] = 192 + (c / 64);
|
||
|
unichar[1] = 128 + (c % 64);
|
||
|
hoedown_buffer_put(buf, unichar, 2);
|
||
|
}
|
||
|
else if (c - 0xd800u < 0x800) {
|
||
|
HOEDOWN_BUFPUTSL(buf, "\xef\xbf\xbd");
|
||
|
}
|
||
|
else if (c < 0x10000) {
|
||
|
unichar[0] = 224 + (c / 4096);
|
||
|
unichar[1] = 128 + (c / 64) % 64;
|
||
|
unichar[2] = 128 + (c % 64);
|
||
|
hoedown_buffer_put(buf, unichar, 3);
|
||
|
}
|
||
|
else if (c < 0x110000) {
|
||
|
unichar[0] = 240 + (c / 262144);
|
||
|
unichar[1] = 128 + (c / 4096) % 64;
|
||
|
unichar[2] = 128 + (c / 64) % 64;
|
||
|
unichar[3] = 128 + (c % 64);
|
||
|
hoedown_buffer_put(buf, unichar, 4);
|
||
|
}
|
||
|
else {
|
||
|
HOEDOWN_BUFPUTSL(buf, "\xef\xbf\xbd");
|
||
|
}
|
||
|
}
|