1 | /* |
2 | * MD4C: Markdown parser for C |
3 | * (http://github.com/mity/md4c) |
4 | * |
5 | * Copyright (c) 2016-2024 Martin Mitáš |
6 | * |
7 | * Permission is hereby granted, free of charge, to any person obtaining a |
8 | * copy of this software and associated documentation files (the "Software"), |
9 | * to deal in the Software without restriction, including without limitation |
10 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
11 | * and/or sell copies of the Software, and to permit persons to whom the |
12 | * Software is furnished to do so, subject to the following conditions: |
13 | * |
14 | * The above copyright notice and this permission notice shall be included in |
15 | * all copies or substantial portions of the Software. |
16 | * |
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
18 | * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
19 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
20 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
21 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
22 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
23 | * IN THE SOFTWARE. |
24 | */ |
25 | |
26 | #include "md4c.h" |
27 | |
28 | #include <limits.h> |
29 | #include <stdio.h> |
30 | #include <stdlib.h> |
31 | #include <string.h> |
32 | |
33 | |
34 | /***************************** |
35 | *** Miscellaneous Stuff *** |
36 | *****************************/ |
37 | |
38 | #if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199409L |
39 | /* C89/90 or old compilers in general may not understand "inline". */ |
40 | #if defined __GNUC__ |
41 | #define inline __inline__ |
42 | #elif defined _MSC_VER |
43 | #define inline __inline |
44 | #else |
45 | #define inline |
46 | #endif |
47 | #endif |
48 | |
49 | /* Make the UTF-8 support the default. */ |
50 | #if !defined MD4C_USE_ASCII && !defined MD4C_USE_UTF8 && !defined MD4C_USE_UTF16 |
51 | #define MD4C_USE_UTF8 |
52 | #endif |
53 | |
54 | /* Magic for making wide literals with MD4C_USE_UTF16. */ |
55 | #ifdef _T |
56 | #undef _T |
57 | #endif |
58 | #if defined MD4C_USE_UTF16 |
59 | #define _T(x) L##x |
60 | #else |
61 | #define _T(x) x |
62 | #endif |
63 | |
64 | /* Misc. macros. */ |
65 | #define SIZEOF_ARRAY(a) (sizeof(a) / sizeof(a[0])) |
66 | |
67 | #define STRINGIZE_(x) #x |
68 | #define STRINGIZE(x) STRINGIZE_(x) |
69 | |
70 | #define MAX(a,b) ((a) > (b) ? (a) : (b)) |
71 | #define MIN(a,b) ((a) < (b) ? (a) : (b)) |
72 | |
73 | #ifndef TRUE |
74 | #define TRUE 1 |
75 | #define FALSE 0 |
76 | #endif |
77 | |
78 | #define MD_LOG(msg) \ |
79 | do { \ |
80 | if(ctx->parser.debug_log != NULL) \ |
81 | ctx->parser.debug_log((msg), ctx->userdata); \ |
82 | } while(0) |
83 | |
84 | #ifdef DEBUG |
85 | #define MD_ASSERT(cond) \ |
86 | do { \ |
87 | if(!(cond)) { \ |
88 | MD_LOG(__FILE__ ":" STRINGIZE(__LINE__) ": " \ |
89 | "Assertion '" STRINGIZE(cond) "' failed."); \ |
90 | exit(1); \ |
91 | } \ |
92 | } while(0) |
93 | |
94 | #define MD_UNREACHABLE() MD_ASSERT(1 == 0) |
95 | #else |
96 | #ifdef __GNUC__ |
97 | #define MD_ASSERT(cond) do { if(!(cond)) __builtin_unreachable(); } while(0) |
98 | #define MD_UNREACHABLE() do { __builtin_unreachable(); } while(0) |
99 | #elif defined _MSC_VER && _MSC_VER > 120 |
100 | #define MD_ASSERT(cond) do { __assume(cond); } while(0) |
101 | #define MD_UNREACHABLE() do { __assume(0); } while(0) |
102 | #else |
103 | #define MD_ASSERT(cond) do {} while(0) |
104 | #define MD_UNREACHABLE() do {} while(0) |
105 | #endif |
106 | #endif |
107 | |
108 | /* For falling through case labels in switch statements. */ |
109 | #if defined __clang__ && __clang_major__ >= 12 |
110 | #define MD_FALLTHROUGH() __attribute__((fallthrough)) |
111 | #elif defined __GNUC__ && __GNUC__ >= 7 |
112 | #define MD_FALLTHROUGH() __attribute__((fallthrough)) |
113 | #else |
114 | #define MD_FALLTHROUGH() ((void)0) |
115 | #endif |
116 | |
117 | /* Suppress "unused parameter" warnings. */ |
118 | #define MD_UNUSED(x) ((void)x) |
119 | |
120 | |
121 | /****************************** |
122 | *** Some internal limits *** |
123 | ******************************/ |
124 | |
125 | /* We limit code span marks to lower than 32 backticks. This solves the |
126 | * pathologic case of too many openers, each of different length: Their |
127 | * resolving would be then O(n^2). */ |
128 | #define CODESPAN_MARK_MAXLEN 32 |
129 | |
130 | /* We limit column count of tables to prevent quadratic explosion of output |
131 | * from pathological input of a table thousands of columns and thousands |
132 | * of rows where rows are requested with as little as single character |
133 | * per-line, relying on us to "helpfully" fill all the missing "<td></td>". */ |
134 | #define TABLE_MAXCOLCOUNT 128 |
135 | |
136 | |
137 | /************************ |
138 | *** Internal Types *** |
139 | ************************/ |
140 | |
141 | /* These are omnipresent so lets save some typing. */ |
142 | #define CHAR MD_CHAR |
143 | #define SZ MD_SIZE |
144 | #define OFF MD_OFFSET |
145 | |
146 | typedef struct MD_MARK_tag MD_MARK; |
147 | typedef struct MD_BLOCK_tag MD_BLOCK; |
148 | typedef struct MD_CONTAINER_tag MD_CONTAINER; |
149 | typedef struct MD_REF_DEF_tag MD_REF_DEF; |
150 | |
151 | |
152 | /* During analyzes of inline marks, we need to manage stacks of unresolved |
153 | * openers of the given type. |
154 | * The stack connects the marks via MD_MARK::next; |
155 | */ |
156 | typedef struct MD_MARKSTACK_tag MD_MARKSTACK; |
157 | struct MD_MARKSTACK_tag { |
158 | int top; /* -1 if empty. */ |
159 | }; |
160 | |
161 | /* Context propagated through all the parsing. */ |
162 | typedef struct MD_CTX_tag MD_CTX; |
163 | struct MD_CTX_tag { |
164 | /* Immutable stuff (parameters of md_parse()). */ |
165 | const CHAR* text; |
166 | SZ size; |
167 | MD_PARSER parser; |
168 | void* userdata; |
169 | |
170 | /* When this is true, it allows some optimizations. */ |
171 | int doc_ends_with_newline; |
172 | |
173 | /* Helper temporary growing buffer. */ |
174 | CHAR* buffer; |
175 | unsigned alloc_buffer; |
176 | |
177 | /* Reference definitions. */ |
178 | MD_REF_DEF* ref_defs; |
179 | int n_ref_defs; |
180 | int alloc_ref_defs; |
181 | void** ref_def_hashtable; |
182 | int ref_def_hashtable_size; |
183 | |
184 | /* Stack of inline/span markers. |
185 | * This is only used for parsing a single block contents but by storing it |
186 | * here we may reuse the stack for subsequent blocks; i.e. we have fewer |
187 | * (re)allocations. */ |
188 | MD_MARK* marks; |
189 | int n_marks; |
190 | int alloc_marks; |
191 | |
192 | #if defined MD4C_USE_UTF16 |
193 | char mark_char_map[128]; |
194 | #else |
195 | char mark_char_map[256]; |
196 | #endif |
197 | |
198 | /* For resolving of inline spans. */ |
199 | MD_MARKSTACK opener_stacks[16]; |
200 | #define ASTERISK_OPENERS_oo_mod3_0 (ctx->opener_stacks[0]) /* Opener-only */ |
201 | #define ASTERISK_OPENERS_oo_mod3_1 (ctx->opener_stacks[1]) |
202 | #define ASTERISK_OPENERS_oo_mod3_2 (ctx->opener_stacks[2]) |
203 | #define ASTERISK_OPENERS_oc_mod3_0 (ctx->opener_stacks[3]) /* Both opener and closer candidate */ |
204 | #define ASTERISK_OPENERS_oc_mod3_1 (ctx->opener_stacks[4]) |
205 | #define ASTERISK_OPENERS_oc_mod3_2 (ctx->opener_stacks[5]) |
206 | #define UNDERSCORE_OPENERS_oo_mod3_0 (ctx->opener_stacks[6]) /* Opener-only */ |
207 | #define UNDERSCORE_OPENERS_oo_mod3_1 (ctx->opener_stacks[7]) |
208 | #define UNDERSCORE_OPENERS_oo_mod3_2 (ctx->opener_stacks[8]) |
209 | #define UNDERSCORE_OPENERS_oc_mod3_0 (ctx->opener_stacks[9]) /* Both opener and closer candidate */ |
210 | #define UNDERSCORE_OPENERS_oc_mod3_1 (ctx->opener_stacks[10]) |
211 | #define UNDERSCORE_OPENERS_oc_mod3_2 (ctx->opener_stacks[11]) |
212 | #define TILDE_OPENERS_1 (ctx->opener_stacks[12]) |
213 | #define TILDE_OPENERS_2 (ctx->opener_stacks[13]) |
214 | #define BRACKET_OPENERS (ctx->opener_stacks[14]) |
215 | #define DOLLAR_OPENERS (ctx->opener_stacks[15]) |
216 | |
217 | /* Stack of dummies which need to call free() for pointers stored in them. |
218 | * These are constructed during inline parsing and freed after all the block |
219 | * is processed (i.e. all callbacks referring those strings are called). */ |
220 | MD_MARKSTACK ptr_stack; |
221 | |
222 | /* For resolving table rows. */ |
223 | int n_table_cell_boundaries; |
224 | int table_cell_boundaries_head; |
225 | int table_cell_boundaries_tail; |
226 | |
227 | /* For resolving links. */ |
228 | int unresolved_link_head; |
229 | int unresolved_link_tail; |
230 | |
231 | /* For resolving raw HTML. */ |
232 | OFF ; |
233 | OFF html_proc_instr_horizon; |
234 | OFF html_decl_horizon; |
235 | OFF html_cdata_horizon; |
236 | |
237 | /* For block analysis. |
238 | * Notes: |
239 | * -- It holds MD_BLOCK as well as MD_LINE structures. After each |
240 | * MD_BLOCK, its (multiple) MD_LINE(s) follow. |
241 | * -- For MD_BLOCK_HTML and MD_BLOCK_CODE, MD_VERBATIMLINE(s) are used |
242 | * instead of MD_LINE(s). |
243 | */ |
244 | void* block_bytes; |
245 | MD_BLOCK* current_block; |
246 | int n_block_bytes; |
247 | int alloc_block_bytes; |
248 | |
249 | /* For container block analysis. */ |
250 | MD_CONTAINER* containers; |
251 | int n_containers; |
252 | int alloc_containers; |
253 | |
254 | /* Minimal indentation to call the block "indented code block". */ |
255 | unsigned code_indent_offset; |
256 | |
257 | /* Contextual info for line analysis. */ |
258 | SZ code_fence_length; /* For checking closing fence length. */ |
259 | int html_block_type; /* For checking closing raw HTML condition. */ |
260 | int last_line_has_list_loosening_effect; |
261 | int last_list_item_starts_with_two_blank_lines; |
262 | }; |
263 | |
264 | enum MD_LINETYPE_tag { |
265 | MD_LINE_BLANK, |
266 | MD_LINE_HR, |
267 | , |
268 | , |
269 | MD_LINE_SETEXTUNDERLINE, |
270 | MD_LINE_INDENTEDCODE, |
271 | MD_LINE_FENCEDCODE, |
272 | MD_LINE_HTML, |
273 | MD_LINE_TEXT, |
274 | MD_LINE_TABLE, |
275 | MD_LINE_TABLEUNDERLINE |
276 | }; |
277 | typedef enum MD_LINETYPE_tag MD_LINETYPE; |
278 | |
279 | typedef struct MD_LINE_ANALYSIS_tag MD_LINE_ANALYSIS; |
280 | struct MD_LINE_ANALYSIS_tag { |
281 | MD_LINETYPE type; |
282 | unsigned data; |
283 | int enforce_new_block; |
284 | OFF beg; |
285 | OFF end; |
286 | unsigned indent; /* Indentation level. */ |
287 | }; |
288 | |
289 | typedef struct MD_LINE_tag MD_LINE; |
290 | struct MD_LINE_tag { |
291 | OFF beg; |
292 | OFF end; |
293 | }; |
294 | |
295 | typedef struct MD_VERBATIMLINE_tag MD_VERBATIMLINE; |
296 | struct MD_VERBATIMLINE_tag { |
297 | OFF beg; |
298 | OFF end; |
299 | OFF indent; |
300 | }; |
301 | |
302 | |
303 | /***************** |
304 | *** Helpers *** |
305 | *****************/ |
306 | |
307 | /* Character accessors. */ |
308 | #define CH(off) (ctx->text[(off)]) |
309 | #define STR(off) (ctx->text + (off)) |
310 | |
311 | /* Character classification. |
312 | * Note we assume ASCII compatibility of code points < 128 here. */ |
313 | #define ISIN_(ch, ch_min, ch_max) ((ch_min) <= (unsigned)(ch) && (unsigned)(ch) <= (ch_max)) |
314 | #define ISANYOF_(ch, palette) ((ch) != _T('\0') && md_strchr((palette), (ch)) != NULL) |
315 | #define ISANYOF2_(ch, ch1, ch2) ((ch) == (ch1) || (ch) == (ch2)) |
316 | #define ISANYOF3_(ch, ch1, ch2, ch3) ((ch) == (ch1) || (ch) == (ch2) || (ch) == (ch3)) |
317 | #define ISASCII_(ch) ((unsigned)(ch) <= 127) |
318 | #define ISBLANK_(ch) (ISANYOF2_((ch), _T(' '), _T('\t'))) |
319 | #define ISNEWLINE_(ch) (ISANYOF2_((ch), _T('\r'), _T('\n'))) |
320 | #define ISWHITESPACE_(ch) (ISBLANK_(ch) || ISANYOF2_((ch), _T('\v'), _T('\f'))) |
321 | #define ISCNTRL_(ch) ((unsigned)(ch) <= 31 || (unsigned)(ch) == 127) |
322 | #define ISPUNCT_(ch) (ISIN_(ch, 33, 47) || ISIN_(ch, 58, 64) || ISIN_(ch, 91, 96) || ISIN_(ch, 123, 126)) |
323 | #define ISUPPER_(ch) (ISIN_(ch, _T('A'), _T('Z'))) |
324 | #define ISLOWER_(ch) (ISIN_(ch, _T('a'), _T('z'))) |
325 | #define ISALPHA_(ch) (ISUPPER_(ch) || ISLOWER_(ch)) |
326 | #define ISDIGIT_(ch) (ISIN_(ch, _T('0'), _T('9'))) |
327 | #define ISXDIGIT_(ch) (ISDIGIT_(ch) || ISIN_(ch, _T('A'), _T('F')) || ISIN_(ch, _T('a'), _T('f'))) |
328 | #define ISALNUM_(ch) (ISALPHA_(ch) || ISDIGIT_(ch)) |
329 | |
330 | #define ISANYOF(off, palette) ISANYOF_(CH(off), (palette)) |
331 | #define ISANYOF2(off, ch1, ch2) ISANYOF2_(CH(off), (ch1), (ch2)) |
332 | #define ISANYOF3(off, ch1, ch2, ch3) ISANYOF3_(CH(off), (ch1), (ch2), (ch3)) |
333 | #define ISASCII(off) ISASCII_(CH(off)) |
334 | #define ISBLANK(off) ISBLANK_(CH(off)) |
335 | #define ISNEWLINE(off) ISNEWLINE_(CH(off)) |
336 | #define ISWHITESPACE(off) ISWHITESPACE_(CH(off)) |
337 | #define ISCNTRL(off) ISCNTRL_(CH(off)) |
338 | #define ISPUNCT(off) ISPUNCT_(CH(off)) |
339 | #define ISUPPER(off) ISUPPER_(CH(off)) |
340 | #define ISLOWER(off) ISLOWER_(CH(off)) |
341 | #define ISALPHA(off) ISALPHA_(CH(off)) |
342 | #define ISDIGIT(off) ISDIGIT_(CH(off)) |
343 | #define ISXDIGIT(off) ISXDIGIT_(CH(off)) |
344 | #define ISALNUM(off) ISALNUM_(CH(off)) |
345 | |
346 | |
347 | #if defined MD4C_USE_UTF16 |
348 | #define md_strchr wcschr |
349 | #else |
350 | #define md_strchr strchr |
351 | #endif |
352 | |
353 | |
354 | /* Case insensitive check of string equality. */ |
355 | static inline int |
356 | md_ascii_case_eq(const CHAR* s1, const CHAR* s2, SZ n) |
357 | { |
358 | OFF i; |
359 | for(i = 0; i < n; i++) { |
360 | CHAR ch1 = s1[i]; |
361 | CHAR ch2 = s2[i]; |
362 | |
363 | if(ISLOWER_(ch1)) |
364 | ch1 += ('A'-'a'); |
365 | if(ISLOWER_(ch2)) |
366 | ch2 += ('A'-'a'); |
367 | if(ch1 != ch2) |
368 | return FALSE; |
369 | } |
370 | return TRUE; |
371 | } |
372 | |
373 | static inline int |
374 | md_ascii_eq(const CHAR* s1, const CHAR* s2, SZ n) |
375 | { |
376 | return memcmp(s1: s1, s2: s2, n: n * sizeof(CHAR)) == 0; |
377 | } |
378 | |
379 | static int |
380 | md_text_with_null_replacement(MD_CTX* ctx, MD_TEXTTYPE type, const CHAR* str, SZ size) |
381 | { |
382 | OFF off = 0; |
383 | int ret = 0; |
384 | |
385 | while(1) { |
386 | while(off < size && str[off] != _T('\0')) |
387 | off++; |
388 | |
389 | if(off > 0) { |
390 | ret = ctx->parser.text(type, str, off, ctx->userdata); |
391 | if(ret != 0) |
392 | return ret; |
393 | |
394 | str += off; |
395 | size -= off; |
396 | off = 0; |
397 | } |
398 | |
399 | if(off >= size) |
400 | return 0; |
401 | |
402 | ret = ctx->parser.text(MD_TEXT_NULLCHAR, _T("" ), 1, ctx->userdata); |
403 | if(ret != 0) |
404 | return ret; |
405 | off++; |
406 | } |
407 | } |
408 | |
409 | |
410 | #define MD_CHECK(func) \ |
411 | do { \ |
412 | ret = (func); \ |
413 | if(ret < 0) \ |
414 | goto abort; \ |
415 | } while(0) |
416 | |
417 | |
418 | #define MD_TEMP_BUFFER(sz) \ |
419 | do { \ |
420 | if(sz > ctx->alloc_buffer) { \ |
421 | CHAR* new_buffer; \ |
422 | SZ new_size = ((sz) + (sz) / 2 + 128) & ~127; \ |
423 | \ |
424 | new_buffer = realloc(ctx->buffer, new_size); \ |
425 | if(new_buffer == NULL) { \ |
426 | MD_LOG("realloc() failed."); \ |
427 | ret = -1; \ |
428 | goto abort; \ |
429 | } \ |
430 | \ |
431 | ctx->buffer = new_buffer; \ |
432 | ctx->alloc_buffer = new_size; \ |
433 | } \ |
434 | } while(0) |
435 | |
436 | |
437 | #define MD_ENTER_BLOCK(type, arg) \ |
438 | do { \ |
439 | ret = ctx->parser.enter_block((type), (arg), ctx->userdata); \ |
440 | if(ret != 0) { \ |
441 | MD_LOG("Aborted from enter_block() callback."); \ |
442 | goto abort; \ |
443 | } \ |
444 | } while(0) |
445 | |
446 | #define MD_LEAVE_BLOCK(type, arg) \ |
447 | do { \ |
448 | ret = ctx->parser.leave_block((type), (arg), ctx->userdata); \ |
449 | if(ret != 0) { \ |
450 | MD_LOG("Aborted from leave_block() callback."); \ |
451 | goto abort; \ |
452 | } \ |
453 | } while(0) |
454 | |
455 | #define MD_ENTER_SPAN(type, arg) \ |
456 | do { \ |
457 | ret = ctx->parser.enter_span((type), (arg), ctx->userdata); \ |
458 | if(ret != 0) { \ |
459 | MD_LOG("Aborted from enter_span() callback."); \ |
460 | goto abort; \ |
461 | } \ |
462 | } while(0) |
463 | |
464 | #define MD_LEAVE_SPAN(type, arg) \ |
465 | do { \ |
466 | ret = ctx->parser.leave_span((type), (arg), ctx->userdata); \ |
467 | if(ret != 0) { \ |
468 | MD_LOG("Aborted from leave_span() callback."); \ |
469 | goto abort; \ |
470 | } \ |
471 | } while(0) |
472 | |
473 | #define MD_TEXT(type, str, size) \ |
474 | do { \ |
475 | if(size > 0) { \ |
476 | ret = ctx->parser.text((type), (str), (size), ctx->userdata); \ |
477 | if(ret != 0) { \ |
478 | MD_LOG("Aborted from text() callback."); \ |
479 | goto abort; \ |
480 | } \ |
481 | } \ |
482 | } while(0) |
483 | |
484 | #define MD_TEXT_INSECURE(type, str, size) \ |
485 | do { \ |
486 | if(size > 0) { \ |
487 | ret = md_text_with_null_replacement(ctx, type, str, size); \ |
488 | if(ret != 0) { \ |
489 | MD_LOG("Aborted from text() callback."); \ |
490 | goto abort; \ |
491 | } \ |
492 | } \ |
493 | } while(0) |
494 | |
495 | |
496 | /* If the offset falls into a gap between line, we return the following |
497 | * line. */ |
498 | static const MD_LINE* |
499 | md_lookup_line(OFF off, const MD_LINE* lines, MD_SIZE n_lines, MD_SIZE* p_line_index) |
500 | { |
501 | MD_SIZE lo, hi; |
502 | MD_SIZE pivot; |
503 | const MD_LINE* line; |
504 | |
505 | lo = 0; |
506 | hi = n_lines - 1; |
507 | while(lo <= hi) { |
508 | pivot = (lo + hi) / 2; |
509 | line = &lines[pivot]; |
510 | |
511 | if(off < line->beg) { |
512 | if(hi == 0 || lines[hi-1].end < off) { |
513 | if(p_line_index != NULL) |
514 | *p_line_index = pivot; |
515 | return line; |
516 | } |
517 | hi = pivot - 1; |
518 | } else if(off > line->end) { |
519 | lo = pivot + 1; |
520 | } else { |
521 | if(p_line_index != NULL) |
522 | *p_line_index = pivot; |
523 | return line; |
524 | } |
525 | } |
526 | |
527 | return NULL; |
528 | } |
529 | |
530 | |
531 | /************************* |
532 | *** Unicode Support *** |
533 | *************************/ |
534 | |
535 | typedef struct MD_UNICODE_FOLD_INFO_tag MD_UNICODE_FOLD_INFO; |
536 | struct MD_UNICODE_FOLD_INFO_tag { |
537 | unsigned codepoints[3]; |
538 | unsigned n_codepoints; |
539 | }; |
540 | |
541 | |
542 | #if defined MD4C_USE_UTF16 || defined MD4C_USE_UTF8 |
543 | /* Binary search over sorted "map" of codepoints. Consecutive sequences |
544 | * of codepoints may be encoded in the map by just using the |
545 | * (MIN_CODEPOINT | 0x40000000) and (MAX_CODEPOINT | 0x80000000). |
546 | * |
547 | * Returns index of the found record in the map (in the case of ranges, |
548 | * the minimal value is used); or -1 on failure. */ |
549 | static int |
550 | md_unicode_bsearch__(unsigned codepoint, const unsigned* map, size_t map_size) |
551 | { |
552 | int beg, end; |
553 | int pivot_beg, pivot_end; |
554 | |
555 | beg = 0; |
556 | end = (int) map_size-1; |
557 | while(beg <= end) { |
558 | /* Pivot may be a range, not just a single value. */ |
559 | pivot_beg = pivot_end = (beg + end) / 2; |
560 | if(map[pivot_end] & 0x40000000) |
561 | pivot_end++; |
562 | if(map[pivot_beg] & 0x80000000) |
563 | pivot_beg--; |
564 | |
565 | if(codepoint < (map[pivot_beg] & 0x00ffffff)) |
566 | end = pivot_beg - 1; |
567 | else if(codepoint > (map[pivot_end] & 0x00ffffff)) |
568 | beg = pivot_end + 1; |
569 | else |
570 | return pivot_beg; |
571 | } |
572 | |
573 | return -1; |
574 | } |
575 | |
576 | static int |
577 | md_is_unicode_whitespace__(unsigned codepoint) |
578 | { |
579 | #define R(cp_min, cp_max) ((cp_min) | 0x40000000), ((cp_max) | 0x80000000) |
580 | #define S(cp) (cp) |
581 | /* Unicode "Zs" category. |
582 | * (generated by scripts/build_whitespace_map.py) */ |
583 | static const unsigned WHITESPACE_MAP[] = { |
584 | S(0x0020), S(0x00a0), S(0x1680), R(0x2000,0x200a), S(0x202f), S(0x205f), S(0x3000) |
585 | }; |
586 | #undef R |
587 | #undef S |
588 | |
589 | /* The ASCII ones are the most frequently used ones, also CommonMark |
590 | * specification requests few more in this range. */ |
591 | if(codepoint <= 0x7f) |
592 | return ISWHITESPACE_(codepoint); |
593 | |
594 | return (md_unicode_bsearch__(codepoint, map: WHITESPACE_MAP, SIZEOF_ARRAY(WHITESPACE_MAP)) >= 0); |
595 | } |
596 | |
597 | static int |
598 | md_is_unicode_punct__(unsigned codepoint) |
599 | { |
600 | #define R(cp_min, cp_max) ((cp_min) | 0x40000000), ((cp_max) | 0x80000000) |
601 | #define S(cp) (cp) |
602 | /* Unicode general "P" and "S" categories. |
603 | * (generated by scripts/build_punct_map.py) */ |
604 | static const unsigned PUNCT_MAP[] = { |
605 | R(0x0021,0x002f), R(0x003a,0x0040), R(0x005b,0x0060), R(0x007b,0x007e), R(0x00a1,0x00a9), |
606 | R(0x00ab,0x00ac), R(0x00ae,0x00b1), S(0x00b4), R(0x00b6,0x00b8), S(0x00bb), S(0x00bf), S(0x00d7), |
607 | S(0x00f7), R(0x02c2,0x02c5), R(0x02d2,0x02df), R(0x02e5,0x02eb), S(0x02ed), R(0x02ef,0x02ff), S(0x0375), |
608 | S(0x037e), R(0x0384,0x0385), S(0x0387), S(0x03f6), S(0x0482), R(0x055a,0x055f), R(0x0589,0x058a), |
609 | R(0x058d,0x058f), S(0x05be), S(0x05c0), S(0x05c3), S(0x05c6), R(0x05f3,0x05f4), R(0x0606,0x060f), |
610 | S(0x061b), R(0x061d,0x061f), R(0x066a,0x066d), S(0x06d4), S(0x06de), S(0x06e9), R(0x06fd,0x06fe), |
611 | R(0x0700,0x070d), R(0x07f6,0x07f9), R(0x07fe,0x07ff), R(0x0830,0x083e), S(0x085e), S(0x0888), |
612 | R(0x0964,0x0965), S(0x0970), R(0x09f2,0x09f3), R(0x09fa,0x09fb), S(0x09fd), S(0x0a76), R(0x0af0,0x0af1), |
613 | S(0x0b70), R(0x0bf3,0x0bfa), S(0x0c77), S(0x0c7f), S(0x0c84), S(0x0d4f), S(0x0d79), S(0x0df4), S(0x0e3f), |
614 | S(0x0e4f), R(0x0e5a,0x0e5b), R(0x0f01,0x0f17), R(0x0f1a,0x0f1f), S(0x0f34), S(0x0f36), S(0x0f38), |
615 | R(0x0f3a,0x0f3d), S(0x0f85), R(0x0fbe,0x0fc5), R(0x0fc7,0x0fcc), R(0x0fce,0x0fda), R(0x104a,0x104f), |
616 | R(0x109e,0x109f), S(0x10fb), R(0x1360,0x1368), R(0x1390,0x1399), S(0x1400), R(0x166d,0x166e), |
617 | R(0x169b,0x169c), R(0x16eb,0x16ed), R(0x1735,0x1736), R(0x17d4,0x17d6), R(0x17d8,0x17db), |
618 | R(0x1800,0x180a), S(0x1940), R(0x1944,0x1945), R(0x19de,0x19ff), R(0x1a1e,0x1a1f), R(0x1aa0,0x1aa6), |
619 | R(0x1aa8,0x1aad), R(0x1b5a,0x1b6a), R(0x1b74,0x1b7e), R(0x1bfc,0x1bff), R(0x1c3b,0x1c3f), |
620 | R(0x1c7e,0x1c7f), R(0x1cc0,0x1cc7), S(0x1cd3), S(0x1fbd), R(0x1fbf,0x1fc1), R(0x1fcd,0x1fcf), |
621 | R(0x1fdd,0x1fdf), R(0x1fed,0x1fef), R(0x1ffd,0x1ffe), R(0x2010,0x2027), R(0x2030,0x205e), |
622 | R(0x207a,0x207e), R(0x208a,0x208e), R(0x20a0,0x20c0), R(0x2100,0x2101), R(0x2103,0x2106), |
623 | R(0x2108,0x2109), S(0x2114), R(0x2116,0x2118), R(0x211e,0x2123), S(0x2125), S(0x2127), S(0x2129), |
624 | S(0x212e), R(0x213a,0x213b), R(0x2140,0x2144), R(0x214a,0x214d), S(0x214f), R(0x218a,0x218b), |
625 | R(0x2190,0x2426), R(0x2440,0x244a), R(0x249c,0x24e9), R(0x2500,0x2775), R(0x2794,0x2b73), |
626 | R(0x2b76,0x2b95), R(0x2b97,0x2bff), R(0x2ce5,0x2cea), R(0x2cf9,0x2cfc), R(0x2cfe,0x2cff), S(0x2d70), |
627 | R(0x2e00,0x2e2e), R(0x2e30,0x2e5d), R(0x2e80,0x2e99), R(0x2e9b,0x2ef3), R(0x2f00,0x2fd5), |
628 | R(0x2ff0,0x2fff), R(0x3001,0x3004), R(0x3008,0x3020), S(0x3030), R(0x3036,0x3037), R(0x303d,0x303f), |
629 | R(0x309b,0x309c), S(0x30a0), S(0x30fb), R(0x3190,0x3191), R(0x3196,0x319f), R(0x31c0,0x31e3), S(0x31ef), |
630 | R(0x3200,0x321e), R(0x322a,0x3247), S(0x3250), R(0x3260,0x327f), R(0x328a,0x32b0), R(0x32c0,0x33ff), |
631 | R(0x4dc0,0x4dff), R(0xa490,0xa4c6), R(0xa4fe,0xa4ff), R(0xa60d,0xa60f), S(0xa673), S(0xa67e), |
632 | R(0xa6f2,0xa6f7), R(0xa700,0xa716), R(0xa720,0xa721), R(0xa789,0xa78a), R(0xa828,0xa82b), |
633 | R(0xa836,0xa839), R(0xa874,0xa877), R(0xa8ce,0xa8cf), R(0xa8f8,0xa8fa), S(0xa8fc), R(0xa92e,0xa92f), |
634 | S(0xa95f), R(0xa9c1,0xa9cd), R(0xa9de,0xa9df), R(0xaa5c,0xaa5f), R(0xaa77,0xaa79), R(0xaade,0xaadf), |
635 | R(0xaaf0,0xaaf1), S(0xab5b), R(0xab6a,0xab6b), S(0xabeb), S(0xfb29), R(0xfbb2,0xfbc2), R(0xfd3e,0xfd4f), |
636 | S(0xfdcf), R(0xfdfc,0xfdff), R(0xfe10,0xfe19), R(0xfe30,0xfe52), R(0xfe54,0xfe66), R(0xfe68,0xfe6b), |
637 | R(0xff01,0xff0f), R(0xff1a,0xff20), R(0xff3b,0xff40), R(0xff5b,0xff65), R(0xffe0,0xffe6), |
638 | R(0xffe8,0xffee), R(0xfffc,0xfffd), R(0x10100,0x10102), R(0x10137,0x1013f), R(0x10179,0x10189), |
639 | R(0x1018c,0x1018e), R(0x10190,0x1019c), S(0x101a0), R(0x101d0,0x101fc), S(0x1039f), S(0x103d0), |
640 | S(0x1056f), S(0x10857), R(0x10877,0x10878), S(0x1091f), S(0x1093f), R(0x10a50,0x10a58), S(0x10a7f), |
641 | S(0x10ac8), R(0x10af0,0x10af6), R(0x10b39,0x10b3f), R(0x10b99,0x10b9c), S(0x10ead), R(0x10f55,0x10f59), |
642 | R(0x10f86,0x10f89), R(0x11047,0x1104d), R(0x110bb,0x110bc), R(0x110be,0x110c1), R(0x11140,0x11143), |
643 | R(0x11174,0x11175), R(0x111c5,0x111c8), S(0x111cd), S(0x111db), R(0x111dd,0x111df), R(0x11238,0x1123d), |
644 | S(0x112a9), R(0x1144b,0x1144f), R(0x1145a,0x1145b), S(0x1145d), S(0x114c6), R(0x115c1,0x115d7), |
645 | R(0x11641,0x11643), R(0x11660,0x1166c), S(0x116b9), R(0x1173c,0x1173f), S(0x1183b), R(0x11944,0x11946), |
646 | S(0x119e2), R(0x11a3f,0x11a46), R(0x11a9a,0x11a9c), R(0x11a9e,0x11aa2), R(0x11b00,0x11b09), |
647 | R(0x11c41,0x11c45), R(0x11c70,0x11c71), R(0x11ef7,0x11ef8), R(0x11f43,0x11f4f), R(0x11fd5,0x11ff1), |
648 | S(0x11fff), R(0x12470,0x12474), R(0x12ff1,0x12ff2), R(0x16a6e,0x16a6f), S(0x16af5), R(0x16b37,0x16b3f), |
649 | R(0x16b44,0x16b45), R(0x16e97,0x16e9a), S(0x16fe2), S(0x1bc9c), S(0x1bc9f), R(0x1cf50,0x1cfc3), |
650 | R(0x1d000,0x1d0f5), R(0x1d100,0x1d126), R(0x1d129,0x1d164), R(0x1d16a,0x1d16c), R(0x1d183,0x1d184), |
651 | R(0x1d18c,0x1d1a9), R(0x1d1ae,0x1d1ea), R(0x1d200,0x1d241), S(0x1d245), R(0x1d300,0x1d356), S(0x1d6c1), |
652 | S(0x1d6db), S(0x1d6fb), S(0x1d715), S(0x1d735), S(0x1d74f), S(0x1d76f), S(0x1d789), S(0x1d7a9), |
653 | S(0x1d7c3), R(0x1d800,0x1d9ff), R(0x1da37,0x1da3a), R(0x1da6d,0x1da74), R(0x1da76,0x1da83), |
654 | R(0x1da85,0x1da8b), S(0x1e14f), S(0x1e2ff), R(0x1e95e,0x1e95f), S(0x1ecac), S(0x1ecb0), S(0x1ed2e), |
655 | R(0x1eef0,0x1eef1), R(0x1f000,0x1f02b), R(0x1f030,0x1f093), R(0x1f0a0,0x1f0ae), R(0x1f0b1,0x1f0bf), |
656 | R(0x1f0c1,0x1f0cf), R(0x1f0d1,0x1f0f5), R(0x1f10d,0x1f1ad), R(0x1f1e6,0x1f202), R(0x1f210,0x1f23b), |
657 | R(0x1f240,0x1f248), R(0x1f250,0x1f251), R(0x1f260,0x1f265), R(0x1f300,0x1f6d7), R(0x1f6dc,0x1f6ec), |
658 | R(0x1f6f0,0x1f6fc), R(0x1f700,0x1f776), R(0x1f77b,0x1f7d9), R(0x1f7e0,0x1f7eb), S(0x1f7f0), |
659 | R(0x1f800,0x1f80b), R(0x1f810,0x1f847), R(0x1f850,0x1f859), R(0x1f860,0x1f887), R(0x1f890,0x1f8ad), |
660 | R(0x1f8b0,0x1f8b1), R(0x1f900,0x1fa53), R(0x1fa60,0x1fa6d), R(0x1fa70,0x1fa7c), R(0x1fa80,0x1fa88), |
661 | R(0x1fa90,0x1fabd), R(0x1fabf,0x1fac5), R(0x1face,0x1fadb), R(0x1fae0,0x1fae8), R(0x1faf0,0x1faf8), |
662 | R(0x1fb00,0x1fb92), R(0x1fb94,0x1fbca) |
663 | }; |
664 | #undef R |
665 | #undef S |
666 | |
667 | /* The ASCII ones are the most frequently used ones, also CommonMark |
668 | * specification requests few more in this range. */ |
669 | if(codepoint <= 0x7f) |
670 | return ISPUNCT_(codepoint); |
671 | |
672 | return (md_unicode_bsearch__(codepoint, map: PUNCT_MAP, SIZEOF_ARRAY(PUNCT_MAP)) >= 0); |
673 | } |
674 | |
675 | static void |
676 | md_get_unicode_fold_info(unsigned codepoint, MD_UNICODE_FOLD_INFO* info) |
677 | { |
678 | #define R(cp_min, cp_max) ((cp_min) | 0x40000000), ((cp_max) | 0x80000000) |
679 | #define S(cp) (cp) |
680 | /* Unicode "Pc", "Pd", "Pe", "Pf", "Pi", "Po", "Ps" categories. |
681 | * (generated by scripts/build_folding_map.py) */ |
682 | static const unsigned FOLD_MAP_1[] = { |
683 | R(0x0041,0x005a), S(0x00b5), R(0x00c0,0x00d6), R(0x00d8,0x00de), R(0x0100,0x012e), R(0x0132,0x0136), |
684 | R(0x0139,0x0147), R(0x014a,0x0176), S(0x0178), R(0x0179,0x017d), S(0x017f), S(0x0181), S(0x0182), |
685 | S(0x0184), S(0x0186), S(0x0187), S(0x0189), S(0x018a), S(0x018b), S(0x018e), S(0x018f), S(0x0190), |
686 | S(0x0191), S(0x0193), S(0x0194), S(0x0196), S(0x0197), S(0x0198), S(0x019c), S(0x019d), S(0x019f), |
687 | R(0x01a0,0x01a4), S(0x01a6), S(0x01a7), S(0x01a9), S(0x01ac), S(0x01ae), S(0x01af), S(0x01b1), S(0x01b2), |
688 | S(0x01b3), S(0x01b5), S(0x01b7), S(0x01b8), S(0x01bc), S(0x01c4), S(0x01c5), S(0x01c7), S(0x01c8), |
689 | S(0x01ca), R(0x01cb,0x01db), R(0x01de,0x01ee), S(0x01f1), S(0x01f2), S(0x01f4), S(0x01f6), S(0x01f7), |
690 | R(0x01f8,0x021e), S(0x0220), R(0x0222,0x0232), S(0x023a), S(0x023b), S(0x023d), S(0x023e), S(0x0241), |
691 | S(0x0243), S(0x0244), S(0x0245), R(0x0246,0x024e), S(0x0345), S(0x0370), S(0x0372), S(0x0376), S(0x037f), |
692 | S(0x0386), R(0x0388,0x038a), S(0x038c), S(0x038e), S(0x038f), R(0x0391,0x03a1), R(0x03a3,0x03ab), |
693 | S(0x03c2), S(0x03cf), S(0x03d0), S(0x03d1), S(0x03d5), S(0x03d6), R(0x03d8,0x03ee), S(0x03f0), S(0x03f1), |
694 | S(0x03f4), S(0x03f5), S(0x03f7), S(0x03f9), S(0x03fa), R(0x03fd,0x03ff), R(0x0400,0x040f), |
695 | R(0x0410,0x042f), R(0x0460,0x0480), R(0x048a,0x04be), S(0x04c0), R(0x04c1,0x04cd), R(0x04d0,0x052e), |
696 | R(0x0531,0x0556), R(0x10a0,0x10c5), S(0x10c7), S(0x10cd), R(0x13f8,0x13fd), S(0x1c80), S(0x1c81), |
697 | S(0x1c82), S(0x1c83), S(0x1c84), S(0x1c85), S(0x1c86), S(0x1c87), S(0x1c88), R(0x1c90,0x1cba), |
698 | R(0x1cbd,0x1cbf), R(0x1e00,0x1e94), S(0x1e9b), R(0x1ea0,0x1efe), R(0x1f08,0x1f0f), R(0x1f18,0x1f1d), |
699 | R(0x1f28,0x1f2f), R(0x1f38,0x1f3f), R(0x1f48,0x1f4d), S(0x1f59), S(0x1f5b), S(0x1f5d), S(0x1f5f), |
700 | R(0x1f68,0x1f6f), S(0x1fb8), S(0x1fb9), S(0x1fba), S(0x1fbb), S(0x1fbe), R(0x1fc8,0x1fcb), S(0x1fd8), |
701 | S(0x1fd9), S(0x1fda), S(0x1fdb), S(0x1fe8), S(0x1fe9), S(0x1fea), S(0x1feb), S(0x1fec), S(0x1ff8), |
702 | S(0x1ff9), S(0x1ffa), S(0x1ffb), S(0x2126), S(0x212a), S(0x212b), S(0x2132), R(0x2160,0x216f), S(0x2183), |
703 | R(0x24b6,0x24cf), R(0x2c00,0x2c2f), S(0x2c60), S(0x2c62), S(0x2c63), S(0x2c64), R(0x2c67,0x2c6b), |
704 | S(0x2c6d), S(0x2c6e), S(0x2c6f), S(0x2c70), S(0x2c72), S(0x2c75), S(0x2c7e), S(0x2c7f), R(0x2c80,0x2ce2), |
705 | S(0x2ceb), S(0x2ced), S(0x2cf2), R(0xa640,0xa66c), R(0xa680,0xa69a), R(0xa722,0xa72e), R(0xa732,0xa76e), |
706 | S(0xa779), S(0xa77b), S(0xa77d), R(0xa77e,0xa786), S(0xa78b), S(0xa78d), S(0xa790), S(0xa792), |
707 | R(0xa796,0xa7a8), S(0xa7aa), S(0xa7ab), S(0xa7ac), S(0xa7ad), S(0xa7ae), S(0xa7b0), S(0xa7b1), S(0xa7b2), |
708 | S(0xa7b3), R(0xa7b4,0xa7c2), S(0xa7c4), S(0xa7c5), S(0xa7c6), S(0xa7c7), S(0xa7c9), S(0xa7d0), S(0xa7d6), |
709 | S(0xa7d8), S(0xa7f5), R(0xab70,0xabbf), R(0xff21,0xff3a), R(0x10400,0x10427), R(0x104b0,0x104d3), |
710 | R(0x10570,0x1057a), R(0x1057c,0x1058a), R(0x1058c,0x10592), S(0x10594), S(0x10595), R(0x10c80,0x10cb2), |
711 | R(0x118a0,0x118bf), R(0x16e40,0x16e5f), R(0x1e900,0x1e921) |
712 | }; |
713 | static const unsigned FOLD_MAP_1_DATA[] = { |
714 | 0x0061, 0x007a, 0x03bc, 0x00e0, 0x00f6, 0x00f8, 0x00fe, 0x0101, 0x012f, 0x0133, 0x0137, 0x013a, 0x0148, |
715 | 0x014b, 0x0177, 0x00ff, 0x017a, 0x017e, 0x0073, 0x0253, 0x0183, 0x0185, 0x0254, 0x0188, 0x0256, 0x0257, |
716 | 0x018c, 0x01dd, 0x0259, 0x025b, 0x0192, 0x0260, 0x0263, 0x0269, 0x0268, 0x0199, 0x026f, 0x0272, 0x0275, |
717 | 0x01a1, 0x01a5, 0x0280, 0x01a8, 0x0283, 0x01ad, 0x0288, 0x01b0, 0x028a, 0x028b, 0x01b4, 0x01b6, 0x0292, |
718 | 0x01b9, 0x01bd, 0x01c6, 0x01c6, 0x01c9, 0x01c9, 0x01cc, 0x01cc, 0x01dc, 0x01df, 0x01ef, 0x01f3, 0x01f3, |
719 | 0x01f5, 0x0195, 0x01bf, 0x01f9, 0x021f, 0x019e, 0x0223, 0x0233, 0x2c65, 0x023c, 0x019a, 0x2c66, 0x0242, |
720 | 0x0180, 0x0289, 0x028c, 0x0247, 0x024f, 0x03b9, 0x0371, 0x0373, 0x0377, 0x03f3, 0x03ac, 0x03ad, 0x03af, |
721 | 0x03cc, 0x03cd, 0x03ce, 0x03b1, 0x03c1, 0x03c3, 0x03cb, 0x03c3, 0x03d7, 0x03b2, 0x03b8, 0x03c6, 0x03c0, |
722 | 0x03d9, 0x03ef, 0x03ba, 0x03c1, 0x03b8, 0x03b5, 0x03f8, 0x03f2, 0x03fb, 0x037b, 0x037d, 0x0450, 0x045f, |
723 | 0x0430, 0x044f, 0x0461, 0x0481, 0x048b, 0x04bf, 0x04cf, 0x04c2, 0x04ce, 0x04d1, 0x052f, 0x0561, 0x0586, |
724 | 0x2d00, 0x2d25, 0x2d27, 0x2d2d, 0x13f0, 0x13f5, 0x0432, 0x0434, 0x043e, 0x0441, 0x0442, 0x0442, 0x044a, |
725 | 0x0463, 0xa64b, 0x10d0, 0x10fa, 0x10fd, 0x10ff, 0x1e01, 0x1e95, 0x1e61, 0x1ea1, 0x1eff, 0x1f00, 0x1f07, |
726 | 0x1f10, 0x1f15, 0x1f20, 0x1f27, 0x1f30, 0x1f37, 0x1f40, 0x1f45, 0x1f51, 0x1f53, 0x1f55, 0x1f57, 0x1f60, |
727 | 0x1f67, 0x1fb0, 0x1fb1, 0x1f70, 0x1f71, 0x03b9, 0x1f72, 0x1f75, 0x1fd0, 0x1fd1, 0x1f76, 0x1f77, 0x1fe0, |
728 | 0x1fe1, 0x1f7a, 0x1f7b, 0x1fe5, 0x1f78, 0x1f79, 0x1f7c, 0x1f7d, 0x03c9, 0x006b, 0x00e5, 0x214e, 0x2170, |
729 | 0x217f, 0x2184, 0x24d0, 0x24e9, 0x2c30, 0x2c5f, 0x2c61, 0x026b, 0x1d7d, 0x027d, 0x2c68, 0x2c6c, 0x0251, |
730 | 0x0271, 0x0250, 0x0252, 0x2c73, 0x2c76, 0x023f, 0x0240, 0x2c81, 0x2ce3, 0x2cec, 0x2cee, 0x2cf3, 0xa641, |
731 | 0xa66d, 0xa681, 0xa69b, 0xa723, 0xa72f, 0xa733, 0xa76f, 0xa77a, 0xa77c, 0x1d79, 0xa77f, 0xa787, 0xa78c, |
732 | 0x0265, 0xa791, 0xa793, 0xa797, 0xa7a9, 0x0266, 0x025c, 0x0261, 0x026c, 0x026a, 0x029e, 0x0287, 0x029d, |
733 | 0xab53, 0xa7b5, 0xa7c3, 0xa794, 0x0282, 0x1d8e, 0xa7c8, 0xa7ca, 0xa7d1, 0xa7d7, 0xa7d9, 0xa7f6, 0x13a0, |
734 | 0x13ef, 0xff41, 0xff5a, 0x10428, 0x1044f, 0x104d8, 0x104fb, 0x10597, 0x105a1, 0x105a3, 0x105b1, 0x105b3, |
735 | 0x105b9, 0x105bb, 0x105bc, 0x10cc0, 0x10cf2, 0x118c0, 0x118df, 0x16e60, 0x16e7f, 0x1e922, 0x1e943 |
736 | }; |
737 | static const unsigned FOLD_MAP_2[] = { |
738 | S(0x00df), S(0x0130), S(0x0149), S(0x01f0), S(0x0587), S(0x1e96), S(0x1e97), S(0x1e98), S(0x1e99), |
739 | S(0x1e9a), S(0x1e9e), S(0x1f50), R(0x1f80,0x1f87), R(0x1f88,0x1f8f), R(0x1f90,0x1f97), R(0x1f98,0x1f9f), |
740 | R(0x1fa0,0x1fa7), R(0x1fa8,0x1faf), S(0x1fb2), S(0x1fb3), S(0x1fb4), S(0x1fb6), S(0x1fbc), S(0x1fc2), |
741 | S(0x1fc3), S(0x1fc4), S(0x1fc6), S(0x1fcc), S(0x1fd6), S(0x1fe4), S(0x1fe6), S(0x1ff2), S(0x1ff3), |
742 | S(0x1ff4), S(0x1ff6), S(0x1ffc), S(0xfb00), S(0xfb01), S(0xfb02), S(0xfb05), S(0xfb06), S(0xfb13), |
743 | S(0xfb14), S(0xfb15), S(0xfb16), S(0xfb17) |
744 | }; |
745 | static const unsigned FOLD_MAP_2_DATA[] = { |
746 | 0x0073,0x0073, 0x0069,0x0307, 0x02bc,0x006e, 0x006a,0x030c, 0x0565,0x0582, 0x0068,0x0331, 0x0074,0x0308, |
747 | 0x0077,0x030a, 0x0079,0x030a, 0x0061,0x02be, 0x0073,0x0073, 0x03c5,0x0313, 0x1f00,0x03b9, 0x1f07,0x03b9, |
748 | 0x1f00,0x03b9, 0x1f07,0x03b9, 0x1f20,0x03b9, 0x1f27,0x03b9, 0x1f20,0x03b9, 0x1f27,0x03b9, 0x1f60,0x03b9, |
749 | 0x1f67,0x03b9, 0x1f60,0x03b9, 0x1f67,0x03b9, 0x1f70,0x03b9, 0x03b1,0x03b9, 0x03ac,0x03b9, 0x03b1,0x0342, |
750 | 0x03b1,0x03b9, 0x1f74,0x03b9, 0x03b7,0x03b9, 0x03ae,0x03b9, 0x03b7,0x0342, 0x03b7,0x03b9, 0x03b9,0x0342, |
751 | 0x03c1,0x0313, 0x03c5,0x0342, 0x1f7c,0x03b9, 0x03c9,0x03b9, 0x03ce,0x03b9, 0x03c9,0x0342, 0x03c9,0x03b9, |
752 | 0x0066,0x0066, 0x0066,0x0069, 0x0066,0x006c, 0x0073,0x0074, 0x0073,0x0074, 0x0574,0x0576, 0x0574,0x0565, |
753 | 0x0574,0x056b, 0x057e,0x0576, 0x0574,0x056d |
754 | }; |
755 | static const unsigned FOLD_MAP_3[] = { |
756 | S(0x0390), S(0x03b0), S(0x1f52), S(0x1f54), S(0x1f56), S(0x1fb7), S(0x1fc7), S(0x1fd2), S(0x1fd3), |
757 | S(0x1fd7), S(0x1fe2), S(0x1fe3), S(0x1fe7), S(0x1ff7), S(0xfb03), S(0xfb04) |
758 | }; |
759 | static const unsigned FOLD_MAP_3_DATA[] = { |
760 | 0x03b9,0x0308,0x0301, 0x03c5,0x0308,0x0301, 0x03c5,0x0313,0x0300, 0x03c5,0x0313,0x0301, |
761 | 0x03c5,0x0313,0x0342, 0x03b1,0x0342,0x03b9, 0x03b7,0x0342,0x03b9, 0x03b9,0x0308,0x0300, |
762 | 0x03b9,0x0308,0x0301, 0x03b9,0x0308,0x0342, 0x03c5,0x0308,0x0300, 0x03c5,0x0308,0x0301, |
763 | 0x03c5,0x0308,0x0342, 0x03c9,0x0342,0x03b9, 0x0066,0x0066,0x0069, 0x0066,0x0066,0x006c |
764 | }; |
765 | #undef R |
766 | #undef S |
767 | static const struct { |
768 | const unsigned* map; |
769 | const unsigned* data; |
770 | size_t map_size; |
771 | unsigned n_codepoints; |
772 | } FOLD_MAP_LIST[] = { |
773 | { FOLD_MAP_1, FOLD_MAP_1_DATA, SIZEOF_ARRAY(FOLD_MAP_1), 1 }, |
774 | { FOLD_MAP_2, FOLD_MAP_2_DATA, SIZEOF_ARRAY(FOLD_MAP_2), 2 }, |
775 | { FOLD_MAP_3, FOLD_MAP_3_DATA, SIZEOF_ARRAY(FOLD_MAP_3), 3 } |
776 | }; |
777 | |
778 | int i; |
779 | |
780 | /* Fast path for ASCII characters. */ |
781 | if(codepoint <= 0x7f) { |
782 | info->codepoints[0] = codepoint; |
783 | if(ISUPPER_(codepoint)) |
784 | info->codepoints[0] += 'a' - 'A'; |
785 | info->n_codepoints = 1; |
786 | return; |
787 | } |
788 | |
789 | /* Try to locate the codepoint in any of the maps. */ |
790 | for(i = 0; i < (int) SIZEOF_ARRAY(FOLD_MAP_LIST); i++) { |
791 | int index; |
792 | |
793 | index = md_unicode_bsearch__(codepoint, map: FOLD_MAP_LIST[i].map, map_size: FOLD_MAP_LIST[i].map_size); |
794 | if(index >= 0) { |
795 | /* Found the mapping. */ |
796 | unsigned n_codepoints = FOLD_MAP_LIST[i].n_codepoints; |
797 | const unsigned* map = FOLD_MAP_LIST[i].map; |
798 | const unsigned* codepoints = FOLD_MAP_LIST[i].data + (index * n_codepoints); |
799 | |
800 | memcpy(dest: info->codepoints, src: codepoints, n: sizeof(unsigned) * n_codepoints); |
801 | info->n_codepoints = n_codepoints; |
802 | |
803 | if(FOLD_MAP_LIST[i].map[index] != codepoint) { |
804 | /* The found mapping maps whole range of codepoints, |
805 | * i.e. we have to offset info->codepoints[0] accordingly. */ |
806 | if((map[index] & 0x00ffffff)+1 == codepoints[0]) { |
807 | /* Alternating type of the range. */ |
808 | info->codepoints[0] = codepoint + ((codepoint & 0x1) == (map[index] & 0x1) ? 1 : 0); |
809 | } else { |
810 | /* Range to range kind of mapping. */ |
811 | info->codepoints[0] += (codepoint - (map[index] & 0x00ffffff)); |
812 | } |
813 | } |
814 | |
815 | return; |
816 | } |
817 | } |
818 | |
819 | /* No mapping found. Map the codepoint to itself. */ |
820 | info->codepoints[0] = codepoint; |
821 | info->n_codepoints = 1; |
822 | } |
823 | #endif |
824 | |
825 | |
826 | #if defined MD4C_USE_UTF16 |
827 | #define IS_UTF16_SURROGATE_HI(word) (((WORD)(word) & 0xfc00) == 0xd800) |
828 | #define IS_UTF16_SURROGATE_LO(word) (((WORD)(word) & 0xfc00) == 0xdc00) |
829 | #define UTF16_DECODE_SURROGATE(hi, lo) (0x10000 + ((((unsigned)(hi) & 0x3ff) << 10) | (((unsigned)(lo) & 0x3ff) << 0))) |
830 | |
831 | static unsigned |
832 | md_decode_utf16le__(const CHAR* str, SZ str_size, SZ* p_size) |
833 | { |
834 | if(IS_UTF16_SURROGATE_HI(str[0])) { |
835 | if(1 < str_size && IS_UTF16_SURROGATE_LO(str[1])) { |
836 | if(p_size != NULL) |
837 | *p_size = 2; |
838 | return UTF16_DECODE_SURROGATE(str[0], str[1]); |
839 | } |
840 | } |
841 | |
842 | if(p_size != NULL) |
843 | *p_size = 1; |
844 | return str[0]; |
845 | } |
846 | |
847 | static unsigned |
848 | md_decode_utf16le_before__(MD_CTX* ctx, OFF off) |
849 | { |
850 | if(off > 2 && IS_UTF16_SURROGATE_HI(CH(off-2)) && IS_UTF16_SURROGATE_LO(CH(off-1))) |
851 | return UTF16_DECODE_SURROGATE(CH(off-2), CH(off-1)); |
852 | |
853 | return CH(off); |
854 | } |
855 | |
856 | /* No whitespace uses surrogates, so no decoding needed here. */ |
857 | #define ISUNICODEWHITESPACE_(codepoint) md_is_unicode_whitespace__(codepoint) |
858 | #define ISUNICODEWHITESPACE(off) md_is_unicode_whitespace__(CH(off)) |
859 | #define ISUNICODEWHITESPACEBEFORE(off) md_is_unicode_whitespace__(CH((off)-1)) |
860 | |
861 | #define ISUNICODEPUNCT(off) md_is_unicode_punct__(md_decode_utf16le__(STR(off), ctx->size - (off), NULL)) |
862 | #define ISUNICODEPUNCTBEFORE(off) md_is_unicode_punct__(md_decode_utf16le_before__(ctx, off)) |
863 | |
864 | static inline int |
865 | md_decode_unicode(const CHAR* str, OFF off, SZ str_size, SZ* p_char_size) |
866 | { |
867 | return md_decode_utf16le__(str+off, str_size-off, p_char_size); |
868 | } |
869 | #elif defined MD4C_USE_UTF8 |
870 | #define IS_UTF8_LEAD1(byte) ((unsigned char)(byte) <= 0x7f) |
871 | #define IS_UTF8_LEAD2(byte) (((unsigned char)(byte) & 0xe0) == 0xc0) |
872 | #define IS_UTF8_LEAD3(byte) (((unsigned char)(byte) & 0xf0) == 0xe0) |
873 | #define IS_UTF8_LEAD4(byte) (((unsigned char)(byte) & 0xf8) == 0xf0) |
874 | #define IS_UTF8_TAIL(byte) (((unsigned char)(byte) & 0xc0) == 0x80) |
875 | |
876 | static unsigned |
877 | md_decode_utf8__(const CHAR* str, SZ str_size, SZ* p_size) |
878 | { |
879 | if(!IS_UTF8_LEAD1(str[0])) { |
880 | if(IS_UTF8_LEAD2(str[0])) { |
881 | if(1 < str_size && IS_UTF8_TAIL(str[1])) { |
882 | if(p_size != NULL) |
883 | *p_size = 2; |
884 | |
885 | return (((unsigned int)str[0] & 0x1f) << 6) | |
886 | (((unsigned int)str[1] & 0x3f) << 0); |
887 | } |
888 | } else if(IS_UTF8_LEAD3(str[0])) { |
889 | if(2 < str_size && IS_UTF8_TAIL(str[1]) && IS_UTF8_TAIL(str[2])) { |
890 | if(p_size != NULL) |
891 | *p_size = 3; |
892 | |
893 | return (((unsigned int)str[0] & 0x0f) << 12) | |
894 | (((unsigned int)str[1] & 0x3f) << 6) | |
895 | (((unsigned int)str[2] & 0x3f) << 0); |
896 | } |
897 | } else if(IS_UTF8_LEAD4(str[0])) { |
898 | if(3 < str_size && IS_UTF8_TAIL(str[1]) && IS_UTF8_TAIL(str[2]) && IS_UTF8_TAIL(str[3])) { |
899 | if(p_size != NULL) |
900 | *p_size = 4; |
901 | |
902 | return (((unsigned int)str[0] & 0x07) << 18) | |
903 | (((unsigned int)str[1] & 0x3f) << 12) | |
904 | (((unsigned int)str[2] & 0x3f) << 6) | |
905 | (((unsigned int)str[3] & 0x3f) << 0); |
906 | } |
907 | } |
908 | } |
909 | |
910 | if(p_size != NULL) |
911 | *p_size = 1; |
912 | return (unsigned) str[0]; |
913 | } |
914 | |
915 | static unsigned |
916 | md_decode_utf8_before__(MD_CTX* ctx, OFF off) |
917 | { |
918 | if(!IS_UTF8_LEAD1(CH(off-1))) { |
919 | if(off > 1 && IS_UTF8_LEAD2(CH(off-2)) && IS_UTF8_TAIL(CH(off-1))) |
920 | return (((unsigned int)CH(off-2) & 0x1f) << 6) | |
921 | (((unsigned int)CH(off-1) & 0x3f) << 0); |
922 | |
923 | if(off > 2 && IS_UTF8_LEAD3(CH(off-3)) && IS_UTF8_TAIL(CH(off-2)) && IS_UTF8_TAIL(CH(off-1))) |
924 | return (((unsigned int)CH(off-3) & 0x0f) << 12) | |
925 | (((unsigned int)CH(off-2) & 0x3f) << 6) | |
926 | (((unsigned int)CH(off-1) & 0x3f) << 0); |
927 | |
928 | if(off > 3 && IS_UTF8_LEAD4(CH(off-4)) && IS_UTF8_TAIL(CH(off-3)) && IS_UTF8_TAIL(CH(off-2)) && IS_UTF8_TAIL(CH(off-1))) |
929 | return (((unsigned int)CH(off-4) & 0x07) << 18) | |
930 | (((unsigned int)CH(off-3) & 0x3f) << 12) | |
931 | (((unsigned int)CH(off-2) & 0x3f) << 6) | |
932 | (((unsigned int)CH(off-1) & 0x3f) << 0); |
933 | } |
934 | |
935 | return (unsigned) CH(off-1); |
936 | } |
937 | |
938 | #define ISUNICODEWHITESPACE_(codepoint) md_is_unicode_whitespace__(codepoint) |
939 | #define ISUNICODEWHITESPACE(off) md_is_unicode_whitespace__(md_decode_utf8__(STR(off), ctx->size - (off), NULL)) |
940 | #define ISUNICODEWHITESPACEBEFORE(off) md_is_unicode_whitespace__(md_decode_utf8_before__(ctx, off)) |
941 | |
942 | #define ISUNICODEPUNCT(off) md_is_unicode_punct__(md_decode_utf8__(STR(off), ctx->size - (off), NULL)) |
943 | #define ISUNICODEPUNCTBEFORE(off) md_is_unicode_punct__(md_decode_utf8_before__(ctx, off)) |
944 | |
945 | static inline unsigned |
946 | md_decode_unicode(const CHAR* str, OFF off, SZ str_size, SZ* p_char_size) |
947 | { |
948 | return md_decode_utf8__(str: str+off, str_size: str_size-off, p_size: p_char_size); |
949 | } |
950 | #else |
951 | #define ISUNICODEWHITESPACE_(codepoint) ISWHITESPACE_(codepoint) |
952 | #define ISUNICODEWHITESPACE(off) ISWHITESPACE(off) |
953 | #define ISUNICODEWHITESPACEBEFORE(off) ISWHITESPACE((off)-1) |
954 | |
955 | #define ISUNICODEPUNCT(off) ISPUNCT(off) |
956 | #define ISUNICODEPUNCTBEFORE(off) ISPUNCT((off)-1) |
957 | |
958 | static inline void |
959 | md_get_unicode_fold_info(unsigned codepoint, MD_UNICODE_FOLD_INFO* info) |
960 | { |
961 | info->codepoints[0] = codepoint; |
962 | if(ISUPPER_(codepoint)) |
963 | info->codepoints[0] += 'a' - 'A'; |
964 | info->n_codepoints = 1; |
965 | } |
966 | |
967 | static inline unsigned |
968 | md_decode_unicode(const CHAR* str, OFF off, SZ str_size, SZ* p_size) |
969 | { |
970 | *p_size = 1; |
971 | return (unsigned) str[off]; |
972 | } |
973 | #endif |
974 | |
975 | |
976 | /************************************* |
977 | *** Helper string manipulations *** |
978 | *************************************/ |
979 | |
980 | /* Fill buffer with copy of the string between 'beg' and 'end' but replace any |
981 | * line breaks with given replacement character. |
982 | * |
983 | * NOTE: Caller is responsible to make sure the buffer is large enough. |
984 | * (Given the output is always shorter then input, (end - beg) is good idea |
985 | * what the caller should allocate.) |
986 | */ |
987 | static void |
988 | md_merge_lines(MD_CTX* ctx, OFF beg, OFF end, const MD_LINE* lines, MD_SIZE n_lines, |
989 | CHAR line_break_replacement_char, CHAR* buffer, SZ* p_size) |
990 | { |
991 | CHAR* ptr = buffer; |
992 | int line_index = 0; |
993 | OFF off = beg; |
994 | |
995 | MD_UNUSED(n_lines); |
996 | |
997 | while(1) { |
998 | const MD_LINE* line = &lines[line_index]; |
999 | OFF line_end = line->end; |
1000 | if(end < line_end) |
1001 | line_end = end; |
1002 | |
1003 | while(off < line_end) { |
1004 | *ptr = CH(off); |
1005 | ptr++; |
1006 | off++; |
1007 | } |
1008 | |
1009 | if(off >= end) { |
1010 | *p_size = (MD_SIZE)(ptr - buffer); |
1011 | return; |
1012 | } |
1013 | |
1014 | *ptr = line_break_replacement_char; |
1015 | ptr++; |
1016 | |
1017 | line_index++; |
1018 | off = lines[line_index].beg; |
1019 | } |
1020 | } |
1021 | |
1022 | /* Wrapper of md_merge_lines() which allocates new buffer for the output string. |
1023 | */ |
1024 | static int |
1025 | md_merge_lines_alloc(MD_CTX* ctx, OFF beg, OFF end, const MD_LINE* lines, MD_SIZE n_lines, |
1026 | CHAR line_break_replacement_char, CHAR** p_str, SZ* p_size) |
1027 | { |
1028 | CHAR* buffer; |
1029 | |
1030 | buffer = (CHAR*) malloc(size: sizeof(CHAR) * (end - beg)); |
1031 | if(buffer == NULL) { |
1032 | MD_LOG("malloc() failed." ); |
1033 | return -1; |
1034 | } |
1035 | |
1036 | md_merge_lines(ctx, beg, end, lines, n_lines, |
1037 | line_break_replacement_char, buffer, p_size); |
1038 | |
1039 | *p_str = buffer; |
1040 | return 0; |
1041 | } |
1042 | |
1043 | static OFF |
1044 | md_skip_unicode_whitespace(const CHAR* label, OFF off, SZ size) |
1045 | { |
1046 | SZ char_size; |
1047 | unsigned codepoint; |
1048 | |
1049 | while(off < size) { |
1050 | codepoint = md_decode_unicode(str: label, off, str_size: size, p_char_size: &char_size); |
1051 | if(!ISUNICODEWHITESPACE_(codepoint) && !ISNEWLINE_(label[off])) |
1052 | break; |
1053 | off += char_size; |
1054 | } |
1055 | |
1056 | return off; |
1057 | } |
1058 | |
1059 | |
1060 | /****************************** |
1061 | *** Recognizing raw HTML *** |
1062 | ******************************/ |
1063 | |
1064 | /* md_is_html_tag() may be called when processing inlines (inline raw HTML) |
1065 | * or when breaking document to blocks (checking for start of HTML block type 7). |
1066 | * |
1067 | * When breaking document to blocks, we do not yet know line boundaries, but |
1068 | * in that case the whole tag has to live on a single line. We distinguish this |
1069 | * by n_lines == 0. |
1070 | */ |
1071 | static int |
1072 | md_is_html_tag(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, OFF max_end, OFF* p_end) |
1073 | { |
1074 | int attr_state; |
1075 | OFF off = beg; |
1076 | OFF line_end = (n_lines > 0) ? lines[0].end : ctx->size; |
1077 | MD_SIZE line_index = 0; |
1078 | |
1079 | MD_ASSERT(CH(beg) == _T('<')); |
1080 | |
1081 | if(off + 1 >= line_end) |
1082 | return FALSE; |
1083 | off++; |
1084 | |
1085 | /* For parsing attributes, we need a little state automaton below. |
1086 | * State -1: no attributes are allowed. |
1087 | * State 0: attribute could follow after some whitespace. |
1088 | * State 1: after a whitespace (attribute name may follow). |
1089 | * State 2: after attribute name ('=' MAY follow). |
1090 | * State 3: after '=' (value specification MUST follow). |
1091 | * State 41: in middle of unquoted attribute value. |
1092 | * State 42: in middle of single-quoted attribute value. |
1093 | * State 43: in middle of double-quoted attribute value. |
1094 | */ |
1095 | attr_state = 0; |
1096 | |
1097 | if(CH(off) == _T('/')) { |
1098 | /* Closer tag "</ ... >". No attributes may be present. */ |
1099 | attr_state = -1; |
1100 | off++; |
1101 | } |
1102 | |
1103 | /* Tag name */ |
1104 | if(off >= line_end || !ISALPHA(off)) |
1105 | return FALSE; |
1106 | off++; |
1107 | while(off < line_end && (ISALNUM(off) || CH(off) == _T('-'))) |
1108 | off++; |
1109 | |
1110 | /* (Optional) attributes (if not closer), (optional) '/' (if not closer) |
1111 | * and final '>'. */ |
1112 | while(1) { |
1113 | while(off < line_end && !ISNEWLINE(off)) { |
1114 | if(attr_state > 40) { |
1115 | if(attr_state == 41 && (ISBLANK(off) || ISANYOF(off, _T("\"'=<>`" )))) { |
1116 | attr_state = 0; |
1117 | off--; /* Put the char back for re-inspection in the new state. */ |
1118 | } else if(attr_state == 42 && CH(off) == _T('\'')) { |
1119 | attr_state = 0; |
1120 | } else if(attr_state == 43 && CH(off) == _T('"')) { |
1121 | attr_state = 0; |
1122 | } |
1123 | off++; |
1124 | } else if(ISWHITESPACE(off)) { |
1125 | if(attr_state == 0) |
1126 | attr_state = 1; |
1127 | off++; |
1128 | } else if(attr_state <= 2 && CH(off) == _T('>')) { |
1129 | /* End. */ |
1130 | goto done; |
1131 | } else if(attr_state <= 2 && CH(off) == _T('/') && off+1 < line_end && CH(off+1) == _T('>')) { |
1132 | /* End with digraph '/>' */ |
1133 | off++; |
1134 | goto done; |
1135 | } else if((attr_state == 1 || attr_state == 2) && (ISALPHA(off) || CH(off) == _T('_') || CH(off) == _T(':'))) { |
1136 | off++; |
1137 | /* Attribute name */ |
1138 | while(off < line_end && (ISALNUM(off) || ISANYOF(off, _T("_.:-" )))) |
1139 | off++; |
1140 | attr_state = 2; |
1141 | } else if(attr_state == 2 && CH(off) == _T('=')) { |
1142 | /* Attribute assignment sign */ |
1143 | off++; |
1144 | attr_state = 3; |
1145 | } else if(attr_state == 3) { |
1146 | /* Expecting start of attribute value. */ |
1147 | if(CH(off) == _T('"')) |
1148 | attr_state = 43; |
1149 | else if(CH(off) == _T('\'')) |
1150 | attr_state = 42; |
1151 | else if(!ISANYOF(off, _T("\"'=<>`" )) && !ISNEWLINE(off)) |
1152 | attr_state = 41; |
1153 | else |
1154 | return FALSE; |
1155 | off++; |
1156 | } else { |
1157 | /* Anything unexpected. */ |
1158 | return FALSE; |
1159 | } |
1160 | } |
1161 | |
1162 | /* We have to be on a single line. See definition of start condition |
1163 | * of HTML block, type 7. */ |
1164 | if(n_lines == 0) |
1165 | return FALSE; |
1166 | |
1167 | line_index++; |
1168 | if(line_index >= n_lines) |
1169 | return FALSE; |
1170 | |
1171 | off = lines[line_index].beg; |
1172 | line_end = lines[line_index].end; |
1173 | |
1174 | if(attr_state == 0 || attr_state == 41) |
1175 | attr_state = 1; |
1176 | |
1177 | if(off >= max_end) |
1178 | return FALSE; |
1179 | } |
1180 | |
1181 | done: |
1182 | if(off >= max_end) |
1183 | return FALSE; |
1184 | |
1185 | *p_end = off+1; |
1186 | return TRUE; |
1187 | } |
1188 | |
1189 | static int |
1190 | md_scan_for_html_closer(MD_CTX* ctx, const MD_CHAR* str, MD_SIZE len, |
1191 | const MD_LINE* lines, MD_SIZE n_lines, |
1192 | OFF beg, OFF max_end, OFF* p_end, |
1193 | OFF* p_scan_horizon) |
1194 | { |
1195 | OFF off = beg; |
1196 | MD_SIZE line_index = 0; |
1197 | |
1198 | if(off < *p_scan_horizon && *p_scan_horizon >= max_end - len) { |
1199 | /* We have already scanned the range up to the max_end so we know |
1200 | * there is nothing to see. */ |
1201 | return FALSE; |
1202 | } |
1203 | |
1204 | while(TRUE) { |
1205 | while(off + len <= lines[line_index].end && off + len <= max_end) { |
1206 | if(md_ascii_eq(STR(off), s2: str, n: len)) { |
1207 | /* Success. */ |
1208 | *p_end = off + len; |
1209 | return TRUE; |
1210 | } |
1211 | off++; |
1212 | } |
1213 | |
1214 | line_index++; |
1215 | if(off >= max_end || line_index >= n_lines) { |
1216 | /* Failure. */ |
1217 | *p_scan_horizon = off; |
1218 | return FALSE; |
1219 | } |
1220 | |
1221 | off = lines[line_index].beg; |
1222 | } |
1223 | } |
1224 | |
1225 | static int |
1226 | (MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, OFF max_end, OFF* p_end) |
1227 | { |
1228 | OFF off = beg; |
1229 | |
1230 | MD_ASSERT(CH(beg) == _T('<')); |
1231 | |
1232 | if(off + 4 >= lines[0].end) |
1233 | return FALSE; |
1234 | if(CH(off+1) != _T('!') || CH(off+2) != _T('-') || CH(off+3) != _T('-')) |
1235 | return FALSE; |
1236 | |
1237 | /* Skip only "<!" so that we accept also "<!-->" or "<!--->" */ |
1238 | off += 2; |
1239 | |
1240 | /* Scan for ordinary comment closer "-->". */ |
1241 | return md_scan_for_html_closer(ctx, _T("-->" ), len: 3, |
1242 | lines, n_lines, beg: off, max_end, p_end, p_scan_horizon: &ctx->html_comment_horizon); |
1243 | } |
1244 | |
1245 | static int |
1246 | md_is_html_processing_instruction(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, OFF max_end, OFF* p_end) |
1247 | { |
1248 | OFF off = beg; |
1249 | |
1250 | if(off + 2 >= lines[0].end) |
1251 | return FALSE; |
1252 | if(CH(off+1) != _T('?')) |
1253 | return FALSE; |
1254 | off += 2; |
1255 | |
1256 | return md_scan_for_html_closer(ctx, _T("?>" ), len: 2, |
1257 | lines, n_lines, beg: off, max_end, p_end, p_scan_horizon: &ctx->html_proc_instr_horizon); |
1258 | } |
1259 | |
1260 | static int |
1261 | md_is_html_declaration(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, OFF max_end, OFF* p_end) |
1262 | { |
1263 | OFF off = beg; |
1264 | |
1265 | if(off + 2 >= lines[0].end) |
1266 | return FALSE; |
1267 | if(CH(off+1) != _T('!')) |
1268 | return FALSE; |
1269 | off += 2; |
1270 | |
1271 | /* Declaration name. */ |
1272 | if(off >= lines[0].end || !ISALPHA(off)) |
1273 | return FALSE; |
1274 | off++; |
1275 | while(off < lines[0].end && ISALPHA(off)) |
1276 | off++; |
1277 | |
1278 | return md_scan_for_html_closer(ctx, _T(">" ), len: 1, |
1279 | lines, n_lines, beg: off, max_end, p_end, p_scan_horizon: &ctx->html_decl_horizon); |
1280 | } |
1281 | |
1282 | static int |
1283 | md_is_html_cdata(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, OFF max_end, OFF* p_end) |
1284 | { |
1285 | static const CHAR open_str[] = _T("<![CDATA[" ); |
1286 | static const SZ open_size = SIZEOF_ARRAY(open_str) - 1; |
1287 | |
1288 | OFF off = beg; |
1289 | |
1290 | if(off + open_size >= lines[0].end) |
1291 | return FALSE; |
1292 | if(memcmp(STR(off), s2: open_str, n: open_size) != 0) |
1293 | return FALSE; |
1294 | off += open_size; |
1295 | |
1296 | return md_scan_for_html_closer(ctx, _T("]]>" ), len: 3, |
1297 | lines, n_lines, beg: off, max_end, p_end, p_scan_horizon: &ctx->html_cdata_horizon); |
1298 | } |
1299 | |
1300 | static int |
1301 | md_is_html_any(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, OFF max_end, OFF* p_end) |
1302 | { |
1303 | MD_ASSERT(CH(beg) == _T('<')); |
1304 | return (md_is_html_tag(ctx, lines, n_lines, beg, max_end, p_end) || |
1305 | md_is_html_comment(ctx, lines, n_lines, beg, max_end, p_end) || |
1306 | md_is_html_processing_instruction(ctx, lines, n_lines, beg, max_end, p_end) || |
1307 | md_is_html_declaration(ctx, lines, n_lines, beg, max_end, p_end) || |
1308 | md_is_html_cdata(ctx, lines, n_lines, beg, max_end, p_end)); |
1309 | } |
1310 | |
1311 | |
1312 | /**************************** |
1313 | *** Recognizing Entity *** |
1314 | ****************************/ |
1315 | |
1316 | static int |
1317 | md_is_hex_entity_contents(MD_CTX* ctx, const CHAR* text, OFF beg, OFF max_end, OFF* p_end) |
1318 | { |
1319 | OFF off = beg; |
1320 | MD_UNUSED(ctx); |
1321 | |
1322 | while(off < max_end && ISXDIGIT_(text[off]) && off - beg <= 8) |
1323 | off++; |
1324 | |
1325 | if(1 <= off - beg && off - beg <= 6) { |
1326 | *p_end = off; |
1327 | return TRUE; |
1328 | } else { |
1329 | return FALSE; |
1330 | } |
1331 | } |
1332 | |
1333 | static int |
1334 | md_is_dec_entity_contents(MD_CTX* ctx, const CHAR* text, OFF beg, OFF max_end, OFF* p_end) |
1335 | { |
1336 | OFF off = beg; |
1337 | MD_UNUSED(ctx); |
1338 | |
1339 | while(off < max_end && ISDIGIT_(text[off]) && off - beg <= 8) |
1340 | off++; |
1341 | |
1342 | if(1 <= off - beg && off - beg <= 7) { |
1343 | *p_end = off; |
1344 | return TRUE; |
1345 | } else { |
1346 | return FALSE; |
1347 | } |
1348 | } |
1349 | |
1350 | static int |
1351 | md_is_named_entity_contents(MD_CTX* ctx, const CHAR* text, OFF beg, OFF max_end, OFF* p_end) |
1352 | { |
1353 | OFF off = beg; |
1354 | MD_UNUSED(ctx); |
1355 | |
1356 | if(off < max_end && ISALPHA_(text[off])) |
1357 | off++; |
1358 | else |
1359 | return FALSE; |
1360 | |
1361 | while(off < max_end && ISALNUM_(text[off]) && off - beg <= 48) |
1362 | off++; |
1363 | |
1364 | if(2 <= off - beg && off - beg <= 48) { |
1365 | *p_end = off; |
1366 | return TRUE; |
1367 | } else { |
1368 | return FALSE; |
1369 | } |
1370 | } |
1371 | |
1372 | static int |
1373 | md_is_entity_str(MD_CTX* ctx, const CHAR* text, OFF beg, OFF max_end, OFF* p_end) |
1374 | { |
1375 | int is_contents; |
1376 | OFF off = beg; |
1377 | |
1378 | MD_ASSERT(text[off] == _T('&')); |
1379 | off++; |
1380 | |
1381 | if(off+2 < max_end && text[off] == _T('#') && (text[off+1] == _T('x') || text[off+1] == _T('X'))) |
1382 | is_contents = md_is_hex_entity_contents(ctx, text, beg: off+2, max_end, p_end: &off); |
1383 | else if(off+1 < max_end && text[off] == _T('#')) |
1384 | is_contents = md_is_dec_entity_contents(ctx, text, beg: off+1, max_end, p_end: &off); |
1385 | else |
1386 | is_contents = md_is_named_entity_contents(ctx, text, beg: off, max_end, p_end: &off); |
1387 | |
1388 | if(is_contents && off < max_end && text[off] == _T(';')) { |
1389 | *p_end = off+1; |
1390 | return TRUE; |
1391 | } else { |
1392 | return FALSE; |
1393 | } |
1394 | } |
1395 | |
1396 | static inline int |
1397 | md_is_entity(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end) |
1398 | { |
1399 | return md_is_entity_str(ctx, text: ctx->text, beg, max_end, p_end); |
1400 | } |
1401 | |
1402 | |
1403 | /****************************** |
1404 | *** Attribute Management *** |
1405 | ******************************/ |
1406 | |
1407 | typedef struct MD_ATTRIBUTE_BUILD_tag MD_ATTRIBUTE_BUILD; |
1408 | struct MD_ATTRIBUTE_BUILD_tag { |
1409 | CHAR* text; |
1410 | MD_TEXTTYPE* substr_types; |
1411 | OFF* substr_offsets; |
1412 | int substr_count; |
1413 | int substr_alloc; |
1414 | MD_TEXTTYPE trivial_types[1]; |
1415 | OFF trivial_offsets[2]; |
1416 | }; |
1417 | |
1418 | |
1419 | #define MD_BUILD_ATTR_NO_ESCAPES 0x0001 |
1420 | |
1421 | static int |
1422 | md_build_attr_append_substr(MD_CTX* ctx, MD_ATTRIBUTE_BUILD* build, |
1423 | MD_TEXTTYPE type, OFF off) |
1424 | { |
1425 | if(build->substr_count >= build->substr_alloc) { |
1426 | MD_TEXTTYPE* new_substr_types; |
1427 | OFF* new_substr_offsets; |
1428 | |
1429 | build->substr_alloc = (build->substr_alloc > 0 |
1430 | ? build->substr_alloc + build->substr_alloc / 2 |
1431 | : 8); |
1432 | new_substr_types = (MD_TEXTTYPE*) realloc(ptr: build->substr_types, |
1433 | size: build->substr_alloc * sizeof(MD_TEXTTYPE)); |
1434 | if(new_substr_types == NULL) { |
1435 | MD_LOG("realloc() failed." ); |
1436 | return -1; |
1437 | } |
1438 | /* Note +1 to reserve space for final offset (== raw_size). */ |
1439 | new_substr_offsets = (OFF*) realloc(ptr: build->substr_offsets, |
1440 | size: (build->substr_alloc+1) * sizeof(OFF)); |
1441 | if(new_substr_offsets == NULL) { |
1442 | MD_LOG("realloc() failed." ); |
1443 | free(ptr: new_substr_types); |
1444 | return -1; |
1445 | } |
1446 | |
1447 | build->substr_types = new_substr_types; |
1448 | build->substr_offsets = new_substr_offsets; |
1449 | } |
1450 | |
1451 | build->substr_types[build->substr_count] = type; |
1452 | build->substr_offsets[build->substr_count] = off; |
1453 | build->substr_count++; |
1454 | return 0; |
1455 | } |
1456 | |
1457 | static void |
1458 | md_free_attribute(MD_CTX* ctx, MD_ATTRIBUTE_BUILD* build) |
1459 | { |
1460 | MD_UNUSED(ctx); |
1461 | |
1462 | if(build->substr_alloc > 0) { |
1463 | free(ptr: build->text); |
1464 | free(ptr: build->substr_types); |
1465 | free(ptr: build->substr_offsets); |
1466 | } |
1467 | } |
1468 | |
1469 | static int |
1470 | md_build_attribute(MD_CTX* ctx, const CHAR* raw_text, SZ raw_size, |
1471 | unsigned flags, MD_ATTRIBUTE* attr, MD_ATTRIBUTE_BUILD* build) |
1472 | { |
1473 | OFF raw_off, off; |
1474 | int is_trivial; |
1475 | int ret = 0; |
1476 | |
1477 | memset(s: build, c: 0, n: sizeof(MD_ATTRIBUTE_BUILD)); |
1478 | |
1479 | /* If there is no backslash and no ampersand, build trivial attribute |
1480 | * without any malloc(). */ |
1481 | is_trivial = TRUE; |
1482 | for(raw_off = 0; raw_off < raw_size; raw_off++) { |
1483 | if(ISANYOF3_(raw_text[raw_off], _T('\\'), _T('&'), _T('\0'))) { |
1484 | is_trivial = FALSE; |
1485 | break; |
1486 | } |
1487 | } |
1488 | |
1489 | if(is_trivial) { |
1490 | build->text = (CHAR*) (raw_size ? raw_text : NULL); |
1491 | build->substr_types = build->trivial_types; |
1492 | build->substr_offsets = build->trivial_offsets; |
1493 | build->substr_count = 1; |
1494 | build->substr_alloc = 0; |
1495 | build->trivial_types[0] = MD_TEXT_NORMAL; |
1496 | build->trivial_offsets[0] = 0; |
1497 | build->trivial_offsets[1] = raw_size; |
1498 | off = raw_size; |
1499 | } else { |
1500 | build->text = (CHAR*) malloc(size: raw_size * sizeof(CHAR)); |
1501 | if(build->text == NULL) { |
1502 | MD_LOG("malloc() failed." ); |
1503 | goto abort; |
1504 | } |
1505 | |
1506 | raw_off = 0; |
1507 | off = 0; |
1508 | |
1509 | while(raw_off < raw_size) { |
1510 | if(raw_text[raw_off] == _T('\0')) { |
1511 | MD_CHECK(md_build_attr_append_substr(ctx, build, MD_TEXT_NULLCHAR, off)); |
1512 | memcpy(dest: build->text + off, src: raw_text + raw_off, n: 1); |
1513 | off++; |
1514 | raw_off++; |
1515 | continue; |
1516 | } |
1517 | |
1518 | if(raw_text[raw_off] == _T('&')) { |
1519 | OFF ent_end; |
1520 | |
1521 | if(md_is_entity_str(ctx, text: raw_text, beg: raw_off, max_end: raw_size, p_end: &ent_end)) { |
1522 | MD_CHECK(md_build_attr_append_substr(ctx, build, MD_TEXT_ENTITY, off)); |
1523 | memcpy(dest: build->text + off, src: raw_text + raw_off, n: ent_end - raw_off); |
1524 | off += ent_end - raw_off; |
1525 | raw_off = ent_end; |
1526 | continue; |
1527 | } |
1528 | } |
1529 | |
1530 | if(build->substr_count == 0 || build->substr_types[build->substr_count-1] != MD_TEXT_NORMAL) |
1531 | MD_CHECK(md_build_attr_append_substr(ctx, build, MD_TEXT_NORMAL, off)); |
1532 | |
1533 | if(!(flags & MD_BUILD_ATTR_NO_ESCAPES) && |
1534 | raw_text[raw_off] == _T('\\') && raw_off+1 < raw_size && |
1535 | (ISPUNCT_(raw_text[raw_off+1]) || ISNEWLINE_(raw_text[raw_off+1]))) |
1536 | raw_off++; |
1537 | |
1538 | build->text[off++] = raw_text[raw_off++]; |
1539 | } |
1540 | build->substr_offsets[build->substr_count] = off; |
1541 | } |
1542 | |
1543 | attr->text = build->text; |
1544 | attr->size = off; |
1545 | attr->substr_offsets = build->substr_offsets; |
1546 | attr->substr_types = build->substr_types; |
1547 | return 0; |
1548 | |
1549 | abort: |
1550 | md_free_attribute(ctx, build); |
1551 | return -1; |
1552 | } |
1553 | |
1554 | |
1555 | /********************************************* |
1556 | *** Dictionary of Reference Definitions *** |
1557 | *********************************************/ |
1558 | |
1559 | #define MD_FNV1A_BASE 2166136261U |
1560 | #define MD_FNV1A_PRIME 16777619U |
1561 | |
1562 | static inline unsigned |
1563 | md_fnv1a(unsigned base, const void* data, size_t n) |
1564 | { |
1565 | const unsigned char* buf = (const unsigned char*) data; |
1566 | unsigned hash = base; |
1567 | size_t i; |
1568 | |
1569 | for(i = 0; i < n; i++) { |
1570 | hash ^= buf[i]; |
1571 | hash *= MD_FNV1A_PRIME; |
1572 | } |
1573 | |
1574 | return hash; |
1575 | } |
1576 | |
1577 | |
1578 | struct MD_REF_DEF_tag { |
1579 | CHAR* label; |
1580 | CHAR* title; |
1581 | unsigned hash; |
1582 | SZ label_size; |
1583 | SZ title_size; |
1584 | OFF dest_beg; |
1585 | OFF dest_end; |
1586 | unsigned char label_needs_free : 1; |
1587 | unsigned char title_needs_free : 1; |
1588 | }; |
1589 | |
1590 | /* Label equivalence is quite complicated with regards to whitespace and case |
1591 | * folding. This complicates computing a hash of it as well as direct comparison |
1592 | * of two labels. */ |
1593 | |
1594 | static unsigned |
1595 | md_link_label_hash(const CHAR* label, SZ size) |
1596 | { |
1597 | unsigned hash = MD_FNV1A_BASE; |
1598 | OFF off; |
1599 | unsigned codepoint; |
1600 | int is_whitespace = FALSE; |
1601 | |
1602 | off = md_skip_unicode_whitespace(label, off: 0, size); |
1603 | while(off < size) { |
1604 | SZ char_size; |
1605 | |
1606 | codepoint = md_decode_unicode(str: label, off, str_size: size, p_char_size: &char_size); |
1607 | is_whitespace = ISUNICODEWHITESPACE_(codepoint) || ISNEWLINE_(label[off]); |
1608 | |
1609 | if(is_whitespace) { |
1610 | codepoint = ' '; |
1611 | hash = md_fnv1a(base: hash, data: &codepoint, n: sizeof(unsigned)); |
1612 | off = md_skip_unicode_whitespace(label, off, size); |
1613 | } else { |
1614 | MD_UNICODE_FOLD_INFO fold_info; |
1615 | |
1616 | md_get_unicode_fold_info(codepoint, info: &fold_info); |
1617 | hash = md_fnv1a(base: hash, data: fold_info.codepoints, n: fold_info.n_codepoints * sizeof(unsigned)); |
1618 | off += char_size; |
1619 | } |
1620 | } |
1621 | |
1622 | return hash; |
1623 | } |
1624 | |
1625 | static OFF |
1626 | md_link_label_cmp_load_fold_info(const CHAR* label, OFF off, SZ size, |
1627 | MD_UNICODE_FOLD_INFO* fold_info) |
1628 | { |
1629 | unsigned codepoint; |
1630 | SZ char_size; |
1631 | |
1632 | if(off >= size) { |
1633 | /* Treat end of a link label as a whitespace. */ |
1634 | goto whitespace; |
1635 | } |
1636 | |
1637 | codepoint = md_decode_unicode(str: label, off, str_size: size, p_char_size: &char_size); |
1638 | off += char_size; |
1639 | if(ISUNICODEWHITESPACE_(codepoint)) { |
1640 | /* Treat all whitespace as equivalent */ |
1641 | goto whitespace; |
1642 | } |
1643 | |
1644 | /* Get real folding info. */ |
1645 | md_get_unicode_fold_info(codepoint, info: fold_info); |
1646 | return off; |
1647 | |
1648 | whitespace: |
1649 | fold_info->codepoints[0] = _T(' '); |
1650 | fold_info->n_codepoints = 1; |
1651 | return md_skip_unicode_whitespace(label, off, size); |
1652 | } |
1653 | |
1654 | static int |
1655 | md_link_label_cmp(const CHAR* a_label, SZ a_size, const CHAR* b_label, SZ b_size) |
1656 | { |
1657 | OFF a_off; |
1658 | OFF b_off; |
1659 | MD_UNICODE_FOLD_INFO a_fi = { { 0 }, 0 }; |
1660 | MD_UNICODE_FOLD_INFO b_fi = { { 0 }, 0 }; |
1661 | OFF a_fi_off = 0; |
1662 | OFF b_fi_off = 0; |
1663 | int cmp; |
1664 | |
1665 | a_off = md_skip_unicode_whitespace(label: a_label, off: 0, size: a_size); |
1666 | b_off = md_skip_unicode_whitespace(label: b_label, off: 0, size: b_size); |
1667 | while(a_off < a_size || a_fi_off < a_fi.n_codepoints || |
1668 | b_off < b_size || b_fi_off < b_fi.n_codepoints) |
1669 | { |
1670 | /* If needed, load fold info for next char. */ |
1671 | if(a_fi_off >= a_fi.n_codepoints) { |
1672 | a_fi_off = 0; |
1673 | a_off = md_link_label_cmp_load_fold_info(label: a_label, off: a_off, size: a_size, fold_info: &a_fi); |
1674 | } |
1675 | if(b_fi_off >= b_fi.n_codepoints) { |
1676 | b_fi_off = 0; |
1677 | b_off = md_link_label_cmp_load_fold_info(label: b_label, off: b_off, size: b_size, fold_info: &b_fi); |
1678 | } |
1679 | |
1680 | cmp = b_fi.codepoints[b_fi_off] - a_fi.codepoints[a_fi_off]; |
1681 | if(cmp != 0) |
1682 | return cmp; |
1683 | |
1684 | a_fi_off++; |
1685 | b_fi_off++; |
1686 | } |
1687 | |
1688 | return 0; |
1689 | } |
1690 | |
1691 | typedef struct MD_REF_DEF_LIST_tag MD_REF_DEF_LIST; |
1692 | struct MD_REF_DEF_LIST_tag { |
1693 | int n_ref_defs; |
1694 | int alloc_ref_defs; |
1695 | MD_REF_DEF* ref_defs[]; /* Valid items always point into ctx->ref_defs[] */ |
1696 | }; |
1697 | |
1698 | static int |
1699 | md_ref_def_cmp(const void* a, const void* b) |
1700 | { |
1701 | const MD_REF_DEF* a_ref = *(const MD_REF_DEF**)a; |
1702 | const MD_REF_DEF* b_ref = *(const MD_REF_DEF**)b; |
1703 | |
1704 | if(a_ref->hash < b_ref->hash) |
1705 | return -1; |
1706 | else if(a_ref->hash > b_ref->hash) |
1707 | return +1; |
1708 | else |
1709 | return md_link_label_cmp(a_label: a_ref->label, a_size: a_ref->label_size, b_label: b_ref->label, b_size: b_ref->label_size); |
1710 | } |
1711 | |
1712 | static int |
1713 | md_ref_def_cmp_for_sort(const void* a, const void* b) |
1714 | { |
1715 | int cmp; |
1716 | |
1717 | cmp = md_ref_def_cmp(a, b); |
1718 | |
1719 | /* Ensure stability of the sorting. */ |
1720 | if(cmp == 0) { |
1721 | const MD_REF_DEF* a_ref = *(const MD_REF_DEF**)a; |
1722 | const MD_REF_DEF* b_ref = *(const MD_REF_DEF**)b; |
1723 | |
1724 | if(a_ref < b_ref) |
1725 | cmp = -1; |
1726 | else if(a_ref > b_ref) |
1727 | cmp = +1; |
1728 | else |
1729 | cmp = 0; |
1730 | } |
1731 | |
1732 | return cmp; |
1733 | } |
1734 | |
1735 | static int |
1736 | md_build_ref_def_hashtable(MD_CTX* ctx) |
1737 | { |
1738 | int i, j; |
1739 | |
1740 | if(ctx->n_ref_defs == 0) |
1741 | return 0; |
1742 | |
1743 | ctx->ref_def_hashtable_size = (ctx->n_ref_defs * 5) / 4; |
1744 | ctx->ref_def_hashtable = malloc(size: ctx->ref_def_hashtable_size * sizeof(void*)); |
1745 | if(ctx->ref_def_hashtable == NULL) { |
1746 | MD_LOG("malloc() failed." ); |
1747 | goto abort; |
1748 | } |
1749 | memset(s: ctx->ref_def_hashtable, c: 0, n: ctx->ref_def_hashtable_size * sizeof(void*)); |
1750 | |
1751 | /* Each member of ctx->ref_def_hashtable[] can be: |
1752 | * -- NULL, |
1753 | * -- pointer to the MD_REF_DEF in ctx->ref_defs[], or |
1754 | * -- pointer to a MD_REF_DEF_LIST, which holds multiple pointers to |
1755 | * such MD_REF_DEFs. |
1756 | */ |
1757 | for(i = 0; i < ctx->n_ref_defs; i++) { |
1758 | MD_REF_DEF* def = &ctx->ref_defs[i]; |
1759 | void* bucket; |
1760 | MD_REF_DEF_LIST* list; |
1761 | |
1762 | def->hash = md_link_label_hash(label: def->label, size: def->label_size); |
1763 | bucket = ctx->ref_def_hashtable[def->hash % ctx->ref_def_hashtable_size]; |
1764 | |
1765 | if(bucket == NULL) { |
1766 | /* The bucket is empty. Make it just point to the def. */ |
1767 | ctx->ref_def_hashtable[def->hash % ctx->ref_def_hashtable_size] = def; |
1768 | continue; |
1769 | } |
1770 | |
1771 | if(ctx->ref_defs <= (MD_REF_DEF*) bucket && (MD_REF_DEF*) bucket < ctx->ref_defs + ctx->n_ref_defs) { |
1772 | /* The bucket already contains one ref. def. Lets see whether it |
1773 | * is the same label (ref. def. duplicate) or different one |
1774 | * (hash conflict). */ |
1775 | MD_REF_DEF* old_def = (MD_REF_DEF*) bucket; |
1776 | |
1777 | if(md_link_label_cmp(a_label: def->label, a_size: def->label_size, b_label: old_def->label, b_size: old_def->label_size) == 0) { |
1778 | /* Duplicate label: Ignore this ref. def. */ |
1779 | continue; |
1780 | } |
1781 | |
1782 | /* Make the bucket complex, i.e. able to hold more ref. defs. */ |
1783 | list = (MD_REF_DEF_LIST*) malloc(size: sizeof(MD_REF_DEF_LIST) + 2 * sizeof(MD_REF_DEF*)); |
1784 | if(list == NULL) { |
1785 | MD_LOG("malloc() failed." ); |
1786 | goto abort; |
1787 | } |
1788 | list->ref_defs[0] = old_def; |
1789 | list->ref_defs[1] = def; |
1790 | list->n_ref_defs = 2; |
1791 | list->alloc_ref_defs = 2; |
1792 | ctx->ref_def_hashtable[def->hash % ctx->ref_def_hashtable_size] = list; |
1793 | continue; |
1794 | } |
1795 | |
1796 | /* Append the def to the complex bucket list. |
1797 | * |
1798 | * Note in this case we ignore potential duplicates to avoid expensive |
1799 | * iterating over the complex bucket. Below, we revisit all the complex |
1800 | * buckets and handle it more cheaply after the complex bucket contents |
1801 | * is sorted. */ |
1802 | list = (MD_REF_DEF_LIST*) bucket; |
1803 | if(list->n_ref_defs >= list->alloc_ref_defs) { |
1804 | int alloc_ref_defs = list->alloc_ref_defs + list->alloc_ref_defs / 2; |
1805 | MD_REF_DEF_LIST* list_tmp = (MD_REF_DEF_LIST*) realloc(ptr: list, |
1806 | size: sizeof(MD_REF_DEF_LIST) + alloc_ref_defs * sizeof(MD_REF_DEF*)); |
1807 | if(list_tmp == NULL) { |
1808 | MD_LOG("realloc() failed." ); |
1809 | goto abort; |
1810 | } |
1811 | list = list_tmp; |
1812 | list->alloc_ref_defs = alloc_ref_defs; |
1813 | ctx->ref_def_hashtable[def->hash % ctx->ref_def_hashtable_size] = list; |
1814 | } |
1815 | |
1816 | list->ref_defs[list->n_ref_defs] = def; |
1817 | list->n_ref_defs++; |
1818 | } |
1819 | |
1820 | /* Sort the complex buckets so we can use bsearch() with them. */ |
1821 | for(i = 0; i < ctx->ref_def_hashtable_size; i++) { |
1822 | void* bucket = ctx->ref_def_hashtable[i]; |
1823 | MD_REF_DEF_LIST* list; |
1824 | |
1825 | if(bucket == NULL) |
1826 | continue; |
1827 | if(ctx->ref_defs <= (MD_REF_DEF*) bucket && (MD_REF_DEF*) bucket < ctx->ref_defs + ctx->n_ref_defs) |
1828 | continue; |
1829 | |
1830 | list = (MD_REF_DEF_LIST*) bucket; |
1831 | qsort(base: list->ref_defs, nmemb: list->n_ref_defs, size: sizeof(MD_REF_DEF*), compar: md_ref_def_cmp_for_sort); |
1832 | |
1833 | /* Disable all duplicates in the complex bucket by forcing all such |
1834 | * records to point to the 1st such ref. def. I.e. no matter which |
1835 | * record is found during the lookup, it will always point to the right |
1836 | * ref. def. in ctx->ref_defs[]. */ |
1837 | for(j = 1; j < list->n_ref_defs; j++) { |
1838 | if(md_ref_def_cmp(a: &list->ref_defs[j-1], b: &list->ref_defs[j]) == 0) |
1839 | list->ref_defs[j] = list->ref_defs[j-1]; |
1840 | } |
1841 | } |
1842 | |
1843 | return 0; |
1844 | |
1845 | abort: |
1846 | return -1; |
1847 | } |
1848 | |
1849 | static void |
1850 | md_free_ref_def_hashtable(MD_CTX* ctx) |
1851 | { |
1852 | if(ctx->ref_def_hashtable != NULL) { |
1853 | int i; |
1854 | |
1855 | for(i = 0; i < ctx->ref_def_hashtable_size; i++) { |
1856 | void* bucket = ctx->ref_def_hashtable[i]; |
1857 | if(bucket == NULL) |
1858 | continue; |
1859 | if(ctx->ref_defs <= (MD_REF_DEF*) bucket && (MD_REF_DEF*) bucket < ctx->ref_defs + ctx->n_ref_defs) |
1860 | continue; |
1861 | free(ptr: bucket); |
1862 | } |
1863 | |
1864 | free(ptr: ctx->ref_def_hashtable); |
1865 | } |
1866 | } |
1867 | |
1868 | static const MD_REF_DEF* |
1869 | md_lookup_ref_def(MD_CTX* ctx, const CHAR* label, SZ label_size) |
1870 | { |
1871 | unsigned hash; |
1872 | void* bucket; |
1873 | |
1874 | if(ctx->ref_def_hashtable_size == 0) |
1875 | return NULL; |
1876 | |
1877 | hash = md_link_label_hash(label, size: label_size); |
1878 | bucket = ctx->ref_def_hashtable[hash % ctx->ref_def_hashtable_size]; |
1879 | |
1880 | if(bucket == NULL) { |
1881 | return NULL; |
1882 | } else if(ctx->ref_defs <= (MD_REF_DEF*) bucket && (MD_REF_DEF*) bucket < ctx->ref_defs + ctx->n_ref_defs) { |
1883 | const MD_REF_DEF* def = (MD_REF_DEF*) bucket; |
1884 | |
1885 | if(md_link_label_cmp(a_label: def->label, a_size: def->label_size, b_label: label, b_size: label_size) == 0) |
1886 | return def; |
1887 | else |
1888 | return NULL; |
1889 | } else { |
1890 | MD_REF_DEF_LIST* list = (MD_REF_DEF_LIST*) bucket; |
1891 | MD_REF_DEF key_buf; |
1892 | const MD_REF_DEF* key = &key_buf; |
1893 | const MD_REF_DEF** ret; |
1894 | |
1895 | key_buf.label = (CHAR*) label; |
1896 | key_buf.label_size = label_size; |
1897 | key_buf.hash = md_link_label_hash(label: key_buf.label, size: key_buf.label_size); |
1898 | |
1899 | ret = (const MD_REF_DEF**) bsearch(key: &key, base: list->ref_defs, |
1900 | nmemb: list->n_ref_defs, size: sizeof(MD_REF_DEF*), compar: md_ref_def_cmp); |
1901 | if(ret != NULL) |
1902 | return *ret; |
1903 | else |
1904 | return NULL; |
1905 | } |
1906 | } |
1907 | |
1908 | |
1909 | /*************************** |
1910 | *** Recognizing Links *** |
1911 | ***************************/ |
1912 | |
1913 | /* Note this code is partially shared between processing inlines and blocks |
1914 | * as reference definitions and links share some helper parser functions. |
1915 | */ |
1916 | |
1917 | typedef struct MD_LINK_ATTR_tag MD_LINK_ATTR; |
1918 | struct MD_LINK_ATTR_tag { |
1919 | OFF dest_beg; |
1920 | OFF dest_end; |
1921 | |
1922 | CHAR* title; |
1923 | SZ title_size; |
1924 | int title_needs_free; |
1925 | }; |
1926 | |
1927 | |
1928 | static int |
1929 | md_is_link_label(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, |
1930 | OFF* p_end, MD_SIZE* p_beg_line_index, MD_SIZE* p_end_line_index, |
1931 | OFF* p_contents_beg, OFF* p_contents_end) |
1932 | { |
1933 | OFF off = beg; |
1934 | OFF contents_beg = 0; |
1935 | OFF contents_end = 0; |
1936 | MD_SIZE line_index = 0; |
1937 | int len = 0; |
1938 | |
1939 | if(CH(off) != _T('[')) |
1940 | return FALSE; |
1941 | off++; |
1942 | |
1943 | while(1) { |
1944 | OFF line_end = lines[line_index].end; |
1945 | |
1946 | while(off < line_end) { |
1947 | if(CH(off) == _T('\\') && off+1 < ctx->size && (ISPUNCT(off+1) || ISNEWLINE(off+1))) { |
1948 | if(contents_end == 0) { |
1949 | contents_beg = off; |
1950 | *p_beg_line_index = line_index; |
1951 | } |
1952 | contents_end = off + 2; |
1953 | off += 2; |
1954 | } else if(CH(off) == _T('[')) { |
1955 | return FALSE; |
1956 | } else if(CH(off) == _T(']')) { |
1957 | if(contents_beg < contents_end) { |
1958 | /* Success. */ |
1959 | *p_contents_beg = contents_beg; |
1960 | *p_contents_end = contents_end; |
1961 | *p_end = off+1; |
1962 | *p_end_line_index = line_index; |
1963 | return TRUE; |
1964 | } else { |
1965 | /* Link label must have some non-whitespace contents. */ |
1966 | return FALSE; |
1967 | } |
1968 | } else { |
1969 | unsigned codepoint; |
1970 | SZ char_size; |
1971 | |
1972 | codepoint = md_decode_unicode(str: ctx->text, off, str_size: ctx->size, p_char_size: &char_size); |
1973 | if(!ISUNICODEWHITESPACE_(codepoint)) { |
1974 | if(contents_end == 0) { |
1975 | contents_beg = off; |
1976 | *p_beg_line_index = line_index; |
1977 | } |
1978 | contents_end = off + char_size; |
1979 | } |
1980 | |
1981 | off += char_size; |
1982 | } |
1983 | |
1984 | len++; |
1985 | if(len > 999) |
1986 | return FALSE; |
1987 | } |
1988 | |
1989 | line_index++; |
1990 | len++; |
1991 | if(line_index < n_lines) |
1992 | off = lines[line_index].beg; |
1993 | else |
1994 | break; |
1995 | } |
1996 | |
1997 | return FALSE; |
1998 | } |
1999 | |
2000 | static int |
2001 | md_is_link_destination_A(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end, |
2002 | OFF* p_contents_beg, OFF* p_contents_end) |
2003 | { |
2004 | OFF off = beg; |
2005 | |
2006 | if(off >= max_end || CH(off) != _T('<')) |
2007 | return FALSE; |
2008 | off++; |
2009 | |
2010 | while(off < max_end) { |
2011 | if(CH(off) == _T('\\') && off+1 < max_end && ISPUNCT(off+1)) { |
2012 | off += 2; |
2013 | continue; |
2014 | } |
2015 | |
2016 | if(ISNEWLINE(off) || CH(off) == _T('<')) |
2017 | return FALSE; |
2018 | |
2019 | if(CH(off) == _T('>')) { |
2020 | /* Success. */ |
2021 | *p_contents_beg = beg+1; |
2022 | *p_contents_end = off; |
2023 | *p_end = off+1; |
2024 | return TRUE; |
2025 | } |
2026 | |
2027 | off++; |
2028 | } |
2029 | |
2030 | return FALSE; |
2031 | } |
2032 | |
2033 | static int |
2034 | md_is_link_destination_B(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end, |
2035 | OFF* p_contents_beg, OFF* p_contents_end) |
2036 | { |
2037 | OFF off = beg; |
2038 | int parenthesis_level = 0; |
2039 | |
2040 | while(off < max_end) { |
2041 | if(CH(off) == _T('\\') && off+1 < max_end && ISPUNCT(off+1)) { |
2042 | off += 2; |
2043 | continue; |
2044 | } |
2045 | |
2046 | if(ISWHITESPACE(off) || ISCNTRL(off)) |
2047 | break; |
2048 | |
2049 | /* Link destination may include balanced pairs of unescaped '(' ')'. |
2050 | * Note we limit the maximal nesting level by 32 to protect us from |
2051 | * https://github.com/jgm/cmark/issues/214 */ |
2052 | if(CH(off) == _T('(')) { |
2053 | parenthesis_level++; |
2054 | if(parenthesis_level > 32) |
2055 | return FALSE; |
2056 | } else if(CH(off) == _T(')')) { |
2057 | if(parenthesis_level == 0) |
2058 | break; |
2059 | parenthesis_level--; |
2060 | } |
2061 | |
2062 | off++; |
2063 | } |
2064 | |
2065 | if(parenthesis_level != 0 || off == beg) |
2066 | return FALSE; |
2067 | |
2068 | /* Success. */ |
2069 | *p_contents_beg = beg; |
2070 | *p_contents_end = off; |
2071 | *p_end = off; |
2072 | return TRUE; |
2073 | } |
2074 | |
2075 | static inline int |
2076 | md_is_link_destination(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end, |
2077 | OFF* p_contents_beg, OFF* p_contents_end) |
2078 | { |
2079 | if(CH(beg) == _T('<')) |
2080 | return md_is_link_destination_A(ctx, beg, max_end, p_end, p_contents_beg, p_contents_end); |
2081 | else |
2082 | return md_is_link_destination_B(ctx, beg, max_end, p_end, p_contents_beg, p_contents_end); |
2083 | } |
2084 | |
2085 | static int |
2086 | md_is_link_title(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, |
2087 | OFF* p_end, MD_SIZE* p_beg_line_index, MD_SIZE* p_end_line_index, |
2088 | OFF* p_contents_beg, OFF* p_contents_end) |
2089 | { |
2090 | OFF off = beg; |
2091 | CHAR closer_char; |
2092 | MD_SIZE line_index = 0; |
2093 | |
2094 | /* White space with up to one line break. */ |
2095 | while(off < lines[line_index].end && ISWHITESPACE(off)) |
2096 | off++; |
2097 | if(off >= lines[line_index].end) { |
2098 | line_index++; |
2099 | if(line_index >= n_lines) |
2100 | return FALSE; |
2101 | off = lines[line_index].beg; |
2102 | } |
2103 | if(off == beg) |
2104 | return FALSE; |
2105 | |
2106 | *p_beg_line_index = line_index; |
2107 | |
2108 | /* First char determines how to detect end of it. */ |
2109 | switch(CH(off)) { |
2110 | case _T('"'): closer_char = _T('"'); break; |
2111 | case _T('\''): closer_char = _T('\''); break; |
2112 | case _T('('): closer_char = _T(')'); break; |
2113 | default: return FALSE; |
2114 | } |
2115 | off++; |
2116 | |
2117 | *p_contents_beg = off; |
2118 | |
2119 | while(line_index < n_lines) { |
2120 | OFF line_end = lines[line_index].end; |
2121 | |
2122 | while(off < line_end) { |
2123 | if(CH(off) == _T('\\') && off+1 < ctx->size && (ISPUNCT(off+1) || ISNEWLINE(off+1))) { |
2124 | off++; |
2125 | } else if(CH(off) == closer_char) { |
2126 | /* Success. */ |
2127 | *p_contents_end = off; |
2128 | *p_end = off+1; |
2129 | *p_end_line_index = line_index; |
2130 | return TRUE; |
2131 | } else if(closer_char == _T(')') && CH(off) == _T('(')) { |
2132 | /* ()-style title cannot contain (unescaped '(')) */ |
2133 | return FALSE; |
2134 | } |
2135 | |
2136 | off++; |
2137 | } |
2138 | |
2139 | line_index++; |
2140 | } |
2141 | |
2142 | return FALSE; |
2143 | } |
2144 | |
2145 | /* Returns 0 if it is not a reference definition. |
2146 | * |
2147 | * Returns N > 0 if it is a reference definition. N then corresponds to the |
2148 | * number of lines forming it). In this case the definition is stored for |
2149 | * resolving any links referring to it. |
2150 | * |
2151 | * Returns -1 in case of an error (out of memory). |
2152 | */ |
2153 | static int |
2154 | md_is_link_reference_definition(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines) |
2155 | { |
2156 | OFF label_contents_beg; |
2157 | OFF label_contents_end; |
2158 | MD_SIZE label_contents_line_index; |
2159 | int label_is_multiline = FALSE; |
2160 | OFF dest_contents_beg; |
2161 | OFF dest_contents_end; |
2162 | OFF title_contents_beg; |
2163 | OFF title_contents_end; |
2164 | MD_SIZE title_contents_line_index; |
2165 | int title_is_multiline = FALSE; |
2166 | OFF off; |
2167 | MD_SIZE line_index = 0; |
2168 | MD_SIZE tmp_line_index; |
2169 | MD_REF_DEF* def = NULL; |
2170 | int ret = 0; |
2171 | |
2172 | /* Link label. */ |
2173 | if(!md_is_link_label(ctx, lines, n_lines, beg: lines[0].beg, |
2174 | p_end: &off, p_beg_line_index: &label_contents_line_index, p_end_line_index: &line_index, |
2175 | p_contents_beg: &label_contents_beg, p_contents_end: &label_contents_end)) |
2176 | return FALSE; |
2177 | label_is_multiline = (label_contents_line_index != line_index); |
2178 | |
2179 | /* Colon. */ |
2180 | if(off >= lines[line_index].end || CH(off) != _T(':')) |
2181 | return FALSE; |
2182 | off++; |
2183 | |
2184 | /* Optional white space with up to one line break. */ |
2185 | while(off < lines[line_index].end && ISWHITESPACE(off)) |
2186 | off++; |
2187 | if(off >= lines[line_index].end) { |
2188 | line_index++; |
2189 | if(line_index >= n_lines) |
2190 | return FALSE; |
2191 | off = lines[line_index].beg; |
2192 | } |
2193 | |
2194 | /* Link destination. */ |
2195 | if(!md_is_link_destination(ctx, beg: off, max_end: lines[line_index].end, |
2196 | p_end: &off, p_contents_beg: &dest_contents_beg, p_contents_end: &dest_contents_end)) |
2197 | return FALSE; |
2198 | |
2199 | /* (Optional) title. Note we interpret it as an title only if nothing |
2200 | * more follows on its last line. */ |
2201 | if(md_is_link_title(ctx, lines: lines + line_index, n_lines: n_lines - line_index, beg: off, |
2202 | p_end: &off, p_beg_line_index: &title_contents_line_index, p_end_line_index: &tmp_line_index, |
2203 | p_contents_beg: &title_contents_beg, p_contents_end: &title_contents_end) |
2204 | && off >= lines[line_index + tmp_line_index].end) |
2205 | { |
2206 | title_is_multiline = (tmp_line_index != title_contents_line_index); |
2207 | title_contents_line_index += line_index; |
2208 | line_index += tmp_line_index; |
2209 | } else { |
2210 | /* Not a title. */ |
2211 | title_is_multiline = FALSE; |
2212 | title_contents_beg = off; |
2213 | title_contents_end = off; |
2214 | title_contents_line_index = 0; |
2215 | } |
2216 | |
2217 | /* Nothing more can follow on the last line. */ |
2218 | if(off < lines[line_index].end) |
2219 | return FALSE; |
2220 | |
2221 | /* So, it _is_ a reference definition. Remember it. */ |
2222 | if(ctx->n_ref_defs >= ctx->alloc_ref_defs) { |
2223 | MD_REF_DEF* new_defs; |
2224 | |
2225 | ctx->alloc_ref_defs = (ctx->alloc_ref_defs > 0 |
2226 | ? ctx->alloc_ref_defs + ctx->alloc_ref_defs / 2 |
2227 | : 16); |
2228 | new_defs = (MD_REF_DEF*) realloc(ptr: ctx->ref_defs, size: ctx->alloc_ref_defs * sizeof(MD_REF_DEF)); |
2229 | if(new_defs == NULL) { |
2230 | MD_LOG("realloc() failed." ); |
2231 | goto abort; |
2232 | } |
2233 | |
2234 | ctx->ref_defs = new_defs; |
2235 | } |
2236 | def = &ctx->ref_defs[ctx->n_ref_defs]; |
2237 | memset(s: def, c: 0, n: sizeof(MD_REF_DEF)); |
2238 | |
2239 | if(label_is_multiline) { |
2240 | MD_CHECK(md_merge_lines_alloc(ctx, label_contents_beg, label_contents_end, |
2241 | lines + label_contents_line_index, n_lines - label_contents_line_index, |
2242 | _T(' '), &def->label, &def->label_size)); |
2243 | def->label_needs_free = TRUE; |
2244 | } else { |
2245 | def->label = (CHAR*) STR(label_contents_beg); |
2246 | def->label_size = label_contents_end - label_contents_beg; |
2247 | } |
2248 | |
2249 | if(title_is_multiline) { |
2250 | MD_CHECK(md_merge_lines_alloc(ctx, title_contents_beg, title_contents_end, |
2251 | lines + title_contents_line_index, n_lines - title_contents_line_index, |
2252 | _T('\n'), &def->title, &def->title_size)); |
2253 | def->title_needs_free = TRUE; |
2254 | } else { |
2255 | def->title = (CHAR*) STR(title_contents_beg); |
2256 | def->title_size = title_contents_end - title_contents_beg; |
2257 | } |
2258 | |
2259 | def->dest_beg = dest_contents_beg; |
2260 | def->dest_end = dest_contents_end; |
2261 | |
2262 | /* Success. */ |
2263 | ctx->n_ref_defs++; |
2264 | return line_index + 1; |
2265 | |
2266 | abort: |
2267 | /* Failure. */ |
2268 | if(def != NULL && def->label_needs_free) |
2269 | free(ptr: def->label); |
2270 | if(def != NULL && def->title_needs_free) |
2271 | free(ptr: def->title); |
2272 | return ret; |
2273 | } |
2274 | |
2275 | static int |
2276 | md_is_link_reference(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, |
2277 | OFF beg, OFF end, MD_LINK_ATTR* attr) |
2278 | { |
2279 | const MD_REF_DEF* def; |
2280 | const MD_LINE* beg_line; |
2281 | int is_multiline; |
2282 | CHAR* label; |
2283 | SZ label_size; |
2284 | int ret; |
2285 | |
2286 | MD_ASSERT(CH(beg) == _T('[') || CH(beg) == _T('!')); |
2287 | MD_ASSERT(CH(end-1) == _T(']')); |
2288 | |
2289 | beg += (CH(beg) == _T('!') ? 2 : 1); |
2290 | end--; |
2291 | |
2292 | /* Find lines corresponding to the beg and end positions. */ |
2293 | beg_line = md_lookup_line(off: beg, lines, n_lines, NULL); |
2294 | is_multiline = (end > beg_line->end); |
2295 | |
2296 | if(is_multiline) { |
2297 | MD_CHECK(md_merge_lines_alloc(ctx, beg, end, beg_line, |
2298 | (int)(n_lines - (beg_line - lines)), _T(' '), &label, &label_size)); |
2299 | } else { |
2300 | label = (CHAR*) STR(beg); |
2301 | label_size = end - beg; |
2302 | } |
2303 | |
2304 | def = md_lookup_ref_def(ctx, label, label_size); |
2305 | if(def != NULL) { |
2306 | attr->dest_beg = def->dest_beg; |
2307 | attr->dest_end = def->dest_end; |
2308 | attr->title = def->title; |
2309 | attr->title_size = def->title_size; |
2310 | attr->title_needs_free = FALSE; |
2311 | } |
2312 | |
2313 | if(is_multiline) |
2314 | free(ptr: label); |
2315 | |
2316 | ret = (def != NULL); |
2317 | |
2318 | abort: |
2319 | return ret; |
2320 | } |
2321 | |
2322 | static int |
2323 | md_is_inline_link_spec(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, |
2324 | OFF beg, OFF* p_end, MD_LINK_ATTR* attr) |
2325 | { |
2326 | MD_SIZE line_index = 0; |
2327 | MD_SIZE tmp_line_index; |
2328 | OFF title_contents_beg; |
2329 | OFF title_contents_end; |
2330 | MD_SIZE title_contents_line_index; |
2331 | int title_is_multiline; |
2332 | OFF off = beg; |
2333 | int ret = FALSE; |
2334 | |
2335 | while(off >= lines[line_index].end) |
2336 | line_index++; |
2337 | |
2338 | MD_ASSERT(CH(off) == _T('(')); |
2339 | off++; |
2340 | |
2341 | /* Optional white space with up to one line break. */ |
2342 | while(off < lines[line_index].end && ISWHITESPACE(off)) |
2343 | off++; |
2344 | if(off >= lines[line_index].end && (off >= ctx->size || ISNEWLINE(off))) { |
2345 | line_index++; |
2346 | if(line_index >= n_lines) |
2347 | return FALSE; |
2348 | off = lines[line_index].beg; |
2349 | } |
2350 | |
2351 | /* Link destination may be omitted, but only when not also having a title. */ |
2352 | if(off < ctx->size && CH(off) == _T(')')) { |
2353 | attr->dest_beg = off; |
2354 | attr->dest_end = off; |
2355 | attr->title = NULL; |
2356 | attr->title_size = 0; |
2357 | attr->title_needs_free = FALSE; |
2358 | off++; |
2359 | *p_end = off; |
2360 | return TRUE; |
2361 | } |
2362 | |
2363 | /* Link destination. */ |
2364 | if(!md_is_link_destination(ctx, beg: off, max_end: lines[line_index].end, |
2365 | p_end: &off, p_contents_beg: &attr->dest_beg, p_contents_end: &attr->dest_end)) |
2366 | return FALSE; |
2367 | |
2368 | /* (Optional) title. */ |
2369 | if(md_is_link_title(ctx, lines: lines + line_index, n_lines: n_lines - line_index, beg: off, |
2370 | p_end: &off, p_beg_line_index: &title_contents_line_index, p_end_line_index: &tmp_line_index, |
2371 | p_contents_beg: &title_contents_beg, p_contents_end: &title_contents_end)) |
2372 | { |
2373 | title_is_multiline = (tmp_line_index != title_contents_line_index); |
2374 | title_contents_line_index += line_index; |
2375 | line_index += tmp_line_index; |
2376 | } else { |
2377 | /* Not a title. */ |
2378 | title_is_multiline = FALSE; |
2379 | title_contents_beg = off; |
2380 | title_contents_end = off; |
2381 | title_contents_line_index = 0; |
2382 | } |
2383 | |
2384 | /* Optional whitespace followed with final ')'. */ |
2385 | while(off < lines[line_index].end && ISWHITESPACE(off)) |
2386 | off++; |
2387 | if(off >= lines[line_index].end) { |
2388 | line_index++; |
2389 | if(line_index >= n_lines) |
2390 | return FALSE; |
2391 | off = lines[line_index].beg; |
2392 | } |
2393 | if(CH(off) != _T(')')) |
2394 | goto abort; |
2395 | off++; |
2396 | |
2397 | if(title_contents_beg >= title_contents_end) { |
2398 | attr->title = NULL; |
2399 | attr->title_size = 0; |
2400 | attr->title_needs_free = FALSE; |
2401 | } else if(!title_is_multiline) { |
2402 | attr->title = (CHAR*) STR(title_contents_beg); |
2403 | attr->title_size = title_contents_end - title_contents_beg; |
2404 | attr->title_needs_free = FALSE; |
2405 | } else { |
2406 | MD_CHECK(md_merge_lines_alloc(ctx, title_contents_beg, title_contents_end, |
2407 | lines + title_contents_line_index, n_lines - title_contents_line_index, |
2408 | _T('\n'), &attr->title, &attr->title_size)); |
2409 | attr->title_needs_free = TRUE; |
2410 | } |
2411 | |
2412 | *p_end = off; |
2413 | ret = TRUE; |
2414 | |
2415 | abort: |
2416 | return ret; |
2417 | } |
2418 | |
2419 | static void |
2420 | md_free_ref_defs(MD_CTX* ctx) |
2421 | { |
2422 | int i; |
2423 | |
2424 | for(i = 0; i < ctx->n_ref_defs; i++) { |
2425 | MD_REF_DEF* def = &ctx->ref_defs[i]; |
2426 | |
2427 | if(def->label_needs_free) |
2428 | free(ptr: def->label); |
2429 | if(def->title_needs_free) |
2430 | free(ptr: def->title); |
2431 | } |
2432 | |
2433 | free(ptr: ctx->ref_defs); |
2434 | } |
2435 | |
2436 | |
2437 | /****************************************** |
2438 | *** Processing Inlines (a.k.a Spans) *** |
2439 | ******************************************/ |
2440 | |
2441 | /* We process inlines in few phases: |
2442 | * |
2443 | * (1) We go through the block text and collect all significant characters |
2444 | * which may start/end a span or some other significant position into |
2445 | * ctx->marks[]. Core of this is what md_collect_marks() does. |
2446 | * |
2447 | * We also do some very brief preliminary context-less analysis, whether |
2448 | * it might be opener or closer (e.g. of an emphasis span). |
2449 | * |
2450 | * This speeds the other steps as we do not need to re-iterate over all |
2451 | * characters anymore. |
2452 | * |
2453 | * (2) We analyze each potential mark types, in order by their precedence. |
2454 | * |
2455 | * In each md_analyze_XXX() function, we re-iterate list of the marks, |
2456 | * skipping already resolved regions (in preceding precedences) and try to |
2457 | * resolve them. |
2458 | * |
2459 | * (2.1) For trivial marks, which are single (e.g. HTML entity), we just mark |
2460 | * them as resolved. |
2461 | * |
2462 | * (2.2) For range-type marks, we analyze whether the mark could be closer |
2463 | * and, if yes, whether there is some preceding opener it could satisfy. |
2464 | * |
2465 | * If not we check whether it could be really an opener and if yes, we |
2466 | * remember it so subsequent closers may resolve it. |
2467 | * |
2468 | * (3) Finally, when all marks were analyzed, we render the block contents |
2469 | * by calling MD_RENDERER::text() callback, interrupting by ::enter_span() |
2470 | * or ::close_span() whenever we reach a resolved mark. |
2471 | */ |
2472 | |
2473 | |
2474 | /* The mark structure. |
2475 | * |
2476 | * '\\': Maybe escape sequence. |
2477 | * '\0': NULL char. |
2478 | * '*': Maybe (strong) emphasis start/end. |
2479 | * '_': Maybe (strong) emphasis start/end. |
2480 | * '~': Maybe strikethrough start/end (needs MD_FLAG_STRIKETHROUGH). |
2481 | * '`': Maybe code span start/end. |
2482 | * '&': Maybe start of entity. |
2483 | * ';': Maybe end of entity. |
2484 | * '<': Maybe start of raw HTML or autolink. |
2485 | * '>': Maybe end of raw HTML or autolink. |
2486 | * '[': Maybe start of link label or link text. |
2487 | * '!': Equivalent of '[' for image. |
2488 | * ']': Maybe end of link label or link text. |
2489 | * '@': Maybe permissive e-mail auto-link (needs MD_FLAG_PERMISSIVEEMAILAUTOLINKS). |
2490 | * ':': Maybe permissive URL auto-link (needs MD_FLAG_PERMISSIVEURLAUTOLINKS). |
2491 | * '.': Maybe permissive WWW auto-link (needs MD_FLAG_PERMISSIVEWWWAUTOLINKS). |
2492 | * 'D': Dummy mark, it reserves a space for splitting a previous mark |
2493 | * (e.g. emphasis) or to make more space for storing some special data |
2494 | * related to the preceding mark (e.g. link). |
2495 | * |
2496 | * Note that not all instances of these chars in the text imply creation of the |
2497 | * structure. Only those which have (or may have, after we see more context) |
2498 | * the special meaning. |
2499 | * |
2500 | * (Keep this struct as small as possible to fit as much of them into CPU |
2501 | * cache line.) |
2502 | */ |
2503 | struct MD_MARK_tag { |
2504 | OFF beg; |
2505 | OFF end; |
2506 | |
2507 | /* For unresolved openers, 'next' may be used to form a stack of |
2508 | * unresolved open openers. |
2509 | * |
2510 | * When resolved with MD_MARK_OPENER/CLOSER flag, next/prev is index of the |
2511 | * respective closer/opener. |
2512 | */ |
2513 | int prev; |
2514 | int next; |
2515 | CHAR ch; |
2516 | unsigned char flags; |
2517 | }; |
2518 | |
2519 | /* Mark flags (these apply to ALL mark types). */ |
2520 | #define MD_MARK_POTENTIAL_OPENER 0x01 /* Maybe opener. */ |
2521 | #define MD_MARK_POTENTIAL_CLOSER 0x02 /* Maybe closer. */ |
2522 | #define MD_MARK_OPENER 0x04 /* Definitely opener. */ |
2523 | #define MD_MARK_CLOSER 0x08 /* Definitely closer. */ |
2524 | #define MD_MARK_RESOLVED 0x10 /* Resolved in any definite way. */ |
2525 | |
2526 | /* Mark flags specific for various mark types (so they can share bits). */ |
2527 | #define MD_MARK_EMPH_OC 0x20 /* Opener/closer mixed candidate. Helper for the "rule of 3". */ |
2528 | #define MD_MARK_EMPH_MOD3_0 0x40 |
2529 | #define MD_MARK_EMPH_MOD3_1 0x80 |
2530 | #define MD_MARK_EMPH_MOD3_2 (0x40 | 0x80) |
2531 | #define MD_MARK_EMPH_MOD3_MASK (0x40 | 0x80) |
2532 | #define MD_MARK_AUTOLINK 0x20 /* Distinguisher for '<', '>'. */ |
2533 | #define MD_MARK_AUTOLINK_MISSING_MAILTO 0x40 |
2534 | #define MD_MARK_VALIDPERMISSIVEAUTOLINK 0x20 /* For permissive autolinks. */ |
2535 | #define MD_MARK_HASNESTEDBRACKETS 0x20 /* For '[' to rule out invalid link labels early */ |
2536 | |
2537 | static MD_MARKSTACK* |
2538 | md_emph_stack(MD_CTX* ctx, MD_CHAR ch, unsigned flags) |
2539 | { |
2540 | MD_MARKSTACK* stack; |
2541 | |
2542 | switch(ch) { |
2543 | case '*': stack = &ASTERISK_OPENERS_oo_mod3_0; break; |
2544 | case '_': stack = &UNDERSCORE_OPENERS_oo_mod3_0; break; |
2545 | default: MD_UNREACHABLE(); |
2546 | } |
2547 | |
2548 | if(flags & MD_MARK_EMPH_OC) |
2549 | stack += 3; |
2550 | |
2551 | switch(flags & MD_MARK_EMPH_MOD3_MASK) { |
2552 | case MD_MARK_EMPH_MOD3_0: stack += 0; break; |
2553 | case MD_MARK_EMPH_MOD3_1: stack += 1; break; |
2554 | case MD_MARK_EMPH_MOD3_2: stack += 2; break; |
2555 | default: MD_UNREACHABLE(); |
2556 | } |
2557 | |
2558 | return stack; |
2559 | } |
2560 | |
2561 | static MD_MARKSTACK* |
2562 | md_opener_stack(MD_CTX* ctx, int mark_index) |
2563 | { |
2564 | MD_MARK* mark = &ctx->marks[mark_index]; |
2565 | |
2566 | switch(mark->ch) { |
2567 | case _T('*'): |
2568 | case _T('_'): return md_emph_stack(ctx, ch: mark->ch, flags: mark->flags); |
2569 | |
2570 | case _T('~'): return (mark->end - mark->beg == 1) ? &TILDE_OPENERS_1 : &TILDE_OPENERS_2; |
2571 | |
2572 | case _T('!'): |
2573 | case _T('['): return &BRACKET_OPENERS; |
2574 | |
2575 | default: MD_UNREACHABLE(); |
2576 | } |
2577 | } |
2578 | |
2579 | static MD_MARK* |
2580 | md_add_mark(MD_CTX* ctx) |
2581 | { |
2582 | if(ctx->n_marks >= ctx->alloc_marks) { |
2583 | MD_MARK* new_marks; |
2584 | |
2585 | ctx->alloc_marks = (ctx->alloc_marks > 0 |
2586 | ? ctx->alloc_marks + ctx->alloc_marks / 2 |
2587 | : 64); |
2588 | new_marks = realloc(ptr: ctx->marks, size: ctx->alloc_marks * sizeof(MD_MARK)); |
2589 | if(new_marks == NULL) { |
2590 | MD_LOG("realloc() failed." ); |
2591 | return NULL; |
2592 | } |
2593 | |
2594 | ctx->marks = new_marks; |
2595 | } |
2596 | |
2597 | return &ctx->marks[ctx->n_marks++]; |
2598 | } |
2599 | |
2600 | #define ADD_MARK_() \ |
2601 | do { \ |
2602 | mark = md_add_mark(ctx); \ |
2603 | if(mark == NULL) { \ |
2604 | ret = -1; \ |
2605 | goto abort; \ |
2606 | } \ |
2607 | } while(0) |
2608 | |
2609 | #define ADD_MARK(ch_, beg_, end_, flags_) \ |
2610 | do { \ |
2611 | ADD_MARK_(); \ |
2612 | mark->beg = (beg_); \ |
2613 | mark->end = (end_); \ |
2614 | mark->prev = -1; \ |
2615 | mark->next = -1; \ |
2616 | mark->ch = (char)(ch_); \ |
2617 | mark->flags = (flags_); \ |
2618 | } while(0) |
2619 | |
2620 | |
2621 | static inline void |
2622 | md_mark_stack_push(MD_CTX* ctx, MD_MARKSTACK* stack, int mark_index) |
2623 | { |
2624 | ctx->marks[mark_index].next = stack->top; |
2625 | stack->top = mark_index; |
2626 | } |
2627 | |
2628 | static inline int |
2629 | md_mark_stack_pop(MD_CTX* ctx, MD_MARKSTACK* stack) |
2630 | { |
2631 | int top = stack->top; |
2632 | if(top >= 0) |
2633 | stack->top = ctx->marks[top].next; |
2634 | return top; |
2635 | } |
2636 | |
2637 | /* Sometimes, we need to store a pointer into the mark. It is quite rare |
2638 | * so we do not bother to make MD_MARK use union, and it can only happen |
2639 | * for dummy marks. */ |
2640 | static inline void |
2641 | md_mark_store_ptr(MD_CTX* ctx, int mark_index, void* ptr) |
2642 | { |
2643 | MD_MARK* mark = &ctx->marks[mark_index]; |
2644 | MD_ASSERT(mark->ch == 'D'); |
2645 | |
2646 | /* Check only members beg and end are misused for this. */ |
2647 | MD_ASSERT(sizeof(void*) <= 2 * sizeof(OFF)); |
2648 | memcpy(dest: mark, src: &ptr, n: sizeof(void*)); |
2649 | } |
2650 | |
2651 | static inline void* |
2652 | md_mark_get_ptr(MD_CTX* ctx, int mark_index) |
2653 | { |
2654 | void* ptr; |
2655 | MD_MARK* mark = &ctx->marks[mark_index]; |
2656 | MD_ASSERT(mark->ch == 'D'); |
2657 | memcpy(dest: &ptr, src: mark, n: sizeof(void*)); |
2658 | return ptr; |
2659 | } |
2660 | |
2661 | static inline void |
2662 | md_resolve_range(MD_CTX* ctx, int opener_index, int closer_index) |
2663 | { |
2664 | MD_MARK* opener = &ctx->marks[opener_index]; |
2665 | MD_MARK* closer = &ctx->marks[closer_index]; |
2666 | |
2667 | /* Interconnect opener and closer and mark both as resolved. */ |
2668 | opener->next = closer_index; |
2669 | closer->prev = opener_index; |
2670 | |
2671 | opener->flags |= MD_MARK_OPENER | MD_MARK_RESOLVED; |
2672 | closer->flags |= MD_MARK_CLOSER | MD_MARK_RESOLVED; |
2673 | } |
2674 | |
2675 | |
2676 | #define MD_ROLLBACK_CROSSING 0 |
2677 | #define MD_ROLLBACK_ALL 1 |
2678 | |
2679 | /* In the range ctx->marks[opener_index] ... [closer_index], undo some or all |
2680 | * resolvings accordingly to these rules: |
2681 | * |
2682 | * (1) All stacks of openers are cut so that any pending potential openers |
2683 | * are discarded from future consideration. |
2684 | * |
2685 | * (2) If 'how' is MD_ROLLBACK_ALL, then ALL resolved marks inside the range |
2686 | * are thrown away and turned into dummy marks ('D'). |
2687 | * |
2688 | * WARNING: Do not call for arbitrary range of opener and closer. |
2689 | * This must form (potentially) valid range not crossing nesting boundaries |
2690 | * of already resolved ranges. |
2691 | */ |
2692 | static void |
2693 | md_rollback(MD_CTX* ctx, int opener_index, int closer_index, int how) |
2694 | { |
2695 | int i; |
2696 | |
2697 | for(i = 0; i < (int) SIZEOF_ARRAY(ctx->opener_stacks); i++) { |
2698 | MD_MARKSTACK* stack = &ctx->opener_stacks[i]; |
2699 | while(stack->top >= opener_index) |
2700 | md_mark_stack_pop(ctx, stack); |
2701 | } |
2702 | |
2703 | if(how == MD_ROLLBACK_ALL) { |
2704 | for(i = opener_index + 1; i < closer_index; i++) { |
2705 | ctx->marks[i].ch = 'D'; |
2706 | ctx->marks[i].flags = 0; |
2707 | } |
2708 | } |
2709 | } |
2710 | |
2711 | static void |
2712 | md_build_mark_char_map(MD_CTX* ctx) |
2713 | { |
2714 | memset(s: ctx->mark_char_map, c: 0, n: sizeof(ctx->mark_char_map)); |
2715 | |
2716 | ctx->mark_char_map['\\'] = 1; |
2717 | ctx->mark_char_map['*'] = 1; |
2718 | ctx->mark_char_map['_'] = 1; |
2719 | ctx->mark_char_map['`'] = 1; |
2720 | ctx->mark_char_map['&'] = 1; |
2721 | ctx->mark_char_map[';'] = 1; |
2722 | ctx->mark_char_map['<'] = 1; |
2723 | ctx->mark_char_map['>'] = 1; |
2724 | ctx->mark_char_map['['] = 1; |
2725 | ctx->mark_char_map['!'] = 1; |
2726 | ctx->mark_char_map[']'] = 1; |
2727 | ctx->mark_char_map['\0'] = 1; |
2728 | |
2729 | if(ctx->parser.flags & MD_FLAG_STRIKETHROUGH) |
2730 | ctx->mark_char_map['~'] = 1; |
2731 | |
2732 | if(ctx->parser.flags & MD_FLAG_LATEXMATHSPANS) |
2733 | ctx->mark_char_map['$'] = 1; |
2734 | |
2735 | if(ctx->parser.flags & MD_FLAG_PERMISSIVEEMAILAUTOLINKS) |
2736 | ctx->mark_char_map['@'] = 1; |
2737 | |
2738 | if(ctx->parser.flags & MD_FLAG_PERMISSIVEURLAUTOLINKS) |
2739 | ctx->mark_char_map[':'] = 1; |
2740 | |
2741 | if(ctx->parser.flags & MD_FLAG_PERMISSIVEWWWAUTOLINKS) |
2742 | ctx->mark_char_map['.'] = 1; |
2743 | |
2744 | if((ctx->parser.flags & MD_FLAG_TABLES) || (ctx->parser.flags & MD_FLAG_WIKILINKS)) |
2745 | ctx->mark_char_map['|'] = 1; |
2746 | |
2747 | if(ctx->parser.flags & MD_FLAG_COLLAPSEWHITESPACE) { |
2748 | int i; |
2749 | |
2750 | for(i = 0; i < (int) sizeof(ctx->mark_char_map); i++) { |
2751 | if(ISWHITESPACE_(i)) |
2752 | ctx->mark_char_map[i] = 1; |
2753 | } |
2754 | } |
2755 | } |
2756 | |
2757 | static int |
2758 | md_is_code_span(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, OFF beg, |
2759 | MD_MARK* opener, MD_MARK* closer, |
2760 | OFF last_potential_closers[CODESPAN_MARK_MAXLEN], |
2761 | int* p_reached_paragraph_end) |
2762 | { |
2763 | OFF opener_beg = beg; |
2764 | OFF opener_end; |
2765 | OFF closer_beg; |
2766 | OFF closer_end; |
2767 | SZ mark_len; |
2768 | OFF line_end; |
2769 | int has_space_after_opener = FALSE; |
2770 | int has_eol_after_opener = FALSE; |
2771 | int has_space_before_closer = FALSE; |
2772 | int has_eol_before_closer = FALSE; |
2773 | int has_only_space = TRUE; |
2774 | MD_SIZE line_index = 0; |
2775 | |
2776 | line_end = lines[0].end; |
2777 | opener_end = opener_beg; |
2778 | while(opener_end < line_end && CH(opener_end) == _T('`')) |
2779 | opener_end++; |
2780 | has_space_after_opener = (opener_end < line_end && CH(opener_end) == _T(' ')); |
2781 | has_eol_after_opener = (opener_end == line_end); |
2782 | |
2783 | /* The caller needs to know end of the opening mark even if we fail. */ |
2784 | opener->end = opener_end; |
2785 | |
2786 | mark_len = opener_end - opener_beg; |
2787 | if(mark_len > CODESPAN_MARK_MAXLEN) |
2788 | return FALSE; |
2789 | |
2790 | /* Check whether we already know there is no closer of this length. |
2791 | * If so, re-scan does no sense. This fixes issue #59. */ |
2792 | if(last_potential_closers[mark_len-1] >= lines[n_lines-1].end || |
2793 | (*p_reached_paragraph_end && last_potential_closers[mark_len-1] < opener_end)) |
2794 | return FALSE; |
2795 | |
2796 | closer_beg = opener_end; |
2797 | closer_end = opener_end; |
2798 | |
2799 | /* Find closer mark. */ |
2800 | while(TRUE) { |
2801 | while(closer_beg < line_end && CH(closer_beg) != _T('`')) { |
2802 | if(CH(closer_beg) != _T(' ')) |
2803 | has_only_space = FALSE; |
2804 | closer_beg++; |
2805 | } |
2806 | closer_end = closer_beg; |
2807 | while(closer_end < line_end && CH(closer_end) == _T('`')) |
2808 | closer_end++; |
2809 | |
2810 | if(closer_end - closer_beg == mark_len) { |
2811 | /* Success. */ |
2812 | has_space_before_closer = (closer_beg > lines[line_index].beg && CH(closer_beg-1) == _T(' ')); |
2813 | has_eol_before_closer = (closer_beg == lines[line_index].beg); |
2814 | break; |
2815 | } |
2816 | |
2817 | if(closer_end - closer_beg > 0) { |
2818 | /* We have found a back-tick which is not part of the closer. */ |
2819 | has_only_space = FALSE; |
2820 | |
2821 | /* But if we eventually fail, remember it as a potential closer |
2822 | * of its own length for future attempts. This mitigates needs for |
2823 | * rescans. */ |
2824 | if(closer_end - closer_beg < CODESPAN_MARK_MAXLEN) { |
2825 | if(closer_beg > last_potential_closers[closer_end - closer_beg - 1]) |
2826 | last_potential_closers[closer_end - closer_beg - 1] = closer_beg; |
2827 | } |
2828 | } |
2829 | |
2830 | if(closer_end >= line_end) { |
2831 | line_index++; |
2832 | if(line_index >= n_lines) { |
2833 | /* Reached end of the paragraph and still nothing. */ |
2834 | *p_reached_paragraph_end = TRUE; |
2835 | return FALSE; |
2836 | } |
2837 | /* Try on the next line. */ |
2838 | line_end = lines[line_index].end; |
2839 | closer_beg = lines[line_index].beg; |
2840 | } else { |
2841 | closer_beg = closer_end; |
2842 | } |
2843 | } |
2844 | |
2845 | /* If there is a space or a new line both after and before the opener |
2846 | * (and if the code span is not made of spaces only), consume one initial |
2847 | * and one trailing space as part of the marks. */ |
2848 | if(!has_only_space && |
2849 | (has_space_after_opener || has_eol_after_opener) && |
2850 | (has_space_before_closer || has_eol_before_closer)) |
2851 | { |
2852 | if(has_space_after_opener) |
2853 | opener_end++; |
2854 | else |
2855 | opener_end = lines[1].beg; |
2856 | |
2857 | if(has_space_before_closer) |
2858 | closer_beg--; |
2859 | else { |
2860 | /* Go back to the end of prev line */ |
2861 | closer_beg = lines[line_index-1].end; |
2862 | /* But restore any trailing whitespace */ |
2863 | while(closer_beg < ctx->size && ISBLANK(closer_beg)) |
2864 | closer_beg++; |
2865 | } |
2866 | } |
2867 | |
2868 | opener->ch = _T('`'); |
2869 | opener->beg = opener_beg; |
2870 | opener->end = opener_end; |
2871 | opener->flags = MD_MARK_POTENTIAL_OPENER; |
2872 | closer->ch = _T('`'); |
2873 | closer->beg = closer_beg; |
2874 | closer->end = closer_end; |
2875 | closer->flags = MD_MARK_POTENTIAL_CLOSER; |
2876 | return TRUE; |
2877 | } |
2878 | |
2879 | static int |
2880 | md_is_autolink_uri(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end) |
2881 | { |
2882 | OFF off = beg+1; |
2883 | |
2884 | MD_ASSERT(CH(beg) == _T('<')); |
2885 | |
2886 | /* Check for scheme. */ |
2887 | if(off >= max_end || !ISASCII(off)) |
2888 | return FALSE; |
2889 | off++; |
2890 | while(1) { |
2891 | if(off >= max_end) |
2892 | return FALSE; |
2893 | if(off - beg > 32) |
2894 | return FALSE; |
2895 | if(CH(off) == _T(':') && off - beg >= 3) |
2896 | break; |
2897 | if(!ISALNUM(off) && CH(off) != _T('+') && CH(off) != _T('-') && CH(off) != _T('.')) |
2898 | return FALSE; |
2899 | off++; |
2900 | } |
2901 | |
2902 | /* Check the path after the scheme. */ |
2903 | while(off < max_end && CH(off) != _T('>')) { |
2904 | if(ISWHITESPACE(off) || ISCNTRL(off) || CH(off) == _T('<')) |
2905 | return FALSE; |
2906 | off++; |
2907 | } |
2908 | |
2909 | if(off >= max_end) |
2910 | return FALSE; |
2911 | |
2912 | MD_ASSERT(CH(off) == _T('>')); |
2913 | *p_end = off+1; |
2914 | return TRUE; |
2915 | } |
2916 | |
2917 | static int |
2918 | md_is_autolink_email(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end) |
2919 | { |
2920 | OFF off = beg + 1; |
2921 | int label_len; |
2922 | |
2923 | MD_ASSERT(CH(beg) == _T('<')); |
2924 | |
2925 | /* The code should correspond to this regexp: |
2926 | /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+ |
2927 | @[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])? |
2928 | (?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/ |
2929 | */ |
2930 | |
2931 | /* Username (before '@'). */ |
2932 | while(off < max_end && (ISALNUM(off) || ISANYOF(off, _T(".!#$%&'*+/=?^_`{|}~-" )))) |
2933 | off++; |
2934 | if(off <= beg+1) |
2935 | return FALSE; |
2936 | |
2937 | /* '@' */ |
2938 | if(off >= max_end || CH(off) != _T('@')) |
2939 | return FALSE; |
2940 | off++; |
2941 | |
2942 | /* Labels delimited with '.'; each label is sequence of 1 - 63 alnum |
2943 | * characters or '-', but '-' is not allowed as first or last char. */ |
2944 | label_len = 0; |
2945 | while(off < max_end) { |
2946 | if(ISALNUM(off)) |
2947 | label_len++; |
2948 | else if(CH(off) == _T('-') && label_len > 0) |
2949 | label_len++; |
2950 | else if(CH(off) == _T('.') && label_len > 0 && CH(off-1) != _T('-')) |
2951 | label_len = 0; |
2952 | else |
2953 | break; |
2954 | |
2955 | if(label_len > 63) |
2956 | return FALSE; |
2957 | |
2958 | off++; |
2959 | } |
2960 | |
2961 | if(label_len <= 0 || off >= max_end || CH(off) != _T('>') || CH(off-1) == _T('-')) |
2962 | return FALSE; |
2963 | |
2964 | *p_end = off+1; |
2965 | return TRUE; |
2966 | } |
2967 | |
2968 | static int |
2969 | md_is_autolink(MD_CTX* ctx, OFF beg, OFF max_end, OFF* p_end, int* p_missing_mailto) |
2970 | { |
2971 | if(md_is_autolink_uri(ctx, beg, max_end, p_end)) { |
2972 | *p_missing_mailto = FALSE; |
2973 | return TRUE; |
2974 | } |
2975 | |
2976 | if(md_is_autolink_email(ctx, beg, max_end, p_end)) { |
2977 | *p_missing_mailto = TRUE; |
2978 | return TRUE; |
2979 | } |
2980 | |
2981 | return FALSE; |
2982 | } |
2983 | |
2984 | static int |
2985 | md_collect_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_mode) |
2986 | { |
2987 | MD_SIZE line_index; |
2988 | int ret = 0; |
2989 | MD_MARK* mark; |
2990 | OFF codespan_last_potential_closers[CODESPAN_MARK_MAXLEN] = { 0 }; |
2991 | int codespan_scanned_till_paragraph_end = FALSE; |
2992 | |
2993 | for(line_index = 0; line_index < n_lines; line_index++) { |
2994 | const MD_LINE* line = &lines[line_index]; |
2995 | OFF off = line->beg; |
2996 | |
2997 | while(TRUE) { |
2998 | CHAR ch; |
2999 | |
3000 | #ifdef MD4C_USE_UTF16 |
3001 | /* For UTF-16, mark_char_map[] covers only ASCII. */ |
3002 | #define IS_MARK_CHAR(off) ((CH(off) < SIZEOF_ARRAY(ctx->mark_char_map)) && \ |
3003 | (ctx->mark_char_map[(unsigned char) CH(off)])) |
3004 | #else |
3005 | /* For 8-bit encodings, mark_char_map[] covers all 256 elements. */ |
3006 | #define IS_MARK_CHAR(off) (ctx->mark_char_map[(unsigned char) CH(off)]) |
3007 | #endif |
3008 | |
3009 | /* Optimization: Use some loop unrolling. */ |
3010 | while(off + 3 < line->end && !IS_MARK_CHAR(off+0) && !IS_MARK_CHAR(off+1) |
3011 | && !IS_MARK_CHAR(off+2) && !IS_MARK_CHAR(off+3)) |
3012 | off += 4; |
3013 | while(off < line->end && !IS_MARK_CHAR(off+0)) |
3014 | off++; |
3015 | |
3016 | if(off >= line->end) |
3017 | break; |
3018 | |
3019 | ch = CH(off); |
3020 | |
3021 | /* A backslash escape. |
3022 | * It can go beyond line->end as it may involve escaped new |
3023 | * line to form a hard break. */ |
3024 | if(ch == _T('\\') && off+1 < ctx->size && (ISPUNCT(off+1) || ISNEWLINE(off+1))) { |
3025 | /* Hard-break cannot be on the last line of the block. */ |
3026 | if(!ISNEWLINE(off+1) || line_index+1 < n_lines) |
3027 | ADD_MARK(ch, off, off+2, MD_MARK_RESOLVED); |
3028 | off += 2; |
3029 | continue; |
3030 | } |
3031 | |
3032 | /* A potential (string) emphasis start/end. */ |
3033 | if(ch == _T('*') || ch == _T('_')) { |
3034 | OFF tmp = off+1; |
3035 | int left_level; /* What precedes: 0 = whitespace; 1 = punctuation; 2 = other char. */ |
3036 | int right_level; /* What follows: 0 = whitespace; 1 = punctuation; 2 = other char. */ |
3037 | |
3038 | while(tmp < line->end && CH(tmp) == ch) |
3039 | tmp++; |
3040 | |
3041 | if(off == line->beg || ISUNICODEWHITESPACEBEFORE(off)) |
3042 | left_level = 0; |
3043 | else if(ISUNICODEPUNCTBEFORE(off)) |
3044 | left_level = 1; |
3045 | else |
3046 | left_level = 2; |
3047 | |
3048 | if(tmp == line->end || ISUNICODEWHITESPACE(tmp)) |
3049 | right_level = 0; |
3050 | else if(ISUNICODEPUNCT(tmp)) |
3051 | right_level = 1; |
3052 | else |
3053 | right_level = 2; |
3054 | |
3055 | /* Intra-word underscore doesn't have special meaning. */ |
3056 | if(ch == _T('_') && left_level == 2 && right_level == 2) { |
3057 | left_level = 0; |
3058 | right_level = 0; |
3059 | } |
3060 | |
3061 | if(left_level != 0 || right_level != 0) { |
3062 | unsigned flags = 0; |
3063 | |
3064 | if(left_level > 0 && left_level >= right_level) |
3065 | flags |= MD_MARK_POTENTIAL_CLOSER; |
3066 | if(right_level > 0 && right_level >= left_level) |
3067 | flags |= MD_MARK_POTENTIAL_OPENER; |
3068 | if(flags == (MD_MARK_POTENTIAL_OPENER | MD_MARK_POTENTIAL_CLOSER)) |
3069 | flags |= MD_MARK_EMPH_OC; |
3070 | |
3071 | /* For "the rule of three" we need to remember the original |
3072 | * size of the mark (modulo three), before we potentially |
3073 | * split the mark when being later resolved partially by some |
3074 | * shorter closer. */ |
3075 | switch((tmp - off) % 3) { |
3076 | case 0: flags |= MD_MARK_EMPH_MOD3_0; break; |
3077 | case 1: flags |= MD_MARK_EMPH_MOD3_1; break; |
3078 | case 2: flags |= MD_MARK_EMPH_MOD3_2; break; |
3079 | } |
3080 | |
3081 | ADD_MARK(ch, off, tmp, flags); |
3082 | |
3083 | /* During resolving, multiple asterisks may have to be |
3084 | * split into independent span start/ends. Consider e.g. |
3085 | * "**foo* bar*". Therefore we push also some empty dummy |
3086 | * marks to have enough space for that. */ |
3087 | off++; |
3088 | while(off < tmp) { |
3089 | ADD_MARK('D', off, off, 0); |
3090 | off++; |
3091 | } |
3092 | continue; |
3093 | } |
3094 | |
3095 | off = tmp; |
3096 | continue; |
3097 | } |
3098 | |
3099 | /* A potential code span start/end. */ |
3100 | if(ch == _T('`')) { |
3101 | MD_MARK opener; |
3102 | MD_MARK closer; |
3103 | int is_code_span; |
3104 | |
3105 | is_code_span = md_is_code_span(ctx, lines: line, n_lines: n_lines - line_index, beg: off, |
3106 | opener: &opener, closer: &closer, last_potential_closers: codespan_last_potential_closers, |
3107 | p_reached_paragraph_end: &codespan_scanned_till_paragraph_end); |
3108 | if(is_code_span) { |
3109 | ADD_MARK(opener.ch, opener.beg, opener.end, opener.flags); |
3110 | ADD_MARK(closer.ch, closer.beg, closer.end, closer.flags); |
3111 | md_resolve_range(ctx, opener_index: ctx->n_marks-2, closer_index: ctx->n_marks-1); |
3112 | off = closer.end; |
3113 | |
3114 | /* Advance the current line accordingly. */ |
3115 | if(off > line->end) |
3116 | line = md_lookup_line(off, lines, n_lines, p_line_index: &line_index); |
3117 | continue; |
3118 | } |
3119 | |
3120 | off = opener.end; |
3121 | continue; |
3122 | } |
3123 | |
3124 | /* A potential entity start. */ |
3125 | if(ch == _T('&')) { |
3126 | ADD_MARK(ch, off, off+1, MD_MARK_POTENTIAL_OPENER); |
3127 | off++; |
3128 | continue; |
3129 | } |
3130 | |
3131 | /* A potential entity end. */ |
3132 | if(ch == _T(';')) { |
3133 | /* We surely cannot be entity unless the previous mark is '&'. */ |
3134 | if(ctx->n_marks > 0 && ctx->marks[ctx->n_marks-1].ch == _T('&')) |
3135 | ADD_MARK(ch, off, off+1, MD_MARK_POTENTIAL_CLOSER); |
3136 | |
3137 | off++; |
3138 | continue; |
3139 | } |
3140 | |
3141 | /* A potential autolink or raw HTML start/end. */ |
3142 | if(ch == _T('<')) { |
3143 | int is_autolink; |
3144 | OFF autolink_end; |
3145 | int missing_mailto; |
3146 | |
3147 | if(!(ctx->parser.flags & MD_FLAG_NOHTMLSPANS)) { |
3148 | int is_html; |
3149 | OFF html_end; |
3150 | |
3151 | /* Given the nature of the raw HTML, we have to recognize |
3152 | * it here. Doing so later in md_analyze_lt_gt() could |
3153 | * open can of worms of quadratic complexity. */ |
3154 | is_html = md_is_html_any(ctx, lines: line, n_lines: n_lines - line_index, beg: off, |
3155 | max_end: lines[n_lines-1].end, p_end: &html_end); |
3156 | if(is_html) { |
3157 | ADD_MARK(_T('<'), off, off, MD_MARK_OPENER | MD_MARK_RESOLVED); |
3158 | ADD_MARK(_T('>'), html_end, html_end, MD_MARK_CLOSER | MD_MARK_RESOLVED); |
3159 | ctx->marks[ctx->n_marks-2].next = ctx->n_marks-1; |
3160 | ctx->marks[ctx->n_marks-1].prev = ctx->n_marks-2; |
3161 | off = html_end; |
3162 | |
3163 | /* Advance the current line accordingly. */ |
3164 | if(off > line->end) |
3165 | line = md_lookup_line(off, lines, n_lines, p_line_index: &line_index); |
3166 | continue; |
3167 | } |
3168 | } |
3169 | |
3170 | is_autolink = md_is_autolink(ctx, beg: off, max_end: lines[n_lines-1].end, |
3171 | p_end: &autolink_end, p_missing_mailto: &missing_mailto); |
3172 | if(is_autolink) { |
3173 | unsigned flags = MD_MARK_RESOLVED | MD_MARK_AUTOLINK; |
3174 | if(missing_mailto) |
3175 | flags |= MD_MARK_AUTOLINK_MISSING_MAILTO; |
3176 | |
3177 | ADD_MARK(_T('<'), off, off+1, MD_MARK_OPENER | flags); |
3178 | ADD_MARK(_T('>'), autolink_end-1, autolink_end, MD_MARK_CLOSER | flags); |
3179 | ctx->marks[ctx->n_marks-2].next = ctx->n_marks-1; |
3180 | ctx->marks[ctx->n_marks-1].prev = ctx->n_marks-2; |
3181 | off = autolink_end; |
3182 | continue; |
3183 | } |
3184 | |
3185 | off++; |
3186 | continue; |
3187 | } |
3188 | |
3189 | /* A potential link or its part. */ |
3190 | if(ch == _T('[') || (ch == _T('!') && off+1 < line->end && CH(off+1) == _T('['))) { |
3191 | OFF tmp = (ch == _T('[') ? off+1 : off+2); |
3192 | ADD_MARK(ch, off, tmp, MD_MARK_POTENTIAL_OPENER); |
3193 | off = tmp; |
3194 | /* Two dummies to make enough place for data we need if it is |
3195 | * a link. */ |
3196 | ADD_MARK('D', off, off, 0); |
3197 | ADD_MARK('D', off, off, 0); |
3198 | continue; |
3199 | } |
3200 | if(ch == _T(']')) { |
3201 | ADD_MARK(ch, off, off+1, MD_MARK_POTENTIAL_CLOSER); |
3202 | off++; |
3203 | continue; |
3204 | } |
3205 | |
3206 | /* A potential permissive e-mail autolink. */ |
3207 | if(ch == _T('@')) { |
3208 | if(line->beg + 1 <= off && ISALNUM(off-1) && |
3209 | off + 3 < line->end && ISALNUM(off+1)) |
3210 | { |
3211 | ADD_MARK(ch, off, off+1, MD_MARK_POTENTIAL_OPENER); |
3212 | /* Push a dummy as a reserve for a closer. */ |
3213 | ADD_MARK('D', line->beg, line->end, 0); |
3214 | } |
3215 | |
3216 | off++; |
3217 | continue; |
3218 | } |
3219 | |
3220 | /* A potential permissive URL autolink. */ |
3221 | if(ch == _T(':')) { |
3222 | static struct { |
3223 | const CHAR* scheme; |
3224 | SZ scheme_size; |
3225 | const CHAR* suffix; |
3226 | SZ suffix_size; |
3227 | } scheme_map[] = { |
3228 | /* In the order from the most frequently used, arguably. */ |
3229 | { _T("http" ), 4, _T("//" ), 2 }, |
3230 | { _T("https" ), 5, _T("//" ), 2 }, |
3231 | { _T("ftp" ), 3, _T("//" ), 2 } |
3232 | }; |
3233 | int scheme_index; |
3234 | |
3235 | for(scheme_index = 0; scheme_index < (int) SIZEOF_ARRAY(scheme_map); scheme_index++) { |
3236 | const CHAR* scheme = scheme_map[scheme_index].scheme; |
3237 | const SZ scheme_size = scheme_map[scheme_index].scheme_size; |
3238 | const CHAR* suffix = scheme_map[scheme_index].suffix; |
3239 | const SZ suffix_size = scheme_map[scheme_index].suffix_size; |
3240 | |
3241 | if(line->beg + scheme_size <= off && md_ascii_eq(STR(off-scheme_size), s2: scheme, n: scheme_size) && |
3242 | off + 1 + suffix_size < line->end && md_ascii_eq(STR(off+1), s2: suffix, n: suffix_size)) |
3243 | { |
3244 | ADD_MARK(ch, off-scheme_size, off+1+suffix_size, MD_MARK_POTENTIAL_OPENER); |
3245 | /* Push a dummy as a reserve for a closer. */ |
3246 | ADD_MARK('D', line->beg, line->end, 0); |
3247 | off += 1 + suffix_size; |
3248 | break; |
3249 | } |
3250 | } |
3251 | |
3252 | off++; |
3253 | continue; |
3254 | } |
3255 | |
3256 | /* A potential permissive WWW autolink. */ |
3257 | if(ch == _T('.')) { |
3258 | if(line->beg + 3 <= off && md_ascii_eq(STR(off-3), _T("www" ), n: 3) && |
3259 | (off-3 == line->beg || ISUNICODEWHITESPACEBEFORE(off-3) || ISUNICODEPUNCTBEFORE(off-3))) |
3260 | { |
3261 | ADD_MARK(ch, off-3, off+1, MD_MARK_POTENTIAL_OPENER); |
3262 | /* Push a dummy as a reserve for a closer. */ |
3263 | ADD_MARK('D', line->beg, line->end, 0); |
3264 | off++; |
3265 | continue; |
3266 | } |
3267 | |
3268 | off++; |
3269 | continue; |
3270 | } |
3271 | |
3272 | /* A potential table cell boundary or wiki link label delimiter. */ |
3273 | if((table_mode || ctx->parser.flags & MD_FLAG_WIKILINKS) && ch == _T('|')) { |
3274 | ADD_MARK(ch, off, off+1, 0); |
3275 | off++; |
3276 | continue; |
3277 | } |
3278 | |
3279 | /* A potential strikethrough start/end. */ |
3280 | if(ch == _T('~')) { |
3281 | OFF tmp = off+1; |
3282 | |
3283 | while(tmp < line->end && CH(tmp) == _T('~')) |
3284 | tmp++; |
3285 | |
3286 | if(tmp - off < 3) { |
3287 | unsigned flags = 0; |
3288 | |
3289 | if(tmp < line->end && !ISUNICODEWHITESPACE(tmp)) |
3290 | flags |= MD_MARK_POTENTIAL_OPENER; |
3291 | if(off > line->beg && !ISUNICODEWHITESPACEBEFORE(off)) |
3292 | flags |= MD_MARK_POTENTIAL_CLOSER; |
3293 | if(flags != 0) |
3294 | ADD_MARK(ch, off, tmp, flags); |
3295 | } |
3296 | |
3297 | off = tmp; |
3298 | continue; |
3299 | } |
3300 | |
3301 | /* A potential equation start/end */ |
3302 | if(ch == _T('$')) { |
3303 | /* We can have at most two consecutive $ signs, |
3304 | * where two dollar signs signify a display equation. */ |
3305 | OFF tmp = off+1; |
3306 | |
3307 | while(tmp < line->end && CH(tmp) == _T('$')) |
3308 | tmp++; |
3309 | |
3310 | if(tmp - off <= 2) { |
3311 | unsigned flags = MD_MARK_POTENTIAL_OPENER | MD_MARK_POTENTIAL_CLOSER; |
3312 | |
3313 | if(off > line->beg && !ISUNICODEWHITESPACEBEFORE(off) && !ISUNICODEPUNCTBEFORE(off)) |
3314 | flags &= ~MD_MARK_POTENTIAL_OPENER; |
3315 | if(tmp < line->end && !ISUNICODEWHITESPACE(tmp) && !ISUNICODEPUNCT(tmp)) |
3316 | flags &= ~MD_MARK_POTENTIAL_CLOSER; |
3317 | if(flags != 0) |
3318 | ADD_MARK(ch, off, tmp, flags); |
3319 | } |
3320 | |
3321 | off = tmp; |
3322 | continue; |
3323 | } |
3324 | |
3325 | /* Turn non-trivial whitespace into single space. */ |
3326 | if(ISWHITESPACE_(ch)) { |
3327 | OFF tmp = off+1; |
3328 | |
3329 | while(tmp < line->end && ISWHITESPACE(tmp)) |
3330 | tmp++; |
3331 | |
3332 | if(tmp - off > 1 || ch != _T(' ')) |
3333 | ADD_MARK(ch, off, tmp, MD_MARK_RESOLVED); |
3334 | |
3335 | off = tmp; |
3336 | continue; |
3337 | } |
3338 | |
3339 | /* NULL character. */ |
3340 | if(ch == _T('\0')) { |
3341 | ADD_MARK(ch, off, off+1, MD_MARK_RESOLVED); |
3342 | off++; |
3343 | continue; |
3344 | } |
3345 | |
3346 | off++; |
3347 | } |
3348 | } |
3349 | |
3350 | /* Add a dummy mark at the end of the mark vector to simplify |
3351 | * process_inlines(). */ |
3352 | ADD_MARK(127, ctx->size, ctx->size, MD_MARK_RESOLVED); |
3353 | |
3354 | abort: |
3355 | return ret; |
3356 | } |
3357 | |
3358 | static void |
3359 | md_analyze_bracket(MD_CTX* ctx, int mark_index) |
3360 | { |
3361 | /* We cannot really resolve links here as for that we would need |
3362 | * more context. E.g. a following pair of brackets (reference link), |
3363 | * or enclosing pair of brackets (if the inner is the link, the outer |
3364 | * one cannot be.) |
3365 | * |
3366 | * Therefore we here only construct a list of '[' ']' pairs ordered by |
3367 | * position of the closer. This allows us to analyze what is or is not |
3368 | * link in the right order, from inside to outside in case of nested |
3369 | * brackets. |
3370 | * |
3371 | * The resolving itself is deferred to md_resolve_links(). |
3372 | */ |
3373 | |
3374 | MD_MARK* mark = &ctx->marks[mark_index]; |
3375 | |
3376 | if(mark->flags & MD_MARK_POTENTIAL_OPENER) { |
3377 | if(BRACKET_OPENERS.top >= 0) |
3378 | ctx->marks[BRACKET_OPENERS.top].flags |= MD_MARK_HASNESTEDBRACKETS; |
3379 | |
3380 | md_mark_stack_push(ctx, stack: &BRACKET_OPENERS, mark_index); |
3381 | return; |
3382 | } |
3383 | |
3384 | if(BRACKET_OPENERS.top >= 0) { |
3385 | int opener_index = md_mark_stack_pop(ctx, stack: &BRACKET_OPENERS); |
3386 | MD_MARK* opener = &ctx->marks[opener_index]; |
3387 | |
3388 | /* Interconnect the opener and closer. */ |
3389 | opener->next = mark_index; |
3390 | mark->prev = opener_index; |
3391 | |
3392 | /* Add the pair into a list of potential links for md_resolve_links(). |
3393 | * Note we misuse opener->prev for this as opener->next points to its |
3394 | * closer. */ |
3395 | if(ctx->unresolved_link_tail >= 0) |
3396 | ctx->marks[ctx->unresolved_link_tail].prev = opener_index; |
3397 | else |
3398 | ctx->unresolved_link_head = opener_index; |
3399 | ctx->unresolved_link_tail = opener_index; |
3400 | opener->prev = -1; |
3401 | } |
3402 | } |
3403 | |
3404 | /* Forward declaration. */ |
3405 | static void md_analyze_link_contents(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, |
3406 | int mark_beg, int mark_end); |
3407 | |
3408 | static int |
3409 | md_resolve_links(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines) |
3410 | { |
3411 | int opener_index = ctx->unresolved_link_head; |
3412 | OFF last_link_beg = 0; |
3413 | OFF last_link_end = 0; |
3414 | OFF last_img_beg = 0; |
3415 | OFF last_img_end = 0; |
3416 | |
3417 | while(opener_index >= 0) { |
3418 | MD_MARK* opener = &ctx->marks[opener_index]; |
3419 | int closer_index = opener->next; |
3420 | MD_MARK* closer = &ctx->marks[closer_index]; |
3421 | int next_index = opener->prev; |
3422 | MD_MARK* next_opener; |
3423 | MD_MARK* next_closer; |
3424 | MD_LINK_ATTR attr; |
3425 | int is_link = FALSE; |
3426 | |
3427 | if(next_index >= 0) { |
3428 | next_opener = &ctx->marks[next_index]; |
3429 | next_closer = &ctx->marks[next_opener->next]; |
3430 | } else { |
3431 | next_opener = NULL; |
3432 | next_closer = NULL; |
3433 | } |
3434 | |
3435 | /* If nested ("[ [ ] ]"), we need to make sure that: |
3436 | * - The outer does not end inside of (...) belonging to the inner. |
3437 | * - The outer cannot be link if the inner is link (i.e. not image). |
3438 | * |
3439 | * (Note we here analyze from inner to outer as the marks are ordered |
3440 | * by closer->beg.) |
3441 | */ |
3442 | if((opener->beg < last_link_beg && closer->end < last_link_end) || |
3443 | (opener->beg < last_img_beg && closer->end < last_img_end) || |
3444 | (opener->beg < last_link_end && opener->ch == '[')) |
3445 | { |
3446 | opener_index = next_index; |
3447 | continue; |
3448 | } |
3449 | |
3450 | /* Recognize and resolve wiki links. |
3451 | * Wiki-links maybe '[[destination]]' or '[[destination|label]]'. |
3452 | */ |
3453 | if ((ctx->parser.flags & MD_FLAG_WIKILINKS) && |
3454 | (opener->end - opener->beg == 1) && /* not image */ |
3455 | next_opener != NULL && /* double '[' opener */ |
3456 | next_opener->ch == '[' && |
3457 | (next_opener->beg == opener->beg - 1) && |
3458 | (next_opener->end - next_opener->beg == 1) && |
3459 | next_closer != NULL && /* double ']' closer */ |
3460 | next_closer->ch == ']' && |
3461 | (next_closer->beg == closer->beg + 1) && |
3462 | (next_closer->end - next_closer->beg == 1)) |
3463 | { |
3464 | MD_MARK* delim = NULL; |
3465 | int delim_index; |
3466 | OFF dest_beg, dest_end; |
3467 | |
3468 | is_link = TRUE; |
3469 | |
3470 | /* We don't allow destination to be longer than 100 characters. |
3471 | * Lets scan to see whether there is '|'. (If not then the whole |
3472 | * wiki-link has to be below the 100 characters.) */ |
3473 | delim_index = opener_index + 1; |
3474 | while(delim_index < closer_index) { |
3475 | MD_MARK* m = &ctx->marks[delim_index]; |
3476 | if(m->ch == '|') { |
3477 | delim = m; |
3478 | break; |
3479 | } |
3480 | if(m->ch != 'D') { |
3481 | if(m->beg - opener->end > 100) |
3482 | break; |
3483 | if(m->ch != 'D' && (m->flags & MD_MARK_OPENER)) |
3484 | delim_index = m->next; |
3485 | } |
3486 | delim_index++; |
3487 | } |
3488 | |
3489 | dest_beg = opener->end; |
3490 | dest_end = (delim != NULL) ? delim->beg : closer->beg; |
3491 | if(dest_end - dest_beg == 0 || dest_end - dest_beg > 100) |
3492 | is_link = FALSE; |
3493 | |
3494 | /* There may not be any new line in the destination. */ |
3495 | if(is_link) { |
3496 | OFF off; |
3497 | for(off = dest_beg; off < dest_end; off++) { |
3498 | if(ISNEWLINE(off)) { |
3499 | is_link = FALSE; |
3500 | break; |
3501 | } |
3502 | } |
3503 | } |
3504 | |
3505 | if(is_link) { |
3506 | if(delim != NULL) { |
3507 | if(delim->end < closer->beg) { |
3508 | md_rollback(ctx, opener_index, closer_index: delim_index, MD_ROLLBACK_ALL); |
3509 | md_rollback(ctx, opener_index: delim_index, closer_index, MD_ROLLBACK_CROSSING); |
3510 | delim->flags |= MD_MARK_RESOLVED; |
3511 | opener->end = delim->beg; |
3512 | } else { |
3513 | /* The pipe is just before the closer: [[foo|]] */ |
3514 | md_rollback(ctx, opener_index, closer_index, MD_ROLLBACK_ALL); |
3515 | closer->beg = delim->beg; |
3516 | delim = NULL; |
3517 | } |
3518 | } |
3519 | |
3520 | opener->beg = next_opener->beg; |
3521 | opener->next = closer_index; |
3522 | opener->flags |= MD_MARK_OPENER | MD_MARK_RESOLVED; |
3523 | |
3524 | closer->end = next_closer->end; |
3525 | closer->prev = opener_index; |
3526 | closer->flags |= MD_MARK_CLOSER | MD_MARK_RESOLVED; |
3527 | |
3528 | last_link_beg = opener->beg; |
3529 | last_link_end = closer->end; |
3530 | |
3531 | if(delim != NULL) |
3532 | md_analyze_link_contents(ctx, lines, n_lines, mark_beg: delim_index+1, mark_end: closer_index); |
3533 | |
3534 | opener_index = next_opener->prev; |
3535 | continue; |
3536 | } |
3537 | } |
3538 | |
3539 | if(next_opener != NULL && next_opener->beg == closer->end) { |
3540 | if(next_closer->beg > closer->end + 1) { |
3541 | /* Might be full reference link. */ |
3542 | if(!(next_opener->flags & MD_MARK_HASNESTEDBRACKETS)) |
3543 | is_link = md_is_link_reference(ctx, lines, n_lines, beg: next_opener->beg, end: next_closer->end, attr: &attr); |
3544 | } else { |
3545 | /* Might be shortcut reference link. */ |
3546 | if(!(opener->flags & MD_MARK_HASNESTEDBRACKETS)) |
3547 | is_link = md_is_link_reference(ctx, lines, n_lines, beg: opener->beg, end: closer->end, attr: &attr); |
3548 | } |
3549 | |
3550 | if(is_link < 0) |
3551 | return -1; |
3552 | |
3553 | if(is_link) { |
3554 | /* Eat the 2nd "[...]". */ |
3555 | closer->end = next_closer->end; |
3556 | |
3557 | /* Do not analyze the label as a standalone link in the next |
3558 | * iteration. */ |
3559 | next_index = ctx->marks[next_index].prev; |
3560 | } |
3561 | } else { |
3562 | if(closer->end < ctx->size && CH(closer->end) == _T('(')) { |
3563 | /* Might be inline link. */ |
3564 | OFF inline_link_end = UINT_MAX; |
3565 | |
3566 | is_link = md_is_inline_link_spec(ctx, lines, n_lines, beg: closer->end, p_end: &inline_link_end, attr: &attr); |
3567 | if(is_link < 0) |
3568 | return -1; |
3569 | |
3570 | /* Check the closing ')' is not inside an already resolved range |
3571 | * (i.e. a range with a higher priority), e.g. a code span. */ |
3572 | if(is_link) { |
3573 | int i = closer_index + 1; |
3574 | |
3575 | while(i < ctx->n_marks) { |
3576 | MD_MARK* mark = &ctx->marks[i]; |
3577 | |
3578 | if(mark->beg >= inline_link_end) |
3579 | break; |
3580 | if((mark->flags & (MD_MARK_OPENER | MD_MARK_RESOLVED)) == (MD_MARK_OPENER | MD_MARK_RESOLVED)) { |
3581 | if(ctx->marks[mark->next].beg >= inline_link_end) { |
3582 | /* Cancel the link status. */ |
3583 | if(attr.title_needs_free) |
3584 | free(ptr: attr.title); |
3585 | is_link = FALSE; |
3586 | break; |
3587 | } |
3588 | |
3589 | i = mark->next + 1; |
3590 | } else { |
3591 | i++; |
3592 | } |
3593 | } |
3594 | } |
3595 | |
3596 | if(is_link) { |
3597 | /* Eat the "(...)" */ |
3598 | closer->end = inline_link_end; |
3599 | } |
3600 | } |
3601 | |
3602 | if(!is_link) { |
3603 | /* Might be collapsed reference link. */ |
3604 | if(!(opener->flags & MD_MARK_HASNESTEDBRACKETS)) |
3605 | is_link = md_is_link_reference(ctx, lines, n_lines, beg: opener->beg, end: closer->end, attr: &attr); |
3606 | if(is_link < 0) |
3607 | return -1; |
3608 | } |
3609 | } |
3610 | |
3611 | if(is_link) { |
3612 | /* Resolve the brackets as a link. */ |
3613 | opener->flags |= MD_MARK_OPENER | MD_MARK_RESOLVED; |
3614 | closer->flags |= MD_MARK_CLOSER | MD_MARK_RESOLVED; |
3615 | |
3616 | /* If it is a link, we store the destination and title in the two |
3617 | * dummy marks after the opener. */ |
3618 | MD_ASSERT(ctx->marks[opener_index+1].ch == 'D'); |
3619 | ctx->marks[opener_index+1].beg = attr.dest_beg; |
3620 | ctx->marks[opener_index+1].end = attr.dest_end; |
3621 | |
3622 | MD_ASSERT(ctx->marks[opener_index+2].ch == 'D'); |
3623 | md_mark_store_ptr(ctx, mark_index: opener_index+2, ptr: attr.title); |
3624 | /* The title might or might not have been allocated for us. */ |
3625 | if(attr.title_needs_free) |
3626 | md_mark_stack_push(ctx, stack: &ctx->ptr_stack, mark_index: opener_index+2); |
3627 | ctx->marks[opener_index+2].prev = attr.title_size; |
3628 | |
3629 | if(opener->ch == '[') { |
3630 | last_link_beg = opener->beg; |
3631 | last_link_end = closer->end; |
3632 | } else { |
3633 | last_img_beg = opener->beg; |
3634 | last_img_end = closer->end; |
3635 | } |
3636 | |
3637 | md_analyze_link_contents(ctx, lines, n_lines, mark_beg: opener_index+1, mark_end: closer_index); |
3638 | |
3639 | /* If the link text is formed by nothing but permissive autolink, |
3640 | * suppress the autolink. |
3641 | * See https://github.com/mity/md4c/issues/152 for more info. */ |
3642 | if(ctx->parser.flags & MD_FLAG_PERMISSIVEAUTOLINKS) { |
3643 | MD_MARK* first_nested; |
3644 | MD_MARK* last_nested; |
3645 | |
3646 | first_nested = opener + 1; |
3647 | while(first_nested->ch == _T('D') && first_nested < closer) |
3648 | first_nested++; |
3649 | |
3650 | last_nested = closer - 1; |
3651 | while(first_nested->ch == _T('D') && last_nested > opener) |
3652 | last_nested--; |
3653 | |
3654 | if((first_nested->flags & MD_MARK_RESOLVED) && |
3655 | first_nested->beg == opener->end && |
3656 | ISANYOF_(first_nested->ch, _T("@:." )) && |
3657 | first_nested->next == (last_nested - ctx->marks) && |
3658 | last_nested->end == closer->beg) |
3659 | { |
3660 | first_nested->ch = _T('D'); |
3661 | first_nested->flags &= ~MD_MARK_RESOLVED; |
3662 | last_nested->ch = _T('D'); |
3663 | last_nested->flags &= ~MD_MARK_RESOLVED; |
3664 | } |
3665 | } |
3666 | } |
3667 | |
3668 | opener_index = next_index; |
3669 | } |
3670 | |
3671 | return 0; |
3672 | } |
3673 | |
3674 | /* Analyze whether the mark '&' starts a HTML entity. |
3675 | * If so, update its flags as well as flags of corresponding closer ';'. */ |
3676 | static void |
3677 | md_analyze_entity(MD_CTX* ctx, int mark_index) |
3678 | { |
3679 | MD_MARK* opener = &ctx->marks[mark_index]; |
3680 | MD_MARK* closer; |
3681 | OFF off; |
3682 | |
3683 | /* Cannot be entity if there is no closer as the next mark. |
3684 | * (Any other mark between would mean strange character which cannot be |
3685 | * part of the entity. |
3686 | * |
3687 | * So we can do all the work on '&' and do not call this later for the |
3688 | * closing mark ';'. |
3689 | */ |
3690 | if(mark_index + 1 >= ctx->n_marks) |
3691 | return; |
3692 | closer = &ctx->marks[mark_index+1]; |
3693 | if(closer->ch != ';') |
3694 | return; |
3695 | |
3696 | if(md_is_entity(ctx, beg: opener->beg, max_end: closer->end, p_end: &off)) { |
3697 | MD_ASSERT(off == closer->end); |
3698 | |
3699 | md_resolve_range(ctx, opener_index: mark_index, closer_index: mark_index+1); |
3700 | opener->end = closer->end; |
3701 | } |
3702 | } |
3703 | |
3704 | static void |
3705 | md_analyze_table_cell_boundary(MD_CTX* ctx, int mark_index) |
3706 | { |
3707 | MD_MARK* mark = &ctx->marks[mark_index]; |
3708 | mark->flags |= MD_MARK_RESOLVED; |
3709 | mark->next = -1; |
3710 | |
3711 | if(ctx->table_cell_boundaries_head < 0) |
3712 | ctx->table_cell_boundaries_head = mark_index; |
3713 | else |
3714 | ctx->marks[ctx->table_cell_boundaries_tail].next = mark_index; |
3715 | ctx->table_cell_boundaries_tail = mark_index; |
3716 | ctx->n_table_cell_boundaries++; |
3717 | } |
3718 | |
3719 | /* Split a longer mark into two. The new mark takes the given count of |
3720 | * characters. May only be called if an adequate number of dummy 'D' marks |
3721 | * follows. |
3722 | */ |
3723 | static int |
3724 | md_split_emph_mark(MD_CTX* ctx, int mark_index, SZ n) |
3725 | { |
3726 | MD_MARK* mark = &ctx->marks[mark_index]; |
3727 | int new_mark_index = mark_index + (mark->end - mark->beg - n); |
3728 | MD_MARK* dummy = &ctx->marks[new_mark_index]; |
3729 | |
3730 | MD_ASSERT(mark->end - mark->beg > n); |
3731 | MD_ASSERT(dummy->ch == 'D'); |
3732 | |
3733 | memcpy(dest: dummy, src: mark, n: sizeof(MD_MARK)); |
3734 | mark->end -= n; |
3735 | dummy->beg = mark->end; |
3736 | |
3737 | return new_mark_index; |
3738 | } |
3739 | |
3740 | static void |
3741 | md_analyze_emph(MD_CTX* ctx, int mark_index) |
3742 | { |
3743 | MD_MARK* mark = &ctx->marks[mark_index]; |
3744 | |
3745 | /* If we can be a closer, try to resolve with the preceding opener. */ |
3746 | if(mark->flags & MD_MARK_POTENTIAL_CLOSER) { |
3747 | MD_MARK* opener = NULL; |
3748 | int opener_index = 0; |
3749 | MD_MARKSTACK* opener_stacks[6]; |
3750 | int i, n_opener_stacks; |
3751 | unsigned flags = mark->flags; |
3752 | |
3753 | n_opener_stacks = 0; |
3754 | |
3755 | /* Apply the rule of 3 */ |
3756 | opener_stacks[n_opener_stacks++] = md_emph_stack(ctx, ch: mark->ch, MD_MARK_EMPH_MOD3_0 | MD_MARK_EMPH_OC); |
3757 | if((flags & MD_MARK_EMPH_MOD3_MASK) != MD_MARK_EMPH_MOD3_2) |
3758 | opener_stacks[n_opener_stacks++] = md_emph_stack(ctx, ch: mark->ch, MD_MARK_EMPH_MOD3_1 | MD_MARK_EMPH_OC); |
3759 | if((flags & MD_MARK_EMPH_MOD3_MASK) != MD_MARK_EMPH_MOD3_1) |
3760 | opener_stacks[n_opener_stacks++] = md_emph_stack(ctx, ch: mark->ch, MD_MARK_EMPH_MOD3_2 | MD_MARK_EMPH_OC); |
3761 | opener_stacks[n_opener_stacks++] = md_emph_stack(ctx, ch: mark->ch, MD_MARK_EMPH_MOD3_0); |
3762 | if(!(flags & MD_MARK_EMPH_OC) || (flags & MD_MARK_EMPH_MOD3_MASK) != MD_MARK_EMPH_MOD3_2) |
3763 | opener_stacks[n_opener_stacks++] = md_emph_stack(ctx, ch: mark->ch, MD_MARK_EMPH_MOD3_1); |
3764 | if(!(flags & MD_MARK_EMPH_OC) || (flags & MD_MARK_EMPH_MOD3_MASK) != MD_MARK_EMPH_MOD3_1) |
3765 | opener_stacks[n_opener_stacks++] = md_emph_stack(ctx, ch: mark->ch, MD_MARK_EMPH_MOD3_2); |
3766 | |
3767 | /* Opener is the most recent mark from the allowed stacks. */ |
3768 | for(i = 0; i < n_opener_stacks; i++) { |
3769 | if(opener_stacks[i]->top >= 0) { |
3770 | int m_index = opener_stacks[i]->top; |
3771 | MD_MARK* m = &ctx->marks[m_index]; |
3772 | |
3773 | if(opener == NULL || m->end > opener->end) { |
3774 | opener_index = m_index; |
3775 | opener = m; |
3776 | } |
3777 | } |
3778 | } |
3779 | |
3780 | /* Resolve, if we have found matching opener. */ |
3781 | if(opener != NULL) { |
3782 | SZ opener_size = opener->end - opener->beg; |
3783 | SZ closer_size = mark->end - mark->beg; |
3784 | MD_MARKSTACK* stack = md_opener_stack(ctx, mark_index: opener_index); |
3785 | |
3786 | if(opener_size > closer_size) { |
3787 | opener_index = md_split_emph_mark(ctx, mark_index: opener_index, n: closer_size); |
3788 | md_mark_stack_push(ctx, stack, mark_index: opener_index); |
3789 | } else if(opener_size < closer_size) { |
3790 | md_split_emph_mark(ctx, mark_index, n: closer_size - opener_size); |
3791 | } |
3792 | |
3793 | /* Above we were only peeking. */ |
3794 | md_mark_stack_pop(ctx, stack); |
3795 | |
3796 | md_rollback(ctx, opener_index, closer_index: mark_index, MD_ROLLBACK_CROSSING); |
3797 | md_resolve_range(ctx, opener_index, closer_index: mark_index); |
3798 | return; |
3799 | } |
3800 | } |
3801 | |
3802 | /* If we could not resolve as closer, we may be yet be an opener. */ |
3803 | if(mark->flags & MD_MARK_POTENTIAL_OPENER) |
3804 | md_mark_stack_push(ctx, stack: md_emph_stack(ctx, ch: mark->ch, flags: mark->flags), mark_index); |
3805 | } |
3806 | |
3807 | static void |
3808 | md_analyze_tilde(MD_CTX* ctx, int mark_index) |
3809 | { |
3810 | MD_MARK* mark = &ctx->marks[mark_index]; |
3811 | MD_MARKSTACK* stack = md_opener_stack(ctx, mark_index); |
3812 | |
3813 | /* We attempt to be Github Flavored Markdown compatible here. GFM accepts |
3814 | * only tildes sequences of length 1 and 2, and the length of the opener |
3815 | * and closer has to match. */ |
3816 | |
3817 | if((mark->flags & MD_MARK_POTENTIAL_CLOSER) && stack->top >= 0) { |
3818 | int opener_index = stack->top; |
3819 | |
3820 | md_mark_stack_pop(ctx, stack); |
3821 | md_rollback(ctx, opener_index, closer_index: mark_index, MD_ROLLBACK_CROSSING); |
3822 | md_resolve_range(ctx, opener_index, closer_index: mark_index); |
3823 | return; |
3824 | } |
3825 | |
3826 | if(mark->flags & MD_MARK_POTENTIAL_OPENER) |
3827 | md_mark_stack_push(ctx, stack, mark_index); |
3828 | } |
3829 | |
3830 | static void |
3831 | md_analyze_dollar(MD_CTX* ctx, int mark_index) |
3832 | { |
3833 | MD_MARK* mark = &ctx->marks[mark_index]; |
3834 | |
3835 | if((mark->flags & MD_MARK_POTENTIAL_CLOSER) && DOLLAR_OPENERS.top >= 0) { |
3836 | /* If the potential closer has a non-matching number of $, discard */ |
3837 | MD_MARK* opener = &ctx->marks[DOLLAR_OPENERS.top]; |
3838 | int opener_index = DOLLAR_OPENERS.top; |
3839 | MD_MARK* closer = mark; |
3840 | int closer_index = mark_index; |
3841 | |
3842 | if(opener->end - opener->beg == closer->end - closer->beg) { |
3843 | /* We are the matching closer */ |
3844 | md_mark_stack_pop(ctx, stack: &DOLLAR_OPENERS); |
3845 | md_rollback(ctx, opener_index, closer_index, MD_ROLLBACK_ALL); |
3846 | md_resolve_range(ctx, opener_index, closer_index); |
3847 | |
3848 | /* Discard all pending openers: Latex math span do not allow |
3849 | * nesting. */ |
3850 | DOLLAR_OPENERS.top = -1; |
3851 | return; |
3852 | } |
3853 | } |
3854 | |
3855 | if(mark->flags & MD_MARK_POTENTIAL_OPENER) |
3856 | md_mark_stack_push(ctx, stack: &DOLLAR_OPENERS, mark_index); |
3857 | } |
3858 | |
3859 | static MD_MARK* |
3860 | md_scan_left_for_resolved_mark(MD_CTX* ctx, MD_MARK* mark_from, OFF off, MD_MARK** p_cursor) |
3861 | { |
3862 | MD_MARK* mark; |
3863 | |
3864 | for(mark = mark_from; mark >= ctx->marks; mark--) { |
3865 | if(mark->ch == 'D' || mark->beg > off) |
3866 | continue; |
3867 | if(mark->beg <= off && off < mark->end && (mark->flags & MD_MARK_RESOLVED)) { |
3868 | if(p_cursor != NULL) |
3869 | *p_cursor = mark; |
3870 | return mark; |
3871 | } |
3872 | if(mark->end <= off) |
3873 | break; |
3874 | } |
3875 | |
3876 | if(p_cursor != NULL) |
3877 | *p_cursor = mark; |
3878 | return NULL; |
3879 | } |
3880 | |
3881 | static MD_MARK* |
3882 | md_scan_right_for_resolved_mark(MD_CTX* ctx, MD_MARK* mark_from, OFF off, MD_MARK** p_cursor) |
3883 | { |
3884 | MD_MARK* mark; |
3885 | |
3886 | for(mark = mark_from; mark < ctx->marks + ctx->n_marks; mark++) { |
3887 | if(mark->ch == 'D' || mark->end <= off) |
3888 | continue; |
3889 | if(mark->beg <= off && off < mark->end && (mark->flags & MD_MARK_RESOLVED)) { |
3890 | if(p_cursor != NULL) |
3891 | *p_cursor = mark; |
3892 | return mark; |
3893 | } |
3894 | if(mark->beg > off) |
3895 | break; |
3896 | } |
3897 | |
3898 | if(p_cursor != NULL) |
3899 | *p_cursor = mark; |
3900 | return NULL; |
3901 | } |
3902 | |
3903 | static void |
3904 | md_analyze_permissive_autolink(MD_CTX* ctx, int mark_index) |
3905 | { |
3906 | static const struct { |
3907 | const MD_CHAR start_char; |
3908 | const MD_CHAR delim_char; |
3909 | const MD_CHAR* allowed_nonalnum_chars; |
3910 | int min_components; |
3911 | const MD_CHAR optional_end_char; |
3912 | } URL_MAP[] = { |
3913 | { _T('\0'), _T('.'), _T(".-_" ), 2, _T('\0') }, /* host, mandatory */ |
3914 | { _T('/'), _T('/'), _T("/.-_" ), 0, _T('/') }, /* path */ |
3915 | { _T('?'), _T('&'), _T("&.-+_=()" ), 1, _T('\0') }, /* query */ |
3916 | { _T('#'), _T('\0'), _T(".-+_" ) , 1, _T('\0') } /* fragment */ |
3917 | }; |
3918 | |
3919 | MD_MARK* opener = &ctx->marks[mark_index]; |
3920 | MD_MARK* closer = &ctx->marks[mark_index + 1]; /* The dummy. */ |
3921 | OFF line_beg = closer->beg; /* md_collect_mark() set this for us */ |
3922 | OFF line_end = closer->end; /* ditto */ |
3923 | OFF beg = opener->beg; |
3924 | OFF end = opener->end; |
3925 | MD_MARK* left_cursor = opener; |
3926 | int left_boundary_ok = FALSE; |
3927 | MD_MARK* right_cursor = opener; |
3928 | int right_boundary_ok = FALSE; |
3929 | unsigned i; |
3930 | |
3931 | MD_ASSERT(closer->ch == 'D'); |
3932 | |
3933 | if(opener->ch == '@') { |
3934 | MD_ASSERT(CH(opener->beg) == _T('@')); |
3935 | |
3936 | /* Scan backwards for the user name (before '@'). */ |
3937 | while(beg > line_beg) { |
3938 | if(ISALNUM(beg-1)) |
3939 | beg--; |
3940 | else if(beg >= line_beg+2 && ISALNUM(beg-2) && |
3941 | ISANYOF(beg-1, _T(".-_+" )) && |
3942 | md_scan_left_for_resolved_mark(ctx, mark_from: left_cursor, off: beg-1, p_cursor: &left_cursor) == NULL && |
3943 | ISALNUM(beg)) |
3944 | beg--; |
3945 | else |
3946 | break; |
3947 | } |
3948 | if(beg == opener->beg) /* empty user name */ |
3949 | return; |
3950 | } |
3951 | |
3952 | /* Verify there's line boundary, whitespace, allowed punctuation or |
3953 | * resolved emphasis mark just before the suspected autolink. */ |
3954 | if(beg == line_beg || ISUNICODEWHITESPACEBEFORE(beg) || ISANYOF(beg-1, _T("({[" ))) { |
3955 | left_boundary_ok = TRUE; |
3956 | } else if(ISANYOF(beg-1, _T("*_~" ))) { |
3957 | MD_MARK* left_mark; |
3958 | |
3959 | left_mark = md_scan_left_for_resolved_mark(ctx, mark_from: left_cursor, off: beg-1, p_cursor: &left_cursor); |
3960 | if(left_mark != NULL && (left_mark->flags & MD_MARK_OPENER)) |
3961 | left_boundary_ok = TRUE; |
3962 | } |
3963 | if(!left_boundary_ok) |
3964 | return; |
3965 | |
3966 | for(i = 0; i < SIZEOF_ARRAY(URL_MAP); i++) { |
3967 | int n_components = 0; |
3968 | int n_open_brackets = 0; |
3969 | |
3970 | if(URL_MAP[i].start_char != _T('\0')) { |
3971 | if(end >= line_end || CH(end) != URL_MAP[i].start_char) |
3972 | continue; |
3973 | if(URL_MAP[i].min_components > 0 && (end+1 >= line_end || !ISALNUM(end+1))) |
3974 | continue; |
3975 | end++; |
3976 | } |
3977 | |
3978 | while(end < line_end) { |
3979 | if(ISALNUM(end)) { |
3980 | if(n_components == 0) |
3981 | n_components++; |
3982 | end++; |
3983 | } else if(end < line_end && |
3984 | ISANYOF(end, URL_MAP[i].allowed_nonalnum_chars) && |
3985 | md_scan_right_for_resolved_mark(ctx, mark_from: right_cursor, off: end, p_cursor: &right_cursor) == NULL && |
3986 | ((end > line_beg && (ISALNUM(end-1) || CH(end-1) == _T(')'))) || CH(end) == _T('(')) && |
3987 | ((end+1 < line_end && (ISALNUM(end+1) || CH(end+1) == _T('('))) || CH(end) == _T(')'))) |
3988 | { |
3989 | if(CH(end) == URL_MAP[i].delim_char) |
3990 | n_components++; |
3991 | |
3992 | /* brackets have to be balanced. */ |
3993 | if(CH(end) == _T('(')) { |
3994 | n_open_brackets++; |
3995 | } else if(CH(end) == _T(')')) { |
3996 | if(n_open_brackets <= 0) |
3997 | break; |
3998 | n_open_brackets--; |
3999 | } |
4000 | |
4001 | end++; |
4002 | } else { |
4003 | break; |
4004 | } |
4005 | } |
4006 | |
4007 | if(end < line_end && URL_MAP[i].optional_end_char != _T('\0') && |
4008 | CH(end) == URL_MAP[i].optional_end_char) |
4009 | end++; |
4010 | |
4011 | if(n_components < URL_MAP[i].min_components || n_open_brackets != 0) |
4012 | return; |
4013 | |
4014 | if(opener->ch == '@') /* E-mail autolinks wants only the host. */ |
4015 | break; |
4016 | } |
4017 | |
4018 | /* Verify there's line boundary, whitespace, allowed punctuation or |
4019 | * resolved emphasis mark just after the suspected autolink. */ |
4020 | if(end == line_end || ISUNICODEWHITESPACE(end) || ISANYOF(end, _T(")}].!?,;" ))) { |
4021 | right_boundary_ok = TRUE; |
4022 | } else { |
4023 | MD_MARK* right_mark; |
4024 | |
4025 | right_mark = md_scan_right_for_resolved_mark(ctx, mark_from: right_cursor, off: end, p_cursor: &right_cursor); |
4026 | if(right_mark != NULL && (right_mark->flags & MD_MARK_CLOSER)) |
4027 | right_boundary_ok = TRUE; |
4028 | } |
4029 | if(!right_boundary_ok) |
4030 | return; |
4031 | |
4032 | /* Success, we are an autolink. */ |
4033 | opener->beg = beg; |
4034 | opener->end = beg; |
4035 | closer->beg = end; |
4036 | closer->end = end; |
4037 | closer->ch = opener->ch; |
4038 | md_resolve_range(ctx, opener_index: mark_index, closer_index: mark_index + 1); |
4039 | } |
4040 | |
4041 | #define MD_ANALYZE_NOSKIP_EMPH 0x01 |
4042 | |
4043 | static inline void |
4044 | md_analyze_marks(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, |
4045 | int mark_beg, int mark_end, const CHAR* mark_chars, unsigned flags) |
4046 | { |
4047 | int i = mark_beg; |
4048 | OFF last_end = lines[0].beg; |
4049 | |
4050 | MD_UNUSED(lines); |
4051 | MD_UNUSED(n_lines); |
4052 | |
4053 | while(i < mark_end) { |
4054 | MD_MARK* mark = &ctx->marks[i]; |
4055 | |
4056 | /* Skip resolved spans. */ |
4057 | if(mark->flags & MD_MARK_RESOLVED) { |
4058 | if((mark->flags & MD_MARK_OPENER) && |
4059 | !((flags & MD_ANALYZE_NOSKIP_EMPH) && ISANYOF_(mark->ch, "*_~" ))) |
4060 | { |
4061 | MD_ASSERT(i < mark->next); |
4062 | i = mark->next + 1; |
4063 | } else { |
4064 | i++; |
4065 | } |
4066 | continue; |
4067 | } |
4068 | |
4069 | /* Skip marks we do not want to deal with. */ |
4070 | if(!ISANYOF_(mark->ch, mark_chars)) { |
4071 | i++; |
4072 | continue; |
4073 | } |
4074 | |
4075 | /* The resolving in previous step could have expanded a mark. */ |
4076 | if(mark->beg < last_end) { |
4077 | i++; |
4078 | continue; |
4079 | } |
4080 | |
4081 | /* Analyze the mark. */ |
4082 | switch(mark->ch) { |
4083 | case '[': /* Pass through. */ |
4084 | case '!': /* Pass through. */ |
4085 | case ']': md_analyze_bracket(ctx, mark_index: i); break; |
4086 | case '&': md_analyze_entity(ctx, mark_index: i); break; |
4087 | case '|': md_analyze_table_cell_boundary(ctx, mark_index: i); break; |
4088 | case '_': /* Pass through. */ |
4089 | case '*': md_analyze_emph(ctx, mark_index: i); break; |
4090 | case '~': md_analyze_tilde(ctx, mark_index: i); break; |
4091 | case '$': md_analyze_dollar(ctx, mark_index: i); break; |
4092 | case '.': /* Pass through. */ |
4093 | case ':': /* Pass through. */ |
4094 | case '@': md_analyze_permissive_autolink(ctx, mark_index: i); break; |
4095 | } |
4096 | |
4097 | if(mark->flags & MD_MARK_RESOLVED) { |
4098 | if(mark->flags & MD_MARK_OPENER) |
4099 | last_end = ctx->marks[mark->next].end; |
4100 | else |
4101 | last_end = mark->end; |
4102 | } |
4103 | |
4104 | i++; |
4105 | } |
4106 | } |
4107 | |
4108 | /* Analyze marks (build ctx->marks). */ |
4109 | static int |
4110 | md_analyze_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, int table_mode) |
4111 | { |
4112 | int ret; |
4113 | |
4114 | /* Reset the previously collected stack of marks. */ |
4115 | ctx->n_marks = 0; |
4116 | |
4117 | /* Collect all marks. */ |
4118 | MD_CHECK(md_collect_marks(ctx, lines, n_lines, table_mode)); |
4119 | |
4120 | /* (1) Links. */ |
4121 | md_analyze_marks(ctx, lines, n_lines, mark_beg: 0, mark_end: ctx->n_marks, _T("[]!" ), flags: 0); |
4122 | MD_CHECK(md_resolve_links(ctx, lines, n_lines)); |
4123 | BRACKET_OPENERS.top = -1; |
4124 | ctx->unresolved_link_head = -1; |
4125 | ctx->unresolved_link_tail = -1; |
4126 | |
4127 | if(table_mode) { |
4128 | /* (2) Analyze table cell boundaries. */ |
4129 | MD_ASSERT(n_lines == 1); |
4130 | ctx->n_table_cell_boundaries = 0; |
4131 | md_analyze_marks(ctx, lines, n_lines, mark_beg: 0, mark_end: ctx->n_marks, _T("|" ), flags: 0); |
4132 | return ret; |
4133 | } |
4134 | |
4135 | /* (3) Emphasis and strong emphasis; permissive autolinks. */ |
4136 | md_analyze_link_contents(ctx, lines, n_lines, mark_beg: 0, mark_end: ctx->n_marks); |
4137 | |
4138 | abort: |
4139 | return ret; |
4140 | } |
4141 | |
4142 | static void |
4143 | md_analyze_link_contents(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines, |
4144 | int mark_beg, int mark_end) |
4145 | { |
4146 | int i; |
4147 | |
4148 | md_analyze_marks(ctx, lines, n_lines, mark_beg, mark_end, _T("&" ), flags: 0); |
4149 | md_analyze_marks(ctx, lines, n_lines, mark_beg, mark_end, _T("*_~$" ), flags: 0); |
4150 | |
4151 | if((ctx->parser.flags & MD_FLAG_PERMISSIVEAUTOLINKS) != 0) { |
4152 | /* These have to be processed last, as they may be greedy and expand |
4153 | * from their original mark. Also their implementation must be careful |
4154 | * not to cross any (previously) resolved marks when doing so. */ |
4155 | md_analyze_marks(ctx, lines, n_lines, mark_beg, mark_end, _T("@:." ), MD_ANALYZE_NOSKIP_EMPH); |
4156 | } |
4157 | |
4158 | for(i = 0; i < (int) SIZEOF_ARRAY(ctx->opener_stacks); i++) |
4159 | ctx->opener_stacks[i].top = -1; |
4160 | } |
4161 | |
4162 | static int |
4163 | md_enter_leave_span_a(MD_CTX* ctx, int enter, MD_SPANTYPE type, |
4164 | const CHAR* dest, SZ dest_size, int is_autolink, |
4165 | const CHAR* title, SZ title_size) |
4166 | { |
4167 | MD_ATTRIBUTE_BUILD href_build = { 0 }; |
4168 | MD_ATTRIBUTE_BUILD title_build = { 0 }; |
4169 | MD_SPAN_A_DETAIL det; |
4170 | int ret = 0; |
4171 | |
4172 | /* Note we here rely on fact that MD_SPAN_A_DETAIL and |
4173 | * MD_SPAN_IMG_DETAIL are binary-compatible. */ |
4174 | memset(s: &det, c: 0, n: sizeof(MD_SPAN_A_DETAIL)); |
4175 | MD_CHECK(md_build_attribute(ctx, dest, dest_size, |
4176 | (is_autolink ? MD_BUILD_ATTR_NO_ESCAPES : 0), |
4177 | &det.href, &href_build)); |
4178 | MD_CHECK(md_build_attribute(ctx, title, title_size, 0, &det.title, &title_build)); |
4179 | det.is_autolink = is_autolink; |
4180 | if(enter) |
4181 | MD_ENTER_SPAN(type, &det); |
4182 | else |
4183 | MD_LEAVE_SPAN(type, &det); |
4184 | |
4185 | abort: |
4186 | md_free_attribute(ctx, build: &href_build); |
4187 | md_free_attribute(ctx, build: &title_build); |
4188 | return ret; |
4189 | } |
4190 | |
4191 | static int |
4192 | md_enter_leave_span_wikilink(MD_CTX* ctx, int enter, const CHAR* target, SZ target_size) |
4193 | { |
4194 | MD_ATTRIBUTE_BUILD target_build = { 0 }; |
4195 | MD_SPAN_WIKILINK_DETAIL det; |
4196 | int ret = 0; |
4197 | |
4198 | memset(s: &det, c: 0, n: sizeof(MD_SPAN_WIKILINK_DETAIL)); |
4199 | MD_CHECK(md_build_attribute(ctx, target, target_size, 0, &det.target, &target_build)); |
4200 | |
4201 | if (enter) |
4202 | MD_ENTER_SPAN(MD_SPAN_WIKILINK, &det); |
4203 | else |
4204 | MD_LEAVE_SPAN(MD_SPAN_WIKILINK, &det); |
4205 | |
4206 | abort: |
4207 | md_free_attribute(ctx, build: &target_build); |
4208 | return ret; |
4209 | } |
4210 | |
4211 | |
4212 | /* Render the output, accordingly to the analyzed ctx->marks. */ |
4213 | static int |
4214 | md_process_inlines(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines) |
4215 | { |
4216 | MD_TEXTTYPE text_type; |
4217 | const MD_LINE* line = lines; |
4218 | MD_MARK* prev_mark = NULL; |
4219 | MD_MARK* mark; |
4220 | OFF off = lines[0].beg; |
4221 | OFF end = lines[n_lines-1].end; |
4222 | OFF tmp; |
4223 | int enforce_hardbreak = 0; |
4224 | int ret = 0; |
4225 | |
4226 | /* Find first resolved mark. Note there is always at least one resolved |
4227 | * mark, the dummy last one after the end of the latest line we actually |
4228 | * never really reach. This saves us of a lot of special checks and cases |
4229 | * in this function. */ |
4230 | mark = ctx->marks; |
4231 | while(!(mark->flags & MD_MARK_RESOLVED)) |
4232 | mark++; |
4233 | |
4234 | text_type = MD_TEXT_NORMAL; |
4235 | |
4236 | while(1) { |
4237 | /* Process the text up to the next mark or end-of-line. */ |
4238 | tmp = (line->end < mark->beg ? line->end : mark->beg); |
4239 | if(tmp > off) { |
4240 | MD_TEXT(text_type, STR(off), tmp - off); |
4241 | off = tmp; |
4242 | } |
4243 | |
4244 | /* If reached the mark, process it and move to next one. */ |
4245 | if(off >= mark->beg) { |
4246 | switch(mark->ch) { |
4247 | case '\\': /* Backslash escape. */ |
4248 | if(ISNEWLINE(mark->beg+1)) |
4249 | enforce_hardbreak = 1; |
4250 | else |
4251 | MD_TEXT(text_type, STR(mark->beg+1), 1); |
4252 | break; |
4253 | |
4254 | case ' ': /* Non-trivial space. */ |
4255 | MD_TEXT(text_type, _T(" " ), 1); |
4256 | break; |
4257 | |
4258 | case '`': /* Code span. */ |
4259 | if(mark->flags & MD_MARK_OPENER) { |
4260 | MD_ENTER_SPAN(MD_SPAN_CODE, NULL); |
4261 | text_type = MD_TEXT_CODE; |
4262 | } else { |
4263 | MD_LEAVE_SPAN(MD_SPAN_CODE, NULL); |
4264 | text_type = MD_TEXT_NORMAL; |
4265 | } |
4266 | break; |
4267 | |
4268 | case '_': /* Underline (or emphasis if we fall through). */ |
4269 | if(ctx->parser.flags & MD_FLAG_UNDERLINE) { |
4270 | if(mark->flags & MD_MARK_OPENER) { |
4271 | while(off < mark->end) { |
4272 | MD_ENTER_SPAN(MD_SPAN_U, NULL); |
4273 | off++; |
4274 | } |
4275 | } else { |
4276 | while(off < mark->end) { |
4277 | MD_LEAVE_SPAN(MD_SPAN_U, NULL); |
4278 | off++; |
4279 | } |
4280 | } |
4281 | break; |
4282 | } |
4283 | MD_FALLTHROUGH(); |
4284 | |
4285 | case '*': /* Emphasis, strong emphasis. */ |
4286 | if(mark->flags & MD_MARK_OPENER) { |
4287 | if((mark->end - off) % 2) { |
4288 | MD_ENTER_SPAN(MD_SPAN_EM, NULL); |
4289 | off++; |
4290 | } |
4291 | while(off + 1 < mark->end) { |
4292 | MD_ENTER_SPAN(MD_SPAN_STRONG, NULL); |
4293 | off += 2; |
4294 | } |
4295 | } else { |
4296 | while(off + 1 < mark->end) { |
4297 | MD_LEAVE_SPAN(MD_SPAN_STRONG, NULL); |
4298 | off += 2; |
4299 | } |
4300 | if((mark->end - off) % 2) { |
4301 | MD_LEAVE_SPAN(MD_SPAN_EM, NULL); |
4302 | off++; |
4303 | } |
4304 | } |
4305 | break; |
4306 | |
4307 | case '~': |
4308 | if(mark->flags & MD_MARK_OPENER) |
4309 | MD_ENTER_SPAN(MD_SPAN_DEL, NULL); |
4310 | else |
4311 | MD_LEAVE_SPAN(MD_SPAN_DEL, NULL); |
4312 | break; |
4313 | |
4314 | case '$': |
4315 | if(mark->flags & MD_MARK_OPENER) { |
4316 | MD_ENTER_SPAN((mark->end - off) % 2 ? MD_SPAN_LATEXMATH : MD_SPAN_LATEXMATH_DISPLAY, NULL); |
4317 | text_type = MD_TEXT_LATEXMATH; |
4318 | } else { |
4319 | MD_LEAVE_SPAN((mark->end - off) % 2 ? MD_SPAN_LATEXMATH : MD_SPAN_LATEXMATH_DISPLAY, NULL); |
4320 | text_type = MD_TEXT_NORMAL; |
4321 | } |
4322 | break; |
4323 | |
4324 | case '[': /* Link, wiki link, image. */ |
4325 | case '!': |
4326 | case ']': |
4327 | { |
4328 | const MD_MARK* opener = (mark->ch != ']' ? mark : &ctx->marks[mark->prev]); |
4329 | const MD_MARK* closer = &ctx->marks[opener->next]; |
4330 | const MD_MARK* dest_mark; |
4331 | const MD_MARK* title_mark; |
4332 | |
4333 | if ((opener->ch == '[' && closer->ch == ']') && |
4334 | opener->end - opener->beg >= 2 && |
4335 | closer->end - closer->beg >= 2) |
4336 | { |
4337 | int has_label = (opener->end - opener->beg > 2); |
4338 | SZ target_sz; |
4339 | |
4340 | if(has_label) |
4341 | target_sz = opener->end - (opener->beg+2); |
4342 | else |
4343 | target_sz = closer->beg - opener->end; |
4344 | |
4345 | MD_CHECK(md_enter_leave_span_wikilink(ctx, (mark->ch != ']'), |
4346 | has_label ? STR(opener->beg+2) : STR(opener->end), |
4347 | target_sz)); |
4348 | |
4349 | break; |
4350 | } |
4351 | |
4352 | dest_mark = opener+1; |
4353 | MD_ASSERT(dest_mark->ch == 'D'); |
4354 | title_mark = opener+2; |
4355 | MD_ASSERT(title_mark->ch == 'D'); |
4356 | |
4357 | MD_CHECK(md_enter_leave_span_a(ctx, (mark->ch != ']'), |
4358 | (opener->ch == '!' ? MD_SPAN_IMG : MD_SPAN_A), |
4359 | STR(dest_mark->beg), dest_mark->end - dest_mark->beg, FALSE, |
4360 | md_mark_get_ptr(ctx, (int)(title_mark - ctx->marks)), |
4361 | title_mark->prev)); |
4362 | |
4363 | /* link/image closer may span multiple lines. */ |
4364 | if(mark->ch == ']') { |
4365 | while(mark->end > line->end) |
4366 | line++; |
4367 | } |
4368 | |
4369 | break; |
4370 | } |
4371 | |
4372 | case '<': |
4373 | case '>': /* Autolink or raw HTML. */ |
4374 | if(!(mark->flags & MD_MARK_AUTOLINK)) { |
4375 | /* Raw HTML. */ |
4376 | if(mark->flags & MD_MARK_OPENER) |
4377 | text_type = MD_TEXT_HTML; |
4378 | else |
4379 | text_type = MD_TEXT_NORMAL; |
4380 | break; |
4381 | } |
4382 | /* Pass through, if auto-link. */ |
4383 | MD_FALLTHROUGH(); |
4384 | |
4385 | case '@': /* Permissive e-mail autolink. */ |
4386 | case ':': /* Permissive URL autolink. */ |
4387 | case '.': /* Permissive WWW autolink. */ |
4388 | { |
4389 | MD_MARK* opener = ((mark->flags & MD_MARK_OPENER) ? mark : &ctx->marks[mark->prev]); |
4390 | MD_MARK* closer = &ctx->marks[opener->next]; |
4391 | const CHAR* dest = STR(opener->end); |
4392 | SZ dest_size = closer->beg - opener->end; |
4393 | |
4394 | /* For permissive auto-links we do not know closer mark |
4395 | * position at the time of md_collect_marks(), therefore |
4396 | * it can be out-of-order in ctx->marks[]. |
4397 | * |
4398 | * With this flag, we make sure that we output the closer |
4399 | * only if we processed the opener. */ |
4400 | if(mark->flags & MD_MARK_OPENER) |
4401 | closer->flags |= MD_MARK_VALIDPERMISSIVEAUTOLINK; |
4402 | |
4403 | if(opener->ch == '@' || opener->ch == '.' || |
4404 | (opener->ch == '<' && (opener->flags & MD_MARK_AUTOLINK_MISSING_MAILTO))) |
4405 | { |
4406 | dest_size += 7; |
4407 | MD_TEMP_BUFFER(dest_size * sizeof(CHAR)); |
4408 | memcpy(dest: ctx->buffer, |
4409 | src: (opener->ch == '.' ? _T("http://" ) : _T("mailto:" )), |
4410 | n: 7 * sizeof(CHAR)); |
4411 | memcpy(dest: ctx->buffer + 7, src: dest, n: (dest_size-7) * sizeof(CHAR)); |
4412 | dest = ctx->buffer; |
4413 | } |
4414 | |
4415 | if(closer->flags & MD_MARK_VALIDPERMISSIVEAUTOLINK) |
4416 | MD_CHECK(md_enter_leave_span_a(ctx, (mark->flags & MD_MARK_OPENER), |
4417 | MD_SPAN_A, dest, dest_size, TRUE, NULL, 0)); |
4418 | break; |
4419 | } |
4420 | |
4421 | case '&': /* Entity. */ |
4422 | MD_TEXT(MD_TEXT_ENTITY, STR(mark->beg), mark->end - mark->beg); |
4423 | break; |
4424 | |
4425 | case '\0': |
4426 | MD_TEXT(MD_TEXT_NULLCHAR, _T("" ), 1); |
4427 | break; |
4428 | |
4429 | case 127: |
4430 | goto abort; |
4431 | } |
4432 | |
4433 | off = mark->end; |
4434 | |
4435 | /* Move to next resolved mark. */ |
4436 | prev_mark = mark; |
4437 | mark++; |
4438 | while(!(mark->flags & MD_MARK_RESOLVED) || mark->beg < off) |
4439 | mark++; |
4440 | } |
4441 | |
4442 | /* If reached end of line, move to next one. */ |
4443 | if(off >= line->end) { |
4444 | /* If it is the last line, we are done. */ |
4445 | if(off >= end) |
4446 | break; |
4447 | |
4448 | if(text_type == MD_TEXT_CODE || text_type == MD_TEXT_LATEXMATH) { |
4449 | MD_ASSERT(prev_mark != NULL); |
4450 | MD_ASSERT(ISANYOF2_(prev_mark->ch, '`', '$') && (prev_mark->flags & MD_MARK_OPENER)); |
4451 | MD_ASSERT(ISANYOF2_(mark->ch, '`', '$') && (mark->flags & MD_MARK_CLOSER)); |
4452 | |
4453 | /* Inside a code span, trailing line whitespace has to be |
4454 | * outputted. */ |
4455 | tmp = off; |
4456 | while(off < ctx->size && ISBLANK(off)) |
4457 | off++; |
4458 | if(off > tmp) |
4459 | MD_TEXT(text_type, STR(tmp), off-tmp); |
4460 | |
4461 | /* and new lines are transformed into single spaces. */ |
4462 | if(off == line->end) |
4463 | MD_TEXT(text_type, _T(" " ), 1); |
4464 | } else if(text_type == MD_TEXT_HTML) { |
4465 | /* Inside raw HTML, we output the new line verbatim, including |
4466 | * any trailing spaces. */ |
4467 | tmp = off; |
4468 | while(tmp < end && ISBLANK(tmp)) |
4469 | tmp++; |
4470 | if(tmp > off) |
4471 | MD_TEXT(MD_TEXT_HTML, STR(off), tmp - off); |
4472 | MD_TEXT(MD_TEXT_HTML, _T("\n" ), 1); |
4473 | } else { |
4474 | /* Output soft or hard line break. */ |
4475 | MD_TEXTTYPE break_type = MD_TEXT_SOFTBR; |
4476 | |
4477 | if(text_type == MD_TEXT_NORMAL) { |
4478 | if(ctx->parser.flags & MD_FLAG_HARD_SOFT_BREAKS) |
4479 | break_type = MD_TEXT_BR; |
4480 | else if(enforce_hardbreak) |
4481 | break_type = MD_TEXT_BR; |
4482 | else if((CH(line->end) == _T(' ') && CH(line->end+1) == _T(' '))) |
4483 | break_type = MD_TEXT_BR; |
4484 | } |
4485 | |
4486 | MD_TEXT(break_type, _T("\n" ), 1); |
4487 | } |
4488 | |
4489 | /* Move to the next line. */ |
4490 | line++; |
4491 | off = line->beg; |
4492 | |
4493 | enforce_hardbreak = 0; |
4494 | } |
4495 | } |
4496 | |
4497 | abort: |
4498 | return ret; |
4499 | } |
4500 | |
4501 | |
4502 | /*************************** |
4503 | *** Processing Tables *** |
4504 | ***************************/ |
4505 | |
4506 | static void |
4507 | md_analyze_table_alignment(MD_CTX* ctx, OFF beg, OFF end, MD_ALIGN* align, int n_align) |
4508 | { |
4509 | static const MD_ALIGN align_map[] = { MD_ALIGN_DEFAULT, MD_ALIGN_LEFT, MD_ALIGN_RIGHT, MD_ALIGN_CENTER }; |
4510 | OFF off = beg; |
4511 | |
4512 | while(n_align > 0) { |
4513 | int index = 0; /* index into align_map[] */ |
4514 | |
4515 | while(CH(off) != _T('-')) |
4516 | off++; |
4517 | if(off > beg && CH(off-1) == _T(':')) |
4518 | index |= 1; |
4519 | while(off < end && CH(off) == _T('-')) |
4520 | off++; |
4521 | if(off < end && CH(off) == _T(':')) |
4522 | index |= 2; |
4523 | |
4524 | *align = align_map[index]; |
4525 | align++; |
4526 | n_align--; |
4527 | } |
4528 | |
4529 | } |
4530 | |
4531 | /* Forward declaration. */ |
4532 | static int md_process_normal_block_contents(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines); |
4533 | |
4534 | static int |
4535 | md_process_table_cell(MD_CTX* ctx, MD_BLOCKTYPE cell_type, MD_ALIGN align, OFF beg, OFF end) |
4536 | { |
4537 | MD_LINE line; |
4538 | MD_BLOCK_TD_DETAIL det; |
4539 | int ret = 0; |
4540 | |
4541 | while(beg < end && ISWHITESPACE(beg)) |
4542 | beg++; |
4543 | while(end > beg && ISWHITESPACE(end-1)) |
4544 | end--; |
4545 | |
4546 | det.align = align; |
4547 | line.beg = beg; |
4548 | line.end = end; |
4549 | |
4550 | MD_ENTER_BLOCK(cell_type, &det); |
4551 | MD_CHECK(md_process_normal_block_contents(ctx, &line, 1)); |
4552 | MD_LEAVE_BLOCK(cell_type, &det); |
4553 | |
4554 | abort: |
4555 | return ret; |
4556 | } |
4557 | |
4558 | static int |
4559 | md_process_table_row(MD_CTX* ctx, MD_BLOCKTYPE cell_type, OFF beg, OFF end, |
4560 | const MD_ALIGN* align, int col_count) |
4561 | { |
4562 | MD_LINE line; |
4563 | OFF* pipe_offs = NULL; |
4564 | int i, j, k, n; |
4565 | int ret = 0; |
4566 | |
4567 | line.beg = beg; |
4568 | line.end = end; |
4569 | |
4570 | /* Break the line into table cells by identifying pipe characters who |
4571 | * form the cell boundary. */ |
4572 | MD_CHECK(md_analyze_inlines(ctx, &line, 1, TRUE)); |
4573 | |
4574 | /* We have to remember the cell boundaries in local buffer because |
4575 | * ctx->marks[] shall be reused during cell contents processing. */ |
4576 | n = ctx->n_table_cell_boundaries + 2; |
4577 | pipe_offs = (OFF*) malloc(size: n * sizeof(OFF)); |
4578 | if(pipe_offs == NULL) { |
4579 | MD_LOG("malloc() failed." ); |
4580 | ret = -1; |
4581 | goto abort; |
4582 | } |
4583 | j = 0; |
4584 | pipe_offs[j++] = beg; |
4585 | for(i = ctx->table_cell_boundaries_head; i >= 0; i = ctx->marks[i].next) { |
4586 | MD_MARK* mark = &ctx->marks[i]; |
4587 | pipe_offs[j++] = mark->end; |
4588 | } |
4589 | pipe_offs[j++] = end+1; |
4590 | |
4591 | /* Process cells. */ |
4592 | MD_ENTER_BLOCK(MD_BLOCK_TR, NULL); |
4593 | k = 0; |
4594 | for(i = 0; i < j-1 && k < col_count; i++) { |
4595 | if(pipe_offs[i] < pipe_offs[i+1]-1) |
4596 | MD_CHECK(md_process_table_cell(ctx, cell_type, align[k++], pipe_offs[i], pipe_offs[i+1]-1)); |
4597 | } |
4598 | /* Make sure we call enough table cells even if the current table contains |
4599 | * too few of them. */ |
4600 | while(k < col_count) |
4601 | MD_CHECK(md_process_table_cell(ctx, cell_type, align[k++], 0, 0)); |
4602 | MD_LEAVE_BLOCK(MD_BLOCK_TR, NULL); |
4603 | |
4604 | abort: |
4605 | free(ptr: pipe_offs); |
4606 | |
4607 | ctx->table_cell_boundaries_head = -1; |
4608 | ctx->table_cell_boundaries_tail = -1; |
4609 | |
4610 | return ret; |
4611 | } |
4612 | |
4613 | static int |
4614 | md_process_table_block_contents(MD_CTX* ctx, int col_count, const MD_LINE* lines, MD_SIZE n_lines) |
4615 | { |
4616 | MD_ALIGN* align; |
4617 | MD_SIZE line_index; |
4618 | int ret = 0; |
4619 | |
4620 | /* At least two lines have to be present: The column headers and the line |
4621 | * with the underlines. */ |
4622 | MD_ASSERT(n_lines >= 2); |
4623 | |
4624 | align = malloc(size: col_count * sizeof(MD_ALIGN)); |
4625 | if(align == NULL) { |
4626 | MD_LOG("malloc() failed." ); |
4627 | ret = -1; |
4628 | goto abort; |
4629 | } |
4630 | |
4631 | md_analyze_table_alignment(ctx, beg: lines[1].beg, end: lines[1].end, align, n_align: col_count); |
4632 | |
4633 | MD_ENTER_BLOCK(MD_BLOCK_THEAD, NULL); |
4634 | MD_CHECK(md_process_table_row(ctx, MD_BLOCK_TH, |
4635 | lines[0].beg, lines[0].end, align, col_count)); |
4636 | MD_LEAVE_BLOCK(MD_BLOCK_THEAD, NULL); |
4637 | |
4638 | if(n_lines > 2) { |
4639 | MD_ENTER_BLOCK(MD_BLOCK_TBODY, NULL); |
4640 | for(line_index = 2; line_index < n_lines; line_index++) { |
4641 | MD_CHECK(md_process_table_row(ctx, MD_BLOCK_TD, |
4642 | lines[line_index].beg, lines[line_index].end, align, col_count)); |
4643 | } |
4644 | MD_LEAVE_BLOCK(MD_BLOCK_TBODY, NULL); |
4645 | } |
4646 | |
4647 | abort: |
4648 | free(ptr: align); |
4649 | return ret; |
4650 | } |
4651 | |
4652 | |
4653 | /************************** |
4654 | *** Processing Block *** |
4655 | **************************/ |
4656 | |
4657 | #define MD_BLOCK_CONTAINER_OPENER 0x01 |
4658 | #define MD_BLOCK_CONTAINER_CLOSER 0x02 |
4659 | #define MD_BLOCK_CONTAINER (MD_BLOCK_CONTAINER_OPENER | MD_BLOCK_CONTAINER_CLOSER) |
4660 | #define MD_BLOCK_LOOSE_LIST 0x04 |
4661 | #define 0x08 |
4662 | |
4663 | struct MD_BLOCK_tag { |
4664 | MD_BLOCKTYPE type : 8; |
4665 | unsigned flags : 8; |
4666 | |
4667 | /* MD_BLOCK_H: Header level (1 - 6) |
4668 | * MD_BLOCK_CODE: Non-zero if fenced, zero if indented. |
4669 | * MD_BLOCK_LI: Task mark character (0 if not task list item, 'x', 'X' or ' '). |
4670 | * MD_BLOCK_TABLE: Column count (as determined by the table underline). |
4671 | */ |
4672 | unsigned data : 16; |
4673 | |
4674 | /* Leaf blocks: Count of lines (MD_LINE or MD_VERBATIMLINE) on the block. |
4675 | * MD_BLOCK_LI: Task mark offset in the input doc. |
4676 | * MD_BLOCK_OL: Start item number. |
4677 | */ |
4678 | MD_SIZE n_lines; |
4679 | }; |
4680 | |
4681 | struct MD_CONTAINER_tag { |
4682 | CHAR ch; |
4683 | unsigned is_loose : 8; |
4684 | unsigned is_task : 8; |
4685 | unsigned start; |
4686 | unsigned mark_indent; |
4687 | unsigned contents_indent; |
4688 | OFF block_byte_off; |
4689 | OFF task_mark_off; |
4690 | }; |
4691 | |
4692 | |
4693 | static int |
4694 | md_process_normal_block_contents(MD_CTX* ctx, const MD_LINE* lines, MD_SIZE n_lines) |
4695 | { |
4696 | int i; |
4697 | int ret; |
4698 | |
4699 | MD_CHECK(md_analyze_inlines(ctx, lines, n_lines, FALSE)); |
4700 | MD_CHECK(md_process_inlines(ctx, lines, n_lines)); |
4701 | |
4702 | abort: |
4703 | /* Free any temporary memory blocks stored within some dummy marks. */ |
4704 | for(i = ctx->ptr_stack.top; i >= 0; i = ctx->marks[i].next) |
4705 | free(ptr: md_mark_get_ptr(ctx, mark_index: i)); |
4706 | ctx->ptr_stack.top = -1; |
4707 | |
4708 | return ret; |
4709 | } |
4710 | |
4711 | static int |
4712 | md_process_verbatim_block_contents(MD_CTX* ctx, MD_TEXTTYPE text_type, const MD_VERBATIMLINE* lines, MD_SIZE n_lines) |
4713 | { |
4714 | static const CHAR indent_chunk_str[] = _T(" " ); |
4715 | static const SZ indent_chunk_size = SIZEOF_ARRAY(indent_chunk_str) - 1; |
4716 | |
4717 | MD_SIZE line_index; |
4718 | int ret = 0; |
4719 | |
4720 | for(line_index = 0; line_index < n_lines; line_index++) { |
4721 | const MD_VERBATIMLINE* line = &lines[line_index]; |
4722 | int indent = line->indent; |
4723 | |
4724 | MD_ASSERT(indent >= 0); |
4725 | |
4726 | /* Output code indentation. */ |
4727 | while(indent > (int) indent_chunk_size) { |
4728 | MD_TEXT(text_type, indent_chunk_str, indent_chunk_size); |
4729 | indent -= indent_chunk_size; |
4730 | } |
4731 | if(indent > 0) |
4732 | MD_TEXT(text_type, indent_chunk_str, indent); |
4733 | |
4734 | /* Output the code line itself. */ |
4735 | MD_TEXT_INSECURE(text_type, STR(line->beg), line->end - line->beg); |
4736 | |
4737 | /* Enforce end-of-line. */ |
4738 | MD_TEXT(text_type, _T("\n" ), 1); |
4739 | } |
4740 | |
4741 | abort: |
4742 | return ret; |
4743 | } |
4744 | |
4745 | static int |
4746 | md_process_code_block_contents(MD_CTX* ctx, int is_fenced, const MD_VERBATIMLINE* lines, MD_SIZE n_lines) |
4747 | { |
4748 | if(is_fenced) { |
4749 | /* Skip the first line in case of fenced code: It is the fence. |
4750 | * (Only the starting fence is present due to logic in md_analyze_line().) */ |
4751 | lines++; |
4752 | n_lines--; |
4753 | } else { |
4754 | /* Ignore blank lines at start/end of indented code block. */ |
4755 | while(n_lines > 0 && lines[0].beg == lines[0].end) { |
4756 | lines++; |
4757 | n_lines--; |
4758 | } |
4759 | while(n_lines > 0 && lines[n_lines-1].beg == lines[n_lines-1].end) { |
4760 | n_lines--; |
4761 | } |
4762 | } |
4763 | |
4764 | if(n_lines == 0) |
4765 | return 0; |
4766 | |
4767 | return md_process_verbatim_block_contents(ctx, text_type: MD_TEXT_CODE, lines, n_lines); |
4768 | } |
4769 | |
4770 | static int |
4771 | md_setup_fenced_code_detail(MD_CTX* ctx, const MD_BLOCK* block, MD_BLOCK_CODE_DETAIL* det, |
4772 | MD_ATTRIBUTE_BUILD* info_build, MD_ATTRIBUTE_BUILD* lang_build) |
4773 | { |
4774 | const MD_VERBATIMLINE* fence_line = (const MD_VERBATIMLINE*)(block + 1); |
4775 | OFF beg = fence_line->beg; |
4776 | OFF end = fence_line->end; |
4777 | OFF lang_end; |
4778 | CHAR fence_ch = CH(fence_line->beg); |
4779 | int ret = 0; |
4780 | |
4781 | /* Skip the fence itself. */ |
4782 | while(beg < ctx->size && CH(beg) == fence_ch) |
4783 | beg++; |
4784 | /* Trim initial spaces. */ |
4785 | while(beg < ctx->size && CH(beg) == _T(' ')) |
4786 | beg++; |
4787 | |
4788 | /* Trim trailing spaces. */ |
4789 | while(end > beg && CH(end-1) == _T(' ')) |
4790 | end--; |
4791 | |
4792 | /* Build info string attribute. */ |
4793 | MD_CHECK(md_build_attribute(ctx, STR(beg), end - beg, 0, &det->info, info_build)); |
4794 | |
4795 | /* Build info string attribute. */ |
4796 | lang_end = beg; |
4797 | while(lang_end < end && !ISWHITESPACE(lang_end)) |
4798 | lang_end++; |
4799 | MD_CHECK(md_build_attribute(ctx, STR(beg), lang_end - beg, 0, &det->lang, lang_build)); |
4800 | |
4801 | det->fence_char = fence_ch; |
4802 | |
4803 | abort: |
4804 | return ret; |
4805 | } |
4806 | |
4807 | static int |
4808 | md_process_leaf_block(MD_CTX* ctx, const MD_BLOCK* block) |
4809 | { |
4810 | union { |
4811 | MD_BLOCK_H_DETAIL ; |
4812 | MD_BLOCK_CODE_DETAIL code; |
4813 | MD_BLOCK_TABLE_DETAIL table; |
4814 | } det; |
4815 | MD_ATTRIBUTE_BUILD info_build; |
4816 | MD_ATTRIBUTE_BUILD lang_build; |
4817 | int is_in_tight_list; |
4818 | int clean_fence_code_detail = FALSE; |
4819 | int ret = 0; |
4820 | |
4821 | memset(s: &det, c: 0, n: sizeof(det)); |
4822 | |
4823 | if(ctx->n_containers == 0) |
4824 | is_in_tight_list = FALSE; |
4825 | else |
4826 | is_in_tight_list = !ctx->containers[ctx->n_containers-1].is_loose; |
4827 | |
4828 | switch(block->type) { |
4829 | case MD_BLOCK_H: |
4830 | det.header.level = block->data; |
4831 | break; |
4832 | |
4833 | case MD_BLOCK_CODE: |
4834 | /* For fenced code block, we may need to set the info string. */ |
4835 | if(block->data != 0) { |
4836 | memset(s: &det.code, c: 0, n: sizeof(MD_BLOCK_CODE_DETAIL)); |
4837 | clean_fence_code_detail = TRUE; |
4838 | MD_CHECK(md_setup_fenced_code_detail(ctx, block, &det.code, &info_build, &lang_build)); |
4839 | } |
4840 | break; |
4841 | |
4842 | case MD_BLOCK_TABLE: |
4843 | det.table.col_count = block->data; |
4844 | det.table.head_row_count = 1; |
4845 | det.table.body_row_count = block->n_lines - 2; |
4846 | break; |
4847 | |
4848 | default: |
4849 | /* Noop. */ |
4850 | break; |
4851 | } |
4852 | |
4853 | if(!is_in_tight_list || block->type != MD_BLOCK_P) |
4854 | MD_ENTER_BLOCK(block->type, (void*) &det); |
4855 | |
4856 | /* Process the block contents accordingly to is type. */ |
4857 | switch(block->type) { |
4858 | case MD_BLOCK_HR: |
4859 | /* noop */ |
4860 | break; |
4861 | |
4862 | case MD_BLOCK_CODE: |
4863 | MD_CHECK(md_process_code_block_contents(ctx, (block->data != 0), |
4864 | (const MD_VERBATIMLINE*)(block + 1), block->n_lines)); |
4865 | break; |
4866 | |
4867 | case MD_BLOCK_HTML: |
4868 | MD_CHECK(md_process_verbatim_block_contents(ctx, MD_TEXT_HTML, |
4869 | (const MD_VERBATIMLINE*)(block + 1), block->n_lines)); |
4870 | break; |
4871 | |
4872 | case MD_BLOCK_TABLE: |
4873 | MD_CHECK(md_process_table_block_contents(ctx, block->data, |
4874 | (const MD_LINE*)(block + 1), block->n_lines)); |
4875 | break; |
4876 | |
4877 | default: |
4878 | MD_CHECK(md_process_normal_block_contents(ctx, |
4879 | (const MD_LINE*)(block + 1), block->n_lines)); |
4880 | break; |
4881 | } |
4882 | |
4883 | if(!is_in_tight_list || block->type != MD_BLOCK_P) |
4884 | MD_LEAVE_BLOCK(block->type, (void*) &det); |
4885 | |
4886 | abort: |
4887 | if(clean_fence_code_detail) { |
4888 | md_free_attribute(ctx, build: &info_build); |
4889 | md_free_attribute(ctx, build: &lang_build); |
4890 | } |
4891 | return ret; |
4892 | } |
4893 | |
4894 | static int |
4895 | md_process_all_blocks(MD_CTX* ctx) |
4896 | { |
4897 | int byte_off = 0; |
4898 | int ret = 0; |
4899 | |
4900 | /* ctx->containers now is not needed for detection of lists and list items |
4901 | * so we reuse it for tracking what lists are loose or tight. We rely |
4902 | * on the fact the vector is large enough to hold the deepest nesting |
4903 | * level of lists. */ |
4904 | ctx->n_containers = 0; |
4905 | |
4906 | while(byte_off < ctx->n_block_bytes) { |
4907 | MD_BLOCK* block = (MD_BLOCK*)((char*)ctx->block_bytes + byte_off); |
4908 | union { |
4909 | MD_BLOCK_UL_DETAIL ul; |
4910 | MD_BLOCK_OL_DETAIL ol; |
4911 | MD_BLOCK_LI_DETAIL li; |
4912 | } det; |
4913 | |
4914 | switch(block->type) { |
4915 | case MD_BLOCK_UL: |
4916 | det.ul.is_tight = (block->flags & MD_BLOCK_LOOSE_LIST) ? FALSE : TRUE; |
4917 | det.ul.mark = (CHAR) block->data; |
4918 | break; |
4919 | |
4920 | case MD_BLOCK_OL: |
4921 | det.ol.start = block->n_lines; |
4922 | det.ol.is_tight = (block->flags & MD_BLOCK_LOOSE_LIST) ? FALSE : TRUE; |
4923 | det.ol.mark_delimiter = (CHAR) block->data; |
4924 | break; |
4925 | |
4926 | case MD_BLOCK_LI: |
4927 | det.li.is_task = (block->data != 0); |
4928 | det.li.task_mark = (CHAR) block->data; |
4929 | det.li.task_mark_offset = (OFF) block->n_lines; |
4930 | break; |
4931 | |
4932 | default: |
4933 | /* noop */ |
4934 | break; |
4935 | } |
4936 | |
4937 | if(block->flags & MD_BLOCK_CONTAINER) { |
4938 | if(block->flags & MD_BLOCK_CONTAINER_CLOSER) { |
4939 | MD_LEAVE_BLOCK(block->type, &det); |
4940 | |
4941 | if(block->type == MD_BLOCK_UL || block->type == MD_BLOCK_OL || block->type == MD_BLOCK_QUOTE) |
4942 | ctx->n_containers--; |
4943 | } |
4944 | |
4945 | if(block->flags & MD_BLOCK_CONTAINER_OPENER) { |
4946 | MD_ENTER_BLOCK(block->type, &det); |
4947 | |
4948 | if(block->type == MD_BLOCK_UL || block->type == MD_BLOCK_OL) { |
4949 | ctx->containers[ctx->n_containers].is_loose = (block->flags & MD_BLOCK_LOOSE_LIST); |
4950 | ctx->n_containers++; |
4951 | } else if(block->type == MD_BLOCK_QUOTE) { |
4952 | /* This causes that any text in a block quote, even if |
4953 | * nested inside a tight list item, is wrapped with |
4954 | * <p>...</p>. */ |
4955 | ctx->containers[ctx->n_containers].is_loose = TRUE; |
4956 | ctx->n_containers++; |
4957 | } |
4958 | } |
4959 | } else { |
4960 | MD_CHECK(md_process_leaf_block(ctx, block)); |
4961 | |
4962 | if(block->type == MD_BLOCK_CODE || block->type == MD_BLOCK_HTML) |
4963 | byte_off += block->n_lines * sizeof(MD_VERBATIMLINE); |
4964 | else |
4965 | byte_off += block->n_lines * sizeof(MD_LINE); |
4966 | } |
4967 | |
4968 | byte_off += sizeof(MD_BLOCK); |
4969 | } |
4970 | |
4971 | ctx->n_block_bytes = 0; |
4972 | |
4973 | abort: |
4974 | return ret; |
4975 | } |
4976 | |
4977 | |
4978 | /************************************ |
4979 | *** Grouping Lines into Blocks *** |
4980 | ************************************/ |
4981 | |
4982 | static void* |
4983 | md_push_block_bytes(MD_CTX* ctx, int n_bytes) |
4984 | { |
4985 | void* ptr; |
4986 | |
4987 | if(ctx->n_block_bytes + n_bytes > ctx->alloc_block_bytes) { |
4988 | void* new_block_bytes; |
4989 | |
4990 | ctx->alloc_block_bytes = (ctx->alloc_block_bytes > 0 |
4991 | ? ctx->alloc_block_bytes + ctx->alloc_block_bytes / 2 |
4992 | : 512); |
4993 | new_block_bytes = realloc(ptr: ctx->block_bytes, size: ctx->alloc_block_bytes); |
4994 | if(new_block_bytes == NULL) { |
4995 | MD_LOG("realloc() failed." ); |
4996 | return NULL; |
4997 | } |
4998 | |
4999 | /* Fix the ->current_block after the reallocation. */ |
5000 | if(ctx->current_block != NULL) { |
5001 | OFF off_current_block = (OFF) ((char*) ctx->current_block - (char*) ctx->block_bytes); |
5002 | ctx->current_block = (MD_BLOCK*) ((char*) new_block_bytes + off_current_block); |
5003 | } |
5004 | |
5005 | ctx->block_bytes = new_block_bytes; |
5006 | } |
5007 | |
5008 | ptr = (char*)ctx->block_bytes + ctx->n_block_bytes; |
5009 | ctx->n_block_bytes += n_bytes; |
5010 | return ptr; |
5011 | } |
5012 | |
5013 | static int |
5014 | md_start_new_block(MD_CTX* ctx, const MD_LINE_ANALYSIS* line) |
5015 | { |
5016 | MD_BLOCK* block; |
5017 | |
5018 | MD_ASSERT(ctx->current_block == NULL); |
5019 | |
5020 | block = (MD_BLOCK*) md_push_block_bytes(ctx, n_bytes: sizeof(MD_BLOCK)); |
5021 | if(block == NULL) |
5022 | return -1; |
5023 | |
5024 | switch(line->type) { |
5025 | case MD_LINE_HR: |
5026 | block->type = MD_BLOCK_HR; |
5027 | break; |
5028 | |
5029 | case MD_LINE_ATXHEADER: |
5030 | case MD_LINE_SETEXTHEADER: |
5031 | block->type = MD_BLOCK_H; |
5032 | break; |
5033 | |
5034 | case MD_LINE_FENCEDCODE: |
5035 | case MD_LINE_INDENTEDCODE: |
5036 | block->type = MD_BLOCK_CODE; |
5037 | break; |
5038 | |
5039 | case MD_LINE_TEXT: |
5040 | block->type = MD_BLOCK_P; |
5041 | break; |
5042 | |
5043 | case MD_LINE_HTML: |
5044 | block->type = MD_BLOCK_HTML; |
5045 | break; |
5046 | |
5047 | case MD_LINE_BLANK: |
5048 | case MD_LINE_SETEXTUNDERLINE: |
5049 | case MD_LINE_TABLEUNDERLINE: |
5050 | default: |
5051 | MD_UNREACHABLE(); |
5052 | break; |
5053 | } |
5054 | |
5055 | block->flags = 0; |
5056 | block->data = line->data; |
5057 | block->n_lines = 0; |
5058 | |
5059 | ctx->current_block = block; |
5060 | return 0; |
5061 | } |
5062 | |
5063 | /* Eat from start of current (textual) block any reference definitions and |
5064 | * remember them so we can resolve any links referring to them. |
5065 | * |
5066 | * (Reference definitions can only be at start of it as they cannot break |
5067 | * a paragraph.) |
5068 | */ |
5069 | static int |
5070 | md_consume_link_reference_definitions(MD_CTX* ctx) |
5071 | { |
5072 | MD_LINE* lines = (MD_LINE*) (ctx->current_block + 1); |
5073 | MD_SIZE n_lines = ctx->current_block->n_lines; |
5074 | MD_SIZE n = 0; |
5075 | |
5076 | /* Compute how many lines at the start of the block form one or more |
5077 | * reference definitions. */ |
5078 | while(n < n_lines) { |
5079 | int n_link_ref_lines; |
5080 | |
5081 | n_link_ref_lines = md_is_link_reference_definition(ctx, |
5082 | lines: lines + n, n_lines: n_lines - n); |
5083 | /* Not a reference definition? */ |
5084 | if(n_link_ref_lines == 0) |
5085 | break; |
5086 | |
5087 | /* We fail if it is the ref. def. but it could not be stored due |
5088 | * a memory allocation error. */ |
5089 | if(n_link_ref_lines < 0) |
5090 | return -1; |
5091 | |
5092 | n += n_link_ref_lines; |
5093 | } |
5094 | |
5095 | /* If there was at least one reference definition, we need to remove |
5096 | * its lines from the block, or perhaps even the whole block. */ |
5097 | if(n > 0) { |
5098 | if(n == n_lines) { |
5099 | /* Remove complete block. */ |
5100 | ctx->n_block_bytes -= n * sizeof(MD_LINE); |
5101 | ctx->n_block_bytes -= sizeof(MD_BLOCK); |
5102 | ctx->current_block = NULL; |
5103 | } else { |
5104 | /* Remove just some initial lines from the block. */ |
5105 | memmove(dest: lines, src: lines + n, n: (n_lines - n) * sizeof(MD_LINE)); |
5106 | ctx->current_block->n_lines -= n; |
5107 | ctx->n_block_bytes -= n * sizeof(MD_LINE); |
5108 | } |
5109 | } |
5110 | |
5111 | return 0; |
5112 | } |
5113 | |
5114 | static int |
5115 | md_end_current_block(MD_CTX* ctx) |
5116 | { |
5117 | int ret = 0; |
5118 | |
5119 | if(ctx->current_block == NULL) |
5120 | return ret; |
5121 | |
5122 | /* Check whether there is a reference definition. (We do this here instead |
5123 | * of in md_analyze_line() because reference definition can take multiple |
5124 | * lines.) */ |
5125 | if(ctx->current_block->type == MD_BLOCK_P || |
5126 | (ctx->current_block->type == MD_BLOCK_H && (ctx->current_block->flags & MD_BLOCK_SETEXT_HEADER))) |
5127 | { |
5128 | MD_LINE* lines = (MD_LINE*) (ctx->current_block + 1); |
5129 | if(lines[0].beg < ctx->size && CH(lines[0].beg) == _T('[')) { |
5130 | MD_CHECK(md_consume_link_reference_definitions(ctx)); |
5131 | if(ctx->current_block == NULL) |
5132 | return ret; |
5133 | } |
5134 | } |
5135 | |
5136 | if(ctx->current_block->type == MD_BLOCK_H && (ctx->current_block->flags & MD_BLOCK_SETEXT_HEADER)) { |
5137 | MD_SIZE n_lines = ctx->current_block->n_lines; |
5138 | |
5139 | if(n_lines > 1) { |
5140 | /* Get rid of the underline. */ |
5141 | ctx->current_block->n_lines--; |
5142 | ctx->n_block_bytes -= sizeof(MD_LINE); |
5143 | } else { |
5144 | /* Only the underline has left after eating the ref. defs. |
5145 | * Keep the line as beginning of a new ordinary paragraph. */ |
5146 | ctx->current_block->type = MD_BLOCK_P; |
5147 | return 0; |
5148 | } |
5149 | } |
5150 | |
5151 | /* Mark we are not building any block anymore. */ |
5152 | ctx->current_block = NULL; |
5153 | |
5154 | abort: |
5155 | return ret; |
5156 | } |
5157 | |
5158 | static int |
5159 | md_add_line_into_current_block(MD_CTX* ctx, const MD_LINE_ANALYSIS* analysis) |
5160 | { |
5161 | MD_ASSERT(ctx->current_block != NULL); |
5162 | |
5163 | if(ctx->current_block->type == MD_BLOCK_CODE || ctx->current_block->type == MD_BLOCK_HTML) { |
5164 | MD_VERBATIMLINE* line; |
5165 | |
5166 | line = (MD_VERBATIMLINE*) md_push_block_bytes(ctx, n_bytes: sizeof(MD_VERBATIMLINE)); |
5167 | if(line == NULL) |
5168 | return -1; |
5169 | |
5170 | line->indent = analysis->indent; |
5171 | line->beg = analysis->beg; |
5172 | line->end = analysis->end; |
5173 | } else { |
5174 | MD_LINE* line; |
5175 | |
5176 | line = (MD_LINE*) md_push_block_bytes(ctx, n_bytes: sizeof(MD_LINE)); |
5177 | if(line == NULL) |
5178 | return -1; |
5179 | |
5180 | line->beg = analysis->beg; |
5181 | line->end = analysis->end; |
5182 | } |
5183 | ctx->current_block->n_lines++; |
5184 | |
5185 | return 0; |
5186 | } |
5187 | |
5188 | static int |
5189 | md_push_container_bytes(MD_CTX* ctx, MD_BLOCKTYPE type, unsigned start, |
5190 | unsigned data, unsigned flags) |
5191 | { |
5192 | MD_BLOCK* block; |
5193 | int ret = 0; |
5194 | |
5195 | MD_CHECK(md_end_current_block(ctx)); |
5196 | |
5197 | block = (MD_BLOCK*) md_push_block_bytes(ctx, n_bytes: sizeof(MD_BLOCK)); |
5198 | if(block == NULL) |
5199 | return -1; |
5200 | |
5201 | block->type = type; |
5202 | block->flags = flags; |
5203 | block->data = data; |
5204 | block->n_lines = start; |
5205 | |
5206 | abort: |
5207 | return ret; |
5208 | } |
5209 | |
5210 | |
5211 | |
5212 | /*********************** |
5213 | *** Line Analysis *** |
5214 | ***********************/ |
5215 | |
5216 | static int |
5217 | md_is_hr_line(MD_CTX* ctx, OFF beg, OFF* p_end, OFF* p_killer) |
5218 | { |
5219 | OFF off = beg + 1; |
5220 | int n = 1; |
5221 | |
5222 | while(off < ctx->size && (CH(off) == CH(beg) || CH(off) == _T(' ') || CH(off) == _T('\t'))) { |
5223 | if(CH(off) == CH(beg)) |
5224 | n++; |
5225 | off++; |
5226 | } |
5227 | |
5228 | if(n < 3) { |
5229 | *p_killer = off; |
5230 | return FALSE; |
5231 | } |
5232 | |
5233 | /* Nothing else can be present on the line. */ |
5234 | if(off < ctx->size && !ISNEWLINE(off)) { |
5235 | *p_killer = off; |
5236 | return FALSE; |
5237 | } |
5238 | |
5239 | *p_end = off; |
5240 | return TRUE; |
5241 | } |
5242 | |
5243 | static int |
5244 | (MD_CTX* ctx, OFF beg, OFF* p_beg, OFF* p_end, unsigned* p_level) |
5245 | { |
5246 | int n; |
5247 | OFF off = beg + 1; |
5248 | |
5249 | while(off < ctx->size && CH(off) == _T('#') && off - beg < 7) |
5250 | off++; |
5251 | n = off - beg; |
5252 | |
5253 | if(n > 6) |
5254 | return FALSE; |
5255 | *p_level = n; |
5256 | |
5257 | if(!(ctx->parser.flags & MD_FLAG_PERMISSIVEATXHEADERS) && off < ctx->size && |
5258 | CH(off) != _T(' ') && CH(off) != _T('\t') && !ISNEWLINE(off)) |
5259 | return FALSE; |
5260 | |
5261 | while(off < ctx->size && CH(off) == _T(' ')) |
5262 | off++; |
5263 | *p_beg = off; |
5264 | *p_end = off; |
5265 | return TRUE; |
5266 | } |
5267 | |
5268 | static int |
5269 | md_is_setext_underline(MD_CTX* ctx, OFF beg, OFF* p_end, unsigned* p_level) |
5270 | { |
5271 | OFF off = beg + 1; |
5272 | |
5273 | while(off < ctx->size && CH(off) == CH(beg)) |
5274 | off++; |
5275 | |
5276 | /* Optionally, space(s) or tabs can follow. */ |
5277 | while(off < ctx->size && ISBLANK(off)) |
5278 | off++; |
5279 | |
5280 | /* But nothing more is allowed on the line. */ |
5281 | if(off < ctx->size && !ISNEWLINE(off)) |
5282 | return FALSE; |
5283 | |
5284 | *p_level = (CH(beg) == _T('=') ? 1 : 2); |
5285 | *p_end = off; |
5286 | return TRUE; |
5287 | } |
5288 | |
5289 | static int |
5290 | md_is_table_underline(MD_CTX* ctx, OFF beg, OFF* p_end, unsigned* p_col_count) |
5291 | { |
5292 | OFF off = beg; |
5293 | int found_pipe = FALSE; |
5294 | unsigned col_count = 0; |
5295 | |
5296 | if(off < ctx->size && CH(off) == _T('|')) { |
5297 | found_pipe = TRUE; |
5298 | off++; |
5299 | while(off < ctx->size && ISWHITESPACE(off)) |
5300 | off++; |
5301 | } |
5302 | |
5303 | while(1) { |
5304 | int delimited = FALSE; |
5305 | |
5306 | /* Cell underline ("-----", ":----", "----:" or ":----:") */ |
5307 | if(off < ctx->size && CH(off) == _T(':')) |
5308 | off++; |
5309 | if(off >= ctx->size || CH(off) != _T('-')) |
5310 | return FALSE; |
5311 | while(off < ctx->size && CH(off) == _T('-')) |
5312 | off++; |
5313 | if(off < ctx->size && CH(off) == _T(':')) |
5314 | off++; |
5315 | |
5316 | col_count++; |
5317 | if(col_count > TABLE_MAXCOLCOUNT) { |
5318 | MD_LOG("Suppressing table (column_count >" STRINGIZE(TABLE_MAXCOLCOUNT) ")" ); |
5319 | return FALSE; |
5320 | } |
5321 | |
5322 | /* Pipe delimiter (optional at the end of line). */ |
5323 | while(off < ctx->size && ISWHITESPACE(off)) |
5324 | off++; |
5325 | if(off < ctx->size && CH(off) == _T('|')) { |
5326 | delimited = TRUE; |
5327 | found_pipe = TRUE; |
5328 | off++; |
5329 | while(off < ctx->size && ISWHITESPACE(off)) |
5330 | off++; |
5331 | } |
5332 | |
5333 | /* Success, if we reach end of line. */ |
5334 | if(off >= ctx->size || ISNEWLINE(off)) |
5335 | break; |
5336 | |
5337 | if(!delimited) |
5338 | return FALSE; |
5339 | } |
5340 | |
5341 | if(!found_pipe) |
5342 | return FALSE; |
5343 | |
5344 | *p_end = off; |
5345 | *p_col_count = col_count; |
5346 | return TRUE; |
5347 | } |
5348 | |
5349 | static int |
5350 | md_is_opening_code_fence(MD_CTX* ctx, OFF beg, OFF* p_end) |
5351 | { |
5352 | OFF off = beg; |
5353 | |
5354 | while(off < ctx->size && CH(off) == CH(beg)) |
5355 | off++; |
5356 | |
5357 | /* Fence must have at least three characters. */ |
5358 | if(off - beg < 3) |
5359 | return FALSE; |
5360 | |
5361 | ctx->code_fence_length = off - beg; |
5362 | |
5363 | /* Optionally, space(s) can follow. */ |
5364 | while(off < ctx->size && CH(off) == _T(' ')) |
5365 | off++; |
5366 | |
5367 | /* Optionally, an info string can follow. */ |
5368 | while(off < ctx->size && !ISNEWLINE(off)) { |
5369 | /* Backtick-based fence must not contain '`' in the info string. */ |
5370 | if(CH(beg) == _T('`') && CH(off) == _T('`')) |
5371 | return FALSE; |
5372 | off++; |
5373 | } |
5374 | |
5375 | *p_end = off; |
5376 | return TRUE; |
5377 | } |
5378 | |
5379 | static int |
5380 | md_is_closing_code_fence(MD_CTX* ctx, CHAR ch, OFF beg, OFF* p_end) |
5381 | { |
5382 | OFF off = beg; |
5383 | int ret = FALSE; |
5384 | |
5385 | /* Closing fence must have at least the same length and use same char as |
5386 | * opening one. */ |
5387 | while(off < ctx->size && CH(off) == ch) |
5388 | off++; |
5389 | if(off - beg < ctx->code_fence_length) |
5390 | goto out; |
5391 | |
5392 | /* Optionally, space(s) can follow */ |
5393 | while(off < ctx->size && CH(off) == _T(' ')) |
5394 | off++; |
5395 | |
5396 | /* But nothing more is allowed on the line. */ |
5397 | if(off < ctx->size && !ISNEWLINE(off)) |
5398 | goto out; |
5399 | |
5400 | ret = TRUE; |
5401 | |
5402 | out: |
5403 | /* Note we set *p_end even on failure: If we are not closing fence, caller |
5404 | * would eat the line anyway without any parsing. */ |
5405 | *p_end = off; |
5406 | return ret; |
5407 | } |
5408 | |
5409 | |
5410 | /* Helper data for md_is_html_block_start_condition() and |
5411 | * md_is_html_block_end_condition() */ |
5412 | typedef struct TAG_tag TAG; |
5413 | struct TAG_tag { |
5414 | const CHAR* name; |
5415 | unsigned len : 8; |
5416 | }; |
5417 | |
5418 | #ifdef X |
5419 | #undef X |
5420 | #endif |
5421 | #define X(name) { _T(name), (sizeof(name)-1) / sizeof(CHAR) } |
5422 | #define Xend { NULL, 0 } |
5423 | |
5424 | static const TAG t1[] = { X("pre" ), X("script" ), X("style" ), X("textarea" ), Xend }; |
5425 | |
5426 | static const TAG a6[] = { X("address" ), X("article" ), X("aside" ), Xend }; |
5427 | static const TAG b6[] = { X("base" ), X("basefont" ), X("blockquote" ), X("body" ), Xend }; |
5428 | static const TAG c6[] = { X("caption" ), X("center" ), X("col" ), X("colgroup" ), Xend }; |
5429 | static const TAG d6[] = { X("dd" ), X("details" ), X("dialog" ), X("dir" ), |
5430 | X("div" ), X("dl" ), X("dt" ), Xend }; |
5431 | static const TAG f6[] = { X("fieldset" ), X("figcaption" ), X("figure" ), X("footer" ), |
5432 | X("form" ), X("frame" ), X("frameset" ), Xend }; |
5433 | static const TAG h6[] = { X("h1" ), X("h2" ), X("h3" ), X("h4" ), X("h5" ), X("h6" ), |
5434 | X("head" ), X("header" ), X("hr" ), X("html" ), Xend }; |
5435 | static const TAG i6[] = { X("iframe" ), Xend }; |
5436 | static const TAG l6[] = { X("legend" ), X("li" ), X("link" ), Xend }; |
5437 | static const TAG m6[] = { X("main" ), X("menu" ), X("menuitem" ), Xend }; |
5438 | static const TAG n6[] = { X("nav" ), X("noframes" ), Xend }; |
5439 | static const TAG o6[] = { X("ol" ), X("optgroup" ), X("option" ), Xend }; |
5440 | static const TAG p6[] = { X("p" ), X("param" ), Xend }; |
5441 | static const TAG s6[] = { X("search" ), X("section" ), X("summary" ), Xend }; |
5442 | static const TAG t6[] = { X("table" ), X("tbody" ), X("td" ), X("tfoot" ), X("th" ), |
5443 | X("thead" ), X("title" ), X("tr" ), X("track" ), Xend }; |
5444 | static const TAG u6[] = { X("ul" ), Xend }; |
5445 | static const TAG xx[] = { Xend }; |
5446 | |
5447 | #undef X |
5448 | #undef Xend |
5449 | |
5450 | /* Returns type of the raw HTML block, or FALSE if it is not HTML block. |
5451 | * (Refer to CommonMark specification for details about the types.) |
5452 | */ |
5453 | static int |
5454 | md_is_html_block_start_condition(MD_CTX* ctx, OFF beg) |
5455 | { |
5456 | /* Type 6 is started by a long list of allowed tags. We use two-level |
5457 | * tree to speed-up the search. */ |
5458 | static const TAG* map6[26] = { |
5459 | a6, b6, c6, d6, xx, f6, xx, h6, i6, xx, xx, l6, m6, |
5460 | n6, o6, p6, xx, xx, s6, t6, u6, xx, xx, xx, xx, xx |
5461 | }; |
5462 | OFF off = beg + 1; |
5463 | int i; |
5464 | |
5465 | /* Check for type 1: <script, <pre, or <style */ |
5466 | for(i = 0; t1[i].name != NULL; i++) { |
5467 | if(off + t1[i].len <= ctx->size) { |
5468 | if(md_ascii_case_eq(STR(off), s2: t1[i].name, n: t1[i].len)) |
5469 | return 1; |
5470 | } |
5471 | } |
5472 | |
5473 | /* Check for type 2: <!-- */ |
5474 | if(off + 3 < ctx->size && CH(off) == _T('!') && CH(off+1) == _T('-') && CH(off+2) == _T('-')) |
5475 | return 2; |
5476 | |
5477 | /* Check for type 3: <? */ |
5478 | if(off < ctx->size && CH(off) == _T('?')) |
5479 | return 3; |
5480 | |
5481 | /* Check for type 4 or 5: <! */ |
5482 | if(off < ctx->size && CH(off) == _T('!')) { |
5483 | /* Check for type 4: <! followed by uppercase letter. */ |
5484 | if(off + 1 < ctx->size && ISASCII(off+1)) |
5485 | return 4; |
5486 | |
5487 | /* Check for type 5: <![CDATA[ */ |
5488 | if(off + 8 < ctx->size) { |
5489 | if(md_ascii_eq(STR(off), _T("![CDATA[" ), n: 8)) |
5490 | return 5; |
5491 | } |
5492 | } |
5493 | |
5494 | /* Check for type 6: Many possible starting tags listed above. */ |
5495 | if(off + 1 < ctx->size && (ISALPHA(off) || (CH(off) == _T('/') && ISALPHA(off+1)))) { |
5496 | int slot; |
5497 | const TAG* tags; |
5498 | |
5499 | if(CH(off) == _T('/')) |
5500 | off++; |
5501 | |
5502 | slot = (ISUPPER(off) ? CH(off) - 'A' : CH(off) - 'a'); |
5503 | tags = map6[slot]; |
5504 | |
5505 | for(i = 0; tags[i].name != NULL; i++) { |
5506 | if(off + tags[i].len <= ctx->size) { |
5507 | if(md_ascii_case_eq(STR(off), s2: tags[i].name, n: tags[i].len)) { |
5508 | OFF tmp = off + tags[i].len; |
5509 | if(tmp >= ctx->size) |
5510 | return 6; |
5511 | if(ISBLANK(tmp) || ISNEWLINE(tmp) || CH(tmp) == _T('>')) |
5512 | return 6; |
5513 | if(tmp+1 < ctx->size && CH(tmp) == _T('/') && CH(tmp+1) == _T('>')) |
5514 | return 6; |
5515 | break; |
5516 | } |
5517 | } |
5518 | } |
5519 | } |
5520 | |
5521 | /* Check for type 7: any COMPLETE other opening or closing tag. */ |
5522 | if(off + 1 < ctx->size) { |
5523 | OFF end; |
5524 | |
5525 | if(md_is_html_tag(ctx, NULL, n_lines: 0, beg, max_end: ctx->size, p_end: &end)) { |
5526 | /* Only optional whitespace and new line may follow. */ |
5527 | while(end < ctx->size && ISWHITESPACE(end)) |
5528 | end++; |
5529 | if(end >= ctx->size || ISNEWLINE(end)) |
5530 | return 7; |
5531 | } |
5532 | } |
5533 | |
5534 | return FALSE; |
5535 | } |
5536 | |
5537 | /* Case sensitive check whether there is a substring 'what' between 'beg' |
5538 | * and end of line. */ |
5539 | static int |
5540 | md_line_contains(MD_CTX* ctx, OFF beg, const CHAR* what, SZ what_len, OFF* p_end) |
5541 | { |
5542 | OFF i; |
5543 | for(i = beg; i + what_len < ctx->size; i++) { |
5544 | if(ISNEWLINE(i)) |
5545 | break; |
5546 | if(memcmp(STR(i), s2: what, n: what_len * sizeof(CHAR)) == 0) { |
5547 | *p_end = i + what_len; |
5548 | return TRUE; |
5549 | } |
5550 | } |
5551 | |
5552 | *p_end = i; |
5553 | return FALSE; |
5554 | } |
5555 | |
5556 | /* Returns type of HTML block end condition or FALSE if not an end condition. |
5557 | * |
5558 | * Note it fills p_end even when it is not end condition as the caller |
5559 | * does not need to analyze contents of a raw HTML block. |
5560 | */ |
5561 | static int |
5562 | md_is_html_block_end_condition(MD_CTX* ctx, OFF beg, OFF* p_end) |
5563 | { |
5564 | switch(ctx->html_block_type) { |
5565 | case 1: |
5566 | { |
5567 | OFF off = beg; |
5568 | int i; |
5569 | |
5570 | while(off+1 < ctx->size && !ISNEWLINE(off)) { |
5571 | if(CH(off) == _T('<') && CH(off+1) == _T('/')) { |
5572 | for(i = 0; t1[i].name != NULL; i++) { |
5573 | if(off + 2 + t1[i].len < ctx->size) { |
5574 | if(md_ascii_case_eq(STR(off+2), s2: t1[i].name, n: t1[i].len) && |
5575 | CH(off+2+t1[i].len) == _T('>')) |
5576 | { |
5577 | *p_end = off+2+t1[i].len+1; |
5578 | return TRUE; |
5579 | } |
5580 | } |
5581 | } |
5582 | } |
5583 | off++; |
5584 | } |
5585 | *p_end = off; |
5586 | return FALSE; |
5587 | } |
5588 | |
5589 | case 2: |
5590 | return (md_line_contains(ctx, beg, _T("-->" ), what_len: 3, p_end) ? 2 : FALSE); |
5591 | |
5592 | case 3: |
5593 | return (md_line_contains(ctx, beg, _T("?>" ), what_len: 2, p_end) ? 3 : FALSE); |
5594 | |
5595 | case 4: |
5596 | return (md_line_contains(ctx, beg, _T(">" ), what_len: 1, p_end) ? 4 : FALSE); |
5597 | |
5598 | case 5: |
5599 | return (md_line_contains(ctx, beg, _T("]]>" ), what_len: 3, p_end) ? 5 : FALSE); |
5600 | |
5601 | case 6: /* Pass through */ |
5602 | case 7: |
5603 | if(beg >= ctx->size || ISNEWLINE(beg)) { |
5604 | /* Blank line ends types 6 and 7. */ |
5605 | *p_end = beg; |
5606 | return ctx->html_block_type; |
5607 | } |
5608 | return FALSE; |
5609 | |
5610 | default: |
5611 | MD_UNREACHABLE(); |
5612 | } |
5613 | return FALSE; |
5614 | } |
5615 | |
5616 | |
5617 | static int |
5618 | md_is_container_compatible(const MD_CONTAINER* pivot, const MD_CONTAINER* container) |
5619 | { |
5620 | /* Block quote has no "items" like lists. */ |
5621 | if(container->ch == _T('>')) |
5622 | return FALSE; |
5623 | |
5624 | if(container->ch != pivot->ch) |
5625 | return FALSE; |
5626 | if(container->mark_indent > pivot->contents_indent) |
5627 | return FALSE; |
5628 | |
5629 | return TRUE; |
5630 | } |
5631 | |
5632 | static int |
5633 | md_push_container(MD_CTX* ctx, const MD_CONTAINER* container) |
5634 | { |
5635 | if(ctx->n_containers >= ctx->alloc_containers) { |
5636 | MD_CONTAINER* new_containers; |
5637 | |
5638 | ctx->alloc_containers = (ctx->alloc_containers > 0 |
5639 | ? ctx->alloc_containers + ctx->alloc_containers / 2 |
5640 | : 16); |
5641 | new_containers = realloc(ptr: ctx->containers, size: ctx->alloc_containers * sizeof(MD_CONTAINER)); |
5642 | if(new_containers == NULL) { |
5643 | MD_LOG("realloc() failed." ); |
5644 | return -1; |
5645 | } |
5646 | |
5647 | ctx->containers = new_containers; |
5648 | } |
5649 | |
5650 | memcpy(dest: &ctx->containers[ctx->n_containers++], src: container, n: sizeof(MD_CONTAINER)); |
5651 | return 0; |
5652 | } |
5653 | |
5654 | static int |
5655 | md_enter_child_containers(MD_CTX* ctx, int n_children) |
5656 | { |
5657 | int i; |
5658 | int ret = 0; |
5659 | |
5660 | for(i = ctx->n_containers - n_children; i < ctx->n_containers; i++) { |
5661 | MD_CONTAINER* c = &ctx->containers[i]; |
5662 | int is_ordered_list = FALSE; |
5663 | |
5664 | switch(c->ch) { |
5665 | case _T(')'): |
5666 | case _T('.'): |
5667 | is_ordered_list = TRUE; |
5668 | MD_FALLTHROUGH(); |
5669 | |
5670 | case _T('-'): |
5671 | case _T('+'): |
5672 | case _T('*'): |
5673 | /* Remember offset in ctx->block_bytes so we can revisit the |
5674 | * block if we detect it is a loose list. */ |
5675 | md_end_current_block(ctx); |
5676 | c->block_byte_off = ctx->n_block_bytes; |
5677 | |
5678 | MD_CHECK(md_push_container_bytes(ctx, |
5679 | (is_ordered_list ? MD_BLOCK_OL : MD_BLOCK_UL), |
5680 | c->start, c->ch, MD_BLOCK_CONTAINER_OPENER)); |
5681 | MD_CHECK(md_push_container_bytes(ctx, MD_BLOCK_LI, |
5682 | c->task_mark_off, |
5683 | (c->is_task ? CH(c->task_mark_off) : 0), |
5684 | MD_BLOCK_CONTAINER_OPENER)); |
5685 | break; |
5686 | |
5687 | case _T('>'): |
5688 | MD_CHECK(md_push_container_bytes(ctx, MD_BLOCK_QUOTE, 0, 0, MD_BLOCK_CONTAINER_OPENER)); |
5689 | break; |
5690 | |
5691 | default: |
5692 | MD_UNREACHABLE(); |
5693 | break; |
5694 | } |
5695 | } |
5696 | |
5697 | abort: |
5698 | return ret; |
5699 | } |
5700 | |
5701 | static int |
5702 | md_leave_child_containers(MD_CTX* ctx, int n_keep) |
5703 | { |
5704 | int ret = 0; |
5705 | |
5706 | while(ctx->n_containers > n_keep) { |
5707 | MD_CONTAINER* c = &ctx->containers[ctx->n_containers-1]; |
5708 | int is_ordered_list = FALSE; |
5709 | |
5710 | switch(c->ch) { |
5711 | case _T(')'): |
5712 | case _T('.'): |
5713 | is_ordered_list = TRUE; |
5714 | MD_FALLTHROUGH(); |
5715 | |
5716 | case _T('-'): |
5717 | case _T('+'): |
5718 | case _T('*'): |
5719 | MD_CHECK(md_push_container_bytes(ctx, MD_BLOCK_LI, |
5720 | c->task_mark_off, (c->is_task ? CH(c->task_mark_off) : 0), |
5721 | MD_BLOCK_CONTAINER_CLOSER)); |
5722 | MD_CHECK(md_push_container_bytes(ctx, |
5723 | (is_ordered_list ? MD_BLOCK_OL : MD_BLOCK_UL), 0, |
5724 | c->ch, MD_BLOCK_CONTAINER_CLOSER)); |
5725 | break; |
5726 | |
5727 | case _T('>'): |
5728 | MD_CHECK(md_push_container_bytes(ctx, MD_BLOCK_QUOTE, 0, |
5729 | 0, MD_BLOCK_CONTAINER_CLOSER)); |
5730 | break; |
5731 | |
5732 | default: |
5733 | MD_UNREACHABLE(); |
5734 | break; |
5735 | } |
5736 | |
5737 | ctx->n_containers--; |
5738 | } |
5739 | |
5740 | abort: |
5741 | return ret; |
5742 | } |
5743 | |
5744 | static int |
5745 | md_is_container_mark(MD_CTX* ctx, unsigned indent, OFF beg, OFF* p_end, MD_CONTAINER* p_container) |
5746 | { |
5747 | OFF off = beg; |
5748 | OFF max_end; |
5749 | |
5750 | if(off >= ctx->size || indent >= ctx->code_indent_offset) |
5751 | return FALSE; |
5752 | |
5753 | /* Check for block quote mark. */ |
5754 | if(CH(off) == _T('>')) { |
5755 | off++; |
5756 | p_container->ch = _T('>'); |
5757 | p_container->is_loose = FALSE; |
5758 | p_container->is_task = FALSE; |
5759 | p_container->mark_indent = indent; |
5760 | p_container->contents_indent = indent + 1; |
5761 | *p_end = off; |
5762 | return TRUE; |
5763 | } |
5764 | |
5765 | /* Check for list item bullet mark. */ |
5766 | if(ISANYOF(off, _T("-+*" )) && (off+1 >= ctx->size || ISBLANK(off+1) || ISNEWLINE(off+1))) { |
5767 | p_container->ch = CH(off); |
5768 | p_container->is_loose = FALSE; |
5769 | p_container->is_task = FALSE; |
5770 | p_container->mark_indent = indent; |
5771 | p_container->contents_indent = indent + 1; |
5772 | *p_end = off+1; |
5773 | return TRUE; |
5774 | } |
5775 | |
5776 | /* Check for ordered list item marks. */ |
5777 | max_end = off + 9; |
5778 | if(max_end > ctx->size) |
5779 | max_end = ctx->size; |
5780 | p_container->start = 0; |
5781 | while(off < max_end && ISDIGIT(off)) { |
5782 | p_container->start = p_container->start * 10 + CH(off) - _T('0'); |
5783 | off++; |
5784 | } |
5785 | if(off > beg && |
5786 | off < ctx->size && |
5787 | (CH(off) == _T('.') || CH(off) == _T(')')) && |
5788 | (off+1 >= ctx->size || ISBLANK(off+1) || ISNEWLINE(off+1))) |
5789 | { |
5790 | p_container->ch = CH(off); |
5791 | p_container->is_loose = FALSE; |
5792 | p_container->is_task = FALSE; |
5793 | p_container->mark_indent = indent; |
5794 | p_container->contents_indent = indent + off - beg + 1; |
5795 | *p_end = off+1; |
5796 | return TRUE; |
5797 | } |
5798 | |
5799 | return FALSE; |
5800 | } |
5801 | |
5802 | static unsigned |
5803 | md_line_indentation(MD_CTX* ctx, unsigned total_indent, OFF beg, OFF* p_end) |
5804 | { |
5805 | OFF off = beg; |
5806 | unsigned indent = total_indent; |
5807 | |
5808 | while(off < ctx->size && ISBLANK(off)) { |
5809 | if(CH(off) == _T('\t')) |
5810 | indent = (indent + 4) & ~3; |
5811 | else |
5812 | indent++; |
5813 | off++; |
5814 | } |
5815 | |
5816 | *p_end = off; |
5817 | return indent - total_indent; |
5818 | } |
5819 | |
5820 | static const MD_LINE_ANALYSIS md_dummy_blank_line = { MD_LINE_BLANK, 0, 0, 0, 0, 0 }; |
5821 | |
5822 | /* Analyze type of the line and find some its properties. This serves as a |
5823 | * main input for determining type and boundaries of a block. */ |
5824 | static int |
5825 | md_analyze_line(MD_CTX* ctx, OFF beg, OFF* p_end, |
5826 | const MD_LINE_ANALYSIS* pivot_line, MD_LINE_ANALYSIS* line) |
5827 | { |
5828 | unsigned total_indent = 0; |
5829 | int n_parents = 0; |
5830 | int n_brothers = 0; |
5831 | int n_children = 0; |
5832 | MD_CONTAINER container = { 0 }; |
5833 | int prev_line_has_list_loosening_effect = ctx->last_line_has_list_loosening_effect; |
5834 | OFF off = beg; |
5835 | OFF hr_killer = 0; |
5836 | int ret = 0; |
5837 | |
5838 | line->indent = md_line_indentation(ctx, total_indent, beg: off, p_end: &off); |
5839 | total_indent += line->indent; |
5840 | line->beg = off; |
5841 | line->enforce_new_block = FALSE; |
5842 | |
5843 | /* Given the indentation and block quote marks '>', determine how many of |
5844 | * the current containers are our parents. */ |
5845 | while(n_parents < ctx->n_containers) { |
5846 | MD_CONTAINER* c = &ctx->containers[n_parents]; |
5847 | |
5848 | if(c->ch == _T('>') && line->indent < ctx->code_indent_offset && |
5849 | off < ctx->size && CH(off) == _T('>')) |
5850 | { |
5851 | /* Block quote mark. */ |
5852 | off++; |
5853 | total_indent++; |
5854 | line->indent = md_line_indentation(ctx, total_indent, beg: off, p_end: &off); |
5855 | total_indent += line->indent; |
5856 | |
5857 | /* The optional 1st space after '>' is part of the block quote mark. */ |
5858 | if(line->indent > 0) |
5859 | line->indent--; |
5860 | |
5861 | line->beg = off; |
5862 | |
5863 | } else if(c->ch != _T('>') && line->indent >= c->contents_indent) { |
5864 | /* List. */ |
5865 | line->indent -= c->contents_indent; |
5866 | } else { |
5867 | break; |
5868 | } |
5869 | |
5870 | n_parents++; |
5871 | } |
5872 | |
5873 | if(off >= ctx->size || ISNEWLINE(off)) { |
5874 | /* Blank line does not need any real indentation to be nested inside |
5875 | * a list. */ |
5876 | if(n_brothers + n_children == 0) { |
5877 | while(n_parents < ctx->n_containers && ctx->containers[n_parents].ch != _T('>')) |
5878 | n_parents++; |
5879 | } |
5880 | } |
5881 | |
5882 | while(TRUE) { |
5883 | /* Check whether we are fenced code continuation. */ |
5884 | if(pivot_line->type == MD_LINE_FENCEDCODE) { |
5885 | line->beg = off; |
5886 | |
5887 | /* We are another MD_LINE_FENCEDCODE unless we are closing fence |
5888 | * which we transform into MD_LINE_BLANK. */ |
5889 | if(line->indent < ctx->code_indent_offset) { |
5890 | if(md_is_closing_code_fence(ctx, CH(pivot_line->beg), beg: off, p_end: &off)) { |
5891 | line->type = MD_LINE_BLANK; |
5892 | ctx->last_line_has_list_loosening_effect = FALSE; |
5893 | break; |
5894 | } |
5895 | } |
5896 | |
5897 | /* Change indentation accordingly to the initial code fence. */ |
5898 | if(n_parents == ctx->n_containers) { |
5899 | if(line->indent > pivot_line->indent) |
5900 | line->indent -= pivot_line->indent; |
5901 | else |
5902 | line->indent = 0; |
5903 | |
5904 | line->type = MD_LINE_FENCEDCODE; |
5905 | break; |
5906 | } |
5907 | } |
5908 | |
5909 | /* Check whether we are HTML block continuation. */ |
5910 | if(pivot_line->type == MD_LINE_HTML && ctx->html_block_type > 0) { |
5911 | if(n_parents < ctx->n_containers) { |
5912 | /* HTML block is implicitly ended if the enclosing container |
5913 | * block ends. */ |
5914 | ctx->html_block_type = 0; |
5915 | } else { |
5916 | int html_block_type; |
5917 | |
5918 | html_block_type = md_is_html_block_end_condition(ctx, beg: off, p_end: &off); |
5919 | if(html_block_type > 0) { |
5920 | MD_ASSERT(html_block_type == ctx->html_block_type); |
5921 | |
5922 | /* Make sure this is the last line of the block. */ |
5923 | ctx->html_block_type = 0; |
5924 | |
5925 | /* Some end conditions serve as blank lines at the same time. */ |
5926 | if(html_block_type == 6 || html_block_type == 7) { |
5927 | line->type = MD_LINE_BLANK; |
5928 | line->indent = 0; |
5929 | break; |
5930 | } |
5931 | } |
5932 | |
5933 | line->type = MD_LINE_HTML; |
5934 | n_parents = ctx->n_containers; |
5935 | break; |
5936 | } |
5937 | } |
5938 | |
5939 | /* Check for blank line. */ |
5940 | if(off >= ctx->size || ISNEWLINE(off)) { |
5941 | if(pivot_line->type == MD_LINE_INDENTEDCODE && n_parents == ctx->n_containers) { |
5942 | line->type = MD_LINE_INDENTEDCODE; |
5943 | if(line->indent > ctx->code_indent_offset) |
5944 | line->indent -= ctx->code_indent_offset; |
5945 | else |
5946 | line->indent = 0; |
5947 | ctx->last_line_has_list_loosening_effect = FALSE; |
5948 | } else { |
5949 | line->type = MD_LINE_BLANK; |
5950 | ctx->last_line_has_list_loosening_effect = (n_parents > 0 && |
5951 | n_brothers + n_children == 0 && |
5952 | ctx->containers[n_parents-1].ch != _T('>')); |
5953 | |
5954 | #if 1 |
5955 | /* See https://github.com/mity/md4c/issues/6 |
5956 | * |
5957 | * This ugly checking tests we are in (yet empty) list item but |
5958 | * not its very first line (i.e. not the line with the list |
5959 | * item mark). |
5960 | * |
5961 | * If we are such a blank line, then any following non-blank |
5962 | * line which would be part of the list item actually has to |
5963 | * end the list because according to the specification, "a list |
5964 | * item can begin with at most one blank line." |
5965 | */ |
5966 | if(n_parents > 0 && ctx->containers[n_parents-1].ch != _T('>') && |
5967 | n_brothers + n_children == 0 && ctx->current_block == NULL && |
5968 | ctx->n_block_bytes > (int) sizeof(MD_BLOCK)) |
5969 | { |
5970 | MD_BLOCK* top_block = (MD_BLOCK*) ((char*)ctx->block_bytes + ctx->n_block_bytes - sizeof(MD_BLOCK)); |
5971 | if(top_block->type == MD_BLOCK_LI) |
5972 | ctx->last_list_item_starts_with_two_blank_lines = TRUE; |
5973 | } |
5974 | #endif |
5975 | } |
5976 | break; |
5977 | } else { |
5978 | #if 1 |
5979 | /* This is the 2nd half of the hack. If the flag is set (i.e. there |
5980 | * was a 2nd blank line at the beginning of the list item) and if |
5981 | * we would otherwise still belong to the list item, we enforce |
5982 | * the end of the list. */ |
5983 | if(ctx->last_list_item_starts_with_two_blank_lines) { |
5984 | if(n_parents > 0 && n_parents == ctx->n_containers && |
5985 | ctx->containers[n_parents-1].ch != _T('>') && |
5986 | n_brothers + n_children == 0 && ctx->current_block == NULL && |
5987 | ctx->n_block_bytes > (int) sizeof(MD_BLOCK)) |
5988 | { |
5989 | MD_BLOCK* top_block = (MD_BLOCK*) ((char*)ctx->block_bytes + ctx->n_block_bytes - sizeof(MD_BLOCK)); |
5990 | if(top_block->type == MD_BLOCK_LI) { |
5991 | n_parents--; |
5992 | |
5993 | line->indent = total_indent; |
5994 | if(n_parents > 0) |
5995 | line->indent -= MIN(line->indent, ctx->containers[n_parents-1].contents_indent); |
5996 | } |
5997 | } |
5998 | |
5999 | ctx->last_list_item_starts_with_two_blank_lines = FALSE; |
6000 | } |
6001 | #endif |
6002 | ctx->last_line_has_list_loosening_effect = FALSE; |
6003 | } |
6004 | |
6005 | /* Check whether we are Setext underline. */ |
6006 | if(line->indent < ctx->code_indent_offset && pivot_line->type == MD_LINE_TEXT |
6007 | && off < ctx->size && ISANYOF2(off, _T('='), _T('-')) |
6008 | && (n_parents == ctx->n_containers)) |
6009 | { |
6010 | unsigned level; |
6011 | |
6012 | if(md_is_setext_underline(ctx, beg: off, p_end: &off, p_level: &level)) { |
6013 | line->type = MD_LINE_SETEXTUNDERLINE; |
6014 | line->data = level; |
6015 | break; |
6016 | } |
6017 | } |
6018 | |
6019 | /* Check for thematic break line. */ |
6020 | if(line->indent < ctx->code_indent_offset |
6021 | && off < ctx->size && off >= hr_killer |
6022 | && ISANYOF(off, _T("-_*" ))) |
6023 | { |
6024 | if(md_is_hr_line(ctx, beg: off, p_end: &off, p_killer: &hr_killer)) { |
6025 | line->type = MD_LINE_HR; |
6026 | break; |
6027 | } |
6028 | } |
6029 | |
6030 | /* Check for "brother" container. I.e. whether we are another list item |
6031 | * in already started list. */ |
6032 | if(n_parents < ctx->n_containers && n_brothers + n_children == 0) { |
6033 | OFF tmp; |
6034 | |
6035 | if(md_is_container_mark(ctx, indent: line->indent, beg: off, p_end: &tmp, p_container: &container) && |
6036 | md_is_container_compatible(pivot: &ctx->containers[n_parents], container: &container)) |
6037 | { |
6038 | pivot_line = &md_dummy_blank_line; |
6039 | |
6040 | off = tmp; |
6041 | |
6042 | total_indent += container.contents_indent - container.mark_indent; |
6043 | line->indent = md_line_indentation(ctx, total_indent, beg: off, p_end: &off); |
6044 | total_indent += line->indent; |
6045 | line->beg = off; |
6046 | |
6047 | /* Some of the following whitespace actually still belongs to the mark. */ |
6048 | if(off >= ctx->size || ISNEWLINE(off)) { |
6049 | container.contents_indent++; |
6050 | } else if(line->indent <= ctx->code_indent_offset) { |
6051 | container.contents_indent += line->indent; |
6052 | line->indent = 0; |
6053 | } else { |
6054 | container.contents_indent += 1; |
6055 | line->indent--; |
6056 | } |
6057 | |
6058 | ctx->containers[n_parents].mark_indent = container.mark_indent; |
6059 | ctx->containers[n_parents].contents_indent = container.contents_indent; |
6060 | |
6061 | n_brothers++; |
6062 | continue; |
6063 | } |
6064 | } |
6065 | |
6066 | /* Check for indented code. |
6067 | * Note indented code block cannot interrupt a paragraph. */ |
6068 | if(line->indent >= ctx->code_indent_offset && (pivot_line->type != MD_LINE_TEXT)) { |
6069 | line->type = MD_LINE_INDENTEDCODE; |
6070 | line->indent -= ctx->code_indent_offset; |
6071 | line->data = 0; |
6072 | break; |
6073 | } |
6074 | |
6075 | /* Check for start of a new container block. */ |
6076 | if(line->indent < ctx->code_indent_offset && |
6077 | md_is_container_mark(ctx, indent: line->indent, beg: off, p_end: &off, p_container: &container)) |
6078 | { |
6079 | if(pivot_line->type == MD_LINE_TEXT && n_parents == ctx->n_containers && |
6080 | (off >= ctx->size || ISNEWLINE(off)) && container.ch != _T('>')) |
6081 | { |
6082 | /* Noop. List mark followed by a blank line cannot interrupt a paragraph. */ |
6083 | } else if(pivot_line->type == MD_LINE_TEXT && n_parents == ctx->n_containers && |
6084 | ISANYOF2_(container.ch, _T('.'), _T(')')) && container.start != 1) |
6085 | { |
6086 | /* Noop. Ordered list cannot interrupt a paragraph unless the start index is 1. */ |
6087 | } else { |
6088 | total_indent += container.contents_indent - container.mark_indent; |
6089 | line->indent = md_line_indentation(ctx, total_indent, beg: off, p_end: &off); |
6090 | total_indent += line->indent; |
6091 | |
6092 | line->beg = off; |
6093 | line->data = container.ch; |
6094 | |
6095 | /* Some of the following whitespace actually still belongs to the mark. */ |
6096 | if(off >= ctx->size || ISNEWLINE(off)) { |
6097 | container.contents_indent++; |
6098 | } else if(line->indent <= ctx->code_indent_offset) { |
6099 | container.contents_indent += line->indent; |
6100 | line->indent = 0; |
6101 | } else { |
6102 | container.contents_indent += 1; |
6103 | line->indent--; |
6104 | } |
6105 | |
6106 | if(n_brothers + n_children == 0) |
6107 | pivot_line = &md_dummy_blank_line; |
6108 | |
6109 | if(n_children == 0) |
6110 | MD_CHECK(md_leave_child_containers(ctx, n_parents + n_brothers)); |
6111 | |
6112 | n_children++; |
6113 | MD_CHECK(md_push_container(ctx, &container)); |
6114 | continue; |
6115 | } |
6116 | } |
6117 | |
6118 | /* Check whether we are table continuation. */ |
6119 | if(pivot_line->type == MD_LINE_TABLE && n_parents == ctx->n_containers) { |
6120 | line->type = MD_LINE_TABLE; |
6121 | break; |
6122 | } |
6123 | |
6124 | /* Check for ATX header. */ |
6125 | if(line->indent < ctx->code_indent_offset && |
6126 | off < ctx->size && CH(off) == _T('#')) |
6127 | { |
6128 | unsigned level; |
6129 | |
6130 | if(md_is_atxheader_line(ctx, beg: off, p_beg: &line->beg, p_end: &off, p_level: &level)) { |
6131 | line->type = MD_LINE_ATXHEADER; |
6132 | line->data = level; |
6133 | break; |
6134 | } |
6135 | } |
6136 | |
6137 | /* Check whether we are starting code fence. */ |
6138 | if(line->indent < ctx->code_indent_offset && |
6139 | off < ctx->size && ISANYOF2(off, _T('`'), _T('~'))) |
6140 | { |
6141 | if(md_is_opening_code_fence(ctx, beg: off, p_end: &off)) { |
6142 | line->type = MD_LINE_FENCEDCODE; |
6143 | line->data = 1; |
6144 | line->enforce_new_block = TRUE; |
6145 | break; |
6146 | } |
6147 | } |
6148 | |
6149 | /* Check for start of raw HTML block. */ |
6150 | if(off < ctx->size && CH(off) == _T('<') |
6151 | && !(ctx->parser.flags & MD_FLAG_NOHTMLBLOCKS)) |
6152 | { |
6153 | ctx->html_block_type = md_is_html_block_start_condition(ctx, beg: off); |
6154 | |
6155 | /* HTML block type 7 cannot interrupt paragraph. */ |
6156 | if(ctx->html_block_type == 7 && pivot_line->type == MD_LINE_TEXT) |
6157 | ctx->html_block_type = 0; |
6158 | |
6159 | if(ctx->html_block_type > 0) { |
6160 | /* The line itself also may immediately close the block. */ |
6161 | if(md_is_html_block_end_condition(ctx, beg: off, p_end: &off) == ctx->html_block_type) { |
6162 | /* Make sure this is the last line of the block. */ |
6163 | ctx->html_block_type = 0; |
6164 | } |
6165 | |
6166 | line->enforce_new_block = TRUE; |
6167 | line->type = MD_LINE_HTML; |
6168 | break; |
6169 | } |
6170 | } |
6171 | |
6172 | /* Check for table underline. */ |
6173 | if((ctx->parser.flags & MD_FLAG_TABLES) && pivot_line->type == MD_LINE_TEXT |
6174 | && off < ctx->size && ISANYOF3(off, _T('|'), _T('-'), _T(':')) |
6175 | && n_parents == ctx->n_containers) |
6176 | { |
6177 | unsigned col_count; |
6178 | |
6179 | if(ctx->current_block != NULL && ctx->current_block->n_lines == 1 && |
6180 | md_is_table_underline(ctx, beg: off, p_end: &off, p_col_count: &col_count)) |
6181 | { |
6182 | line->data = col_count; |
6183 | line->type = MD_LINE_TABLEUNDERLINE; |
6184 | break; |
6185 | } |
6186 | } |
6187 | |
6188 | /* By default, we are normal text line. */ |
6189 | line->type = MD_LINE_TEXT; |
6190 | if(pivot_line->type == MD_LINE_TEXT && n_brothers + n_children == 0) { |
6191 | /* Lazy continuation. */ |
6192 | n_parents = ctx->n_containers; |
6193 | } |
6194 | |
6195 | /* Check for task mark. */ |
6196 | if((ctx->parser.flags & MD_FLAG_TASKLISTS) && n_brothers + n_children > 0 && |
6197 | ISANYOF_(ctx->containers[ctx->n_containers-1].ch, _T("-+*.)" ))) |
6198 | { |
6199 | OFF tmp = off; |
6200 | |
6201 | while(tmp < ctx->size && tmp < off + 3 && ISBLANK(tmp)) |
6202 | tmp++; |
6203 | if(tmp + 2 < ctx->size && CH(tmp) == _T('[') && |
6204 | ISANYOF(tmp+1, _T("xX " )) && CH(tmp+2) == _T(']') && |
6205 | (tmp + 3 == ctx->size || ISBLANK(tmp+3) || ISNEWLINE(tmp+3))) |
6206 | { |
6207 | MD_CONTAINER* task_container = (n_children > 0 ? &ctx->containers[ctx->n_containers-1] : &container); |
6208 | task_container->is_task = TRUE; |
6209 | task_container->task_mark_off = tmp + 1; |
6210 | off = tmp + 3; |
6211 | while(off < ctx->size && ISWHITESPACE(off)) |
6212 | off++; |
6213 | line->beg = off; |
6214 | } |
6215 | } |
6216 | |
6217 | break; |
6218 | } |
6219 | |
6220 | /* Scan for end of the line. |
6221 | * |
6222 | * Note this is quite a bottleneck of the parsing as we here iterate almost |
6223 | * over compete document. |
6224 | */ |
6225 | #if defined __linux__ && !defined MD4C_USE_UTF16 |
6226 | /* Recent glibc versions have superbly optimized strcspn(), even using |
6227 | * vectorization if available. */ |
6228 | if(ctx->doc_ends_with_newline && off < ctx->size) { |
6229 | while(TRUE) { |
6230 | off += (OFF) strcspn(STR(off), reject: "\r\n" ); |
6231 | |
6232 | /* strcspn() can stop on zero terminator; but that can appear |
6233 | * anywhere in the Markfown input... */ |
6234 | if(CH(off) == _T('\0')) |
6235 | off++; |
6236 | else |
6237 | break; |
6238 | } |
6239 | } else |
6240 | #endif |
6241 | { |
6242 | /* Optimization: Use some loop unrolling. */ |
6243 | while(off + 3 < ctx->size && !ISNEWLINE(off+0) && !ISNEWLINE(off+1) |
6244 | && !ISNEWLINE(off+2) && !ISNEWLINE(off+3)) |
6245 | off += 4; |
6246 | while(off < ctx->size && !ISNEWLINE(off)) |
6247 | off++; |
6248 | } |
6249 | |
6250 | /* Set end of the line. */ |
6251 | line->end = off; |
6252 | |
6253 | /* But for ATX header, we should exclude the optional trailing mark. */ |
6254 | if(line->type == MD_LINE_ATXHEADER) { |
6255 | OFF tmp = line->end; |
6256 | while(tmp > line->beg && CH(tmp-1) == _T(' ')) |
6257 | tmp--; |
6258 | while(tmp > line->beg && CH(tmp-1) == _T('#')) |
6259 | tmp--; |
6260 | if(tmp == line->beg || CH(tmp-1) == _T(' ') || (ctx->parser.flags & MD_FLAG_PERMISSIVEATXHEADERS)) |
6261 | line->end = tmp; |
6262 | } |
6263 | |
6264 | /* Trim trailing spaces. */ |
6265 | if(line->type != MD_LINE_INDENTEDCODE && line->type != MD_LINE_FENCEDCODE && line->type != MD_LINE_HTML) { |
6266 | while(line->end > line->beg && CH(line->end-1) == _T(' ')) |
6267 | line->end--; |
6268 | } |
6269 | |
6270 | /* Eat also the new line. */ |
6271 | if(off < ctx->size && CH(off) == _T('\r')) |
6272 | off++; |
6273 | if(off < ctx->size && CH(off) == _T('\n')) |
6274 | off++; |
6275 | |
6276 | *p_end = off; |
6277 | |
6278 | /* If we belong to a list after seeing a blank line, the list is loose. */ |
6279 | if(prev_line_has_list_loosening_effect && line->type != MD_LINE_BLANK && n_parents + n_brothers > 0) { |
6280 | MD_CONTAINER* c = &ctx->containers[n_parents + n_brothers - 1]; |
6281 | if(c->ch != _T('>')) { |
6282 | MD_BLOCK* block = (MD_BLOCK*) (((char*)ctx->block_bytes) + c->block_byte_off); |
6283 | block->flags |= MD_BLOCK_LOOSE_LIST; |
6284 | } |
6285 | } |
6286 | |
6287 | /* Leave any containers we are not part of anymore. */ |
6288 | if(n_children == 0 && n_parents + n_brothers < ctx->n_containers) |
6289 | MD_CHECK(md_leave_child_containers(ctx, n_parents + n_brothers)); |
6290 | |
6291 | /* Enter any container we found a mark for. */ |
6292 | if(n_brothers > 0) { |
6293 | MD_ASSERT(n_brothers == 1); |
6294 | MD_CHECK(md_push_container_bytes(ctx, MD_BLOCK_LI, |
6295 | ctx->containers[n_parents].task_mark_off, |
6296 | (ctx->containers[n_parents].is_task ? CH(ctx->containers[n_parents].task_mark_off) : 0), |
6297 | MD_BLOCK_CONTAINER_CLOSER)); |
6298 | MD_CHECK(md_push_container_bytes(ctx, MD_BLOCK_LI, |
6299 | container.task_mark_off, |
6300 | (container.is_task ? CH(container.task_mark_off) : 0), |
6301 | MD_BLOCK_CONTAINER_OPENER)); |
6302 | ctx->containers[n_parents].is_task = container.is_task; |
6303 | ctx->containers[n_parents].task_mark_off = container.task_mark_off; |
6304 | } |
6305 | |
6306 | if(n_children > 0) |
6307 | MD_CHECK(md_enter_child_containers(ctx, n_children)); |
6308 | |
6309 | abort: |
6310 | return ret; |
6311 | } |
6312 | |
6313 | static int |
6314 | md_process_line(MD_CTX* ctx, const MD_LINE_ANALYSIS** p_pivot_line, MD_LINE_ANALYSIS* line) |
6315 | { |
6316 | const MD_LINE_ANALYSIS* pivot_line = *p_pivot_line; |
6317 | int ret = 0; |
6318 | |
6319 | /* Blank line ends current leaf block. */ |
6320 | if(line->type == MD_LINE_BLANK) { |
6321 | MD_CHECK(md_end_current_block(ctx)); |
6322 | *p_pivot_line = &md_dummy_blank_line; |
6323 | return 0; |
6324 | } |
6325 | |
6326 | if(line->enforce_new_block) |
6327 | MD_CHECK(md_end_current_block(ctx)); |
6328 | |
6329 | /* Some line types form block on their own. */ |
6330 | if(line->type == MD_LINE_HR || line->type == MD_LINE_ATXHEADER) { |
6331 | MD_CHECK(md_end_current_block(ctx)); |
6332 | |
6333 | /* Add our single-line block. */ |
6334 | MD_CHECK(md_start_new_block(ctx, line)); |
6335 | MD_CHECK(md_add_line_into_current_block(ctx, line)); |
6336 | MD_CHECK(md_end_current_block(ctx)); |
6337 | *p_pivot_line = &md_dummy_blank_line; |
6338 | return 0; |
6339 | } |
6340 | |
6341 | /* MD_LINE_SETEXTUNDERLINE changes meaning of the current block and ends it. */ |
6342 | if(line->type == MD_LINE_SETEXTUNDERLINE) { |
6343 | MD_ASSERT(ctx->current_block != NULL); |
6344 | ctx->current_block->type = MD_BLOCK_H; |
6345 | ctx->current_block->data = line->data; |
6346 | ctx->current_block->flags |= MD_BLOCK_SETEXT_HEADER; |
6347 | MD_CHECK(md_add_line_into_current_block(ctx, line)); |
6348 | MD_CHECK(md_end_current_block(ctx)); |
6349 | if(ctx->current_block == NULL) { |
6350 | *p_pivot_line = &md_dummy_blank_line; |
6351 | } else { |
6352 | /* This happens if we have consumed all the body as link ref. defs. |
6353 | * and downgraded the underline into start of a new paragraph block. */ |
6354 | line->type = MD_LINE_TEXT; |
6355 | *p_pivot_line = line; |
6356 | } |
6357 | return 0; |
6358 | } |
6359 | |
6360 | /* MD_LINE_TABLEUNDERLINE changes meaning of the current block. */ |
6361 | if(line->type == MD_LINE_TABLEUNDERLINE) { |
6362 | MD_ASSERT(ctx->current_block != NULL); |
6363 | MD_ASSERT(ctx->current_block->n_lines == 1); |
6364 | ctx->current_block->type = MD_BLOCK_TABLE; |
6365 | ctx->current_block->data = line->data; |
6366 | MD_ASSERT(pivot_line != &md_dummy_blank_line); |
6367 | ((MD_LINE_ANALYSIS*)pivot_line)->type = MD_LINE_TABLE; |
6368 | MD_CHECK(md_add_line_into_current_block(ctx, line)); |
6369 | return 0; |
6370 | } |
6371 | |
6372 | /* The current block also ends if the line has different type. */ |
6373 | if(line->type != pivot_line->type) |
6374 | MD_CHECK(md_end_current_block(ctx)); |
6375 | |
6376 | /* The current line may start a new block. */ |
6377 | if(ctx->current_block == NULL) { |
6378 | MD_CHECK(md_start_new_block(ctx, line)); |
6379 | *p_pivot_line = line; |
6380 | } |
6381 | |
6382 | /* In all other cases the line is just a continuation of the current block. */ |
6383 | MD_CHECK(md_add_line_into_current_block(ctx, line)); |
6384 | |
6385 | abort: |
6386 | return ret; |
6387 | } |
6388 | |
6389 | static int |
6390 | md_process_doc(MD_CTX *ctx) |
6391 | { |
6392 | const MD_LINE_ANALYSIS* pivot_line = &md_dummy_blank_line; |
6393 | MD_LINE_ANALYSIS line_buf[2]; |
6394 | MD_LINE_ANALYSIS* line = &line_buf[0]; |
6395 | OFF off = 0; |
6396 | int ret = 0; |
6397 | |
6398 | MD_ENTER_BLOCK(MD_BLOCK_DOC, NULL); |
6399 | |
6400 | while(off < ctx->size) { |
6401 | if(line == pivot_line) |
6402 | line = (line == &line_buf[0] ? &line_buf[1] : &line_buf[0]); |
6403 | |
6404 | MD_CHECK(md_analyze_line(ctx, off, &off, pivot_line, line)); |
6405 | MD_CHECK(md_process_line(ctx, &pivot_line, line)); |
6406 | } |
6407 | |
6408 | md_end_current_block(ctx); |
6409 | |
6410 | MD_CHECK(md_build_ref_def_hashtable(ctx)); |
6411 | |
6412 | /* Process all blocks. */ |
6413 | MD_CHECK(md_leave_child_containers(ctx, 0)); |
6414 | MD_CHECK(md_process_all_blocks(ctx)); |
6415 | |
6416 | MD_LEAVE_BLOCK(MD_BLOCK_DOC, NULL); |
6417 | |
6418 | abort: |
6419 | |
6420 | #if 0 |
6421 | /* Output some memory consumption statistics. */ |
6422 | { |
6423 | char buffer[256]; |
6424 | sprintf(buffer, "Alloced %u bytes for block buffer." , |
6425 | (unsigned)(ctx->alloc_block_bytes)); |
6426 | MD_LOG(buffer); |
6427 | |
6428 | sprintf(buffer, "Alloced %u bytes for containers buffer." , |
6429 | (unsigned)(ctx->alloc_containers * sizeof(MD_CONTAINER))); |
6430 | MD_LOG(buffer); |
6431 | |
6432 | sprintf(buffer, "Alloced %u bytes for marks buffer." , |
6433 | (unsigned)(ctx->alloc_marks * sizeof(MD_MARK))); |
6434 | MD_LOG(buffer); |
6435 | |
6436 | sprintf(buffer, "Alloced %u bytes for aux. buffer." , |
6437 | (unsigned)(ctx->alloc_buffer * sizeof(MD_CHAR))); |
6438 | MD_LOG(buffer); |
6439 | } |
6440 | #endif |
6441 | |
6442 | return ret; |
6443 | } |
6444 | |
6445 | |
6446 | /******************** |
6447 | *** Public API *** |
6448 | ********************/ |
6449 | |
6450 | int |
6451 | md_parse(const MD_CHAR* text, MD_SIZE size, const MD_PARSER* parser, void* userdata) |
6452 | { |
6453 | MD_CTX ctx; |
6454 | int i; |
6455 | int ret; |
6456 | |
6457 | if(parser->abi_version != 0) { |
6458 | if(parser->debug_log != NULL) |
6459 | parser->debug_log("Unsupported abi_version." , userdata); |
6460 | return -1; |
6461 | } |
6462 | |
6463 | /* Setup context structure. */ |
6464 | memset(s: &ctx, c: 0, n: sizeof(MD_CTX)); |
6465 | ctx.text = text; |
6466 | ctx.size = size; |
6467 | memcpy(dest: &ctx.parser, src: parser, n: sizeof(MD_PARSER)); |
6468 | ctx.userdata = userdata; |
6469 | ctx.code_indent_offset = (ctx.parser.flags & MD_FLAG_NOINDENTEDCODEBLOCKS) ? (OFF)(-1) : 4; |
6470 | md_build_mark_char_map(ctx: &ctx); |
6471 | ctx.doc_ends_with_newline = (size > 0 && ISNEWLINE_(text[size-1])); |
6472 | |
6473 | /* Reset all mark stacks and lists. */ |
6474 | for(i = 0; i < (int) SIZEOF_ARRAY(ctx.opener_stacks); i++) |
6475 | ctx.opener_stacks[i].top = -1; |
6476 | ctx.ptr_stack.top = -1; |
6477 | ctx.unresolved_link_head = -1; |
6478 | ctx.unresolved_link_tail = -1; |
6479 | ctx.table_cell_boundaries_head = -1; |
6480 | ctx.table_cell_boundaries_tail = -1; |
6481 | |
6482 | /* All the work. */ |
6483 | ret = md_process_doc(ctx: &ctx); |
6484 | |
6485 | /* Clean-up. */ |
6486 | md_free_ref_defs(ctx: &ctx); |
6487 | md_free_ref_def_hashtable(ctx: &ctx); |
6488 | free(ptr: ctx.buffer); |
6489 | free(ptr: ctx.marks); |
6490 | free(ptr: ctx.block_bytes); |
6491 | free(ptr: ctx.containers); |
6492 | |
6493 | return ret; |
6494 | } |
6495 | |