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);
}
}
int md_process(cmark_node *const node) {
assert(node);
cmark_iter *iter = cmark_iter_new(node);
assert(iter);
// Due to the way cmark_iter_reset works, we're missing
// the first event each time. But that's fine.
cmark_iter_reset(iter, node, CMARK_EVENT_ENTER);
md_escape(iter);
cmark_iter_reset(iter, node, CMARK_EVENT_ENTER);
md_escape_inline(iter);
cmark_iter_reset(iter, node, CMARK_EVENT_ENTER);
md_autolink(iter);
cmark_iter_reset(iter, node, CMARK_EVENT_ENTER);
md_block_external_images(iter);
cmark_iter_reset(iter, node, CMARK_EVENT_ENTER);
md_convert_hashes(iter);
cmark_iter_free(iter); iter = NULL;
return 0;
}
char*
cmark_render(cmark_node *root,
int options,
int width,
void (*outc)(cmark_renderer*,
cmark_escaping,
int32_t,
unsigned char),
int (*render_node)(cmark_renderer *renderer,
cmark_node *node,
cmark_event_type ev_type,
int options))
{
cmark_strbuf pref = GH_BUF_INIT;
cmark_strbuf buf = GH_BUF_INIT;
cmark_node *cur;
cmark_event_type ev_type;
char *result;
cmark_iter *iter = cmark_iter_new(root);
cmark_renderer renderer = { &buf, &pref, 0, width,
0, 0, true, false, false,
outc, S_cr, S_blankline, S_out
};
while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
cur = cmark_iter_get_node(iter);
if (!render_node(&renderer, cur, ev_type, options)) {
// a false value causes us to skip processing
// the node's contents. this is used for
// autolinks.
cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT);
}
}
// ensure final newline
if (renderer.buffer->ptr[renderer.buffer->size - 1] != '\n') {
cmark_strbuf_putc(renderer.buffer, '\n');
}
result = (char *)cmark_strbuf_detach(renderer.buffer);
cmark_iter_free(iter);
cmark_strbuf_free(renderer.prefix);
cmark_strbuf_free(renderer.buffer);
return result;
}
// Convert a single node.
static char*
S_node_to_pod(cmark_node *node, CFCClass *klass, int header_level) {
char *result = CFCUtil_strdup("");
if (node == NULL) {
return result;
}
int found_matching_code_block = false;
cmark_iter *iter = cmark_iter_new(node);
cmark_event_type ev_type;
while (CMARK_EVENT_DONE != (ev_type = cmark_iter_next(iter))) {
cmark_node *node = cmark_iter_get_node(iter);
cmark_node_type type = cmark_node_get_type(node);
switch (type) {
case CMARK_NODE_DOCUMENT:
break;
case CMARK_NODE_PARAGRAPH:
if (ev_type == CMARK_EVENT_EXIT) {
result = CFCUtil_cat(result, "\n\n", NULL);
}
break;
case CMARK_NODE_BLOCK_QUOTE:
case CMARK_NODE_LIST:
if (ev_type == CMARK_EVENT_ENTER) {
result = CFCUtil_cat(result, "=over\n\n", NULL);
}
else {
result = CFCUtil_cat(result, "=back\n\n", NULL);
}
break;
case CMARK_NODE_ITEM:
// TODO: Ordered lists.
if (ev_type == CMARK_EVENT_ENTER) {
result = CFCUtil_cat(result, "=item *\n\n", NULL);
}
break;
case CMARK_NODE_HEADER:
if (ev_type == CMARK_EVENT_ENTER) {
int extra_level = cmark_node_get_header_level(node) - 1;
char *header = CFCUtil_sprintf("=head%d ",
header_level + extra_level);
result = CFCUtil_cat(result, header, NULL);
FREEMEM(header);
}
else {
result = CFCUtil_cat(result, "\n\n", NULL);
}
break;
case CMARK_NODE_CODE_BLOCK: {
int is_host = CFCMarkdown_code_block_is_host(node, "perl");
if (is_host) {
found_matching_code_block = true;
const char *content = cmark_node_get_literal(node);
char *copy = CFCUtil_strdup(content);
// Chomp trailing newline.
size_t len = strlen(copy);
if (len > 0 && copy[len-1] == '\n') {
copy[len-1] = '\0';
}
char *indented
= CFCUtil_global_replace(copy, "\n", "\n ");
result
= CFCUtil_cat(result, " ", indented, "\n\n", NULL);
FREEMEM(indented);
FREEMEM(copy);
}
if (CFCMarkdown_code_block_is_last(node)) {
if (!found_matching_code_block) {
result = CFCUtil_cat(result,
" Code example for Perl is missing\n\n");
}
else {
// Reset.
found_matching_code_block = false;
}
}
break;
}
case CMARK_NODE_HTML: {
const char *html = cmark_node_get_literal(node);
result = CFCUtil_cat(result, "=begin html\n\n", html,
"\n=end\n\n", NULL);
break;
}
case CMARK_NODE_HRULE:
break;
case CMARK_NODE_TEXT: {
const char *content = cmark_node_get_literal(node);
char *escaped = S_pod_escape(content);
result = CFCUtil_cat(result, escaped, NULL);
FREEMEM(escaped);
break;
}
case CMARK_NODE_LINEBREAK:
// POD doesn't support line breaks. Start a new paragraph.
result = CFCUtil_cat(result, "\n\n", NULL);
break;
case CMARK_NODE_SOFTBREAK:
result = CFCUtil_cat(result, "\n", NULL);
break;
case CMARK_NODE_CODE: {
const char *content = cmark_node_get_literal(node);
char *escaped = S_pod_escape(content);
result = CFCUtil_cat(result, "C<", escaped, ">", NULL);
FREEMEM(escaped);
break;
}
case CMARK_NODE_INLINE_HTML: {
const char *html = cmark_node_get_literal(node);
CFCUtil_warn("Inline HTML not supported in POD: %s", html);
break;
}
case CMARK_NODE_LINK:
if (ev_type == CMARK_EVENT_ENTER) {
char *pod = S_convert_link(node, klass, header_level);
result = CFCUtil_cat(result, pod, NULL);
FREEMEM(pod);
cmark_iter_reset(iter, node, CMARK_EVENT_EXIT);
}
break;
case CMARK_NODE_IMAGE:
CFCUtil_warn("Images not supported in POD");
break;
case CMARK_NODE_STRONG:
if (ev_type == CMARK_EVENT_ENTER) {
result = CFCUtil_cat(result, "B<", NULL);
}
else {
result = CFCUtil_cat(result, ">", NULL);
}
break;
case CMARK_NODE_EMPH:
if (ev_type == CMARK_EVENT_ENTER) {
result = CFCUtil_cat(result, "I<", NULL);
}
else {
result = CFCUtil_cat(result, ">", NULL);
}
break;
default:
CFCUtil_die("Invalid cmark node type: %d", (int)type);
break;
}
}
cmark_iter_free(iter);
return result;
}