static void md_convert_hashes(cmark_iter *const iter) {
for(;;) {
cmark_event_type const event = cmark_iter_next(iter);
if(CMARK_EVENT_DONE == event) break;
if(CMARK_EVENT_EXIT != event) continue;
cmark_node *const node = cmark_iter_get_node(iter);
cmark_node_type const type = cmark_node_get_type(node);
if(CMARK_NODE_LINK != type && CMARK_NODE_IMAGE != type) continue;
char const *const URI = cmark_node_get_url(node);
if(!URI) continue;
if(0 != strncasecmp(URI, STR_LEN("hash:"))) continue;
cmark_node *sup = superscript("#", HASH_INFO_MSG, URI);
cmark_node_insert_after(node, sup);
cmark_iter_reset(iter, sup, CMARK_EVENT_EXIT);
char *escaped = QSEscape(URI, strlen(URI), true);
size_t const elen = strlen(escaped);
cmark_strbuf rel[1];
char const qpfx[] = "/sources/";
cmark_strbuf_init(&DEFAULT_MEM_ALLOCATOR, rel, sizeof(qpfx)-1+elen);
cmark_strbuf_put(rel, (unsigned char const *)qpfx, sizeof(qpfx)-1);
cmark_strbuf_put(rel, (unsigned char const *)escaped, elen);
free(escaped); escaped = NULL;
cmark_node_set_url(node, cmark_strbuf_cstr(rel));
cmark_strbuf_free(rel);
}
}
static delimiter *S_insert_emph(subject *subj, delimiter *opener,
delimiter *closer) {
delimiter *delim, *tmp_delim;
bufsize_t use_delims;
cmark_node *opener_inl = opener->inl_text;
cmark_node *closer_inl = closer->inl_text;
bufsize_t opener_num_chars = opener_inl->as.literal.len;
bufsize_t closer_num_chars = closer_inl->as.literal.len;
cmark_node *tmp, *tmpnext, *emph;
// calculate the actual number of characters used from this closer
use_delims = (closer_num_chars >= 2 && opener_num_chars >=2) ? 2 : 1;
// remove used characters from associated inlines.
opener_num_chars -= use_delims;
closer_num_chars -= use_delims;
opener_inl->as.literal.len = opener_num_chars;
closer_inl->as.literal.len = closer_num_chars;
// free delimiters between opener and closer
delim = closer->previous;
while (delim != NULL && delim != opener) {
tmp_delim = delim->previous;
remove_delimiter(subj, delim);
delim = tmp_delim;
}
// create new emph or strong, and splice it in to our inlines
// between the opener and closer
emph = use_delims == 1 ? make_emph(subj->mem) : make_strong(subj->mem);
tmp = opener_inl->next;
while (tmp && tmp != closer_inl) {
tmpnext = tmp->next;
cmark_node_append_child(emph, tmp);
tmp = tmpnext;
}
cmark_node_insert_after(opener_inl, emph);
// if opener has 0 characters, remove it and its associated inline
if (opener_num_chars == 0) {
cmark_node_free(opener_inl);
remove_delimiter(subj, opener);
}
// if closer has 0 characters, remove it and its associated inline
if (closer_num_chars == 0) {
// remove empty closer inline
cmark_node_free(closer_inl);
// remove closer from list
tmp_delim = closer->next;
remove_delimiter(subj, closer);
closer = tmp_delim;
}
return closer;
}
static void postprocess_text(cmark_parser *parser, cmark_node *text, int offset) {
size_t link_end;
uint8_t *data = text->as.literal.data,
*at;
size_t size = text->as.literal.len;
int rewind, max_rewind,
nb = 0, np = 0, ns = 0;
if (offset < 0 || (size_t)offset >= size)
return;
data += offset;
size -= offset;
at = (uint8_t *)memchr(data, '@', size);
if (!at)
return;
max_rewind = (int)(at - data);
data += max_rewind;
size -= max_rewind;
for (rewind = 0; rewind < max_rewind; ++rewind) {
uint8_t c = data[-rewind - 1];
if (cmark_isalnum(c))
continue;
if (strchr(".+-_", c) != NULL)
continue;
if (c == '/')
ns++;
break;
}
if (rewind == 0 || ns > 0) {
postprocess_text(parser, text, max_rewind + 1 + offset);
return;
}
for (link_end = 0; link_end < size; ++link_end) {
uint8_t c = data[link_end];
if (cmark_isalnum(c))
continue;
if (c == '@')
nb++;
else if (c == '.' && link_end < size - 1 && cmark_isalnum(data[link_end + 1]))
np++;
else if (c != '-' && c != '_')
break;
}
if (link_end < 2 || nb != 1 || np == 0 ||
(!cmark_isalpha(data[link_end - 1]) && data[link_end - 1] != '.')) {
postprocess_text(parser, text, max_rewind + 1 + offset);
return;
}
link_end = autolink_delim(data, link_end);
if (link_end == 0) {
postprocess_text(parser, text, max_rewind + 1 + offset);
return;
}
cmark_chunk_to_cstr(parser->mem, &text->as.literal);
cmark_node *link_node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
cmark_strbuf buf;
cmark_strbuf_init(parser->mem, &buf, 10);
cmark_strbuf_puts(&buf, "mailto:");
cmark_strbuf_put(&buf, data - rewind, (bufsize_t)(link_end + rewind));
link_node->as.link.url = cmark_chunk_buf_detach(&buf);
cmark_node *link_text = cmark_node_new_with_mem(CMARK_NODE_TEXT, parser->mem);
cmark_chunk email = cmark_chunk_dup(
&text->as.literal,
offset + max_rewind - rewind,
(bufsize_t)(link_end + rewind));
cmark_chunk_to_cstr(parser->mem, &email);
link_text->as.literal = email;
cmark_node_append_child(link_node, link_text);
cmark_node_insert_after(text, link_node);
cmark_node *post = cmark_node_new_with_mem(CMARK_NODE_TEXT, parser->mem);
post->as.literal = cmark_chunk_dup(&text->as.literal,
(bufsize_t)(offset + max_rewind + link_end),
(bufsize_t)(size - link_end));
cmark_chunk_to_cstr(parser->mem, &post->as.literal);
cmark_node_insert_after(link_node, post);
text->as.literal.len = offset + max_rewind - rewind;
text->as.literal.data[text->as.literal.len] = 0;
postprocess_text(parser, post, 0);
}
static void
create_tree(test_batch_runner *runner)
{
char *html;
cmark_node *doc = cmark_node_new(CMARK_NODE_DOCUMENT);
cmark_node *p = cmark_node_new(CMARK_NODE_PARAGRAPH);
OK(runner, !cmark_node_insert_before(doc, p),
"insert before root fails");
OK(runner, !cmark_node_insert_after(doc, p),
"insert after root fails");
OK(runner, cmark_node_append_child(doc, p), "append1");
INT_EQ(runner, cmark_node_check(doc, NULL), 0, "append1 consistent");
OK(runner, cmark_node_parent(p) == doc, "node_parent");
cmark_node *emph = cmark_node_new(CMARK_NODE_EMPH);
OK(runner, cmark_node_prepend_child(p, emph), "prepend1");
INT_EQ(runner, cmark_node_check(doc, NULL), 0, "prepend1 consistent");
cmark_node *str1 = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(str1, "Hello, ");
OK(runner, cmark_node_prepend_child(p, str1), "prepend2");
INT_EQ(runner, cmark_node_check(doc, NULL), 0, "prepend2 consistent");
cmark_node *str3 = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(str3, "!");
OK(runner, cmark_node_append_child(p, str3), "append2");
INT_EQ(runner, cmark_node_check(doc, NULL), 0, "append2 consistent");
cmark_node *str2 = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(str2, "world");
OK(runner, cmark_node_append_child(emph, str2), "append3");
INT_EQ(runner, cmark_node_check(doc, NULL), 0, "append3 consistent");
html = cmark_render_html(doc, CMARK_OPT_DEFAULT);
STR_EQ(runner, html, "<p>Hello, <em>world</em>!</p>\n",
"render_html");
free(html);
OK(runner, cmark_node_insert_before(str1, str3), "ins before1");
INT_EQ(runner, cmark_node_check(doc, NULL), 0,
"ins before1 consistent");
// 31e
OK(runner, cmark_node_first_child(p) == str3, "ins before1 works");
OK(runner, cmark_node_insert_before(str1, emph), "ins before2");
INT_EQ(runner, cmark_node_check(doc, NULL), 0,
"ins before2 consistent");
// 3e1
OK(runner, cmark_node_last_child(p) == str1, "ins before2 works");
OK(runner, cmark_node_insert_after(str1, str3), "ins after1");
INT_EQ(runner, cmark_node_check(doc, NULL), 0,
"ins after1 consistent");
// e13
OK(runner, cmark_node_next(str1) == str3, "ins after1 works");
OK(runner, cmark_node_insert_after(str1, emph), "ins after2");
INT_EQ(runner, cmark_node_check(doc, NULL), 0,
"ins after2 consistent");
// 1e3
OK(runner, cmark_node_previous(emph) == str1, "ins after2 works");
cmark_node_unlink(emph);
html = cmark_render_html(doc, CMARK_OPT_DEFAULT);
STR_EQ(runner, html, "<p>Hello, !</p>\n",
"render_html after shuffling");
free(html);
cmark_node_free(doc);
// TODO: Test that the contents of an unlinked inline are valid
// after the parent block was destroyed. This doesn't work so far.
cmark_node_free(emph);
}
