static void md_block_external_images(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);
if(CMARK_NODE_IMAGE != cmark_node_get_type(node)) continue;
char const *const URI = cmark_node_get_url(node);
if(URI) {
if(0 == strncasecmp(URI, STR_LEN("hash:"))) continue;
if(0 == strncasecmp(URI, STR_LEN("data:"))) continue;
}
cmark_node *link = cmark_node_new(CMARK_NODE_LINK);
cmark_node *text = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_url(link, URI);
for(;;) {
cmark_node *child = cmark_node_first_child(node);
if(!child) break;
cmark_node_append_child(link, child);
}
if(cmark_node_first_child(link)) {
cmark_node_set_literal(text, " (external image)");
} else {
cmark_node_set_literal(text, "(external image)");
}
cmark_node_append_child(link, text);
cmark_node_insert_before(node, link);
cmark_node_free(node);
}
}
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 cmark_node *symbol_link_match(cmark_syntax_extension *self,
cmark_parser *parser,
cmark_node *parent,
cmark_inline_parser *inline_parser) {
cmark_node *link;
char *symbol_name;
if (cmark_inline_parser_get_offset(inline_parser) > 0) {
char prev_char = cmark_inline_parser_peek_at(
inline_parser,
cmark_inline_parser_get_offset(inline_parser) - 1);
if (prev_char && prev_char != ' ' && prev_char != '\t' && prev_char != '\n')
return NULL;
}
cmark_inline_parser_advance_offset(inline_parser);
symbol_name = cmark_inline_parser_take_while(inline_parser,
(CMarkInlinePredicate) is_valid_symbol_name);
if (!symbol_name)
return NULL;
link = cmark_node_new(CMARK_NODE_LINK);
cmark_node_set_url(link, symbol_name);
free(symbol_name);
return link;
}
static void md_autolink(cmark_iter *const iter) {
regex_t linkify[1];
// <http://daringfireball.net/2010/07/improved_regex_for_matching_urls>
// Painstakingly ported to POSIX
int rc = regcomp(linkify, "([a-z][a-z0-9_-]+:(/{1,3}|[a-z0-9%])|www[0-9]{0,3}[.]|[a-z0-9.-]+[.][a-z]{2,4}/)([^[:space:]()<>]+|\\(([^[:space:]()<>]+|(\\([^[:space:]()<>]+\\)))*\\))+(\\(([^[:space:]()<>]+|(\\([^[:space:]()<>]+\\)))*\\)|[^][[:space:]`!(){};:'\".,<>?«»“”‘’])", REG_ICASE | REG_EXTENDED);
assert(0 == rc);
for(;;) {
cmark_event_type const event = cmark_iter_next(iter);
if(CMARK_EVENT_DONE == event) break;
if(CMARK_EVENT_ENTER != event) continue;
cmark_node *const node = cmark_iter_get_node(iter);
if(CMARK_NODE_TEXT != cmark_node_get_type(node)) continue;
char const *const str = cmark_node_get_literal(node);
char const *pos = str;
regmatch_t match;
while(0 == regexec(linkify, pos, 1, &match, 0)) {
regoff_t const loc = match.rm_so;
regoff_t const len = match.rm_eo - match.rm_so;
char *pfx = strndup(pos, loc);
char *link_abs = strndup(pos+loc, len);
char *link_rel = aasprintf("/history/%s", link_abs);
assert(pfx);
assert(link_abs);
assert(link_rel);
cmark_node *text = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(text, pfx);
cmark_node *link = cmark_node_new(CMARK_NODE_LINK);
cmark_node_set_url(link, link_rel);
cmark_node *sup = superscript("^", "", link_abs);
cmark_node *face = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(face, link_abs);
cmark_node_append_child(link, face);
cmark_node_insert_before(node, text);
cmark_node_insert_before(node, link);
cmark_node_insert_before(node, sup);
free(pfx); pfx = NULL;
free(link_abs); link_abs = NULL;
free(link_rel); link_rel = NULL;
pos += loc+len;
}
if(str != pos) {
cmark_node *text = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(text, pos);
cmark_node_insert_before(node, text);
cmark_node_free(node);
}
}
regfree(linkify);
}
static cmark_node *fixup_nodes(cmark_inline_parser *inline_parser,
cmark_node *parent,
int size)
{
int node_text_len;
cmark_node *prev = NULL;
cmark_node *tmp;
int name_size = size;
cmark_strbuf *name;
for (prev = cmark_node_last_child(parent); prev; prev = cmark_node_previous(prev)) {
if (cmark_node_get_type(prev) == CMARK_NODE_TEXT) {
const char *text = cmark_node_get_literal(prev);
node_text_len = strlen(text);
size -= node_text_len;
if (size <= 0) {
if (size < 0) {
char *split_text = my_strndup(text, size * -1);
cmark_node *split = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(split, split_text);
free(split_text);
split_text = my_strndup(text + (size * - 1), node_text_len - size);
cmark_node_set_literal(prev, split_text);
free(split_text);
cmark_node_insert_before(prev, split);
}
break;
}
} else {
return NULL;
}
}
name = cmark_strbuf_new(name_size + 1);
tmp = prev;
while (tmp) {
cmark_node *next = cmark_node_next(tmp);
cmark_strbuf_puts(name, cmark_node_get_literal(tmp));
if (tmp != prev)
cmark_node_free(tmp);
tmp = next;
}
cmark_node_set_type(prev, CMARK_NODE_LINK);
cmark_node_set_url(prev, cmark_strbuf_get(name));
cmark_strbuf_free(name);
return prev;
}
static cmark_node *symbol_link_match(cmark_syntax_extension *self,
cmark_parser *parser,
cmark_node *parent,
cmark_inline_parser *inline_parser) {
cmark_node *link = NULL;
char *symbol_name = NULL;
NamedLink *named_link = NULL;
int start_offset = cmark_inline_parser_get_offset(inline_parser);
ParsingContext context;
context.parser = inline_parser;
context.allow_dashes = 0;
if (start_offset > 0) {
char prev_char = cmark_inline_parser_peek_at(
inline_parser,
start_offset - 1);
if (prev_char && prev_char != ' ' && prev_char != '\t' && prev_char != '\n')
return NULL;
}
cmark_inline_parser_advance_offset(inline_parser);
symbol_name = cmark_inline_parser_take_while(inline_parser,
(CMarkInlinePredicate) is_valid_symbol_name, &context);
if (!symbol_name)
goto done;
named_link = PRIV(self)->link_resolve_func(symbol_name);
if (!named_link || !named_link->ref) {
int actual_line, actual_col;
translate_sourcepos(get_first_parent_block(parent),
start_offset, &actual_line, &actual_col);
cmark_strbuf *message = cmark_strbuf_new(0);
cmark_strbuf_puts(message, "Trying to link to non-existing symbol ‘");
cmark_strbuf_puts(message, symbol_name);
cmark_strbuf_puts(message, "’");
diagnose("gtk-doc-bad-link", cmark_strbuf_get(message), actual_line - 1, actual_col - 1);
cmark_strbuf_free(message);
link = cmark_node_new (CMARK_NODE_TEXT);
cmark_node_set_literal (link, symbol_name);
} else {
link = cmark_node_new(CMARK_NODE_LINK);
}
cmark_node_set_url(link, symbol_name);
done:
free(symbol_name);
free_named_link(named_link);
return link;
}
static cmark_node *superscript(char const *const label, char const *const title, char const *const link) {
cmark_node *node = cmark_node_new(CMARK_NODE_CUSTOM_INLINE);
cmark_node *a = cmark_node_new(CMARK_NODE_LINK);
cmark_node_set_url(a, link);
cmark_node_set_title(a, title);
cmark_node *op = cmark_node_new(CMARK_NODE_INLINE_HTML);
cmark_node_set_literal(op, "<sup>[");
cmark_node *ed = cmark_node_new(CMARK_NODE_INLINE_HTML);
cmark_node_set_literal(ed, "]</sup>");
cmark_node *face = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(face, label);
cmark_node_append_child(a, face);
cmark_node_append_child(node, op);
cmark_node_append_child(node, a);
cmark_node_append_child(node, ed);
return node;
}
static cmark_node *fixup_nodes(cmark_syntax_extension *self,
cmark_parser *parser,
cmark_inline_parser *inline_parser,
cmark_node *parent,
int start_offset,
int size)
{
int node_text_len;
cmark_node *prev = NULL;
cmark_node *tmp;
int name_size = size;
cmark_strbuf *name;
NamedLink *named_link;
for (prev = cmark_node_last_child(parent); prev; prev = cmark_node_previous(prev)) {
if (cmark_node_get_type(prev) == CMARK_NODE_TEXT) {
const char *text = cmark_node_get_literal(prev);
node_text_len = strlen(text);
size -= node_text_len;
if (size <= 0) {
if (size < 0) {
char *split_text = my_strndup(text, size * -1);
cmark_node *split = cmark_node_new(CMARK_NODE_TEXT);
cmark_node_set_literal(split, split_text);
free(split_text);
split_text = my_strndup(text + (size * - 1), node_text_len - size);
cmark_node_set_literal(prev, split_text);
free(split_text);
cmark_node_insert_before(prev, split);
}
break;
}
} else {
return NULL;
}
}
name = cmark_strbuf_new(name_size + 1);
tmp = prev;
while (tmp) {
cmark_node *next = cmark_node_next(tmp);
cmark_strbuf_puts(name, cmark_node_get_literal(tmp));
if (tmp != prev)
cmark_node_free(tmp);
tmp = next;
}
named_link = PRIV(self)->link_resolve_func(cmark_strbuf_get(name));
if (!named_link || !named_link->ref) {
int actual_line, actual_col;
translate_sourcepos(get_first_parent_block(parent),
start_offset, &actual_line, &actual_col);
cmark_strbuf *message = cmark_strbuf_new(0);
cmark_strbuf_puts(message, "Trying to link to non-existing symbol ‘");
cmark_strbuf_puts(message, cmark_strbuf_get(name));
cmark_strbuf_puts(message, "’");
diagnose("gtk-doc-bad-link", cmark_strbuf_get(message), actual_line - 1,
actual_col - 1);
cmark_strbuf_free(message);
cmark_node_set_literal(prev, cmark_strbuf_get(name));
cmark_strbuf_free(name);
return prev;
}
free_named_link(named_link);
cmark_node_set_type(prev, CMARK_NODE_LINK);
cmark_node_set_url(prev, cmark_strbuf_get(name));
cmark_strbuf_free(name);
return prev;
}
static void
accessors(test_batch_runner *runner)
{
static const char markdown[] =
"## Header\n"
"\n"
"* Item 1\n"
"* Item 2\n"
"\n"
"2. Item 1\n"
"\n"
"3. Item 2\n"
"\n"
"\n"
" code\n"
"\n"
"``` lang\n"
"fenced\n"
"```\n"
"\n"
"<div>html</div>\n"
"\n"
"[link](url 'title')\n";
cmark_node *doc = cmark_parse_document(markdown, sizeof(markdown) - 1, CMARK_OPT_DEFAULT);
// Getters
cmark_node *header = cmark_node_first_child(doc);
INT_EQ(runner, cmark_node_get_header_level(header), 2,
"get_header_level");
cmark_node *bullet_list = cmark_node_next(header);
INT_EQ(runner, cmark_node_get_list_type(bullet_list),
CMARK_BULLET_LIST, "get_list_type bullet");
INT_EQ(runner, cmark_node_get_list_tight(bullet_list), 1,
"get_list_tight tight");
cmark_node *ordered_list = cmark_node_next(bullet_list);
INT_EQ(runner, cmark_node_get_list_type(ordered_list),
CMARK_ORDERED_LIST, "get_list_type ordered");
INT_EQ(runner, cmark_node_get_list_delim(ordered_list),
CMARK_PERIOD_DELIM, "get_list_delim ordered");
INT_EQ(runner, cmark_node_get_list_start(ordered_list), 2,
"get_list_start");
INT_EQ(runner, cmark_node_get_list_tight(ordered_list), 0,
"get_list_tight loose");
cmark_node *code = cmark_node_next(ordered_list);
STR_EQ(runner, cmark_node_get_literal(code), "code\n",
"get_literal indented code");
cmark_node *fenced = cmark_node_next(code);
STR_EQ(runner, cmark_node_get_literal(fenced), "fenced\n",
"get_literal fenced code");
STR_EQ(runner, cmark_node_get_fence_info(fenced), "lang",
"get_fence_info");
cmark_node *html = cmark_node_next(fenced);
STR_EQ(runner, cmark_node_get_literal(html),
"<div>html</div>\n", "get_literal html");
cmark_node *paragraph = cmark_node_next(html);
INT_EQ(runner, cmark_node_get_start_line(paragraph), 19,
"get_start_line");
INT_EQ(runner, cmark_node_get_start_column(paragraph), 1,
"get_start_column");
INT_EQ(runner, cmark_node_get_end_line(paragraph), 19,
"get_end_line");
cmark_node *link = cmark_node_first_child(paragraph);
STR_EQ(runner, cmark_node_get_url(link), "url",
"get_url");
STR_EQ(runner, cmark_node_get_title(link), "title",
"get_title");
cmark_node *string = cmark_node_first_child(link);
STR_EQ(runner, cmark_node_get_literal(string), "link",
"get_literal string");
// Setters
OK(runner, cmark_node_set_header_level(header, 3),
"set_header_level");
OK(runner, cmark_node_set_list_type(bullet_list, CMARK_ORDERED_LIST),
"set_list_type ordered");
OK(runner, cmark_node_set_list_delim(bullet_list, CMARK_PAREN_DELIM),
"set_list_delim paren");
OK(runner, cmark_node_set_list_start(bullet_list, 3),
"set_list_start");
OK(runner, cmark_node_set_list_tight(bullet_list, 0),
"set_list_tight loose");
OK(runner, cmark_node_set_list_type(ordered_list, CMARK_BULLET_LIST),
"set_list_type bullet");
OK(runner, cmark_node_set_list_tight(ordered_list, 1),
"set_list_tight tight");
OK(runner, cmark_node_set_literal(code, "CODE\n"),
"set_literal indented code");
OK(runner, cmark_node_set_literal(fenced, "FENCED\n"),
"set_literal fenced code");
OK(runner, cmark_node_set_fence_info(fenced, "LANG"),
"set_fence_info");
OK(runner, cmark_node_set_literal(html, "<div>HTML</div>\n"),
"set_literal html");
OK(runner, cmark_node_set_url(link, "URL"),
"set_url");
OK(runner, cmark_node_set_title(link, "TITLE"),
"set_title");
OK(runner, cmark_node_set_literal(string, "LINK"),
"set_literal string");
char *rendered_html = cmark_render_html(doc, CMARK_OPT_DEFAULT);
static const char expected_html[] =
"<h3>Header</h3>\n"
"<ol start=\"3\">\n"
"<li>\n"
"<p>Item 1</p>\n"
"</li>\n"
"<li>\n"
"<p>Item 2</p>\n"
"</li>\n"
"</ol>\n"
"<ul>\n"
"<li>Item 1</li>\n"
"<li>Item 2</li>\n"
"</ul>\n"
"<pre><code>CODE\n"
"</code></pre>\n"
"<pre><code class=\"language-LANG\">FENCED\n"
"</code></pre>\n"
"<div>HTML</div>\n"
"<p><a href=\"URL\" title=\"TITLE\">LINK</a></p>\n";
STR_EQ(runner, rendered_html, expected_html, "setters work");
free(rendered_html);
// Getter errors
INT_EQ(runner, cmark_node_get_header_level(bullet_list), 0,
"get_header_level error");
INT_EQ(runner, cmark_node_get_list_type(header), CMARK_NO_LIST,
"get_list_type error");
INT_EQ(runner, cmark_node_get_list_start(code), 0,
"get_list_start error");
INT_EQ(runner, cmark_node_get_list_tight(fenced), 0,
"get_list_tight error");
OK(runner, cmark_node_get_literal(ordered_list) == NULL,
"get_literal error");
OK(runner, cmark_node_get_fence_info(paragraph) == NULL,
"get_fence_info error");
OK(runner, cmark_node_get_url(html) == NULL,
"get_url error");
OK(runner, cmark_node_get_title(header) == NULL,
"get_title error");
// Setter errors
OK(runner, !cmark_node_set_header_level(bullet_list, 3),
"set_header_level error");
OK(runner, !cmark_node_set_list_type(header, CMARK_ORDERED_LIST),
"set_list_type error");
OK(runner, !cmark_node_set_list_start(code, 3),
"set_list_start error");
OK(runner, !cmark_node_set_list_tight(fenced, 0),
"set_list_tight error");
OK(runner, !cmark_node_set_literal(ordered_list, "content\n"),
"set_literal error");
OK(runner, !cmark_node_set_fence_info(paragraph, "lang"),
"set_fence_info error");
OK(runner, !cmark_node_set_url(html, "url"),
"set_url error");
OK(runner, !cmark_node_set_title(header, "title"),
"set_title error");
OK(runner, !cmark_node_set_header_level(header, 0),
"set_header_level too small");
OK(runner, !cmark_node_set_header_level(header, 7),
"set_header_level too large");
OK(runner, !cmark_node_set_list_type(bullet_list, CMARK_NO_LIST),
"set_list_type invalid");
OK(runner, !cmark_node_set_list_start(bullet_list, -1),
"set_list_start negative");
cmark_node_free(doc);
}
