factotum/cmark-zig
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cmark: patch allocator to accept a context object

Browse Source 
This is necessary to be able to use arbitrary zig allocators as the
cmark allocator. I'm not sure if this patch is worth trying to
upstream.
This commit is contained in:
torque 2023-09-04 15:17:29 -07:00
parent 24810cbbbd
commit 20b3ef3515
Signed by: torque
SSH Key Fingerprint: SHA256:nCrXefBNo6EbjNSQhv0nXmEg/VuNq3sMF5b8zETw3Tk
12 changed files with 61 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
deps/cmark/api_test/main.c vendored
View File

@ -322,7 +322,7 @@ static void iterator_delete(test_batch_runner *runner) {
cmark_mem *allocator = cmark_get_default_mem_allocator();
allocator->free(html);
allocator->free(allocator->ctx, html);
cmark_iter_free(iter);
cmark_node_free(doc);
}

14
deps/cmark/src/blocks.c vendored
View File

@ -73,7 +73,7 @@ static cmark_node *make_block(cmark_mem *mem, cmark_node_type tag,
int start_line, int start_column) {
cmark_node *e;
e = (cmark_node *)mem->calloc(1, sizeof(*e));
e = (cmark_node *)mem->calloc(mem->ctx, 1, sizeof(*e));
e->mem = mem;
e->type = (uint16_t)tag;
e->flags = CMARK_NODE__OPEN;
@ -91,7 +91,7 @@ static cmark_node *make_document(cmark_mem *mem) {
}
cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem) {
cmark_parser *parser = (cmark_parser *)mem->calloc(1, sizeof(cmark_parser));
cmark_parser *parser = (cmark_parser *)mem->calloc(mem->ctx, 1, sizeof(cmark_parser));
parser->mem = mem;
cmark_node *document = make_document(mem);
@ -129,7 +129,7 @@ void cmark_parser_free(cmark_parser *parser) {
cmark_strbuf_free(&parser->curline);
cmark_strbuf_free(&parser->linebuf);
cmark_reference_map_free(parser->refmap);
mem->free(parser);
mem->free(mem->ctx, parser);
}
static cmark_node *finalize(cmark_parser *parser, cmark_node *b);
@ -406,7 +406,7 @@ static void process_inlines(cmark_mem *mem, cmark_node *root,
if (ev_type == CMARK_EVENT_ENTER) {
if (contains_inlines(S_type(cur))) {
cmark_parse_inlines(mem, cur, refmap, options);
mem->free(cur->data);
mem->free(mem->ctx, cur->data);
cur->data = NULL;
cur->len = 0;
}
@ -447,7 +447,7 @@ static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input,
}
}
data = (cmark_list *)mem->calloc(1, sizeof(*data));
data = (cmark_list *)mem->calloc(mem->ctx, 1, sizeof(*data));
data->marker_offset = 0; // will be adjusted later
data->list_type = CMARK_BULLET_LIST;
data->bullet_char = c;
@ -487,7 +487,7 @@ static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input,
}
}
data = (cmark_list *)mem->calloc(1, sizeof(*data));
data = (cmark_list *)mem->calloc(mem->ctx, 1, sizeof(*data));
data->marker_offset = 0; // will be adjusted later
data->list_type = CMARK_ORDERED_LIST;
data->bullet_char = 0;
@ -1100,7 +1100,7 @@ static void open_new_blocks(cmark_parser *parser, cmark_node **container,
parser->first_nonspace + 1);
/* TODO: static */
memcpy(&((*container)->as.list), data, sizeof(*data));
parser->mem->free(data);
parser->mem->free(parser->mem->ctx, data);
} else if (indented && !maybe_lazy && !parser->blank) {
S_advance_offset(parser, input, CODE_INDENT, true);
*container = add_child(parser, *container, CMARK_NODE_CODE_BLOCK,

6
deps/cmark/src/buffer.c vendored
View File

@ -54,7 +54,7 @@ void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) {
new_size += 1;
new_size = (new_size + 7) & ~7;
buf->ptr = (unsigned char *)buf->mem->realloc(buf->asize ? buf->ptr : NULL,
buf->ptr = (unsigned char *)buf->mem->realloc(buf->mem->ctx, buf->asize ? buf->ptr : NULL,
new_size);
buf->asize = new_size;
}
@ -66,7 +66,7 @@ void cmark_strbuf_free(cmark_strbuf *buf) {
return;
if (buf->ptr != cmark_strbuf__initbuf)
buf->mem->free(buf->ptr);
buf->mem->free(buf->mem->ctx, buf->ptr);
cmark_strbuf_init(buf->mem, buf, 0);
}
@ -150,7 +150,7 @@ unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) {
if (buf->asize == 0) {
/* return an empty string */
return (unsigned char *)buf->mem->calloc(1, 1);
return (unsigned char *)buf->mem->calloc(buf->mem->ctx, 1, 1);
}
cmark_strbuf_init(buf->mem, buf, 0);

10
deps/cmark/src/cmark.c vendored
View File

@ -10,7 +10,7 @@ int cmark_version(void) { return CMARK_VERSION; }
const char *cmark_version_string(void) { return CMARK_VERSION_STRING; }
static void *xcalloc(size_t nmem, size_t size) {
static void *xcalloc(void *ctx, size_t nmem, size_t size) {
void *ptr = calloc(nmem, size);
if (!ptr) {
fprintf(stderr, "[cmark] calloc returned null pointer, aborting\n");
@ -19,7 +19,7 @@ static void *xcalloc(size_t nmem, size_t size) {
return ptr;
}
static void *xrealloc(void *ptr, size_t size) {
static void *xrealloc(void *ctx, void *ptr, size_t size) {
void *new_ptr = realloc(ptr, size);
if (!new_ptr) {
fprintf(stderr, "[cmark] realloc returned null pointer, aborting\n");
@ -28,7 +28,11 @@ static void *xrealloc(void *ptr, size_t size) {
return new_ptr;
}
cmark_mem DEFAULT_MEM_ALLOCATOR = {xcalloc, xrealloc, free};
static void xfree(void *ctx, void *ptr) {
return free(ptr);
}
cmark_mem DEFAULT_MEM_ALLOCATOR = {NULL, xcalloc, xrealloc, xfree};
cmark_mem *cmark_get_default_mem_allocator(void) {
return &DEFAULT_MEM_ALLOCATOR;

7
deps/cmark/src/cmark.h vendored
View File

@ -95,9 +95,10 @@ typedef struct cmark_iter cmark_iter;
* when parsing and allocating a document tree
*/
typedef struct cmark_mem {
void *(*calloc)(size_t, size_t);
void *(*realloc)(void *, size_t);
void (*free)(void *);
void *ctx;
void *(*calloc)(void*, size_t, size_t);
void *(*realloc)(void*, void *, size_t);
void (*free)(void*, void *);
} cmark_mem;
/** Returns a pointer to the default memory allocator.

18
deps/cmark/src/inlines.c vendored
View File

@ -86,7 +86,7 @@ static bufsize_t subject_find_special_char(subject *subj, int options);
// Create an inline with a literal string value.
static CMARK_INLINE cmark_node *make_literal(subject *subj, cmark_node_type t,
int start_column, int end_column) {
cmark_node *e = (cmark_node *)subj->mem->calloc(1, sizeof(*e));
cmark_node *e = (cmark_node *)subj->mem->calloc(subj->mem->ctx, 1, sizeof(*e));
e->mem = subj->mem;
e->type = (uint16_t)t;
e->start_line = e->end_line = subj->line;
@ -98,7 +98,7 @@ static CMARK_INLINE cmark_node *make_literal(subject *subj, cmark_node_type t,
// Create an inline with no value.
static CMARK_INLINE cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) {
cmark_node *e = (cmark_node *)mem->calloc(1, sizeof(*e));
cmark_node *e = (cmark_node *)mem->calloc(mem->ctx, 1, sizeof(*e));
e->mem = mem;
e->type = t;
return e;
@ -106,7 +106,7 @@ static CMARK_INLINE cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) {
static cmark_node *make_str(subject *subj, int sc, int ec, cmark_chunk s) {
cmark_node *e = make_literal(subj, CMARK_NODE_TEXT, sc, ec);
e->data = (unsigned char *)subj->mem->realloc(NULL, s.len + 1);
e->data = (unsigned char *)subj->mem->realloc(subj->mem->ctx, NULL, s.len + 1);
if (s.data != NULL) {
memcpy(e->data, s.data, s.len);
}
@ -161,7 +161,7 @@ static unsigned char *cmark_strdup(cmark_mem *mem, unsigned char *src) {
return NULL;
}
size_t len = strlen((char *)src);
unsigned char *data = (unsigned char *)mem->realloc(NULL, len + 1);
unsigned char *data = (unsigned char *)mem->realloc(mem->ctx, NULL, len + 1);
memcpy(data, src, len + 1);
return data;
}
@ -514,7 +514,7 @@ static void remove_delimiter(subject *subj, delimiter *delim) {
if (delim->previous != NULL) {
delim->previous->next = delim->next;
}
subj->mem->free(delim);
subj->mem->free(subj->mem->ctx, delim);
}
static void pop_bracket(subject *subj) {
@ -523,12 +523,12 @@ static void pop_bracket(subject *subj) {
return;
b = subj->last_bracket;
subj->last_bracket = subj->last_bracket->previous;
subj->mem->free(b);
subj->mem->free(subj->mem->ctx, b);
}
static void push_delimiter(subject *subj, unsigned char c, bool can_open,
bool can_close, cmark_node *inl_text) {
delimiter *delim = (delimiter *)subj->mem->calloc(1, sizeof(delimiter));
delimiter *delim = (delimiter *)subj->mem->calloc(subj->mem->ctx, 1, sizeof(delimiter));
delim->delim_char = c;
delim->can_open = can_open;
delim->can_close = can_close;
@ -544,7 +544,7 @@ static void push_delimiter(subject *subj, unsigned char c, bool can_open,
}
static void push_bracket(subject *subj, bool image, cmark_node *inl_text) {
bracket *b = (bracket *)subj->mem->calloc(1, sizeof(bracket));
bracket *b = (bracket *)subj->mem->calloc(subj->mem->ctx, 1, sizeof(bracket));
if (subj->last_bracket != NULL) {
subj->last_bracket->bracket_after = true;
}
@ -972,7 +972,7 @@ static cmark_node *handle_pointy_brace(subject *subj, int options) {
subj->pos += matchlen;
cmark_node *node = make_literal(subj, CMARK_NODE_HTML_INLINE,
subj->pos - matchlen - 1, subj->pos - 1);
node->data = (unsigned char *)subj->mem->realloc(NULL, len + 1);
node->data = (unsigned char *)subj->mem->realloc(subj->mem->ctx, NULL, len + 1);
memcpy(node->data, src, len);
node->data[len] = 0;
node->len = len;

6
deps/cmark/src/iterator.c vendored
View File

@ -17,7 +17,7 @@ cmark_iter *cmark_iter_new(cmark_node *root) {
return NULL;
}
cmark_mem *mem = root->mem;
cmark_iter *iter = (cmark_iter *)mem->calloc(1, sizeof(cmark_iter));
cmark_iter *iter = (cmark_iter *)mem->calloc(mem->ctx, 1, sizeof(cmark_iter));
iter->mem = mem;
iter->root = root;
iter->cur.ev_type = CMARK_EVENT_NONE;
@ -27,7 +27,7 @@ cmark_iter *cmark_iter_new(cmark_node *root) {
return iter;
}
void cmark_iter_free(cmark_iter *iter) { iter->mem->free(iter); }
void cmark_iter_free(cmark_iter *iter) { iter->mem->free(iter->mem->ctx, iter); }
static bool S_is_leaf(cmark_node *node) {
return ((1 << node->type) & S_leaf_mask) != 0;
@ -111,7 +111,7 @@ void cmark_consolidate_text_nodes(cmark_node *root) {
cmark_node_free(tmp);
tmp = next;
}
iter->mem->free(cur->data);
iter->mem->free(iter->mem->ctx, cur->data);
cur->len = buf.size;
cur->data = cmark_strbuf_detach(&buf);
}

2
deps/cmark/src/main.c vendored
View File

@ -70,7 +70,7 @@ static void print_document(cmark_node *document, writer_format writer,
exit(1);
}
printf("%s", result);
document->mem->free(result);
document->mem->free(document->mem->ctx, result);
}
int main(int argc, char *argv[]) {

4
deps/cmark/src/man.c vendored
View File

@ -116,7 +116,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
case CMARK_NODE_ITEM:
if (entering) {
new_block_number = allocator->calloc(1, sizeof(struct block_number));
new_block_number = allocator->calloc(allocator->ctx, 1, sizeof(struct block_number));
new_block_number->number = 0;
new_block_number->parent = renderer->block_number_in_list_item;
renderer->block_number_in_list_item = new_block_number;
@ -145,7 +145,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
new_block_number = renderer->block_number_in_list_item;
renderer->block_number_in_list_item =
renderer->block_number_in_list_item->parent;
allocator->free(new_block_number);
allocator->free(allocator->ctx, new_block_number);
}
CR();
}

22
deps/cmark/src/node.c vendored
View File

@ -72,7 +72,7 @@ static bool S_can_contain(cmark_node *node, cmark_node *child) {
}
cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) {
cmark_node *node = (cmark_node *)mem->calloc(1, sizeof(*node));
cmark_node *node = (cmark_node *)mem->calloc(mem->ctx, 1, sizeof(*node));
node->mem = mem;
node->type = (uint16_t)type;
@ -108,24 +108,24 @@ static void S_free_nodes(cmark_node *e) {
while (e != NULL) {
switch (e->type) {
case CMARK_NODE_CODE_BLOCK:
mem->free(e->data);
mem->free(e->as.code.info);
mem->free(mem->ctx, e->data);
mem->free(mem->ctx, e->as.code.info);
break;
case CMARK_NODE_TEXT:
case CMARK_NODE_HTML_INLINE:
case CMARK_NODE_CODE:
case CMARK_NODE_HTML_BLOCK:
mem->free(e->data);
mem->free(mem->ctx, e->data);
break;
case CMARK_NODE_LINK:
case CMARK_NODE_IMAGE:
mem->free(e->as.link.url);
mem->free(e->as.link.title);
mem->free(mem->ctx, e->as.link.url);
mem->free(mem->ctx, e->as.link.title);
break;
case CMARK_NODE_CUSTOM_BLOCK:
case CMARK_NODE_CUSTOM_INLINE:
mem->free(e->as.custom.on_enter);
mem->free(e->as.custom.on_exit);
mem->free(mem->ctx, e->as.custom.on_enter);
mem->free(mem->ctx, e->as.custom.on_exit);
break;
default:
break;
@ -136,7 +136,7 @@ static void S_free_nodes(cmark_node *e) {
e->next = e->first_child;
}
next = e->next;
mem->free(e);
mem->free(mem->ctx, e);
e = next;
}
}
@ -255,14 +255,14 @@ static bufsize_t cmark_set_cstr(cmark_mem *mem, unsigned char **dst,
if (src && src[0]) {
len = (bufsize_t)strlen(src);
*dst = (unsigned char *)mem->realloc(NULL, len + 1);
*dst = (unsigned char *)mem->realloc(mem->ctx, NULL, len + 1);
memcpy(*dst, src, len + 1);
} else {
len = 0;
*dst = NULL;
}
if (old) {
mem->free(old);
mem->free(mem->ctx, old);
}
return len;

22
deps/cmark/src/references.c vendored
View File

@ -8,10 +8,10 @@
static void reference_free(cmark_reference_map *map, cmark_reference *ref) {
cmark_mem *mem = map->mem;
if (ref != NULL) {
mem->free(ref->label);
mem->free(ref->url);
mem->free(ref->title);
mem->free(ref);
mem->free(mem->ctx, ref->label);
mem->free(mem->ctx, ref->url);
mem->free(mem->ctx, ref->title);
mem->free(mem->ctx, ref);
}
}
@ -37,7 +37,7 @@ static unsigned char *normalize_reference(cmark_mem *mem, cmark_chunk *ref) {
assert(result);
if (result[0] == '\0') {
mem->free(result);
mem->free(mem->ctx, result);
return NULL;
}
@ -55,7 +55,7 @@ void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label,
assert(map->sorted == NULL);
ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref));
ref = (cmark_reference *)map->mem->calloc(map->mem->ctx, 1, sizeof(*ref));
ref->label = reflabel;
ref->url = cmark_clean_url(map->mem, url);
ref->title = cmark_clean_title(map->mem, title);
@ -94,7 +94,7 @@ static void sort_references(cmark_reference_map *map) {
unsigned int i = 0, last = 0, size = map->size;
cmark_reference *r = map->refs, **sorted = NULL;
sorted = (cmark_reference **)map->mem->calloc(size, sizeof(cmark_reference *));
sorted = (cmark_reference **)map->mem->calloc(map->mem->ctx, size, sizeof(cmark_reference *));
while (r) {
sorted[i++] = r;
r = r->next;
@ -133,7 +133,7 @@ cmark_reference *cmark_reference_lookup(cmark_reference_map *map,
ref = (cmark_reference **)bsearch(norm, map->sorted, map->size, sizeof(cmark_reference *),
refsearch);
map->mem->free(norm);
map->mem->free(map->mem->ctx, norm);
if (ref != NULL) {
r = ref[0];
@ -159,13 +159,13 @@ void cmark_reference_map_free(cmark_reference_map *map) {
ref = next;
}
map->mem->free(map->sorted);
map->mem->free(map);
map->mem->free(map->mem->ctx, map->sorted);
map->mem->free(map->mem->ctx, map);
}
cmark_reference_map *cmark_reference_map_new(cmark_mem *mem) {
cmark_reference_map *map =
(cmark_reference_map *)mem->calloc(1, sizeof(cmark_reference_map));
(cmark_reference_map *)mem->calloc(mem->ctx, 1, sizeof(cmark_reference_map));
map->mem = mem;
return map;
}

4
deps/cmark/src/render.c vendored
View File

@ -116,7 +116,7 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap,
bufsize_t remainder_len = renderer->buffer->size -
renderer->last_breakable - 1;
unsigned char *remainder =
(unsigned char *)renderer->mem->realloc(NULL, remainder_len);
(unsigned char *)renderer->mem->realloc(renderer->mem->ctx, NULL, remainder_len);
memcpy(remainder, src, remainder_len);
// truncate at last_breakable
cmark_strbuf_truncate(renderer->buffer, renderer->last_breakable);
@ -126,7 +126,7 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap,
renderer->prefix->size);
cmark_strbuf_put(renderer->buffer, remainder, remainder_len);
renderer->column = renderer->prefix->size + remainder_len;
renderer->mem->free(remainder);
renderer->mem->free(renderer->mem->ctx, remainder);
renderer->last_breakable = 0;
renderer->begin_line = false;
renderer->begin_content = false;