commonmarker 0.23.9 → 1.0.0.pre

Sign up to get free protection for your applications and to get access to all the features.
Files changed (89) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +70 -212
  3. data/commonmarker.gemspec +34 -31
  4. data/ext/commonmarker/Cargo.toml +12 -0
  5. data/ext/commonmarker/_util.rb +102 -0
  6. data/ext/commonmarker/extconf.rb +4 -5
  7. data/ext/commonmarker/src/comrak_options.rs +107 -0
  8. data/ext/commonmarker/src/lib.rs +27 -0
  9. data/lib/commonmarker/config.rb +57 -38
  10. data/lib/commonmarker/extension.rb +14 -0
  11. data/lib/commonmarker/renderer.rb +1 -127
  12. data/lib/commonmarker/version.rb +2 -2
  13. data/lib/commonmarker.rb +14 -29
  14. metadata +37 -181
  15. data/Rakefile +0 -109
  16. data/bin/commonmarker +0 -118
  17. data/ext/commonmarker/arena.c +0 -104
  18. data/ext/commonmarker/autolink.c +0 -508
  19. data/ext/commonmarker/autolink.h +0 -8
  20. data/ext/commonmarker/blocks.c +0 -1620
  21. data/ext/commonmarker/buffer.c +0 -278
  22. data/ext/commonmarker/buffer.h +0 -116
  23. data/ext/commonmarker/case_fold_switch.inc +0 -4327
  24. data/ext/commonmarker/chunk.h +0 -135
  25. data/ext/commonmarker/cmark-gfm-core-extensions.h +0 -54
  26. data/ext/commonmarker/cmark-gfm-extension_api.h +0 -737
  27. data/ext/commonmarker/cmark-gfm-extensions_export.h +0 -42
  28. data/ext/commonmarker/cmark-gfm.h +0 -833
  29. data/ext/commonmarker/cmark-gfm_export.h +0 -42
  30. data/ext/commonmarker/cmark-gfm_version.h +0 -7
  31. data/ext/commonmarker/cmark.c +0 -55
  32. data/ext/commonmarker/cmark_ctype.c +0 -44
  33. data/ext/commonmarker/cmark_ctype.h +0 -33
  34. data/ext/commonmarker/commonmark.c +0 -514
  35. data/ext/commonmarker/commonmarker.c +0 -1308
  36. data/ext/commonmarker/commonmarker.h +0 -16
  37. data/ext/commonmarker/config.h +0 -76
  38. data/ext/commonmarker/core-extensions.c +0 -27
  39. data/ext/commonmarker/entities.inc +0 -2138
  40. data/ext/commonmarker/ext_scanners.c +0 -879
  41. data/ext/commonmarker/ext_scanners.h +0 -24
  42. data/ext/commonmarker/footnotes.c +0 -63
  43. data/ext/commonmarker/footnotes.h +0 -27
  44. data/ext/commonmarker/houdini.h +0 -57
  45. data/ext/commonmarker/houdini_href_e.c +0 -100
  46. data/ext/commonmarker/houdini_html_e.c +0 -66
  47. data/ext/commonmarker/houdini_html_u.c +0 -149
  48. data/ext/commonmarker/html.c +0 -502
  49. data/ext/commonmarker/html.h +0 -27
  50. data/ext/commonmarker/inlines.c +0 -1788
  51. data/ext/commonmarker/inlines.h +0 -29
  52. data/ext/commonmarker/iterator.c +0 -159
  53. data/ext/commonmarker/iterator.h +0 -26
  54. data/ext/commonmarker/latex.c +0 -468
  55. data/ext/commonmarker/linked_list.c +0 -37
  56. data/ext/commonmarker/man.c +0 -274
  57. data/ext/commonmarker/map.c +0 -129
  58. data/ext/commonmarker/map.h +0 -44
  59. data/ext/commonmarker/node.c +0 -1044
  60. data/ext/commonmarker/node.h +0 -166
  61. data/ext/commonmarker/parser.h +0 -59
  62. data/ext/commonmarker/plaintext.c +0 -218
  63. data/ext/commonmarker/plugin.c +0 -36
  64. data/ext/commonmarker/plugin.h +0 -34
  65. data/ext/commonmarker/references.c +0 -43
  66. data/ext/commonmarker/references.h +0 -26
  67. data/ext/commonmarker/registry.c +0 -63
  68. data/ext/commonmarker/registry.h +0 -24
  69. data/ext/commonmarker/render.c +0 -213
  70. data/ext/commonmarker/render.h +0 -62
  71. data/ext/commonmarker/scanners.c +0 -14056
  72. data/ext/commonmarker/scanners.h +0 -70
  73. data/ext/commonmarker/scanners.re +0 -341
  74. data/ext/commonmarker/strikethrough.c +0 -167
  75. data/ext/commonmarker/strikethrough.h +0 -9
  76. data/ext/commonmarker/syntax_extension.c +0 -149
  77. data/ext/commonmarker/syntax_extension.h +0 -34
  78. data/ext/commonmarker/table.c +0 -872
  79. data/ext/commonmarker/table.h +0 -12
  80. data/ext/commonmarker/tagfilter.c +0 -60
  81. data/ext/commonmarker/tagfilter.h +0 -8
  82. data/ext/commonmarker/tasklist.c +0 -156
  83. data/ext/commonmarker/tasklist.h +0 -8
  84. data/ext/commonmarker/utf8.c +0 -317
  85. data/ext/commonmarker/utf8.h +0 -35
  86. data/ext/commonmarker/xml.c +0 -182
  87. data/lib/commonmarker/node/inspect.rb +0 -47
  88. data/lib/commonmarker/node.rb +0 -83
  89. data/lib/commonmarker/renderer/html_renderer.rb +0 -256
@@ -1,29 +0,0 @@
1
- #ifndef CMARK_INLINES_H
2
- #define CMARK_INLINES_H
3
-
4
- #ifdef __cplusplus
5
- extern "C" {
6
- #endif
7
-
8
- #include "references.h"
9
-
10
- cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url);
11
- cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title);
12
-
13
- CMARK_GFM_EXPORT
14
- void cmark_parse_inlines(cmark_parser *parser,
15
- cmark_node *parent,
16
- cmark_map *refmap,
17
- int options);
18
-
19
- bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
20
- cmark_map *refmap);
21
-
22
- void cmark_inlines_add_special_character(unsigned char c, bool emphasis);
23
- void cmark_inlines_remove_special_character(unsigned char c, bool emphasis);
24
-
25
- #ifdef __cplusplus
26
- }
27
- #endif
28
-
29
- #endif
@@ -1,159 +0,0 @@
1
- #include <assert.h>
2
- #include <stdlib.h>
3
-
4
- #include "config.h"
5
- #include "node.h"
6
- #include "cmark-gfm.h"
7
- #include "iterator.h"
8
-
9
- cmark_iter *cmark_iter_new(cmark_node *root) {
10
- if (root == NULL) {
11
- return NULL;
12
- }
13
- cmark_mem *mem = root->content.mem;
14
- cmark_iter *iter = (cmark_iter *)mem->calloc(1, sizeof(cmark_iter));
15
- iter->mem = mem;
16
- iter->root = root;
17
- iter->cur.ev_type = CMARK_EVENT_NONE;
18
- iter->cur.node = NULL;
19
- iter->next.ev_type = CMARK_EVENT_ENTER;
20
- iter->next.node = root;
21
- return iter;
22
- }
23
-
24
- void cmark_iter_free(cmark_iter *iter) { iter->mem->free(iter); }
25
-
26
- static bool S_is_leaf(cmark_node *node) {
27
- switch (node->type) {
28
- case CMARK_NODE_HTML_BLOCK:
29
- case CMARK_NODE_THEMATIC_BREAK:
30
- case CMARK_NODE_CODE_BLOCK:
31
- case CMARK_NODE_TEXT:
32
- case CMARK_NODE_SOFTBREAK:
33
- case CMARK_NODE_LINEBREAK:
34
- case CMARK_NODE_CODE:
35
- case CMARK_NODE_HTML_INLINE:
36
- return 1;
37
- }
38
- return 0;
39
- }
40
-
41
- cmark_event_type cmark_iter_next(cmark_iter *iter) {
42
- cmark_event_type ev_type = iter->next.ev_type;
43
- cmark_node *node = iter->next.node;
44
-
45
- iter->cur.ev_type = ev_type;
46
- iter->cur.node = node;
47
-
48
- if (ev_type == CMARK_EVENT_DONE) {
49
- return ev_type;
50
- }
51
-
52
- /* roll forward to next item, setting both fields */
53
- if (ev_type == CMARK_EVENT_ENTER && !S_is_leaf(node)) {
54
- if (node->first_child == NULL) {
55
- /* stay on this node but exit */
56
- iter->next.ev_type = CMARK_EVENT_EXIT;
57
- } else {
58
- iter->next.ev_type = CMARK_EVENT_ENTER;
59
- iter->next.node = node->first_child;
60
- }
61
- } else if (node == iter->root) {
62
- /* don't move past root */
63
- iter->next.ev_type = CMARK_EVENT_DONE;
64
- iter->next.node = NULL;
65
- } else if (node->next) {
66
- iter->next.ev_type = CMARK_EVENT_ENTER;
67
- iter->next.node = node->next;
68
- } else if (node->parent) {
69
- iter->next.ev_type = CMARK_EVENT_EXIT;
70
- iter->next.node = node->parent;
71
- } else {
72
- assert(false);
73
- iter->next.ev_type = CMARK_EVENT_DONE;
74
- iter->next.node = NULL;
75
- }
76
-
77
- return ev_type;
78
- }
79
-
80
- void cmark_iter_reset(cmark_iter *iter, cmark_node *current,
81
- cmark_event_type event_type) {
82
- iter->next.ev_type = event_type;
83
- iter->next.node = current;
84
- cmark_iter_next(iter);
85
- }
86
-
87
- cmark_node *cmark_iter_get_node(cmark_iter *iter) { return iter->cur.node; }
88
-
89
- cmark_event_type cmark_iter_get_event_type(cmark_iter *iter) {
90
- return iter->cur.ev_type;
91
- }
92
-
93
- cmark_node *cmark_iter_get_root(cmark_iter *iter) { return iter->root; }
94
-
95
- void cmark_consolidate_text_nodes(cmark_node *root) {
96
- if (root == NULL) {
97
- return;
98
- }
99
- cmark_iter *iter = cmark_iter_new(root);
100
- cmark_strbuf buf = CMARK_BUF_INIT(iter->mem);
101
- cmark_event_type ev_type;
102
- cmark_node *cur, *tmp, *next;
103
-
104
- while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
105
- cur = cmark_iter_get_node(iter);
106
- if (ev_type == CMARK_EVENT_ENTER && cur->type == CMARK_NODE_TEXT &&
107
- cur->next && cur->next->type == CMARK_NODE_TEXT) {
108
- cmark_strbuf_clear(&buf);
109
- cmark_strbuf_put(&buf, cur->as.literal.data, cur->as.literal.len);
110
- tmp = cur->next;
111
- while (tmp && tmp->type == CMARK_NODE_TEXT) {
112
- cmark_iter_next(iter); // advance pointer
113
- cmark_strbuf_put(&buf, tmp->as.literal.data, tmp->as.literal.len);
114
- cur->end_column = tmp->end_column;
115
- next = tmp->next;
116
- cmark_node_free(tmp);
117
- tmp = next;
118
- }
119
- cmark_chunk_free(iter->mem, &cur->as.literal);
120
- cur->as.literal = cmark_chunk_buf_detach(&buf);
121
- }
122
- }
123
-
124
- cmark_strbuf_free(&buf);
125
- cmark_iter_free(iter);
126
- }
127
-
128
- void cmark_node_own(cmark_node *root) {
129
- if (root == NULL) {
130
- return;
131
- }
132
- cmark_iter *iter = cmark_iter_new(root);
133
- cmark_event_type ev_type;
134
- cmark_node *cur;
135
-
136
- while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
137
- cur = cmark_iter_get_node(iter);
138
- if (ev_type == CMARK_EVENT_ENTER) {
139
- switch (cur->type) {
140
- case CMARK_NODE_TEXT:
141
- case CMARK_NODE_HTML_INLINE:
142
- case CMARK_NODE_CODE:
143
- case CMARK_NODE_HTML_BLOCK:
144
- cmark_chunk_to_cstr(iter->mem, &cur->as.literal);
145
- break;
146
- case CMARK_NODE_LINK:
147
- cmark_chunk_to_cstr(iter->mem, &cur->as.link.url);
148
- cmark_chunk_to_cstr(iter->mem, &cur->as.link.title);
149
- break;
150
- case CMARK_NODE_CUSTOM_INLINE:
151
- cmark_chunk_to_cstr(iter->mem, &cur->as.custom.on_enter);
152
- cmark_chunk_to_cstr(iter->mem, &cur->as.custom.on_exit);
153
- break;
154
- }
155
- }
156
- }
157
-
158
- cmark_iter_free(iter);
159
- }
@@ -1,26 +0,0 @@
1
- #ifndef CMARK_ITERATOR_H
2
- #define CMARK_ITERATOR_H
3
-
4
- #ifdef __cplusplus
5
- extern "C" {
6
- #endif
7
-
8
- #include "cmark-gfm.h"
9
-
10
- typedef struct {
11
- cmark_event_type ev_type;
12
- cmark_node *node;
13
- } cmark_iter_state;
14
-
15
- struct cmark_iter {
16
- cmark_mem *mem;
17
- cmark_node *root;
18
- cmark_iter_state cur;
19
- cmark_iter_state next;
20
- };
21
-
22
- #ifdef __cplusplus
23
- }
24
- #endif
25
-
26
- #endif
@@ -1,468 +0,0 @@
1
- #include <stdlib.h>
2
- #include <stdio.h>
3
- #include <string.h>
4
- #include <assert.h>
5
-
6
- #include "config.h"
7
- #include "cmark-gfm.h"
8
- #include "node.h"
9
- #include "buffer.h"
10
- #include "utf8.h"
11
- #include "scanners.h"
12
- #include "render.h"
13
- #include "syntax_extension.h"
14
-
15
- #define OUT(s, wrap, escaping) renderer->out(renderer, node, s, wrap, escaping)
16
- #define LIT(s) renderer->out(renderer, node, s, false, LITERAL)
17
- #define CR() renderer->cr(renderer)
18
- #define BLANKLINE() renderer->blankline(renderer)
19
- #define LIST_NUMBER_STRING_SIZE 20
20
-
21
- static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_node *node,
22
- cmark_escaping escape,
23
- int32_t c, unsigned char nextc) {
24
- if (escape == LITERAL) {
25
- cmark_render_code_point(renderer, c);
26
- return;
27
- }
28
-
29
- switch (c) {
30
- case 123: // '{'
31
- case 125: // '}'
32
- case 35: // '#'
33
- case 37: // '%'
34
- case 38: // '&'
35
- cmark_render_ascii(renderer, "\\");
36
- cmark_render_code_point(renderer, c);
37
- break;
38
- case 36: // '$'
39
- case 95: // '_'
40
- if (escape == NORMAL) {
41
- cmark_render_ascii(renderer, "\\");
42
- }
43
- cmark_render_code_point(renderer, c);
44
- break;
45
- case 45: // '-'
46
- if (nextc == 45) { // prevent ligature
47
- cmark_render_ascii(renderer, "-{}");
48
- } else {
49
- cmark_render_ascii(renderer, "-");
50
- }
51
- break;
52
- case 126: // '~'
53
- if (escape == NORMAL) {
54
- cmark_render_ascii(renderer, "\\textasciitilde{}");
55
- } else {
56
- cmark_render_code_point(renderer, c);
57
- }
58
- break;
59
- case 94: // '^'
60
- cmark_render_ascii(renderer, "\\^{}");
61
- break;
62
- case 92: // '\\'
63
- if (escape == URL) {
64
- // / acts as path sep even on windows:
65
- cmark_render_ascii(renderer, "/");
66
- } else {
67
- cmark_render_ascii(renderer, "\\textbackslash{}");
68
- }
69
- break;
70
- case 124: // '|'
71
- cmark_render_ascii(renderer, "\\textbar{}");
72
- break;
73
- case 60: // '<'
74
- cmark_render_ascii(renderer, "\\textless{}");
75
- break;
76
- case 62: // '>'
77
- cmark_render_ascii(renderer, "\\textgreater{}");
78
- break;
79
- case 91: // '['
80
- case 93: // ']'
81
- cmark_render_ascii(renderer, "{");
82
- cmark_render_code_point(renderer, c);
83
- cmark_render_ascii(renderer, "}");
84
- break;
85
- case 34: // '"'
86
- cmark_render_ascii(renderer, "\\textquotedbl{}");
87
- // requires \usepackage[T1]{fontenc}
88
- break;
89
- case 39: // '\''
90
- cmark_render_ascii(renderer, "\\textquotesingle{}");
91
- // requires \usepackage{textcomp}
92
- break;
93
- case 160: // nbsp
94
- cmark_render_ascii(renderer, "~");
95
- break;
96
- case 8230: // hellip
97
- cmark_render_ascii(renderer, "\\ldots{}");
98
- break;
99
- case 8216: // lsquo
100
- if (escape == NORMAL) {
101
- cmark_render_ascii(renderer, "`");
102
- } else {
103
- cmark_render_code_point(renderer, c);
104
- }
105
- break;
106
- case 8217: // rsquo
107
- if (escape == NORMAL) {
108
- cmark_render_ascii(renderer, "\'");
109
- } else {
110
- cmark_render_code_point(renderer, c);
111
- }
112
- break;
113
- case 8220: // ldquo
114
- if (escape == NORMAL) {
115
- cmark_render_ascii(renderer, "``");
116
- } else {
117
- cmark_render_code_point(renderer, c);
118
- }
119
- break;
120
- case 8221: // rdquo
121
- if (escape == NORMAL) {
122
- cmark_render_ascii(renderer, "''");
123
- } else {
124
- cmark_render_code_point(renderer, c);
125
- }
126
- break;
127
- case 8212: // emdash
128
- if (escape == NORMAL) {
129
- cmark_render_ascii(renderer, "---");
130
- } else {
131
- cmark_render_code_point(renderer, c);
132
- }
133
- break;
134
- case 8211: // endash
135
- if (escape == NORMAL) {
136
- cmark_render_ascii(renderer, "--");
137
- } else {
138
- cmark_render_code_point(renderer, c);
139
- }
140
- break;
141
- default:
142
- cmark_render_code_point(renderer, c);
143
- }
144
- }
145
-
146
- typedef enum {
147
- NO_LINK,
148
- URL_AUTOLINK,
149
- EMAIL_AUTOLINK,
150
- NORMAL_LINK,
151
- INTERNAL_LINK
152
- } link_type;
153
-
154
- static link_type get_link_type(cmark_node *node) {
155
- size_t title_len, url_len;
156
- cmark_node *link_text;
157
- char *realurl;
158
- int realurllen;
159
- bool isemail = false;
160
-
161
- if (node->type != CMARK_NODE_LINK) {
162
- return NO_LINK;
163
- }
164
-
165
- const char *url = cmark_node_get_url(node);
166
- cmark_chunk url_chunk = cmark_chunk_literal(url);
167
-
168
- if (url && *url == '#') {
169
- return INTERNAL_LINK;
170
- }
171
-
172
- url_len = strlen(url);
173
- if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) {
174
- return NO_LINK;
175
- }
176
-
177
- const char *title = cmark_node_get_title(node);
178
- title_len = strlen(title);
179
- // if it has a title, we can't treat it as an autolink:
180
- if (title_len == 0) {
181
-
182
- link_text = node->first_child;
183
- cmark_consolidate_text_nodes(link_text);
184
-
185
- if (!link_text)
186
- return NO_LINK;
187
-
188
- realurl = (char *)url;
189
- realurllen = (int)url_len;
190
- if (strncmp(realurl, "mailto:", 7) == 0) {
191
- realurl += 7;
192
- realurllen -= 7;
193
- isemail = true;
194
- }
195
- if (realurllen == link_text->as.literal.len &&
196
- strncmp(realurl, (char *)link_text->as.literal.data,
197
- link_text->as.literal.len) == 0) {
198
- if (isemail) {
199
- return EMAIL_AUTOLINK;
200
- } else {
201
- return URL_AUTOLINK;
202
- }
203
- }
204
- }
205
-
206
- return NORMAL_LINK;
207
- }
208
-
209
- static int S_get_enumlevel(cmark_node *node) {
210
- int enumlevel = 0;
211
- cmark_node *tmp = node;
212
- while (tmp) {
213
- if (tmp->type == CMARK_NODE_LIST &&
214
- cmark_node_get_list_type(node) == CMARK_ORDERED_LIST) {
215
- enumlevel++;
216
- }
217
- tmp = tmp->parent;
218
- }
219
- return enumlevel;
220
- }
221
-
222
- static int S_render_node(cmark_renderer *renderer, cmark_node *node,
223
- cmark_event_type ev_type, int options) {
224
- int list_number;
225
- int enumlevel;
226
- char list_number_string[LIST_NUMBER_STRING_SIZE];
227
- bool entering = (ev_type == CMARK_EVENT_ENTER);
228
- cmark_list_type list_type;
229
- bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options);
230
-
231
- if (node->extension && node->extension->latex_render_func) {
232
- node->extension->latex_render_func(node->extension, renderer, node, ev_type, options);
233
- return 1;
234
- }
235
-
236
- switch (node->type) {
237
- case CMARK_NODE_DOCUMENT:
238
- break;
239
-
240
- case CMARK_NODE_BLOCK_QUOTE:
241
- if (entering) {
242
- LIT("\\begin{quote}");
243
- CR();
244
- } else {
245
- LIT("\\end{quote}");
246
- BLANKLINE();
247
- }
248
- break;
249
-
250
- case CMARK_NODE_LIST:
251
- list_type = cmark_node_get_list_type(node);
252
- if (entering) {
253
- LIT("\\begin{");
254
- LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize");
255
- LIT("}");
256
- CR();
257
- list_number = cmark_node_get_list_start(node);
258
- if (list_number > 1) {
259
- enumlevel = S_get_enumlevel(node);
260
- // latex normally supports only five levels
261
- if (enumlevel >= 1 && enumlevel <= 5) {
262
- snprintf(list_number_string, LIST_NUMBER_STRING_SIZE, "%d",
263
- list_number);
264
- LIT("\\setcounter{enum");
265
- switch (enumlevel) {
266
- case 1: LIT("i"); break;
267
- case 2: LIT("ii"); break;
268
- case 3: LIT("iii"); break;
269
- case 4: LIT("iv"); break;
270
- case 5: LIT("v"); break;
271
- default: LIT("i"); break;
272
- }
273
- LIT("}{");
274
- OUT(list_number_string, false, NORMAL);
275
- LIT("}");
276
- }
277
- CR();
278
- }
279
- } else {
280
- LIT("\\end{");
281
- LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize");
282
- LIT("}");
283
- BLANKLINE();
284
- }
285
- break;
286
-
287
- case CMARK_NODE_ITEM:
288
- if (entering) {
289
- LIT("\\item ");
290
- } else {
291
- CR();
292
- }
293
- break;
294
-
295
- case CMARK_NODE_HEADING:
296
- if (entering) {
297
- switch (cmark_node_get_heading_level(node)) {
298
- case 1:
299
- LIT("\\section");
300
- break;
301
- case 2:
302
- LIT("\\subsection");
303
- break;
304
- case 3:
305
- LIT("\\subsubsection");
306
- break;
307
- case 4:
308
- LIT("\\paragraph");
309
- break;
310
- case 5:
311
- LIT("\\subparagraph");
312
- break;
313
- }
314
- LIT("{");
315
- } else {
316
- LIT("}");
317
- BLANKLINE();
318
- }
319
- break;
320
-
321
- case CMARK_NODE_CODE_BLOCK:
322
- CR();
323
- LIT("\\begin{verbatim}");
324
- CR();
325
- OUT(cmark_node_get_literal(node), false, LITERAL);
326
- CR();
327
- LIT("\\end{verbatim}");
328
- BLANKLINE();
329
- break;
330
-
331
- case CMARK_NODE_HTML_BLOCK:
332
- break;
333
-
334
- case CMARK_NODE_CUSTOM_BLOCK:
335
- CR();
336
- OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
337
- false, LITERAL);
338
- CR();
339
- break;
340
-
341
- case CMARK_NODE_THEMATIC_BREAK:
342
- BLANKLINE();
343
- LIT("\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}");
344
- BLANKLINE();
345
- break;
346
-
347
- case CMARK_NODE_PARAGRAPH:
348
- if (!entering) {
349
- BLANKLINE();
350
- }
351
- break;
352
-
353
- case CMARK_NODE_TEXT:
354
- OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
355
- break;
356
-
357
- case CMARK_NODE_LINEBREAK:
358
- LIT("\\\\");
359
- CR();
360
- break;
361
-
362
- case CMARK_NODE_SOFTBREAK:
363
- if (options & CMARK_OPT_HARDBREAKS) {
364
- LIT("\\\\");
365
- CR();
366
- } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) {
367
- CR();
368
- } else {
369
- OUT(" ", allow_wrap, NORMAL);
370
- }
371
- break;
372
-
373
- case CMARK_NODE_CODE:
374
- LIT("\\texttt{");
375
- OUT(cmark_node_get_literal(node), false, NORMAL);
376
- LIT("}");
377
- break;
378
-
379
- case CMARK_NODE_HTML_INLINE:
380
- break;
381
-
382
- case CMARK_NODE_CUSTOM_INLINE:
383
- OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
384
- false, LITERAL);
385
- break;
386
-
387
- case CMARK_NODE_STRONG:
388
- if (node->parent == NULL || node->parent->type != CMARK_NODE_STRONG) {
389
- if (entering) {
390
- LIT("\\textbf{");
391
- } else {
392
- LIT("}");
393
- }
394
- }
395
- break;
396
-
397
- case CMARK_NODE_EMPH:
398
- if (entering) {
399
- LIT("\\emph{");
400
- } else {
401
- LIT("}");
402
- }
403
- break;
404
-
405
- case CMARK_NODE_LINK:
406
- if (entering) {
407
- const char *url = cmark_node_get_url(node);
408
- // requires \usepackage{hyperref}
409
- switch (get_link_type(node)) {
410
- case URL_AUTOLINK:
411
- LIT("\\url{");
412
- OUT(url, false, URL);
413
- LIT("}");
414
- return 0; // Don't process further nodes to avoid double-rendering artefacts
415
- case EMAIL_AUTOLINK:
416
- LIT("\\href{");
417
- OUT(url, false, URL);
418
- LIT("}\\nolinkurl{");
419
- break;
420
- case NORMAL_LINK:
421
- LIT("\\href{");
422
- OUT(url, false, URL);
423
- LIT("}{");
424
- break;
425
- case INTERNAL_LINK:
426
- LIT("\\protect\\hyperlink{");
427
- OUT(url + 1, false, URL);
428
- LIT("}{");
429
- break;
430
- case NO_LINK:
431
- LIT("{"); // error?
432
- }
433
- } else {
434
- LIT("}");
435
- }
436
-
437
- break;
438
-
439
- case CMARK_NODE_IMAGE:
440
- if (entering) {
441
- LIT("\\protect\\includegraphics{");
442
- // requires \include{graphicx}
443
- OUT(cmark_node_get_url(node), false, URL);
444
- LIT("}");
445
- return 0;
446
- }
447
- break;
448
-
449
- case CMARK_NODE_FOOTNOTE_DEFINITION:
450
- case CMARK_NODE_FOOTNOTE_REFERENCE:
451
- // TODO
452
- break;
453
-
454
- default:
455
- assert(false);
456
- break;
457
- }
458
-
459
- return 1;
460
- }
461
-
462
- char *cmark_render_latex(cmark_node *root, int options, int width) {
463
- return cmark_render_latex_with_mem(root, options, width, cmark_node_mem(root));
464
- }
465
-
466
- char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmark_mem *mem) {
467
- return cmark_render(mem, root, options, width, outc, S_render_node);
468
- }
@@ -1,37 +0,0 @@
1
- #include <stdlib.h>
2
-
3
- #include "cmark-gfm.h"
4
-
5
- cmark_llist *cmark_llist_append(cmark_mem *mem, cmark_llist *head, void *data) {
6
- cmark_llist *tmp;
7
- cmark_llist *new_node = (cmark_llist *) mem->calloc(1, sizeof(cmark_llist));
8
-
9
- new_node->data = data;
10
- new_node->next = NULL;
11
-
12
- if (!head)
13
- return new_node;
14
-
15
- for (tmp = head; tmp->next; tmp=tmp->next);
16
-
17
- tmp->next = new_node;
18
-
19
- return head;
20
- }
21
-
22
- void cmark_llist_free_full(cmark_mem *mem, cmark_llist *head, cmark_free_func free_func) {
23
- cmark_llist *tmp, *prev;
24
-
25
- for (tmp = head; tmp;) {
26
- if (free_func)
27
- free_func(mem, tmp->data);
28
-
29
- prev = tmp;
30
- tmp = tmp->next;
31
- mem->free(prev);
32
- }
33
- }
34
-
35
- void cmark_llist_free(cmark_mem *mem, cmark_llist *head) {
36
- cmark_llist_free_full(mem, head, NULL);
37
- }