summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/commonmark.c180
-rw-r--r--src/latex.c278
-rw-r--r--src/render.c112
-rw-r--r--src/render.h18
4 files changed, 294 insertions, 294 deletions
diff --git a/src/commonmark.c b/src/commonmark.c
index c6a13e8..5bbc8d4 100644
--- a/src/commonmark.c
+++ b/src/commonmark.c
@@ -14,7 +14,7 @@
// Functions to convert cmark_nodes to commonmark strings.
-static inline void outc(cmark_render_state *state,
+static inline void outc(cmark_renderer *renderer,
cmark_escaping escape,
int32_t c,
unsigned char nextc)
@@ -27,10 +27,10 @@ static inline void outc(cmark_render_state *state,
c == '<' || c == '>' || c == '\\' || c == '`' ||
(c == '&' && isalpha(nextc)) ||
(c == '!' && nextc == '[') ||
- (state->begin_line &&
+ (renderer->begin_line &&
(c == '-' || c == '+' || c == '#' || c == '=')) ||
((c == '.' || c == ')') &&
- isdigit(state->buffer->ptr[state->buffer->size - 1])))) ||
+ isdigit(renderer->buffer->ptr[renderer->buffer->size - 1])))) ||
(escape == URL &&
(c == '`' || c == '<' || c == '>' || isspace(c) ||
c == '\\' || c == ')' || c == '(')) ||
@@ -41,18 +41,18 @@ static inline void outc(cmark_render_state *state,
if (needs_escaping) {
if (isspace(c)) {
// use percent encoding for spaces
- cmark_strbuf_printf(state->buffer, "%%%2x", c);
- state->column += 3;
+ cmark_strbuf_printf(renderer->buffer, "%%%2x", c);
+ renderer->column += 3;
} else {
- cmark_strbuf_putc(state->buffer, '\\');
- utf8proc_encode_char(c, state->buffer);
- state->column += 2;
+ cmark_strbuf_putc(renderer->buffer, '\\');
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 2;
}
- state->begin_line = false;
+ renderer->begin_line = false;
} else {
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
- state->begin_line = false;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
+ renderer->begin_line = false;
}
}
@@ -156,7 +156,7 @@ get_containing_block(cmark_node *node)
static int
S_render_node(cmark_node *node, cmark_event_type ev_type,
- cmark_render_state *state)
+ cmark_renderer *renderer)
{
cmark_node *tmp;
cmark_chunk *code;
@@ -177,7 +177,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL &&
entering)) {
tmp = get_containing_block(node);
- state->in_tight_list_item =
+ renderer->in_tight_list_item =
(tmp->type == CMARK_NODE_ITEM &&
cmark_node_get_list_tight(tmp->parent)) ||
(tmp &&
@@ -189,18 +189,18 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
switch (node->type) {
case CMARK_NODE_DOCUMENT:
if (!entering) {
- cmark_strbuf_putc(state->buffer, '\n');
+ cmark_strbuf_putc(renderer->buffer, '\n');
}
break;
case CMARK_NODE_BLOCK_QUOTE:
if (entering) {
- lit(state, "> ", false);
- cmark_strbuf_puts(state->prefix, "> ");
+ lit(renderer, "> ", false);
+ cmark_strbuf_puts(renderer->prefix, "> ");
} else {
- cmark_strbuf_truncate(state->prefix,
- state->prefix->size - 2);
- blankline(state);
+ cmark_strbuf_truncate(renderer->prefix,
+ renderer->prefix->size - 2);
+ blankline(renderer);
}
break;
@@ -210,8 +210,8 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
node->next->type == CMARK_NODE_LIST)) {
// this ensures 2 blank lines after list,
// if before code block or list:
- lit(state, "\n", false);
- state->need_cr = 0;
+ lit(renderer, "\n", false);
+ renderer->need_cr = 0;
}
break;
@@ -240,19 +240,19 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
if (entering) {
if (cmark_node_get_list_type(node->parent) ==
CMARK_BULLET_LIST) {
- lit(state, "* ", false);
- cmark_strbuf_puts(state->prefix, " ");
+ lit(renderer, "* ", false);
+ cmark_strbuf_puts(renderer->prefix, " ");
} else {
- lit(state, (char *)listmarker.ptr, false);
+ lit(renderer, (char *)listmarker.ptr, false);
for (i = marker_width; i--;) {
- cmark_strbuf_putc(state->prefix, ' ');
+ cmark_strbuf_putc(renderer->prefix, ' ');
}
}
} else {
- cmark_strbuf_truncate(state->prefix,
- state->prefix->size -
+ cmark_strbuf_truncate(renderer->prefix,
+ renderer->prefix->size -
marker_width);
- cr(state);
+ cr(renderer);
}
cmark_strbuf_free(&listmarker);
break;
@@ -260,18 +260,18 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
case CMARK_NODE_HEADER:
if (entering) {
for (int i = cmark_node_get_header_level(node); i > 0; i--) {
- lit(state, "#", false);
+ lit(renderer, "#", false);
}
- lit(state, " ", false);
- state->no_wrap = true;
+ lit(renderer, " ", false);
+ renderer->no_wrap = true;
} else {
- state->no_wrap = false;
- blankline(state);
+ renderer->no_wrap = false;
+ blankline(renderer);
}
break;
case CMARK_NODE_CODE_BLOCK:
- blankline(state);
+ blankline(renderer);
info = &node->as.code.info;
code = &node->as.code.literal;
// use indented form if no info, and code doesn't
@@ -284,65 +284,65 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
isspace(code->data[code->len - 2]))) &&
!(node->prev == NULL && node->parent &&
node->parent->type == CMARK_NODE_ITEM)) {
- lit(state, " ", false);
- cmark_strbuf_puts(state->prefix, " ");
- out(state, node->as.code.literal, false, LITERAL);
- cmark_strbuf_truncate(state->prefix,
- state->prefix->size - 4);
+ lit(renderer, " ", false);
+ cmark_strbuf_puts(renderer->prefix, " ");
+ out(renderer, node->as.code.literal, false, LITERAL);
+ cmark_strbuf_truncate(renderer->prefix,
+ renderer->prefix->size - 4);
} else {
numticks = longest_backtick_sequence(code) + 1;
if (numticks < 3) {
numticks = 3;
}
for (i = 0; i < numticks; i++) {
- lit(state, "`", false);
+ lit(renderer, "`", false);
}
- lit(state, " ", false);
- out(state, *info, false, LITERAL);
- cr(state);
- out(state, node->as.code.literal, false, LITERAL);
- cr(state);
+ lit(renderer, " ", false);
+ out(renderer, *info, false, LITERAL);
+ cr(renderer);
+ out(renderer, node->as.code.literal, false, LITERAL);
+ cr(renderer);
for (i = 0; i < numticks; i++) {
- lit(state, "`", false);
+ lit(renderer, "`", false);
}
}
- blankline(state);
+ blankline(renderer);
break;
case CMARK_NODE_HTML:
- blankline(state);
- out(state, node->as.literal, false, LITERAL);
- blankline(state);
+ blankline(renderer);
+ out(renderer, node->as.literal, false, LITERAL);
+ blankline(renderer);
break;
case CMARK_NODE_HRULE:
- blankline(state);
- lit(state, "-----", false);
- blankline(state);
+ blankline(renderer);
+ lit(renderer, "-----", false);
+ blankline(renderer);
break;
case CMARK_NODE_PARAGRAPH:
if (!entering) {
- blankline(state);
+ blankline(renderer);
}
break;
case CMARK_NODE_TEXT:
- out(state, node->as.literal, true, NORMAL);
+ out(renderer, node->as.literal, true, NORMAL);
break;
case CMARK_NODE_LINEBREAK:
- if (!(CMARK_OPT_HARDBREAKS & state->options)) {
- lit(state, "\\", false);
+ if (!(CMARK_OPT_HARDBREAKS & renderer->options)) {
+ lit(renderer, "\\", false);
}
- cr(state);
+ cr(renderer);
break;
case CMARK_NODE_SOFTBREAK:
- if (state->width == 0) {
- cr(state);
+ if (renderer->width == 0) {
+ cr(renderer);
} else {
- lit(state, " ", true);
+ lit(renderer, " ", true);
}
break;
@@ -350,29 +350,29 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
code = &node->as.literal;
numticks = shortest_unused_backtick_sequence(code);
for (i = 0; i < numticks; i++) {
- lit(state, "`", false);
+ lit(renderer, "`", false);
}
if (code->len == 0 || code->data[0] == '`') {
- lit(state, " ", false);
+ lit(renderer, " ", false);
}
- out(state, node->as.literal, true, LITERAL);
+ out(renderer, node->as.literal, true, LITERAL);
if (code->len == 0 || code->data[code->len - 1] == '`') {
- lit(state, " ", false);
+ lit(renderer, " ", false);
}
for (i = 0; i < numticks; i++) {
- lit(state, "`", false);
+ lit(renderer, "`", false);
}
break;
case CMARK_NODE_INLINE_HTML:
- out(state, node->as.literal, false, LITERAL);
+ out(renderer, node->as.literal, false, LITERAL);
break;
case CMARK_NODE_STRONG:
if (entering) {
- lit(state, "**", false);
+ lit(renderer, "**", false);
} else {
- lit(state, "**", false);
+ lit(renderer, "**", false);
}
break;
@@ -386,62 +386,62 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
emph_delim = "*";
}
if (entering) {
- lit(state, emph_delim, false);
+ lit(renderer, emph_delim, false);
} else {
- lit(state, emph_delim, false);
+ lit(renderer, emph_delim, false);
}
break;
case CMARK_NODE_LINK:
if (is_autolink(node)) {
if (entering) {
- lit(state, "<", false);
+ lit(renderer, "<", false);
if (strncmp(cmark_node_get_url(node),
"mailto:", 7) == 0) {
- lit(state,
+ lit(renderer,
(char *)cmark_node_get_url(node) + 7,
false);
} else {
- lit(state,
+ lit(renderer,
(char *)cmark_node_get_url(node),
false);
}
- lit(state, ">", false);
+ lit(renderer, ">", false);
// return signal to skip contents of node...
return 0;
}
} else {
if (entering) {
- lit(state, "[", false);
+ lit(renderer, "[", false);
} else {
- lit(state, "](", false);
- out(state,
+ lit(renderer, "](", false);
+ out(renderer,
cmark_chunk_literal(cmark_node_get_url(node)),
false, URL);
title = &node->as.link.title;
if (title->len > 0) {
- lit(state, " \"", true);
- out(state, *title, false, TITLE);
- lit(state, "\"", false);
+ lit(renderer, " \"", true);
+ out(renderer, *title, false, TITLE);
+ lit(renderer, "\"", false);
}
- lit(state, ")", false);
+ lit(renderer, ")", false);
}
}
break;
case CMARK_NODE_IMAGE:
if (entering) {
- lit(state, "![", false);
+ lit(renderer, "![", false);
} else {
- lit(state, "](", false);
- out(state, cmark_chunk_literal(cmark_node_get_url(node)), false, URL);
+ lit(renderer, "](", false);
+ out(renderer, cmark_chunk_literal(cmark_node_get_url(node)), false, URL);
title = &node->as.link.title;
if (title->len > 0) {
- lit(state, " \"", true);
- out(state, *title, false, TITLE);
- lit(state, "\"", false);
+ lit(renderer, " \"", true);
+ out(renderer, *title, false, TITLE);
+ lit(renderer, "\"", false);
}
- lit(state, ")", false);
+ lit(renderer, ")", false);
}
break;
diff --git a/src/latex.c b/src/latex.c
index c3d39da..6cca96e 100644
--- a/src/latex.c
+++ b/src/latex.c
@@ -12,14 +12,14 @@
#include "scanners.h"
#include "render.h"
-static inline void outc(cmark_render_state *state,
+static inline void outc(cmark_renderer *renderer,
cmark_escaping escape,
int32_t c,
unsigned char nextc)
{
if (escape == LITERAL) {
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
} else {
switch(c) {
case 123: // '{'
@@ -27,153 +27,153 @@ static inline void outc(cmark_render_state *state,
case 35: // '#'
case 37: // '%'
case 38: // '&'
- cmark_strbuf_putc(state->buffer, '\\');
- utf8proc_encode_char(c, state->buffer);
- state->column += 2;
+ cmark_strbuf_putc(renderer->buffer, '\\');
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 2;
break;
case 36: // '$'
case 95: // '_'
if (escape == NORMAL) {
- cmark_strbuf_putc(state->buffer, '\\');
- state->column += 1;
+ cmark_strbuf_putc(renderer->buffer, '\\');
+ renderer->column += 1;
}
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
break;
case 45 : // '-'
if (nextc == 45) { // prevent ligature
- cmark_strbuf_putc(state->buffer, '\\');
- state->column += 1;
+ cmark_strbuf_putc(renderer->buffer, '\\');
+ renderer->column += 1;
}
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
break;
case 126: // '~'
if (escape == NORMAL) {
- cmark_strbuf_puts(state->buffer,
+ cmark_strbuf_puts(renderer->buffer,
"\\textasciitilde{}");
- state->column += 17;
+ renderer->column += 17;
} else {
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
}
break;
case 94: // '^'
- cmark_strbuf_puts(state->buffer,
+ cmark_strbuf_puts(renderer->buffer,
"\\^{}");
- state->column += 4;
+ renderer->column += 4;
break;
case 92: // '\\'
if (escape == URL) {
// / acts as path sep even on windows:
- cmark_strbuf_puts(state->buffer, "/");
- state->column += 1;
+ cmark_strbuf_puts(renderer->buffer, "/");
+ renderer->column += 1;
} else {
- cmark_strbuf_puts(state->buffer,
+ cmark_strbuf_puts(renderer->buffer,
"\\textbackslash{}");
- state->column += 16;
+ renderer->column += 16;
}
break;
case 124: // '|'
- cmark_strbuf_puts(state->buffer,
+ cmark_strbuf_puts(renderer->buffer,
"\\textbar{}");
- state->column += 10;
+ renderer->column += 10;
break;
case 60: // '<'
- cmark_strbuf_puts(state->buffer,
+ cmark_strbuf_puts(renderer->buffer,
"\\textless{}");
- state->column += 11;
+ renderer->column += 11;
break;
case 62: // '>'
- cmark_strbuf_puts(state->buffer,
+ cmark_strbuf_puts(renderer->buffer,
"\\textgreater{}");
- state->column += 14;
+ renderer->column += 14;
break;
case 91: // '['
case 93: // ']'
- cmark_strbuf_putc(state->buffer, '{');
- utf8proc_encode_char(c, state->buffer);
- cmark_strbuf_putc(state->buffer, '}');
- state->column += 3;
+ cmark_strbuf_putc(renderer->buffer, '{');
+ utf8proc_encode_char(c, renderer->buffer);
+ cmark_strbuf_putc(renderer->buffer, '}');
+ renderer->column += 3;
break;
case 34: // '"'
- cmark_strbuf_puts(state->buffer,
+ cmark_strbuf_puts(renderer->buffer,
"\\textquotedbl{}");
// requires \usepackage[T1]{fontenc}
- state->column += 15;
+ renderer->column += 15;
break;
case 39: // '\''
- cmark_strbuf_puts(state->buffer,
+ cmark_strbuf_puts(renderer->buffer,
"\\textquotesingle{}");
- state->column += 18;
+ renderer->column += 18;
// requires \usepackage{textcomp}
break;
case 160: // nbsp
- cmark_strbuf_putc(state->buffer, '~');
- state->column += 1;
+ cmark_strbuf_putc(renderer->buffer, '~');
+ renderer->column += 1;
break;
case 8230: // hellip
- cmark_strbuf_puts(state->buffer, "\\ldots{}");
- state->column += 8;
+ cmark_strbuf_puts(renderer->buffer, "\\ldots{}");
+ renderer->column += 8;
break;
case 8216: // lsquo
if (escape == NORMAL) {
- cmark_strbuf_putc(state->buffer, '`');
- state->column += 1;
+ cmark_strbuf_putc(renderer->buffer, '`');
+ renderer->column += 1;
} else {
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
}
break;
case 8217: // rsquo
if (escape == NORMAL) {
- cmark_strbuf_putc(state->buffer, '\'');
- state->column += 1;
+ cmark_strbuf_putc(renderer->buffer, '\'');
+ renderer->column += 1;
} else {
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
}
break;
case 8220: // ldquo
if (escape == NORMAL) {
- cmark_strbuf_puts(state->buffer, "``");
- state->column += 2;
+ cmark_strbuf_puts(renderer->buffer, "``");
+ renderer->column += 2;
} else {
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
}
break;
case 8221: // rdquo
if (escape == NORMAL) {
- cmark_strbuf_puts(state->buffer, "''");
- state->column += 2;
+ cmark_strbuf_puts(renderer->buffer, "''");
+ renderer->column += 2;
} else {
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
}
break;
case 8212: // emdash
if (escape == NORMAL) {
- cmark_strbuf_puts(state->buffer, "---");
- state->column += 3;
+ cmark_strbuf_puts(renderer->buffer, "---");
+ renderer->column += 3;
} else {
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
}
break;
case 8211: // endash
if (escape == NORMAL) {
- cmark_strbuf_puts(state->buffer, "--");
- state->column += 2;
+ cmark_strbuf_puts(renderer->buffer, "--");
+ renderer->column += 2;
} else {
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
}
break;
default:
- utf8proc_encode_char(c, state->buffer);
- state->column += 1;
- state->begin_line = false;
+ utf8proc_encode_char(c, renderer->buffer);
+ renderer->column += 1;
+ renderer->begin_line = false;
}
}
}
@@ -248,7 +248,7 @@ get_containing_block(cmark_node *node)
static int
S_render_node(cmark_node *node, cmark_event_type ev_type,
- cmark_render_state *state)
+ cmark_renderer *renderer)
{
cmark_node *tmp;
int list_number;
@@ -266,7 +266,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL &&
entering)) {
tmp = get_containing_block(node);
- state->in_tight_list_item =
+ renderer->in_tight_list_item =
(tmp->type == CMARK_NODE_ITEM &&
cmark_node_get_list_tight(tmp->parent)) ||
(tmp &&
@@ -278,17 +278,17 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
switch (node->type) {
case CMARK_NODE_DOCUMENT:
if (!entering) {
- cmark_strbuf_putc(state->buffer, '\n');
+ cmark_strbuf_putc(renderer->buffer, '\n');
}
break;
case CMARK_NODE_BLOCK_QUOTE:
if (entering) {
- lit(state, "\\begin{quote}", false);
- cr(state);
+ lit(renderer, "\\begin{quote}", false);
+ cr(renderer);
} else {
- lit(state, "\\end{quote}", false);
- blankline(state);
+ lit(renderer, "\\end{quote}", false);
+ blankline(renderer);
}
break;
@@ -296,46 +296,46 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
list_type = cmark_node_get_list_type(node);
if (entering) {
if (list_type == CMARK_ORDERED_LIST) {
- state->enumlevel++;
+ renderer->enumlevel++;
}
- lit(state, "\\begin{", false);
- lit(state,
+ lit(renderer, "\\begin{", false);
+ lit(renderer,
list_type == CMARK_ORDERED_LIST ?
"enumerate" : "itemize", false);
- lit(state, "}", false);
- cr(state);
+ lit(renderer, "}", false);
+ cr(renderer);
list_number = cmark_node_get_list_start(node);
if (list_number > 1) {
sprintf(list_number_string,
"%d", list_number);
- lit(state, "\\setcounter{enum", false);
- lit(state, (char *)roman_numerals[state->enumlevel],
+ lit(renderer, "\\setcounter{enum", false);
+ lit(renderer, (char *)roman_numerals[renderer->enumlevel],
false);
- lit(state, "}{", false);
- out(state,
+ lit(renderer, "}{", false);
+ out(renderer,
cmark_chunk_literal(list_number_string),
false, NORMAL);
- lit(state, "}", false);
- cr(state);
+ lit(renderer, "}", false);
+ cr(renderer);
}
} else {
if (list_type == CMARK_ORDERED_LIST) {
- state->enumlevel--;
+ renderer->enumlevel--;
}
- lit(state, "\\end{", false);
- lit(state,
+ lit(renderer, "\\end{", false);
+ lit(renderer,
list_type == CMARK_ORDERED_LIST ?
"enumerate" : "itemize", false);
- lit(state, "}", false);
- blankline(state);
+ lit(renderer, "}", false);
+ blankline(renderer);
}
break;
case CMARK_NODE_ITEM:
if (entering) {
- lit(state, "\\item ", false);
+ lit(renderer, "\\item ", false);
} else {
- cr(state);
+ cr(renderer);
}
break;
@@ -343,74 +343,74 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
if (entering) {
switch (cmark_node_get_header_level(node)) {
case 1:
- lit(state, "\\section", false);
+ lit(renderer, "\\section", false);
break;
case 2:
- lit(state, "\\subsection", false);
+ lit(renderer, "\\subsection", false);
break;
case 3:
- lit(state, "\\subsubsection", false);
+ lit(renderer, "\\subsubsection", false);
break;
case 4:
- lit(state, "\\paragraph", false);
+ lit(renderer, "\\paragraph", false);
break;
case 5:
- lit(state, "\\subparagraph", false);
+ lit(renderer, "\\subparagraph", false);
break;
}
- lit(state, "{", false);
+ lit(renderer, "{", false);
} else {
- lit(state, "}", false);
- blankline(state);
+ lit(renderer, "}", false);
+ blankline(renderer);
}
break;
case CMARK_NODE_CODE_BLOCK:
- cr(state);
- lit(state, "\\begin{verbatim}", false);
- cr(state);
- out(state, node->as.code.literal, false, LITERAL);
- cr(state);
- lit(state, "\\end{verbatim}", false);
- blankline(state);
+ cr(renderer);
+ lit(renderer, "\\begin{verbatim}", false);
+ cr(renderer);
+ out(renderer, node->as.code.literal, false, LITERAL);
+ cr(renderer);
+ lit(renderer, "\\end{verbatim}", false);
+ blankline(renderer);
break;
case CMARK_NODE_HTML:
break;
case CMARK_NODE_HRULE:
- blankline(state);
- lit(state, "\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}", false);
- blankline(state);
+ blankline(renderer);
+ lit(renderer, "\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}", false);
+ blankline(renderer);
break;
case CMARK_NODE_PARAGRAPH:
if (!entering) {
- blankline(state);
+ blankline(renderer);
}
break;
case CMARK_NODE_TEXT:
- out(state, node->as.literal, true, NORMAL);
+ out(renderer, node->as.literal, true, NORMAL);
break;
case CMARK_NODE_LINEBREAK:
- lit(state, "\\\\", false);
- cr(state);
+ lit(renderer, "\\\\", false);
+ cr(renderer);
break;
case CMARK_NODE_SOFTBREAK:
- if (state->width == 0) {
- cr(state);
+ if (renderer->width == 0) {
+ cr(renderer);
} else {
- lit(state, " ", true);
+ lit(renderer, " ", true);
}
break;
case CMARK_NODE_CODE:
- lit(state, "\\texttt{", false);
- out(state, node->as.literal, false, NORMAL);
- lit(state, "}", false);
+ lit(renderer, "\\texttt{", false);
+ out(renderer, node->as.literal, false, NORMAL);
+ lit(renderer, "}", false);
break;
case CMARK_NODE_INLINE_HTML:
@@ -418,17 +418,17 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
case CMARK_NODE_STRONG:
if (entering) {
- lit(state, "\\textbf{", false);
+ lit(renderer, "\\textbf{", false);
} else {
- lit(state, "}", false);
+ lit(renderer, "}", false);
}
break;
case CMARK_NODE_EMPH:
if (entering) {
- lit(state, "\\emph{", false);
+ lit(renderer, "\\emph{", false);
} else {
- lit(state, "}", false);
+ lit(renderer, "}", false);
}
break;
@@ -438,24 +438,24 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
// requires \usepackage{hyperref}
switch(get_link_type(node)) {
case URL_AUTOLINK:
- lit(state, "\\url{", false);
- out(state, url, false, URL);
+ lit(renderer, "\\url{", false);
+ out(renderer, url, false, URL);
break;
case EMAIL_AUTOLINK:
- lit(state, "\\href{", false);
- out(state, url, false, URL);
- lit(state, "}\\nolinkurl{", false);
+ lit(renderer, "\\href{", false);
+ out(renderer, url, false, URL);
+ lit(renderer, "}\\nolinkurl{", false);
break;
case NORMAL_LINK:
- lit(state, "\\href{", false);
- out(state, url, false, URL);
- lit(state, "}{", false);
+ lit(renderer, "\\href{", false);
+ out(renderer, url, false, URL);
+ lit(renderer, "}{", false);
break;
case NO_LINK:
- lit(state, "{", false); // error?
+ lit(renderer, "{", false); // error?
}
} else {
- lit(state, "}", false);
+ lit(renderer, "}", false);
}
break;
@@ -463,10 +463,10 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
case CMARK_NODE_IMAGE:
if (entering) {
url = cmark_chunk_literal(cmark_node_get_url(node));
- lit(state, "\\protect\\includegraphics{", false);
+ lit(renderer, "\\protect\\includegraphics{", false);
// requires \include{graphicx}
- out(state, url, false, URL);
- lit(state, "}", false);
+ out(renderer, url, false, URL);
+ lit(renderer, "}", false);
return 0;
}
break;
diff --git a/src/render.c b/src/render.c
index f4c56ac..442a7fc 100644
--- a/src/render.c
+++ b/src/render.c
@@ -5,21 +5,21 @@
#include "utf8.h"
#include "render.h"
-void cr(cmark_render_state *state)
+void cr(cmark_renderer *renderer)
{
- if (state->need_cr < 1) {
- state->need_cr = 1;
+ if (renderer->need_cr < 1) {
+ renderer->need_cr = 1;
}
}
-void blankline(cmark_render_state *state)
+void blankline(cmark_renderer *renderer)
{
- if (state->need_cr < 2) {
- state->need_cr = 2;
+ if (renderer->need_cr < 2) {
+ renderer->need_cr = 2;
}
}
-void out(cmark_render_state *state,
+void out(cmark_renderer *renderer,
cmark_chunk str,
bool wrap,
cmark_escaping escape)
@@ -31,34 +31,34 @@ void out(cmark_render_state *state,
int i = 0;
int len;
cmark_chunk remainder = cmark_chunk_literal("");
- int k = state->buffer->size - 1;
+ int k = renderer->buffer->size - 1;
- wrap = wrap && !state->no_wrap;
+ wrap = wrap && !renderer->no_wrap;
- if (state->in_tight_list_item && state->need_cr > 1) {
- state->need_cr = 1;
+ if (renderer->in_tight_list_item && renderer->need_cr > 1) {
+ renderer->need_cr = 1;
}
- while (state->need_cr) {
- if (k < 0 || state->buffer->ptr[k] == '\n') {
+ while (renderer->need_cr) {
+ if (k < 0 || renderer->buffer->ptr[k] == '\n') {
k -= 1;
} else {
- cmark_strbuf_putc(state->buffer, '\n');
- if (state->need_cr > 1) {
- cmark_strbuf_put(state->buffer, state->prefix->ptr,
- state->prefix->size);
+ cmark_strbuf_putc(renderer->buffer, '\n');
+ if (renderer->need_cr > 1) {
+ cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+ renderer->prefix->size);
}
}
- state->column = 0;
- state->begin_line = true;
- state->need_cr -= 1;
+ renderer->column = 0;
+ renderer->begin_line = true;
+ renderer->need_cr -= 1;
}
while (i < length) {
- if (state->begin_line) {
- cmark_strbuf_put(state->buffer, state->prefix->ptr,
- state->prefix->size);
+ if (renderer->begin_line) {
+ cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+ renderer->prefix->size);
// note: this assumes prefix is ascii:
- state->column = state->prefix->size;
+ renderer->column = renderer->prefix->size;
}
len = utf8proc_iterate(source + i, length - i, &c);
@@ -67,11 +67,11 @@ void out(cmark_render_state *state,
}
nextc = source[i + len];
if (c == 32 && wrap) {
- if (!state->begin_line) {
- cmark_strbuf_putc(state->buffer, ' ');
- state->column += 1;
- state->begin_line = false;
- state->last_breakable = state->buffer->size -
+ if (!renderer->begin_line) {
+ cmark_strbuf_putc(renderer->buffer, ' ');
+ renderer->column += 1;
+ renderer->begin_line = false;
+ renderer->last_breakable = renderer->buffer->size -
1;
// skip following spaces
while (source[i + 1] == ' ') {
@@ -80,57 +80,57 @@ void out(cmark_render_state *state,
}
} else if (c == 10) {
- cmark_strbuf_putc(state->buffer, '\n');
- state->column = 0;
- state->begin_line = true;
- state->last_breakable = 0;
+ cmark_strbuf_putc(renderer->buffer, '\n');
+ renderer->column = 0;
+ renderer->begin_line = true;
+ renderer->last_breakable = 0;
} else {
- (state->outc)(state, escape, c, nextc);
+ (renderer->outc)(renderer, escape, c, nextc);
}
// If adding the character went beyond width, look for an
// earlier place where the line could be broken:
- if (state->width > 0 &&
- state->column > state->width &&
- !state->begin_line &&
- state->last_breakable > 0) {
+ if (renderer->width > 0 &&
+ renderer->column > renderer->width &&
+ !renderer->begin_line &&
+ renderer->last_breakable > 0) {
// copy from last_breakable to remainder
- cmark_chunk_set_cstr(&remainder, (char *) state->buffer->ptr + state->last_breakable + 1);
+ cmark_chunk_set_cstr(&remainder, (char *) renderer->buffer->ptr + renderer->last_breakable + 1);
// truncate at last_breakable
- cmark_strbuf_truncate(state->buffer, state->last_breakable);
+ cmark_strbuf_truncate(renderer->buffer, renderer->last_breakable);
// add newline, prefix, and remainder
- cmark_strbuf_putc(state->buffer, '\n');
- cmark_strbuf_put(state->buffer, state->prefix->ptr,
- state->prefix->size);
- cmark_strbuf_put(state->buffer, remainder.data, remainder.len);
- state->column = state->prefix->size + remainder.len;
+ cmark_strbuf_putc(renderer->buffer, '\n');
+ cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+ renderer->prefix->size);
+ cmark_strbuf_put(renderer->buffer, remainder.data, remainder.len);
+ renderer->column = renderer->prefix->size + remainder.len;
cmark_chunk_free(&remainder);
- state->last_breakable = 0;
- state->begin_line = false;
+ renderer->last_breakable = 0;
+ renderer->begin_line = false;
}
i += len;
}
}
-void lit(cmark_render_state *state, char *s, bool wrap)
+void lit(cmark_renderer *renderer, char *s, bool wrap)
{
cmark_chunk str = cmark_chunk_literal(s);
- out(state, str, wrap, LITERAL);
+ out(renderer, str, wrap, LITERAL);
}
char*
cmark_render(cmark_node *root,
int options,
int width,
- void (*outc)(cmark_render_state*,
+ void (*outc)(cmark_renderer*,
cmark_escaping,
int32_t,
unsigned char),
int (*render_node)(cmark_node *node,
cmark_event_type ev_type,
- cmark_render_state *state))
+ cmark_renderer *renderer))
{
cmark_strbuf pref = GH_BUF_INIT;
cmark_strbuf buf = GH_BUF_INIT;
@@ -144,12 +144,12 @@ cmark_render(cmark_node *root,
width = 0;
}
- cmark_render_state state = { options, &buf, &pref, 0, width,
+ cmark_renderer renderer = { options, &buf, &pref, 0, width,
0, 0, 0, true, false, false, outc };
while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
cur = cmark_iter_get_node(iter);
- if (!render_node(cur, ev_type, &state)) {
+ if (!render_node(cur, ev_type, &renderer)) {
// a false value causes us to skip processing
// the node's contents. this is used for
// autolinks.
@@ -157,11 +157,11 @@ cmark_render(cmark_node *root,
}
}
- result = (char *)cmark_strbuf_detach(state.buffer);
+ result = (char *)cmark_strbuf_detach(renderer.buffer);
cmark_iter_free(iter);
- cmark_strbuf_free(state.prefix);
- cmark_strbuf_free(state.buffer);
+ cmark_strbuf_free(renderer.prefix);
+ cmark_strbuf_free(renderer.buffer);
return result;
}
diff --git a/src/render.h b/src/render.h
index 6c268a1..718050e 100644
--- a/src/render.h
+++ b/src/render.h
@@ -16,7 +16,7 @@ typedef enum {
URL
} cmark_escaping;
-struct cmark_render_state {
+struct cmark_renderer {
int options;
cmark_strbuf* buffer;
cmark_strbuf* prefix;
@@ -28,36 +28,36 @@ struct cmark_render_state {
bool begin_line;
bool no_wrap;
bool in_tight_list_item;
- void (*outc)(struct cmark_render_state*,
+ void (*outc)(struct cmark_renderer*,
cmark_escaping,
int32_t,
unsigned char);
};
-typedef struct cmark_render_state cmark_render_state;
+typedef struct cmark_renderer cmark_renderer;
-void cr(cmark_render_state *state);
+void cr(cmark_renderer *renderer);
-void blankline(cmark_render_state *state);
+void blankline(cmark_renderer *renderer);
-void out(cmark_render_state *state,
+void out(cmark_renderer *renderer,
cmark_chunk str,
bool wrap,
cmark_escaping escape);
-void lit(cmark_render_state *state, char *s, bool wrap);
+void lit(cmark_renderer *renderer, char *s, bool wrap);
char*
cmark_render(cmark_node *root,
int options,
int width,
- void (*outc)(cmark_render_state*,
+ void (*outc)(cmark_renderer*,
cmark_escaping,
int32_t,
unsigned char),
int (*render_node)(cmark_node *node,
cmark_event_type ev_type,
- cmark_render_state *state));
+ cmark_renderer *renderer));
#ifdef __cplusplus